41#define TINYGLTF_NO_STB_IMAGE
42#define TINYGLTF_NO_STB_IMAGE_WRITE
47 , mLayerName( layer->name() )
49 , mEnableProfile( context.flags() &
Qgis::RenderContextFlag::RecordProfile )
67 mRenderTileBorders = mRenderer->isTileBorderRenderingEnabled();
71 mPreparationTime = timer.elapsed();
81 std::unique_ptr< QgsScopedRuntimeProfile > profile;
84 profile = std::make_unique< QgsScopedRuntimeProfile >( mLayerName, QStringLiteral(
"rendering" ),
layerId() );
85 if ( mPreparationTime > 0 )
89 std::unique_ptr< QgsScopedRuntimeProfile > preparingProfile;
92 preparingProfile = std::make_unique< QgsScopedRuntimeProfile >( QObject::tr(
"Preparing render" ), QStringLiteral(
"rendering" ) );
99 QPainter *painter = rc->
painter();
104 if ( !mClippingRegions.empty() )
106 bool needsPainterClipPath =
false;
108 if ( needsPainterClipPath )
109 rc->
painter()->setClipPath( path, Qt::IntersectClip );
112 mElapsedTimer.start();
116 mRenderer->startRender( context );
118 preparingProfile.reset();
119 std::unique_ptr< QgsScopedRuntimeProfile > renderingProfile;
120 if ( mEnableProfile )
122 renderingProfile = std::make_unique< QgsScopedRuntimeProfile >( QObject::tr(
"Rendering" ), QStringLiteral(
"rendering" ) );
125 const bool result = renderTiles( context );
126 mRenderer->stopRender( context );
153 const double maximumErrorPixels = context->
convertToPainterUnits( mRenderer->maximumScreenError(), mRenderer->maximumScreenErrorUnit() );
155 const double mapYCenter = 0.5 * ( mapExtent.
yMinimum() + mapExtent.
yMaximum() );
160 const double mapMetersPerPixel = mapWidthMeters / context->
outputSize().width();
161 const double maximumErrorInMeters = maximumErrorPixels * mapMetersPerPixel;
167 const QVector< QgsVector3D > corners =
QgsBox3D( mapExtent, -10000, 10000 ).
corners();
174 for (
int i = 0; i < 8; ++i )
177 x.append( corner.
x() );
178 y.append( corner.
y() );
179 z.append( corner.
z() );
183 const auto minMaxX = std::minmax_element( x.constBegin(), x.constEnd() );
184 const auto minMaxY = std::minmax_element( y.constBegin(), y.constEnd() );
185 const auto minMaxZ = std::minmax_element( z.constBegin(), z.constEnd() );
198 auto tileIsVisibleInMap = [mapExtent,
this](
const QgsTiledSceneTile & tile )->
bool
204 const QgsGeometry tileGeometry( tile.boundingVolume().as2DGeometry( mSceneToMapTransform ) );
205 return tileGeometry.intersects( mapExtent );
209 QVector< long long > tileIds = mIndex.
getTiles( request );
210 while ( !tileIds.empty() )
215 const long long tileId = tileIds.first();
219 if ( !tile.
isValid() || !tileIsVisibleInMap( tile ) )
227 renderTile( tile, context );
236 const QVector< long long > newTileIdsToRender = mIndex.
getTiles( request );
237 tileIds.append( newTileIdsToRender );
248 renderTile( tile, context );
262 std::sort( mPrimitiveData.begin(), mPrimitiveData.end(), [](
const PrimitiveData & a,
const PrimitiveData & b )
265 if ( qgsDoubleNear( a.z, b.z, 0.001 ) )
268 if ( a.type == PrimitiveType::Line )
270 else if ( b.type == PrimitiveType::Line )
275 for (
const PrimitiveData &data : std::as_const( mPrimitiveData ) )
279 case PrimitiveType::Line:
280 mRenderer->renderLine( context, data.coordinates );
283 case PrimitiveType::Triangle:
288 data.textureCoords[2], data.textureCoords[3],
289 data.textureCoords[4], data.textureCoords[5] );
291 mRenderer->renderTriangle( context, data.coordinates );
296 if ( mRenderTileBorders )
298 QPainter *painter = renderContext()->painter();
299 for (
const TileDetails &tile : std::as_const( mTileDetails ) )
303 if ( tile.hasContent )
305 brush = QBrush( QColor( 0, 0, 255, 10 ) );
306 pen = QPen( QColor( 0, 0, 255, 150 ) );
310 brush = QBrush( QColor( 255, 0, 255, 10 ) );
311 pen = QPen( QColor( 255, 0, 255, 150 ) );
314 painter->setPen( pen );
315 painter->setBrush( brush );
316 painter->drawPolygon( tile.boundary );
319 format.
setColor( QColor( 255, 0, 0 ) );
322 QgsTextRenderer::drawText( QRectF( QPoint( 0, 0 ), renderContext()->outputSize() ).intersected( tile.boundary.boundingRect() ),
334 const bool hasContent = renderTileContent( tile, context );
336 if ( mRenderTileBorders )
341 std::unique_ptr< QgsAbstractGeometry > volumeGeometry( volume.
as2DGeometry( mSceneToMapTransform ) );
342 if (
QgsCurvePolygon *polygon = qgsgeometry_cast< QgsCurvePolygon * >( volumeGeometry.get() ) )
344 QPolygonF volumePolygon = polygon->exteriorRing()->asQPolygonF( );
347 volumePolygon.erase( std::remove_if( volumePolygon.begin(), volumePolygon.end(),
348 [](
const QPointF point )
350 return !std::isfinite( point.x() ) || !std::isfinite( point.y() );
351 } ), volumePolygon.end() );
353 QPointF *ptr = volumePolygon.data();
354 for (
int i = 0; i < volumePolygon.size(); ++i, ++ptr )
360 details.boundary = volumePolygon;
361 details.hasContent = hasContent;
362 details.id = QString::number( tile.
id() );
363 mTileDetails.append( details );
368 QgsDebugError( QStringLiteral(
"Error transforming bounding volume" ) );
375 const QString contentUri = tile.
resources().value( QStringLiteral(
"content" ) ).toString();
376 if ( contentUri.isEmpty() )
384 tinygltf::Model model;
388 const auto &format = tile.
metadata().value( QStringLiteral(
"contentFormat" ) ).value<QString>();
389 if ( format == QLatin1String(
"quantizedmesh" ) )
394 qmTile.removeDegenerateTriangles();
395 model = qmTile.toGltf();
399 QgsDebugError( QStringLiteral(
"Failed to parse tile from '%1'" ).arg( contentUri ) );
403 else if ( format == QLatin1String(
"cesiumtiles" ) )
406 if ( content.
gltf.isEmpty() )
413 QString gltfWarnings;
414 const bool res = QgsGltfUtils::loadGltfModel( content.
gltf, model,
415 &gltfErrors, &gltfWarnings );
416 if ( !gltfErrors.isEmpty() )
418 if ( !
mErrors.contains( gltfErrors ) )
420 QgsDebugError( QStringLiteral(
"Error raised reading %1: %2" )
421 .arg( contentUri, gltfErrors ) );
423 if ( !gltfWarnings.isEmpty() )
425 QgsDebugError( QStringLiteral(
"Warnings raised reading %1: %2" )
426 .arg( contentUri, gltfWarnings ) );
428 if ( !res )
return false;
435 QgsGltfUtils::extractTileTranslation(
438 .value( QStringLiteral(
"gltfUpAxis" ),
442 bool sceneOk =
false;
443 const std::size_t sceneIndex =
444 QgsGltfUtils::sourceSceneForModel( model, sceneOk );
447 const QString error = QObject::tr(
"No scenes found in model" );
450 QStringLiteral(
"Error raised reading %1: %2" ).arg( contentUri, error ) );
454 const tinygltf::Scene &scene = model.scenes[sceneIndex];
456 std::function< void(
int nodeIndex,
const QMatrix4x4 &transform ) > traverseNode;
457 traverseNode = [&model, &context, &tileTranslationEcef, &tile, &contentUri, &traverseNode,
this](
int nodeIndex,
const QMatrix4x4 & parentTransform )
459 const tinygltf::Node &gltfNode = model.nodes[nodeIndex];
460 std::unique_ptr< QMatrix4x4 > gltfLocalTransform = QgsGltfUtils::parseNodeTransform( gltfNode );
462 if ( !parentTransform.isIdentity() )
464 if ( gltfLocalTransform )
465 *gltfLocalTransform = parentTransform * *gltfLocalTransform;
468 gltfLocalTransform.reset(
new QMatrix4x4( parentTransform ) );
472 if ( gltfNode.mesh >= 0 )
474 const tinygltf::Mesh &mesh = model.meshes[gltfNode.mesh];
476 for (
const tinygltf::Primitive &primitive : mesh.primitives )
478 if ( context.renderContext().renderingStopped() )
481 renderPrimitive( model, primitive, tile, tileTranslationEcef, gltfLocalTransform.get(), contentUri, context );
485 for (
int childNode : gltfNode.children )
487 traverseNode( childNode, gltfLocalTransform ? *gltfLocalTransform : QMatrix4x4() );
491 for (
int nodeIndex : scene.nodes )
493 traverseNode( nodeIndex, QMatrix4x4() );
499void QgsTiledSceneLayerRenderer::renderPrimitive(
const tinygltf::Model &model,
const tinygltf::Primitive &primitive,
const QgsTiledSceneTile &tile,
const QgsVector3D &tileTranslationEcef,
const QMatrix4x4 *gltfLocalTransform,
const QString &contentUri,
QgsTiledSceneRenderContext &context )
501 switch ( primitive.mode )
503 case TINYGLTF_MODE_TRIANGLES:
505 renderTrianglePrimitive( model, primitive, tile, tileTranslationEcef, gltfLocalTransform, contentUri, context );
508 case TINYGLTF_MODE_LINE:
510 renderLinePrimitive( model, primitive, tile, tileTranslationEcef, gltfLocalTransform, contentUri, context );
513 case TINYGLTF_MODE_POINTS:
514 if ( !mWarnedPrimitiveTypes.contains( TINYGLTF_MODE_POINTS ) )
516 mErrors << QObject::tr(
"Point objects in tiled scenes are not supported" );
517 mWarnedPrimitiveTypes.insert( TINYGLTF_MODE_POINTS );
521 case TINYGLTF_MODE_LINE_LOOP:
522 if ( !mWarnedPrimitiveTypes.contains( TINYGLTF_MODE_LINE_LOOP ) )
524 mErrors << QObject::tr(
"Line loops in tiled scenes are not supported" );
525 mWarnedPrimitiveTypes.insert( TINYGLTF_MODE_LINE_LOOP );
529 case TINYGLTF_MODE_LINE_STRIP:
530 if ( !mWarnedPrimitiveTypes.contains( TINYGLTF_MODE_LINE_STRIP ) )
532 mErrors << QObject::tr(
"Line strips in tiled scenes are not supported" );
533 mWarnedPrimitiveTypes.insert( TINYGLTF_MODE_LINE_STRIP );
537 case TINYGLTF_MODE_TRIANGLE_STRIP:
538 if ( !mWarnedPrimitiveTypes.contains( TINYGLTF_MODE_TRIANGLE_STRIP ) )
540 mErrors << QObject::tr(
"Triangular strips in tiled scenes are not supported" );
541 mWarnedPrimitiveTypes.insert( TINYGLTF_MODE_TRIANGLE_STRIP );
545 case TINYGLTF_MODE_TRIANGLE_FAN:
546 if ( !mWarnedPrimitiveTypes.contains( TINYGLTF_MODE_TRIANGLE_FAN ) )
548 mErrors << QObject::tr(
"Triangular fans in tiled scenes are not supported" );
549 mWarnedPrimitiveTypes.insert( TINYGLTF_MODE_TRIANGLE_FAN );
554 if ( !mWarnedPrimitiveTypes.contains( primitive.mode ) )
556 mErrors << QObject::tr(
"Primitive type %1 in tiled scenes are not supported" ).arg( primitive.mode );
557 mWarnedPrimitiveTypes.insert( primitive.mode );
563void QgsTiledSceneLayerRenderer::renderTrianglePrimitive(
const tinygltf::Model &model,
const tinygltf::Primitive &primitive,
const QgsTiledSceneTile &tile,
const QgsVector3D &tileTranslationEcef,
const QMatrix4x4 *gltfLocalTransform,
const QString &contentUri,
QgsTiledSceneRenderContext &context )
565 auto posIt = primitive.attributes.find(
"POSITION" );
566 if ( posIt == primitive.attributes.end() )
568 mErrors << QObject::tr(
"Could not find POSITION attribute for primitive" );
571 int positionAccessorIndex = posIt->second;
576 QgsGltfUtils::accessorToMapCoordinates(
578 &mSceneToMapTransform,
581 static_cast<
Qgis::Axis >( tile.metadata().value( QStringLiteral(
"gltfUpAxis" ), static_cast< int >(
Qgis::Axis::Y ) ).toInt() ),
590 QVector< float > texturePointX;
591 QVector< float > texturePointY;
592 QPair< int, int > textureId{ -1, -1 };
593 if ( needsTextures && primitive.material != -1 )
595 const tinygltf::Material &material = model.materials[primitive.material];
596 const tinygltf::PbrMetallicRoughness &pbr = material.pbrMetallicRoughness;
598 if ( pbr.baseColorTexture.index >= 0
599 &&
static_cast< int >( model.textures.size() ) > pbr.baseColorTexture.index )
601 const tinygltf::Texture &tex = model.textures[pbr.baseColorTexture.index];
603 switch ( QgsGltfUtils::imageResourceType( model, tex.source ) )
605 case QgsGltfUtils::ResourceType::Embedded:
606 textureImage = QgsGltfUtils::extractEmbeddedImage( model, tex.source );
609 case QgsGltfUtils::ResourceType::Linked:
611 const QString linkedPath = QgsGltfUtils::linkedImagePath( model, tex.source );
612 const QString textureUri = QUrl( contentUri ).resolved( linkedPath ).toString();
614 if ( !rep.isEmpty() )
616 textureImage = QImage::fromData( rep );
622 if ( !textureImage.isNull() )
624 auto texIt = primitive.attributes.find(
"TEXCOORD_0" );
625 if ( texIt != primitive.attributes.end() )
627 QgsGltfUtils::extractTextureCoordinates(
628 model, texIt->second, texturePointX, texturePointY
632 textureId = qMakePair( mCurrentModelId, pbr.baseColorTexture.index );
643 auto needTriangle = [&outputRect](
const QPolygonF & triangle ) ->
bool
645 return triangle.boundingRect().intersects( outputRect );
648 const bool useTexture = !textureImage.isNull();
649 bool hasStoredTexture =
false;
651 QVector< PrimitiveData > thisTileTriangleData;
653 if ( primitive.indices == -1 )
655 Q_ASSERT( x.size() % 3 == 0 );
657 thisTileTriangleData.reserve( x.size() );
658 for (
int i = 0; i < x.size(); i += 3 )
664 data.type = PrimitiveType::Triangle;
665 data.textureId = textureId;
668 data.textureCoords[0] = texturePointX[i];
669 data.textureCoords[1] = texturePointY[i];
670 data.textureCoords[2] = texturePointX[i + 1];
671 data.textureCoords[3] = texturePointY[i + 1];
672 data.textureCoords[4] = texturePointX[i + 2];
673 data.textureCoords[5] = texturePointY[i + 2];
675 data.coordinates = QVector<QPointF> { QPointF( x[i], y[i] ), QPointF( x[i + 1], y[i + 1] ), QPointF( x[i + 2], y[i + 2] ), QPointF( x[i], y[i] ) };
676 data.z = ( z[i] + z[i + 1] + z[i + 2] ) / 3;
677 if ( needTriangle( data.coordinates ) )
679 thisTileTriangleData.push_back( data );
680 if ( !hasStoredTexture && !textureImage.isNull() )
683 mTextures.insert( textureId, textureImage.copy() );
684 hasStoredTexture =
true;
691 const tinygltf::Accessor &primitiveAccessor = model.accessors[primitive.indices];
692 const tinygltf::BufferView &bvPrimitive = model.bufferViews[primitiveAccessor.bufferView];
693 const tinygltf::Buffer &bPrimitive = model.buffers[bvPrimitive.buffer];
695 Q_ASSERT( ( primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT
696 || primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT
697 || primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE )
698 && primitiveAccessor.type == TINYGLTF_TYPE_SCALAR );
700 const char *primitivePtr =
reinterpret_cast< const char *
>( bPrimitive.data.data() ) + bvPrimitive.byteOffset + primitiveAccessor.byteOffset;
702 thisTileTriangleData.reserve( primitiveAccessor.count / 3 );
703 for ( std::size_t i = 0; i < primitiveAccessor.count / 3; i++ )
708 unsigned int index1 = 0;
709 unsigned int index2 = 0;
710 unsigned int index3 = 0;
713 data.type = PrimitiveType::Triangle;
714 data.textureId = textureId;
716 if ( primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT )
718 const unsigned short *usPtrPrimitive =
reinterpret_cast< const unsigned short *
>( primitivePtr );
719 if ( bvPrimitive.byteStride )
720 primitivePtr += bvPrimitive.byteStride;
722 primitivePtr += 3 *
sizeof(
unsigned short );
724 index1 = usPtrPrimitive[0];
725 index2 = usPtrPrimitive[1];
726 index3 = usPtrPrimitive[2];
728 else if ( primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE )
730 const unsigned char *usPtrPrimitive =
reinterpret_cast< const unsigned char *
>( primitivePtr );
731 if ( bvPrimitive.byteStride )
732 primitivePtr += bvPrimitive.byteStride;
734 primitivePtr += 3 *
sizeof(
unsigned char );
736 index1 = usPtrPrimitive[0];
737 index2 = usPtrPrimitive[1];
738 index3 = usPtrPrimitive[2];
742 const unsigned int *uintPtrPrimitive =
reinterpret_cast< const unsigned int *
>( primitivePtr );
743 if ( bvPrimitive.byteStride )
744 primitivePtr += bvPrimitive.byteStride;
746 primitivePtr += 3 *
sizeof(
unsigned int );
748 index1 = uintPtrPrimitive[0];
749 index2 = uintPtrPrimitive[1];
750 index3 = uintPtrPrimitive[2];
755 data.textureCoords[0] = texturePointX[index1];
756 data.textureCoords[1] = texturePointY[index1];
757 data.textureCoords[2] = texturePointX[index2];
758 data.textureCoords[3] = texturePointY[index2];
759 data.textureCoords[4] = texturePointX[index3];
760 data.textureCoords[5] = texturePointY[index3];
763 data.coordinates = { QVector<QPointF>{ QPointF( x[index1], y[index1] ), QPointF( x[index2], y[index2] ), QPointF( x[index3], y[index3] ), QPointF( x[index1], y[index1] ) } };
764 data.z = ( z[index1] + z[index2] + z[index3] ) / 3;
765 if ( needTriangle( data.coordinates ) )
767 thisTileTriangleData.push_back( data );
768 if ( !hasStoredTexture && !textureImage.isNull() )
771 mTextures.insert( textureId, textureImage.copy() );
772 hasStoredTexture =
true;
785 std::sort( thisTileTriangleData.begin(), thisTileTriangleData.end(), [](
const PrimitiveData & a,
const PrimitiveData & b )
790 for (
const PrimitiveData &data : std::as_const( thisTileTriangleData ) )
792 if ( useTexture && data.textureId.first >= 0 )
796 data.textureCoords[2], data.textureCoords[3],
797 data.textureCoords[4], data.textureCoords[5] );
799 mRenderer->renderTriangle( context, data.coordinates );
804 mPrimitiveData.append( thisTileTriangleData );
815void QgsTiledSceneLayerRenderer::renderLinePrimitive(
const tinygltf::Model &model,
const tinygltf::Primitive &primitive,
const QgsTiledSceneTile &tile,
const QgsVector3D &tileTranslationEcef,
const QMatrix4x4 *gltfLocalTransform,
const QString &,
QgsTiledSceneRenderContext &context )
817 auto posIt = primitive.attributes.find(
"POSITION" );
818 if ( posIt == primitive.attributes.end() )
820 mErrors << QObject::tr(
"Could not find POSITION attribute for primitive" );
823 int positionAccessorIndex = posIt->second;
828 QgsGltfUtils::accessorToMapCoordinates(
830 &mSceneToMapTransform,
833 static_cast<
Qgis::Axis >( tile.metadata().value( QStringLiteral(
"gltfUpAxis" ), static_cast< int >(
Qgis::Axis::Y ) ).toInt() ),
840 auto needLine = [&outputRect](
const QPolygonF & line ) ->
bool
842 return line.boundingRect().intersects( outputRect );
845 QVector< PrimitiveData > thisTileLineData;
847 if ( primitive.indices == -1 )
849 Q_ASSERT( x.size() % 2 == 0 );
851 thisTileLineData.reserve( x.size() );
852 for (
int i = 0; i < x.size(); i += 2 )
858 data.type = PrimitiveType::Line;
859 data.coordinates = QVector<QPointF> { QPointF( x[i], y[i] ), QPointF( x[i + 1], y[i + 1] ) };
861 data.z = std::max( z[i], z[i + 1] );
862 if ( needLine( data.coordinates ) )
864 thisTileLineData.push_back( data );
870 const tinygltf::Accessor &primitiveAccessor = model.accessors[primitive.indices];
871 const tinygltf::BufferView &bvPrimitive = model.bufferViews[primitiveAccessor.bufferView];
872 const tinygltf::Buffer &bPrimitive = model.buffers[bvPrimitive.buffer];
874 Q_ASSERT( ( primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT
875 || primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT
876 || primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE )
877 && primitiveAccessor.type == TINYGLTF_TYPE_SCALAR );
879 const char *primitivePtr =
reinterpret_cast< const char *
>( bPrimitive.data.data() ) + bvPrimitive.byteOffset + primitiveAccessor.byteOffset;
881 thisTileLineData.reserve( primitiveAccessor.count / 2 );
882 for ( std::size_t i = 0; i < primitiveAccessor.count / 2; i++ )
887 unsigned int index1 = 0;
888 unsigned int index2 = 0;
891 data.type = PrimitiveType::Line;
893 if ( primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT )
895 const unsigned short *usPtrPrimitive =
reinterpret_cast< const unsigned short *
>( primitivePtr );
896 if ( bvPrimitive.byteStride )
897 primitivePtr += bvPrimitive.byteStride;
899 primitivePtr += 2 *
sizeof(
unsigned short );
901 index1 = usPtrPrimitive[0];
902 index2 = usPtrPrimitive[1];
904 else if ( primitiveAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE )
906 const unsigned char *usPtrPrimitive =
reinterpret_cast< const unsigned char *
>( primitivePtr );
907 if ( bvPrimitive.byteStride )
908 primitivePtr += bvPrimitive.byteStride;
910 primitivePtr += 2 *
sizeof(
unsigned char );
912 index1 = usPtrPrimitive[0];
913 index2 = usPtrPrimitive[1];
917 const unsigned int *uintPtrPrimitive =
reinterpret_cast< const unsigned int *
>( primitivePtr );
918 if ( bvPrimitive.byteStride )
919 primitivePtr += bvPrimitive.byteStride;
921 primitivePtr += 2 *
sizeof(
unsigned int );
923 index1 = uintPtrPrimitive[0];
924 index2 = uintPtrPrimitive[1];
927 data.coordinates = { QVector<QPointF>{ QPointF( x[index1], y[index1] ), QPointF( x[index2], y[index2] ) } };
929 data.z = std::max( z[index1], z[index2] );
930 if ( needLine( data.coordinates ) )
932 thisTileLineData.push_back( data );
944 std::sort( thisTileLineData.begin(), thisTileLineData.end(), [](
const PrimitiveData & a,
const PrimitiveData & b )
949 for (
const PrimitiveData &data : std::as_const( thisTileLineData ) )
951 mRenderer->renderLine( context, data.coordinates );
956 mPrimitiveData.append( thisTileLineData );
The Qgis class provides global constants for use throughout the application.
QFlags< MapLayerRendererFlag > MapLayerRendererFlags
Flags which control how map layer renderers behave.
@ RendersLines
Renderer can render line primitives.
@ RequiresTextures
Renderer requires textures.
@ ForceRasterRender
Layer should always be rendered as a raster image.
@ RendersTriangles
Renderer can render triangle primitives.
@ Available
Tile children are already available.
@ NeedFetching
Tile has children, but they are not yet available and must be fetched.
@ NoChildren
Tile is known to have no children.
@ VectorTile
Vector tile layer. Added in QGIS 3.14.
@ RenderPartialOutputOverPreviousCachedImage
When rendering temporary in-progress preview renders, these preview renders can be drawn over any pre...
@ RenderPartialOutputs
The renderer benefits from rendering temporary in-progress preview renders. These are temporary resul...
@ VerticalCenter
Center align.
@ Additive
When tile is refined its content should be used alongside its children simultaneously.
@ Replacement
When tile is refined then its children should be used in place of itself.
@ Reverse
Reverse/inverse transform (from destination to source)
static QgsRuntimeProfiler * profiler()
Returns the application runtime profiler.
A 3-dimensional box composed of x, y, z coordinates.
QVector< QgsVector3D > corners() const
Returns an array of all box corners as 3D vectors.
static TileContents extractGltfFromTileContent(const QByteArray &tileContent)
Parses tile content.
Custom exception class for Coordinate Reference System related exceptions.
Curve polygon geometry type.
double measureLine(const QVector< QgsPointXY > &points) const
Measures the length of a line with multiple segments.
Base class for feedback objects to be used for cancellation of something running in a worker thread.
A geometry is the spatial representation of a feature.
static QPainterPath calculatePainterClipRegion(const QList< QgsMapClippingRegion > ®ions, const QgsRenderContext &context, Qgis::LayerType layerType, bool &shouldClip)
Returns a QPainterPath representing the intersection of clipping regions from context which should be...
static QList< QgsMapClippingRegion > collectClippingRegionsForLayer(const QgsRenderContext &context, const QgsMapLayer *layer)
Collects the list of map clipping regions from a context which apply to a map layer.
Base class for utility classes that encapsulate information necessary for rendering of map layers.
bool mReadyToCompose
The flag must be set to false in renderer's constructor if wants to use the smarter map redraws funct...
static constexpr int MAX_TIME_TO_USE_CACHED_PREVIEW_IMAGE
Maximum time (in ms) to allow display of a previously cached preview image while rendering layers,...
QString layerId() const
Gets access to the ID of the layer rendered by this class.
QgsRenderContext * renderContext()
Returns the render context associated with the renderer.
void transformInPlace(double &x, double &y) const
Transforms map coordinates to device coordinates.
A simple 4x4 matrix implementation useful for transformation in 3D space.
static QgsOrientedBox3D fromBox3D(const QgsBox3D &box)
Constructs an oriented box from an axis-aligned bounding box.
A class to represent a 2D point.
Exception thrown on failure to parse Quantized Mesh tile (malformed data)
A rectangle specified with double values.
double xMinimum() const
Returns the x minimum value (left side of rectangle).
double yMinimum() const
Returns the y minimum value (bottom side of rectangle).
double xMaximum() const
Returns the x maximum value (right side of rectangle).
double yMaximum() const
Returns the y maximum value (top side of rectangle).
Contains information about the context of a rendering operation.
double convertToPainterUnits(double size, Qgis::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale(), Qgis::RenderSubcomponentProperty property=Qgis::RenderSubcomponentProperty::Generic) const
Converts a size from the specified units to painter units (pixels).
const QgsDistanceArea & distanceArea() const
A general purpose distance and area calculator, capable of performing ellipsoid based calculations.
QPainter * painter()
Returns the destination QPainter for the render operation.
void setPainterFlagsUsingContext(QPainter *painter=nullptr) const
Sets relevant flags on a destination painter, using the flags and settings currently defined for the ...
QgsCoordinateTransformContext transformContext() const
Returns the context's coordinate transform context, which stores various information regarding which ...
QSize outputSize() const
Returns the size of the resulting rendered image, in pixels.
QgsRectangle mapExtent() const
Returns the original extent of the map being rendered.
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
void setPainter(QPainter *p)
Sets the destination QPainter for the render operation.
bool renderingStopped() const
Returns true if the rendering operation has been stopped and any ongoing rendering should be canceled...
QPainter * previewRenderPainter()
Returns the const destination QPainter for temporary in-progress preview renders.
QgsCoordinateTransform coordinateTransform() const
Returns the current coordinate transform for the context.
void record(const QString &name, double time, const QString &group="startup", const QString &id=QString())
Manually adds a profile event with the given name and total time (in seconds).
Scoped object for saving and restoring a QPainter object's state.
void setEnabled(bool enabled)
Sets whether the text buffer will be drawn.
Container for all settings relating to text rendering.
void setColor(const QColor &color)
Sets the color that text will be rendered in.
QgsTextBufferSettings & buffer()
Returns a reference to the text buffer settings.
static void drawText(const QRectF &rect, double rotation, Qgis::TextHorizontalAlignment alignment, const QStringList &textLines, QgsRenderContext &context, const QgsTextFormat &format, bool drawAsOutlines=true, Qgis::TextVerticalAlignment vAlignment=Qgis::TextVerticalAlignment::Top, Qgis::TextRendererFlags flags=Qgis::TextRendererFlags(), Qgis::TextLayoutMode mode=Qgis::TextLayoutMode::Rectangle)
Draws text within a rectangle using the specified settings.
Represents a bounding volume for a tiled scene.
QgsAbstractGeometry * as2DGeometry(const QgsCoordinateTransform &transform=QgsCoordinateTransform(), Qgis::TransformDirection direction=Qgis::TransformDirection::Forward) const
Returns a new geometry representing the 2-dimensional X/Y center slice of the volume.
virtual const QgsCoordinateReferenceSystem sceneCrs() const =0
Returns the original coordinate reference system for the tiled scene data.
virtual QgsTiledSceneIndex index() const =0
Returns the provider's tile index.
virtual const QgsTiledSceneBoundingVolume & boundingVolume() const =0
Returns the bounding volume for the data provider.
Qgis::TileChildrenAvailability childAvailability(long long id) const
Returns the availability for a tile's children.
QByteArray retrieveContent(const QString &uri, QgsFeedback *feedback=nullptr)
Retrieves index content for the specified uri.
bool fetchHierarchy(long long id, QgsFeedback *feedback=nullptr)
Populates the tile with the given id by fetching any sub datasets attached to the tile.
QgsTiledSceneTile getTile(long long id)
Returns the tile with matching id, or an invalid tile if the matching tile is not available.
QVector< long long > getTiles(const QgsTiledSceneRequest &request)
Returns the list of tile IDs which match the given request.
bool isValid() const
Returns true if the index is valid.
bool forceRasterRender() const override
Returns true if the renderer must be rendered to a raster paint device (e.g.
QgsTiledSceneLayerRenderer(QgsTiledSceneLayer *layer, QgsRenderContext &context)
Ctor.
QgsFeedback * feedback() const override
Access to feedback object of the layer renderer (may be nullptr)
bool render() override
Do the rendering (based on data stored in the class).
~QgsTiledSceneLayerRenderer()
Qgis::MapLayerRendererFlags flags() const override
Returns flags which control how the map layer rendering behaves.
Represents a map layer supporting display of tiled scene objects.
QgsTiledSceneDataProvider * dataProvider() override
Returns the layer's data provider, it may be nullptr.
QgsTiledSceneRenderer * renderer()
Returns the 2D renderer for the tiled scene.
Encapsulates the render context for a 2D tiled scene rendering operation.
void setTextureImage(const QImage &image)
Sets the current texture image.
QgsRenderContext & renderContext()
Returns a reference to the context's render context.
void setTextureCoordinates(float textureX1, float textureY1, float textureX2, float textureY2, float textureX3, float textureY3)
Sets the current texture coordinates.
virtual QgsTiledSceneRenderer * clone() const =0
Create a deep copy of this renderer.
Tiled scene data request.
void setParentTileId(long long id)
Sets the parent tile id, if filtering is to be limited to children of a specific tile.
void setFilterBox(const QgsOrientedBox3D &box)
Sets the box from which data will be taken.
void setFeedback(QgsFeedback *feedback)
Attach a feedback object that can be queried regularly by the request to check if it should be cancel...
void setRequiredGeometricError(double error)
Sets the required geometric error threshold for the returned tiles, in meters.
Represents an individual tile from a tiled scene data source.
bool isValid() const
Returns true if the tile is a valid tile (i.e.
Qgis::TileRefinementProcess refinementProcess() const
Returns the tile's refinement process.
QVariantMap resources() const
Returns the resources attached to the tile.
const QgsTiledSceneBoundingVolume & boundingVolume() const
Returns the bounding volume for the tile.
QVariantMap metadata() const
Returns additional metadata attached to the tile.
long long id() const
Returns the tile's unique ID.
const QgsMatrix4x4 * transform() const
Returns the tile's transform.
Class for storage of 3D vectors similar to QVector3D, with the difference that it uses double precisi...
double y() const
Returns Y coordinate.
double z() const
Returns Z coordinate.
double x() const
Returns X coordinate.
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
#define QgsDebugError(str)
Encapsulates the contents of a 3D tile.
QgsVector3D rtcCenter
Center position of relative-to-center coordinates (when used)
QByteArray gltf
GLTF binary content.