48#include <QOpenGLContext>
49#include <QOpenGLFunctions>
51#include <Qt3DCore/QBuffer>
52#include <Qt3DExtras/QPhongMaterial>
53#include <Qt3DLogic/QFrameAction>
54#include <Qt3DRender/QRenderSettings>
57using namespace Qt::StringLiterals;
59#if !defined( Q_OS_MAC )
70 Qt3DRender::QRenderSettings::RenderPolicy oldPolicy = engine.
renderSettings()->renderPolicy();
71 engine.
renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
74 Qt3DLogic::QFrameAction *frameAction =
new Qt3DLogic::QFrameAction();
75 scene->addComponent( frameAction );
77 QObject::connect( frameAction, &Qt3DLogic::QFrameAction::triggered, &evLoop, &QEventLoop::quit );
79 scene->removeComponent( frameAction );
80 frameAction->deleteLater();
89 QgsApplication::processEvents();
99 engine.
renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
103 auto saveImageFcn = [&evLoop, &resImage](
const QImage &img ) {
109 QMetaObject::Connection conn2;
111 auto requestImageFcn = [&engine, scene] {
114 engine.
renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
131 QObject::disconnect( conn1 );
133 QObject::disconnect( conn2 );
135 engine.
renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
145 engine.
renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
147 auto requestImageFcn = [&engine, scene] {
150 engine.
renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
155 auto saveImageFcn = [&evLoop, &resImage](
const QImage &img ) {
161 QMetaObject::Connection conn2;
177 QObject::disconnect( conn1 );
179 QObject::disconnect( conn2 );
181 engine.
renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
188 long long usedGpuMemory = 0;
189 for ( Qt3DCore::QBuffer *buffer : entity->findChildren<Qt3DCore::QBuffer *>() )
191 usedGpuMemory += buffer->data().size();
193 for ( Qt3DRender::QTexture2D *tex : entity->findChildren<Qt3DRender::QTexture2D *>() )
196 usedGpuMemory +=
static_cast< long long >( tex->width() ) *
static_cast< long long >( tex->height() ) * 4;
198 return usedGpuMemory / 1024.0 / 1024.0;
206 const QString &outputDirectory,
207 const QString &fileNameTemplate,
208 const QSize &outputSize,
213 if ( animationSettings.
keyFrames().size() < 2 )
215 error = QObject::tr(
"Unable to export 3D animation. Add at least 2 keyframes" );
219 const float duration = animationSettings.
duration();
222 error = QObject::tr(
"Unable to export 3D animation (invalid duration)." );
228 const int totalFrames =
static_cast<int>( duration * framesPerSecond );
230 if ( fileNameTemplate.isEmpty() )
232 error = QObject::tr(
"Filename template is empty" );
236 const int numberOfDigits = fileNameTemplate.count(
'#'_L1 );
237 if ( numberOfDigits < 0 )
239 error = QObject::tr(
"Wrong filename template format (must contain #)" );
242 const QString token( numberOfDigits,
'#'_L1 );
243 if ( !fileNameTemplate.contains( token ) )
245 error = QObject::tr(
"Filename template must contain all # placeholders in one continuous group." );
249 if ( !QDir().exists( outputDirectory ) )
251 if ( !QDir().mkpath( outputDirectory ) )
253 error = QObject::tr(
"Output directory could not be created." );
263 engine.
renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
265 while ( time <= duration )
271 error = QObject::tr(
"Export canceled" );
274 feedback->
setProgress( frameNo /
static_cast<double>( totalFrames ) * 100 );
281 QString fileName( fileNameTemplate );
282 const QString frameNoPaddedLeft( u
"%1"_s.arg( frameNo, numberOfDigits, 10, QChar(
'0' ) ) );
283 fileName.replace( token, frameNoPaddedLeft );
284 const QString path = QDir( outputDirectory ).filePath( fileName );
290 time += 1.0f /
static_cast<float>( framesPerSecond );
299 if ( maxError <= 0 || tileResolution <= 0 || tile0width <= 0 )
306 const double zoomLevel = -log( tileResolution * maxError / tile0width ) / log( 2 );
307 return std::max<int>( 0, round( zoomLevel ) );
315 return u
"absolute"_s;
317 return u
"relative"_s;
327 if ( str ==
"absolute"_L1 )
329 else if ( str ==
"terrain"_L1 )
343 return u
"centroid"_s;
351 if ( str ==
"vertex"_L1 )
362 return u
"no-culling"_s;
368 return u
"front-and-back"_s;
375 if ( str ==
"front"_L1 )
377 else if ( str ==
"back"_L1 )
379 else if ( str ==
"front-and-back"_L1 )
435 pt.
setX( lineString->
xAt( i ) );
436 pt.
setY( lineString->
yAt( i ) );
440 pt.
set( centroid.
x(), centroid.
y() );
458 geomZ = lineString->
zAt( i );
466 lineString->
setZAt( i, z );
473 if ( !polygon->
is3D() )
492 clampAltitudes( lineString, altClamp, altBind, centroid, offset, context );
501 clampAltitudes( lineString, altClamp, altBind, centroid, offset, context );
509 const float *d = m.constData();
512 for (
int i = 0; i < 16; ++i )
513 elems << QString::number( d[i] );
514 return elems.join(
' ' );
521 QStringList elems = str.split(
' ' );
522 for (
int i = 0; i < 16; ++i )
523 d[i] = elems[i].toFloat();
530 return srgb <= 0.04045f ? srgb / 12.92f : std::pow( ( srgb + 0.055f ) / 1.055f, 2.4f );
561 const float terrainZ = useTerrainHeight
573 h = terrainZ + geomZ;
579 positions.append( QVector3D(
580 static_cast<float>( pt.
x() - chunkOrigin.
x() ),
581 static_cast<float>( pt.
y() - chunkOrigin.
y() ),
582 static_cast<float>( h - chunkOrigin.
z() )
585 QgsDebugMsgLevel( u
"%1 %2 %3"_s.arg( positions.last().x() ).arg( positions.last().y() ).arg( positions.last().z() ), 2 );
594static inline uint outcode( QVector4D v )
604 if ( v.x() < -v.w() )
608 if ( v.y() < -v.w() )
612 if ( v.z() < -v.w() )
634 for (
int i = 0; i < 8; ++i )
636 const QVector4D p( ( ( i >> 0 ) & 1 ) ? bbox.
xMin : bbox.
xMax, ( ( i >> 1 ) & 1 ) ? bbox.
yMin : bbox.
yMax, ( ( i >> 2 ) & 1 ) ? bbox.
zMin : bbox.
zMax, 1 );
637 const QVector4D pc = viewProjectionMatrix * p;
641 out = out & outcode( pc );
648 return QgsVector3D( mapCoords.
x() - origin.
x(), mapCoords.
y() - origin.
y(), mapCoords.
z() - origin.
z() );
653 return QgsVector3D( worldCoords.
x() + origin.
x(), worldCoords.
y() + origin.
y(), worldCoords.
z() + origin.
z() );
705 QgsAABB rootBbox( worldExtentMin3D.
x(), worldExtentMin3D.
y(), worldExtentMin3D.
z(), worldExtentMax3D.
x(), worldExtentMax3D.
y(), worldExtentMax3D.
z() );
717 return QgsAABB(
static_cast<float>( worldExtentMin3D.
x() ),
static_cast<float>( worldExtentMin3D.
y() ),
static_cast<float>( worldExtentMin3D.
z() ),
718 static_cast<float>( worldExtentMax3D.
x() ),
static_cast<float>( worldExtentMax3D.
y() ),
static_cast<float>( worldExtentMax3D.
z() )
727 const QgsRectangle extentMap( worldExtentMin3D.
x(), worldExtentMin3D.
y(), worldExtentMax3D.
x(), worldExtentMax3D.
y() );
751 mapPoint2.
set( pt.
x(), pt.
y(), mapPoint1.
z() );
770 zMin = std::numeric_limits<double>::max();
771 zMax = std::numeric_limits<double>::lowest();
780 const double z = ( *vit ).z();
788 if ( zMin == std::numeric_limits<double>::max() && zMax == std::numeric_limits<double>::lowest() )
807 const QVector3D deviceCoords( point.x(), point.y(), 0.0 );
809 const QVector3D normDeviceCoords( 2.0 * deviceCoords.x() / windowSize.width() - 1.0f, 1.0f - 2.0 * deviceCoords.y() / windowSize.height(), camera->nearPlane() );
811 const QVector4D rayEndClip( normDeviceCoords.x(), normDeviceCoords.y(), 0.0, 1.0 );
813 const QMatrix4x4 invertedProjMatrix = camera->projectionMatrix().inverted();
814 const QMatrix4x4 invertedViewMatrix = camera->viewMatrix().inverted();
816 QVector3D rayOriginWorld;
817 switch ( camera->projectionType() )
819 case Qt3DRender::QCameraLens::PerspectiveProjection:
822 rayOriginWorld = QVector3D( invertedViewMatrix * QVector4D( 0.0f, 0.0f, 0.0f, 1.0f ) );
825 case Qt3DRender::QCameraLens::OrthographicProjection:
829 QVector4D rayOriginView = invertedProjMatrix * rayEndClip;
830 rayOriginView.setZ( 0.0f );
831 rayOriginWorld = QVector3D( invertedViewMatrix * rayOriginView );
839 const QVector4D rayEndView = invertedProjMatrix * rayEndClip;
840 const QVector4D rayEndWorld4D = invertedViewMatrix * rayEndView;
841 const QVector3D rayEndWorld = rayEndWorld4D.toVector3DAffine();
842 QVector3D rayDirWorld = rayEndWorld - rayOriginWorld;
843 rayDirWorld = rayDirWorld.normalized();
845 return QgsRay3D( rayOriginWorld, rayDirWorld );
852 QVector3D screenPointNdc {
853 (
static_cast<float>( screenPoint.x() ) / (
static_cast<float>( screenSize.width() ) / 2.0f ) - 1.0f ),
854 -(
static_cast<float>( screenPoint.y() ) / (
static_cast<float>( screenSize.height() ) / 2.0f ) - 1.0f ),
855 static_cast<float>( depth * 2 - 1 ),
859 return camera->viewMatrix().inverted() * camera->projectionMatrix().inverted() * screenPointNdc;
866 pitch = qRadiansToDegrees( qAcos( vect.y() ) );
867 yaw = qRadiansToDegrees( qAtan2( -vect.z(), vect.x() ) ) + 90;
872 return QVector2D( screenXY.x() / winSize.width(), 1 - screenXY.y() / winSize.width() );
877 return QVector2D( textureXY.x() * winSize.width(), ( 1 - textureXY.y() ) * winSize.height() );
885 std::unique_ptr<QgsPointCloud3DSymbol> symbol3D;
886 if ( renderer->
type() ==
"ramp"_L1 )
889 symbol3D = std::make_unique<QgsColorRampPointCloud3DSymbol>();
895 else if ( renderer->
type() ==
"rgb"_L1 )
898 symbol3D = std::make_unique<QgsRgbPointCloud3DSymbol>();
908 else if ( renderer->
type() ==
"classified"_L1 )
911 symbol3D = std::make_unique<QgsClassificationPointCloud3DSymbol>();
919 auto renderer3D = std::make_unique<QgsPointCloudLayer3DRenderer>();
920 renderer3D->setSymbol( symbol3D.release() );
929 const QList<QgsMapLayer *> keys = scene->
layers();
932 Qt3DCore::QEntity *entity = scene->
layerEntity( layer );
934 if ( QgsChunkedEntity *chunkedEntity = qobject_cast<QgsChunkedEntity *>( entity ) )
936 const QList<QgsRayCastHit> hits = chunkedEntity->rayIntersection( ray, context );
938 if ( !hits.isEmpty() )
944 const QList<QgsRayCastHit> hits = terrain->rayIntersection( ray, context );
946 if ( !hits.isEmpty() )
949 if ( QgsGlobeEntity *globe = scene->
globeEntity() )
951 const QList<QgsRayCastHit> hits = globe->rayIntersection( ray, context );
953 if ( !hits.isEmpty() )
981 float phi = epsilon *
static_cast<float>( screenSize ) /
static_cast<float>( 2 * distance * tan( fov * M_PI / ( 2 * 180 ) ) );
990 for (
int i = 0; i < 8; ++i )
992 const QVector4D p( ( ( i >> 0 ) & 1 ) ? bbox.
xMin : bbox.
xMax, ( ( i >> 1 ) & 1 ) ? bbox.
yMin : bbox.
yMax, ( ( i >> 2 ) & 1 ) ? bbox.
zMin : bbox.
zMax, 1 );
994 const QVector4D pc = viewMatrix * p;
996 const float dst = -pc.z();
997 fnear = std::min( fnear, dst );
998 ffar = std::max( ffar, dst );
1007 return Qt3DRender::QCullFace::NoCulling;
1009 return Qt3DRender::QCullFace::Front;
1011 return Qt3DRender::QCullFace::Back;
1013 return Qt3DRender::QCullFace::FrontAndBack;
1015 return Qt3DRender::QCullFace::NoCulling;
1025 QStringList defineLines;
1026 for (
const QString &define : defines )
1027 defineLines +=
"#define " + define +
"\n";
1029 QString definesText = defineLines.join( QString() );
1031 QByteArray newShaderCode = shaderCode;
1032 int versionIndex = shaderCode.indexOf(
"#version " );
1033 int insertionIndex = versionIndex == -1 ? 0 : shaderCode.indexOf(
'\n', versionIndex + 1 ) + 1;
1034 newShaderCode.insert( insertionIndex, definesText.toLatin1() );
1035 return newShaderCode;
1038QVector3D Qgs3DUtils::axisStringToVector(
const QString &axis )
1040 if ( axis ==
"x"_L1 )
1041 return QVector3D( 1.0f, 0.0f, 0.0f );
1042 if ( axis ==
"-x"_L1 )
1043 return QVector3D( -1.0f, 0.0f, 0.0f );
1044 if ( axis ==
"y"_L1 )
1045 return QVector3D( 0.0f, 1.0f, 0.0f );
1046 if ( axis ==
"-y"_L1 )
1047 return QVector3D( 0.0f, -1.0f, 0.0f );
1048 if ( axis ==
"z"_L1 )
1049 return QVector3D( 0.0f, 0.0f, 1.0f );
1050 if ( axis ==
"-z"_L1 )
1051 return QVector3D( 0.0f, 0.0f, -1.0f );
1057 const QVector3D up = axisStringToVector( upAxis );
1058 const QVector3D forward = axisStringToVector( forwardAxis );
1060 if ( up.isNull() || forward.isNull() )
1061 return QMatrix4x4();
1063 const QVector3D right = QVector3D::crossProduct( forward, up );
1064 if ( right.isNull() )
1065 return QMatrix4x4();
1067 const float data[9] = {
1078 return QMatrix4x4( QMatrix3x3( data ) );
1083 QByteArray newShaderCode = shaderCode;
1085 for (
const QString &define : defines )
1087 const QString defineLine =
"#define " + define +
"\n";
1088 const int defineLineIndex = newShaderCode.indexOf( defineLine.toUtf8() );
1089 if ( defineLineIndex != -1 )
1091 newShaderCode.remove( defineLineIndex, defineLine.size() );
1095 return newShaderCode;
1103 const float *md = matrix.data();
1104 const float sx = QVector3D( md[0], md[1], md[2] ).length();
1105 const float sy = QVector3D( md[4], md[5], md[6] ).length();
1106 const float sz = QVector3D( md[8], md[9], md[10] ).length();
1118 const QMatrix3x3 rot3x3( rd );
1120 scale = QVector3D( sx, sy, sz );
1121 rotation = QQuaternion::fromRotationMatrix( rot3x3 );
1122 translation = QVector3D( md[12], md[13], md[14] );
1129 QOpenGLContext context;
1130 context.setFormat( QSurfaceFormat::defaultFormat() );
1131 if ( context.create() )
1133 if ( context.makeCurrent( surface ) )
1135 QOpenGLFunctions *funcs = context.functions();
1136 funcs->glGetIntegerv( GL_MAX_CLIP_PLANES, &numPlanes );
1145 return QQuaternion::fromAxisAndAngle( QVector3D( 0, 0, 1 ), headingAngle ) * QQuaternion::fromAxisAndAngle( QVector3D( 1, 0, 0 ), pitchAngle );
1153 const float pointDistance = ( cameraController->
camera()->farPlane() + cameraController->
camera()->nearPlane() ) / 2;
1154 const QVector3D worldPoint = ray.
point( pointDistance );
1156 const QgsPoint mapPoint( mapTransform.
x(), mapTransform.
y(), mapTransform.
z() );
1162 QVector3D up( 0.0f, 1.0f, 0.0f );
1163 if ( std::abs( QVector3D::dotProduct( lightDirection, up ) ) > 0.99f )
1164 up = QVector3D( 0.0f, 0.0f, 1.0f );
1171 const float safeNearPlane = std::max( nearPlane, 0.0001f );
1173 std::vector<float> cascadeSplits( numberCascades + 1 );
1176 for (
int i = 0; i <= numberCascades; ++i )
1178 const float p =
static_cast<float>( i ) /
static_cast<float>( numberCascades );
1179 const float logSplit = safeNearPlane * std::pow( farPlane / safeNearPlane, p );
1180 const float uniSplit = safeNearPlane + ( farPlane - safeNearPlane ) * p;
1181 cascadeSplits[i] = lambda * logSplit + ( 1.0f - lambda ) * uniSplit;
1183 return cascadeSplits;
1188 const float fovC =
static_cast< float >( std::tan( fov * M_PI / 360.0 ) );
1189 const float halfYNear = zNear * fovC;
1190 const float halfXNear = halfYNear * aspectRatio;
1191 const float halfYFar = zFar * fovC;
1192 const float halfXFar = halfYFar * aspectRatio;
1195 corners[0] = invertedCameraView.map( QVector3D( -halfXNear, -halfYNear, -zNear ) );
1196 corners[1] = invertedCameraView.map( QVector3D( halfXNear, -halfYNear, -zNear ) );
1197 corners[2] = invertedCameraView.map( QVector3D( halfXNear, halfYNear, -zNear ) );
1198 corners[3] = invertedCameraView.map( QVector3D( -halfXNear, halfYNear, -zNear ) );
1199 corners[4] = invertedCameraView.map( QVector3D( -halfXFar, -halfYFar, -zFar ) );
1200 corners[5] = invertedCameraView.map( QVector3D( halfXFar, -halfYFar, -zFar ) );
1201 corners[6] = invertedCameraView.map( QVector3D( halfXFar, halfYFar, -zFar ) );
1202 corners[7] = invertedCameraView.map( QVector3D( -halfXFar, halfYFar, -zFar ) );
1205 center = QVector3D( 0, 0, 0 );
1206 for (
int j = 0; j < 8; ++j )
1208 center += corners[j];
1214 const QVector3D ( &worldCorners )[8],
const QMatrix4x4 &viewMatrix,
float &left,
float &right,
float &bottom,
float &top,
float &nearPlane,
float &farPlane
1218 left = std::numeric_limits<float>::max();
1219 right = std::numeric_limits<float>::lowest();
1220 bottom = std::numeric_limits<float>::max();
1221 top = std::numeric_limits<float>::lowest();
1222 nearPlane = std::numeric_limits<float>::max();
1223 farPlane = std::numeric_limits<float>::lowest();
1224 for (
int j = 0; j < 8; ++j )
1226 const QVector3D lightSpaceCorner = viewMatrix.map( worldCorners[j] );
1227 left = std::min( left, lightSpaceCorner.x() );
1228 right = std::max( right, lightSpaceCorner.x() );
1229 bottom = std::min( bottom, lightSpaceCorner.y() );
1230 top = std::max( top, lightSpaceCorner.y() );
1231 const float zDistance = -lightSpaceCorner.z();
1232 nearPlane = std::min( nearPlane, zDistance );
1233 farPlane = std::max( farPlane, zDistance );
1241 return QList<QVector4D>();
1243 QgsVector3D lineDirection( endPoint - startPoint );
1246 const QgsVector3D linePerp( lineDirection2DPerp.
x(), lineDirection2DPerp.
y(), 0 );
1248 QList<QVector4D> clippingPlanes;
1250 double originDistance;
1254 planePoint = startPoint;
1256 clippingPlanes << QVector4D( static_cast<float>( lineDirection.
x() ),
static_cast<float>( lineDirection.
y() ), 0,
static_cast<float>( -originDistance ) );
1259 planePoint = startPoint + linePerp * distance;
1261 clippingPlanes << QVector4D( static_cast<float>( -linePerp.
x() ),
static_cast<float>( -linePerp.
y() ), 0,
static_cast<float>( -originDistance ) );
1264 planePoint = endPoint;
1266 clippingPlanes << QVector4D( static_cast<float>( -lineDirection.
x() ),
static_cast<float>( -lineDirection.
y() ), 0,
static_cast<float>( -originDistance ) );
1269 planePoint = startPoint - linePerp * distance;
1271 clippingPlanes << QVector4D( static_cast<float>( linePerp.
x() ),
static_cast<float>( linePerp.
y() ), 0,
static_cast<float>( -originDistance ) );
1273 return clippingPlanes;
1283 QgsVector linePerpVec( ( endPoint - startPoint ).x(), ( endPoint - startPoint ).y() );
1285 const QgsVector3D linePerpVec3D( linePerpVec.
x(), linePerpVec.
y(), 0 );
1286 QgsVector3D middle( startPoint + ( endPoint - startPoint ) / 2 );
1288 double elevationRangeHalf;
1289 elevationRange.
isInfinite() ? elevationRangeHalf = 0 : elevationRangeHalf = ( elevationRange.
upper() - elevationRange.
lower() ) / 2;
1290 const double side = std::max( middle.
distance( startPoint ), elevationRangeHalf );
1291 const double distance = ( side / std::tan( fieldOfView / 2 * M_PI / 180 ) ) * 1.05;
1299 float yawAngle =
static_cast<float>( acos(
QgsVector3D::dotProduct( linePerpVec3D, northDirectionVec ) ) * 180 / M_PI );
1303 yawAngle = 360 - yawAngle;
1312 auto copy = std::make_unique<Qt3DRender::QCamera>();
1313 copy->setPosition( cam->position() );
1314 copy->setViewCenter( cam->viewCenter() );
1315 copy->setUpVector( cam->upVector() );
1317 switch ( cam->projectionType() )
1319 case Qt3DRender::QCameraLens::OrthographicProjection:
1320 copy->lens()->setOrthographicProjection( cam->left(), cam->right(), cam->bottom(), cam->top(), cam->nearPlane(), cam->farPlane() );
1322 case Qt3DRender::QCameraLens::FrustumProjection:
1323 copy->lens()->setFrustumProjection( cam->left(), cam->right(), cam->bottom(), cam->top(), cam->nearPlane(), cam->farPlane() );
1325 case Qt3DRender::QCameraLens::PerspectiveProjection:
1326 copy->lens()->setPerspectiveProjection( cam->fieldOfView(), cam->aspectRatio(), cam->nearPlane(), cam->farPlane() );
1328 case Qt3DRender::QCameraLens::CustomProjection:
1329 copy->setProjectionMatrix( cam->projectionMatrix() );
1337 texture->setGenerateMipMaps(
true );
1338 texture->setMagnificationFilter( Qt3DRender::QTexture2D::Linear );
1339 texture->setMinificationFilter( Qt3DRender::QTexture2D::LinearMipMapLinear );
1344 texture->setMaximumAnisotropy( 1 );
1347 texture->setMaximumAnisotropy( 2 );
1350 texture->setMaximumAnisotropy( 4 );
1353 texture->setMaximumAnisotropy( 8 );
1356 texture->setMaximumAnisotropy( 16 );
1363 requiresConversionToRgb =
false;
1364 switch ( imageFormat )
1366 case QImage::Format_RGBA32FPx4:
1367 case QImage::Format_RGBA32FPx4_Premultiplied:
1368 return Qt3DRender::QAbstractTexture::RGBA32F;
1370 case QImage::Format_RGBX32FPx4:
1371 return Qt3DRender::QAbstractTexture::RGB32F;
1373 case QImage::Format_RGBA16FPx4:
1374 case QImage::Format_RGBA16FPx4_Premultiplied:
1375 return Qt3DRender::QAbstractTexture::RGBA16F;
1377 case QImage::Format_RGBX16FPx4:
1378 return Qt3DRender::QAbstractTexture::RGB16F;
1380 case QImage::Format_RGBA8888:
1381 case QImage::Format_RGBA8888_Premultiplied:
1382 case QImage::Format_ARGB32:
1383 case QImage::Format_ARGB32_Premultiplied:
1384 return isSrgb ? Qt3DRender::QAbstractTexture::SRGB8_Alpha8 : Qt3DRender::QAbstractTexture::RGBA8_UNorm;
1386 case QImage::Format_RGB32:
1387 case QImage::Format_RGB888:
1388 return isSrgb ? Qt3DRender::QAbstractTexture::SRGB8 : Qt3DRender::QAbstractTexture::RGB8_UNorm;
1390 case QImage::Format_Grayscale8:
1391 case QImage::Format_Alpha8:
1392 return Qt3DRender::QAbstractTexture::R8_UNorm;
1393 case QImage::Format_Grayscale16:
1394 return Qt3DRender::QAbstractTexture::R16_UNorm;
1396 case QImage::Format_Invalid:
1397 case QImage::Format_Mono:
1398 case QImage::Format_MonoLSB:
1399 case QImage::Format_Indexed8:
1400 case QImage::Format_RGB16:
1401 case QImage::Format_ARGB8565_Premultiplied:
1402 case QImage::Format_RGB666:
1403 case QImage::Format_ARGB6666_Premultiplied:
1404 case QImage::Format_RGB555:
1405 case QImage::Format_ARGB8555_Premultiplied:
1406 case QImage::Format_RGB444:
1407 case QImage::Format_ARGB4444_Premultiplied:
1408 case QImage::Format_RGBX8888:
1409 case QImage::Format_BGR30:
1410 case QImage::Format_A2BGR30_Premultiplied:
1411 case QImage::Format_RGB30:
1412 case QImage::Format_A2RGB30_Premultiplied:
1413 case QImage::Format_RGBX64:
1414 case QImage::Format_RGBA64:
1415 case QImage::Format_RGBA64_Premultiplied:
1416 case QImage::Format_BGR888:
1417#if QT_VERSION >= QT_VERSION_CHECK( 6, 8, 0 )
1418 case QImage::Format_CMYK8888:
1420 case QImage::NImageFormats:
1422 requiresConversionToRgb =
true;
1425 return isSrgb ? Qt3DRender::QAbstractTexture::SRGB8_Alpha8 : Qt3DRender::QAbstractTexture::RGBA8_UNorm;
AltitudeClamping
Altitude clamping.
@ Relative
Elevation is relative to terrain height (final elevation = terrain elevation + feature elevation).
@ Terrain
Elevation is clamped to terrain (final elevation = terrain elevation).
@ Absolute
Elevation is taken directly from feature and is independent of terrain height (final elevation = feat...
@ Anisotropic8x
Anisotropic filtering (8x).
@ Anisotropic2x
Anisotropic filtering (2x).
@ Anisotropic4x
Anisotropic filtering (4x).
@ Trilinear
Trilinear (LinearMipmapLinear).
@ Anisotropic16x
Anisotropic filtering (16x).
@ Geocentric
Geocentric CRS.
AltitudeBinding
Altitude binding.
@ Centroid
Clamp just centroid of feature.
@ Vertex
Clamp every vertex of feature.
Holds information about animation in 3D view.
Keyframe interpolate(float time) const
Interpolates camera position and rotation at the given point in time.
float duration() const
Returns duration of the whole animation in seconds.
Keyframes keyFrames() const
Returns keyframes of the animation.
Entity that encapsulates our 3D scene - contains all other entities (such as terrain) as children.
QgsTerrainEntity * terrainEntity() SIP_SKIP
Returns terrain entity (may be nullptr if using globe scene, terrain rendering is disabled or when te...
QgsCameraController * cameraController() const
Returns camera controller.
@ Ready
The scene is fully loaded/updated.
int totalPendingJobsCount() const
Returns number of pending jobs for all chunked entities.
QList< QgsMapLayer * > layers() const SIP_SKIP
Returns the layers that contain chunked entities.
void sceneStateChanged()
Emitted when the scene's state has changed.
SceneState sceneState() const
Returns the current state of the scene.
Qt3DCore::QEntity * layerEntity(QgsMapLayer *layer) const SIP_SKIP
Returns the entity belonging to layer.
QgsGlobeEntity * globeEntity() SIP_SKIP
Returns globe entity (may be nullptr if not using globe scene, terrain rendering is disabled or when ...
QgsVector3D origin() const
Returns coordinates in map CRS at which 3D scene has origin (0,0,0).
Rendering context for preparation of 3D entities.
QgsCoordinateReferenceSystem crs() const
Returns the coordinate reference system used in the 3D scene.
const QgsAbstractTerrainSettings * terrainSettings() const
Returns the terrain settings.
QgsTerrainGenerator * terrainGenerator() const
Returns the terrain generator.
bool terrainRenderingEnabled() const
Returns whether the 2D terrain surface will be rendered.
static const char * PROP_NAME_3D_RENDERER_FLAG
Qt property name to hold the 3D geometry renderer flag.
CullingMode
Triangle culling mode.
@ FrontAndBack
Will not render anything.
@ NoCulling
Will render both front and back faces of triangles.
@ Front
Will render only back faces of triangles.
@ Back
Will render only front faces of triangles (recommended when input data are consistent).
static QgsVector3D transformWorldCoordinates(const QgsVector3D &worldPoint1, const QgsVector3D &origin1, const QgsCoordinateReferenceSystem &crs1, const QgsVector3D &origin2, const QgsCoordinateReferenceSystem &crs2, const QgsCoordinateTransformContext &context)
Transforms a world point from (origin1, crs1) to (origin2, crs2).
static QQuaternion rotationFromPitchHeadingAngles(float pitchAngle, float headingAngle)
Returns rotation quaternion that performs rotation around X axis by pitchAngle, followed by rotation ...
static QByteArray removeDefinesFromShaderCode(const QByteArray &shaderCode, const QStringList &defines)
Removes some define macros from a shader source code.
static Qt3DRender::QCullFace::CullingMode qt3DcullingMode(Qgs3DTypes::CullingMode mode)
Converts Qgs3DTypes::CullingMode mode into its Qt3D equivalent.
static QList< QVector4D > lineSegmentToClippingPlanes(const QgsVector3D &startPoint, const QgsVector3D &endPoint, double distance, const QgsVector3D &origin)
Returns a list of 4 planes derived from a line extending from startPoint to endPoint.
static Qgs3DTypes::CullingMode cullingModeFromString(const QString &str)
Converts a string to a value from CullingMode enum.
static Qgis::AltitudeClamping altClampingFromString(const QString &str)
Converts a string to a value from AltitudeClamping enum.
static QString matrix4x4toString(const QMatrix4x4 &m)
Converts a 4x4 transform matrix to a string.
static QgsRectangle worldToMapExtent(const QgsAABB &bbox, const QgsVector3D &mapOrigin)
Converts axis aligned bounding box in 3D world coordinates to extent in map coordinates.
static void setTextureFiltering(Qt3DRender::QAbstractTexture *texture, const QgsMaterialContext &context)
Sets the default filtering options for a texture.
static QgsRectangle worldToLayerExtent(const QgsAABB &bbox, const QgsCoordinateReferenceSystem &layerCrs, const QgsVector3D &mapOrigin, const QgsCoordinateReferenceSystem &mapCrs, const QgsCoordinateTransformContext &context)
Converts axis aligned bounding box in 3D world coordinates to extent in map layer CRS.
static void pitchAndYawFromViewVector(QVector3D vect, double &pitch, double &yaw)
Function used to extract the pitch and yaw (also known as heading) angles in degrees from the view ve...
static void decomposeTransformMatrix(const QMatrix4x4 &matrix, QVector3D &translation, QQuaternion &rotation, QVector3D &scale)
Tries to decompose a 4x4 transform matrix into translation, rotation and scale components.
static int maxZoomLevel(double tile0width, double tileResolution, double maxError)
Calculates the highest needed zoom level for tiles in quad-tree given width of the base tile (zoom le...
static QgsAABB mapToWorldExtent(const QgsRectangle &extent, double zMin, double zMax, const QgsVector3D &mapOrigin)
Converts map extent to axis aligned bounding box in 3D world coordinates.
static QgsAABB layerToWorldExtent(const QgsRectangle &extent, double zMin, double zMax, const QgsCoordinateReferenceSystem &layerCrs, const QgsVector3D &mapOrigin, const QgsCoordinateReferenceSystem &mapCrs, const QgsCoordinateTransformContext &context)
Converts extent (in map layer's CRS) to axis aligned bounding box in 3D world coordinates.
static Qgis::AltitudeBinding altBindingFromString(const QString &str)
Converts a string to a value from AltitudeBinding enum.
static double calculateEntityGpuMemorySize(Qt3DCore::QEntity *entity)
Calculates approximate usage of GPU memory by an entity.
static std::unique_ptr< Qt3DRender::QCamera > copyCamera(Qt3DRender::QCamera *cam)
Returns new camera object with copied properties.
static void calculateViewSpaceOrthographicBounds(const QVector3D(&worldCorners)[8], const QMatrix4x4 &viewMatrix, float &left, float &right, float &bottom, float &top, float &nearPlane, float &farPlane)
Calculates the orthographic projection bounds required to tightly enclose a set of 8 world-space corn...
static QString cullingModeToString(Qgs3DTypes::CullingMode mode)
Converts a value from CullingMode enum to a string.
static bool isCullable(const QgsAABB &bbox, const QMatrix4x4 &viewProjectionMatrix)
Returns true if bbox is completely outside the current viewing volume.
static QVector2D screenToTextureCoordinates(QVector2D screenXY, QSize winSize)
Converts from screen coordinates to texture coordinates.
static float screenSpaceError(float epsilon, float distance, int screenSize, float fov)
This routine approximately calculates how an error (epsilon) of an object in world coordinates at giv...
static void estimateVectorLayerZRange(QgsVectorLayer *layer, double &zMin, double &zMax)
Try to estimate range of Z values used in the given vector layer and store that in zMin and zMax.
static QgsPoint screenPointToMapCoordinates(const QPoint &screenPoint, QSize size, const QgsCameraController *cameraController, const Qgs3DMapSettings *mapSettings)
Transform the given screen point to QgsPoint in map coordinates.
static QgsPhongMaterialSettings phongMaterialFromQt3DComponent(Qt3DExtras::QPhongMaterial *material)
Returns phong material settings object based on the Qt3D material.
static QString altClampingToString(Qgis::AltitudeClamping altClamp)
Converts a value from AltitudeClamping enum to a string.
static QVector3D calculateDirectionalLightUpVector(const QVector3D &lightDirection)
Calculates an appropriate up vector for a directional light.
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.
static QByteArray addDefinesToShaderCode(const QByteArray &shaderCode, const QStringList &defines)
Inserts some define macros into a shader source code.
static QgsRayCastResult castRay(Qgs3DMapScene *scene, const QgsRay3D &ray, const QgsRayCastContext &context)
Casts a ray through the scene and returns information about the intersecting entities (ray uses World...
static Qt3DRender::QAbstractTexture::TextureFormat determineTextureFormat(QImage::Format format, bool isSrgb, bool &requiresConversionToRgb)
Given a QImage format, returns the most appropriate corresponding texture format.
static QMatrix4x4 stringToMatrix4x4(const QString &str)
Convert a string to a 4x4 transform matrix.
static QgsVector3D worldToMapCoordinates(const QgsVector3D &worldCoords, const QgsVector3D &origin)
Converts 3D world coordinates to map coordinates (applies offset).
static QgsVector3D mapToWorldCoordinates(const QgsVector3D &mapCoords, const QgsVector3D &origin)
Converts map coordinates to 3D world coordinates (applies offset).
static QVector2D textureToScreenCoordinates(QVector2D textureXY, QSize winSize)
Converts from texture coordinates coordinates to screen coordinates.
static void computeBoundingBoxNearFarPlanes(const QgsAABB &bbox, const QMatrix4x4 &viewMatrix, float &fnear, float &ffar)
This routine computes nearPlane farPlane from the closest and farthest corners point of bounding box ...
static bool exportAnimation(const Qgs3DAnimationSettings &animationSettings, Qgs3DMapSettings &mapSettings, int framesPerSecond, const QString &outputDirectory, const QString &fileNameTemplate, const QSize &outputSize, QString &error, QgsFeedback *feedback=nullptr)
Captures 3D animation frames to the selected folder.
static QVector3D screenPointToWorldPos(const QPoint &screenPoint, double depth, const QSize &screenSize, Qt3DRender::QCamera *camera)
Converts the clicked mouse position to the corresponding 3D world coordinates.
static void waitForFrame(QgsAbstract3DEngine &engine, Qgs3DMapScene *scene)
Waits for a frame to be rendered.
static float clampAltitude(const QgsPoint &p, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, float offset, const QgsPoint ¢roid, const Qgs3DRenderContext &context)
Clamps altitude of a vertex according to the settings, returns Z value.
static QString altBindingToString(Qgis::AltitudeBinding altBind)
Converts a value from AltitudeBinding enum to a string.
static void clampAltitudes(QgsLineString *lineString, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, const QgsPoint ¢roid, float offset, const Qgs3DRenderContext &context)
Clamps altitude of vertices of a linestring according to the settings.
static std::vector< float > calculateCascadeSplits(int numberCascades, float nearPlane, float farPlane, float lambda=0.9f)
Calculates the split distances for cascading shadow maps using the "Practical Split Scheme".
static QgsRay3D rayFromScreenPoint(const QPoint &point, const QSize &windowSize, Qt3DRender::QCamera *camera)
Convert from clicked point on the screen to a ray in world coordinates.
static QImage captureSceneImage(QgsAbstract3DEngine &engine, Qgs3DMapScene *scene)
Captures image of the current 3D scene of a 3D engine.
static QColor srgbToLinear(const QColor &color)
Converts a SRGB color to a linear color.
static QgsCameraPose lineSegmentToCameraPose(const QgsVector3D &startPoint, const QgsVector3D &endPoint, const QgsDoubleRange &elevationRange, float fieldOfView, const QgsVector3D &worldOrigin)
Returns the camera pose for a camera looking at mid-point between startPoint and endPoint.
static QMatrix4x4 axisTransformMatrix(const QString &upAxis, const QString &forwardAxis)
Computes a 3x3 orientation matrix from the given up and forward axis strings.
static void waitForEntitiesLoaded(Qgs3DMapScene *scene)
Waits for all entities in the scene to be loaded.
static std::unique_ptr< QgsPointCloudLayer3DRenderer > convert2DPointCloudRendererTo3D(QgsPointCloudRenderer *renderer)
Creates a QgsPointCloudLayer3DRenderer matching the symbol settings of a given QgsPointCloudRenderer.
static void calculateFrustumSliceCorners(float zNear, float zFar, float fov, float aspectRatio, const QMatrix4x4 &invertedCameraView, QVector3D(&corners)[8], QVector3D ¢er)
Calculates the 8 corners of a camera frustum slice in world space and its center point.
static void extractPointPositions(const QgsFeature &f, const Qgs3DRenderContext &context, const QgsVector3D &chunkOrigin, Qgis::AltitudeClamping altClamp, QVector< QVector3D > &positions)
Calculates (x,y,z) positions of (multi)point from the given feature.
static QImage captureSceneDepthBuffer(QgsAbstract3DEngine &engine, Qgs3DMapScene *scene)
Captures the depth buffer of the current 3D scene of a 3D engine.
static int openGlMaxClipPlanes(QSurface *surface)
Gets the maximum number of clip planes that can be used.
Axis-aligned bounding box - in world coords.
Base class for 3D engine implementation.
void requestCaptureImage()
Starts a request for an image rendered by the engine.
void requestDepthBufferCapture()
Starts a request for an image containing the depth buffer data of the engine.
void imageCaptured(const QImage &image)
Emitted after a call to requestCaptureImage() to return the captured image.
void depthBufferCaptured(const QImage &image)
Emitted after a call to requestDepthBufferCapture() to return the captured depth buffer.
virtual Qt3DRender::QRenderSettings * renderSettings()=0
Returns access to the engine's render settings (the frame graph can be accessed from here).
Abstract base class for all geometries.
vertex_iterator vertices_end() const
Returns STL-style iterator pointing to the imaginary vertex after the last vertex of the geometry.
bool is3D() const
Returns true if the geometry is 3D and contains a z-value.
vertex_iterator vertices_begin() const
Returns STL-style iterator pointing to the first vertex of the geometry.
virtual QgsPoint centroid() const
Returns the centroid of the geometry.
double verticalScale() const
Returns the vertical scale (exaggeration) for terrain.
A 3-dimensional box composed of x, y, z coordinates.
double yMaximum() const
Returns the maximum y value.
double xMinimum() const
Returns the minimum x value.
double zMaximum() const
Returns the maximum z value.
double xMaximum() const
Returns the maximum x value.
double zMinimum() const
Returns the minimum z value.
double yMinimum() const
Returns the minimum y value.
Object that controls camera movement based on user input.
void setLookingAtMapPoint(const QgsVector3D &point, float distance, float pitch, float yaw)
Sets camera configuration like setLookingAtPoint(), but the point is given in map coordinates.
Qt3DRender::QCamera * camera() const
Returns camera that is being controlled.
Encapsulates camera pose in a 3D scene.
void setPitchAngle(float pitch)
Sets pitch angle in degrees.
void setCenterPoint(const QgsVector3D &point)
Sets center point (towards which point the camera is looking).
void setHeadingAngle(float heading)
Sets heading (yaw) angle in degrees.
void setDistanceFromCenterPoint(float distance)
Sets distance of the camera from the center point.
3D symbol that draws point cloud geometries as 3D objects using classification of the dataset.
void setCategoriesList(const QgsPointCloudCategoryList &categories)
Sets the list of categories of the classification.
void setAttribute(const QString &attribute)
Sets the attribute used to select the color of the point cloud.
3D symbol that draws point cloud geometries as 3D objects using color ramp shader.
void setAttribute(const QString &attribute)
Sets the attribute used to select the color of the point cloud.
void setColorRampShaderMinMax(double min, double max)
Sets the minimum and maximum values used when classifying colors in the color ramp shader.
void setColorRampShader(const QgsColorRampShader &colorRampShader)
Sets the color ramp shader used to render the point cloud.
Handles contrast enhancement and clipping.
Represents a coordinate reference system (CRS).
Qgis::CrsType type() const
Returns the type of the CRS.
Contains information about the context in which a coordinate transform is executed.
Custom exception class for Coordinate Reference System related exceptions.
int numInteriorRings() const
Returns the number of interior rings contained with the curve polygon.
bool addZValue(double zValue=0) override
Adds a z-dimension to the geometry, initialized to a preset value.
const QgsCurve * exteriorRing() const
Returns the curve polygon's exterior ring.
const QgsCurve * interiorRing(int i) const
Retrieves an interior ring from the curve polygon.
Abstract base class for curved geometry type.
QgsRange which stores a range of double values.
bool isInfinite() const
Returns true if the range consists of all possible values.
Wrapper for iterator of features from vector data provider or vector layer.
bool nextFeature(QgsFeature &f)
Fetch next feature and stores in f, returns true on success.
Wraps a request for features to a vector layer (or directly its vector data provider).
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Base class for feedback objects to be used for cancellation of something running in a worker thread.
bool isCanceled() const
Tells whether the operation has been canceled already.
void setProgress(double progress)
Sets the current progress for the feedback object.
A geometry is the spatial representation of a feature.
const QgsAbstractGeometry * constGet() const
Returns a non-modifiable (const) reference to the underlying abstract geometry primitive.
QgsAbstractGeometry::vertex_iterator vertices_begin() const
Returns STL-style iterator pointing to the first vertex of the geometry.
QgsAbstractGeometry::vertex_iterator vertices_end() const
Returns STL-style iterator pointing to the imaginary vertex after the last vertex of the geometry.
Line string geometry type, with support for z-dimension and m-values.
Base class for all map layer types.
Context settings for a material.
Qgis::TextureFilterQuality textureFilterQuality() const
Returns the texture filtering quality.
Off-screen 3D engine implementation.
void setSize(QSize s) override
Sets the size of the rendering area (in pixels).
void setRootEntity(Qt3DCore::QEntity *root) override
Sets root entity of the 3D scene.
Qt3DRender::QRenderSettings * renderSettings() override
Returns access to the engine's render settings (the frame graph can be accessed from here).
Basic shading material used for rendering based on the Phong shading model with three color component...
void setDiffuse(const QColor &diffuse)
Sets diffuse color component.
void setShininess(double shininess)
Sets shininess of the surface.
void setAmbient(const QColor &ambient)
Sets ambient color component.
void setSpecular(const QColor &specular)
Sets specular color component.
An RGB renderer for 2d visualisation of point clouds using embedded red, green and blue attributes.
double maximum() const
Returns the maximum value for attributes which will be used by the color ramp shader.
QgsColorRampShader colorRampShader() const
Returns the color ramp shader function used to visualize the attribute.
double minimum() const
Returns the minimum value for attributes which will be used by the color ramp shader.
QString attribute() const
Returns the attribute to use for the renderer.
Renders point clouds by a classification attribute.
QString attribute() const
Returns the attribute to use for the renderer.
QgsPointCloudCategoryList categories() const
Returns the classification categories used for rendering.
Abstract base class for 2d point cloud renderers.
virtual QString type() const =0
Returns the identifier of the renderer type.
An RGB renderer for 2d visualisation of point clouds using embedded red, green and blue attributes.
QString redAttribute() const
Returns the attribute to use for the red channel.
QString greenAttribute() const
Returns the attribute to use for the green channel.
const QgsContrastEnhancement * greenContrastEnhancement() const
Returns the contrast enhancement to use for the green channel.
QString blueAttribute() const
Returns the attribute to use for the blue channel.
const QgsContrastEnhancement * blueContrastEnhancement() const
Returns the contrast enhancement to use for the blue channel.
const QgsContrastEnhancement * redContrastEnhancement() const
Returns the contrast enhancement to use for the red channel.
void setY(double y)
Sets the y value of the point.
void set(double x, double y)
Sets the x and y value of the point.
void setX(double x)
Sets the x value of the point.
Point geometry type, with support for z-dimension and m-values.
T lower() const
Returns the lower bound of the range.
T upper() const
Returns the upper bound of the range.
A representation of a ray in 3D.
QVector3D point(float distance) const
Returns the point along the ray with the specified distance from the ray's origin.
Responsible for defining parameters of the ray casting operations in 3D map canvases.
Contains the results of ray casting operations in a 3D map canvas.
void addLayerHits(QgsMapLayer *layer, const QList< QgsRayCastHit > &hits)
Adds all hits from layer to the result.
void addTerrainHits(const QList< QgsRayCastHit > &hits)
Adds all terrain hits to the result.
A rectangle specified with double values.
Q_INVOKABLE QString toString(int precision=16) const
Returns a string representation of form xmin,ymin : xmax,ymax Coordinates will be rounded to the spec...
3D symbol that draws point cloud geometries as 3D objects using RGB colors in the dataset.
void setBlueAttribute(const QString &attribute)
Sets the attribute to use for the blue channel.
void setGreenContrastEnhancement(QgsContrastEnhancement *enhancement SIP_TRANSFER)
Sets the contrast enhancement to use for the green channel.
void setGreenAttribute(const QString &attribute)
Sets the attribute to use for the green channel.
void setBlueContrastEnhancement(QgsContrastEnhancement *enhancement SIP_TRANSFER)
Sets the contrast enhancement to use for the blue channel.
void setRedContrastEnhancement(QgsContrastEnhancement *enhancement SIP_TRANSFER)
Sets the contrast enhancement to use for the red channel.
void setRedAttribute(const QString &attribute)
Sets the attribute to use for the red channel.
double yAt(int index) const override
Returns the y-coordinate of the specified node in the line string.
void setZAt(int index, double z)
Sets the z-coordinate of the specified node in the simple curve.
int nCoordinates() const override
Returns the number of nodes contained in the geometry.
double xAt(int index) const override
Returns the x-coordinate of the specified node in the line string.
double zAt(int index) const override
Returns the z-coordinate of the specified node in the simple curve.
virtual float heightAt(double x, double y, const Qgs3DRenderContext &context) const =0
Returns height at (x,y) in map's CRS.
A 3D vector (similar to QVector3D) with the difference that it uses double precision instead of singl...
double y() const
Returns Y coordinate.
double z() const
Returns Z coordinate.
void setZ(double z)
Sets Z coordinate.
double distance(const QgsVector3D &other) const
Returns the distance with the other QgsVector3D.
static double dotProduct(const QgsVector3D &v1, const QgsVector3D &v2)
Returns the dot product of two vectors.
double x() const
Returns X coordinate.
void normalize()
Normalizes the current vector in place.
static QgsVector3D crossProduct(const QgsVector3D &v1, const QgsVector3D &v2)
Returns the cross product of two vectors.
void set(double x, double y, double z)
Sets vector coordinates.
Represents a vector layer which manages a vector based dataset.
Q_INVOKABLE Qgis::WkbType wkbType() const final
Returns the WKBType or WKBUnknown in case of error.
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest()) const final
Queries the layer for features specified in request.
Represent a 2-dimensional vector.
double y() const
Returns the vector's y-component.
QgsVector normalized() const
Returns the vector's normalized (or "unit") vector (ie same angle but length of 1....
QgsVector perpVector() const
Returns the perpendicular vector to this vector (rotated 90 degrees counter-clockwise).
double x() const
Returns the vector's x-component.
static Q_INVOKABLE bool hasZ(Qgis::WkbType type)
Tests whether a WKB type contains the z-dimension.
#define BUILTIN_UNREACHABLE
float srgbFloatToLinear(float srgb)
T qgsgeometry_cast(QgsAbstractGeometry *geom)
#define QgsDebugMsgLevel(str, level)
#define QgsDebugError(str)
float pitch
Tilt of the camera in degrees (0 = looking from the top, 90 = looking from the side,...
float yaw
Horizontal rotation around the focal point in degrees.
QgsVector3D point
Point towards which the camera is looking in 3D map coords.
float dist
Distance of the camera from the focal point.