qgspolygon3dsymbol_p.cpp

Go to the documentation of this file.

/***************************************************************************
  qgspolygon3dsymbol_p.cpp
  --------------------------------------
  Date                 : July 2017
  Copyright            : (C) 2017 by Martin Dobias
  Email                : wonder dot sk at gmail dot com
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "qgspolygon3dsymbol_p.h"
 
#include "qgs3d.h"
#include "qgs3drendercontext.h"
#include "qgs3dutils.h"
#include "qgsfeature3dhandler_p.h"
#include "qgsgeotransform.h"
#include "qgslinematerial_p.h"
#include "qgslinestring.h"
#include "qgslinevertexdata_p.h"
#include "qgsmaterial3dhandler.h"
#include "qgsmessagelog.h"
#include "qgsmetalroughtexturedmaterialsettings.h"
#include "qgsmultilinestring.h"
#include "qgsmultipolygon.h"
#include "qgsphongtexturedmaterialsettings.h"
#include "qgspolygon.h"
#include "qgspolygon3dsymbol.h"
#include "qgspolyhedralsurface.h"
#include "qgssymbollayerutils.h"
#include "qgstessellatedpolygongeometry.h"
#include "qgstessellator.h"
#include "qgsvectorlayer.h"
#include "qgsvertexid.h"
 
#include <QString>
#include <Qt3DCore/QBuffer>
#include <Qt3DRender/QAbstractTextureImage>
#include <Qt3DRender/QCullFace>
#include <Qt3DRender/QEffect>
#include <Qt3DRender/QGeometryRenderer>
#include <Qt3DRender/QTechnique>
#include <Qt3DRender/QTexture>
 
using namespace Qt::StringLiterals;

 
 
class QgsPolygon3DSymbolHandler : public QgsFeature3DHandler
{
  public:
    QgsPolygon3DSymbolHandler( const QgsPolygon3DSymbol *symbol, const QgsFeatureIds &selectedIds )
      : mSymbol( static_cast<QgsPolygon3DSymbol *>( symbol->clone() ) )
      , mSelectedIds( selectedIds )
    {}
 
    bool prepare( const Qgs3DRenderContext &context, QSet<QString> &attributeNames, const QgsBox3D &chunkExtent ) override;
    void processFeature( const QgsFeature &f, const Qgs3DRenderContext &context ) override;
    void finalize( Qt3DCore::QEntity *parent, const Qgs3DRenderContext &context ) override;
 
  private:
    struct PolygonData
    {
        std::unique_ptr<QgsTessellator> tessellator;
        QVector<QgsFeatureId> triangleIndexFids;
        QVector<uint> triangleIndexStartingIndices;
        QByteArray materialDataDefined;
        QVector<float> ddTextureTransformData;
    };
 
    void processPolygon(
      const QgsPolygon *poly,
      QgsFeatureId fid,
      float offset,
      float extrusionHeight,
      float dataDefinedTextureScale,
      float dataDefinedTextureRotation,
      float dataDefinedTextureOffsetX,
      float dataDefinedTextureOffsetY,
      const Qgs3DRenderContext &context,
      PolygonData &out
    );
    void processMaterialDatadefined( uint verticesCount, const QgsExpressionContext &context, PolygonData &out );
    void makeEntity( Qt3DCore::QEntity *parent, const Qgs3DRenderContext &context, PolygonData &out, bool selected );
    QgsMaterial *material( const QgsPolygon3DSymbol *symbol, bool isSelected, const Qgs3DRenderContext &context ) const;
 
    // input specific for this class
    std::unique_ptr<QgsPolygon3DSymbol> mSymbol;
    // inputs - generic
    QgsFeatureIds mSelectedIds;
    // outputs
    PolygonData outNormal;   
    PolygonData outSelected; 
 
    QgsLineVertexData outEdges; 

    bool mWasClippedToExtent = false;
};
 
 
bool QgsPolygon3DSymbolHandler::prepare( const Qgs3DRenderContext &context, QSet<QString> &attributeNames, const QgsBox3D &chunkExtent )
{
  mChunkOrigin = chunkExtent.center();
  mChunkOrigin.setZ( 0. ); // set the chunk origin to the bottom of the box, as the tessellator currently always considers origin z to be zero
  mChunkExtent = chunkExtent;
 
  outEdges.init( mSymbol->altitudeClamping(), mSymbol->altitudeBinding(), 0, context, mChunkOrigin );
 
  const QgsAbstractMaterialSettings *materialSettings = mSymbol->materialSettings();
  const bool requiresTextureCoordinates = materialSettings->requiresTextureCoordinates();
  const bool requiresTangents = materialSettings->requiresTangents();
 
  auto tessellator = std::make_unique<QgsTessellator>();
  tessellator->setOrigin( mChunkOrigin );
  tessellator->setAddNormals( true );
  tessellator->setInvertNormals( mSymbol->invertNormals() );
  tessellator->setBackFacesEnabled( mSymbol->addBackFaces() );
  tessellator->setExtrusionFaces( mSymbol->extrusionFaces() );
  tessellator->setAddTextureUVs( requiresTextureCoordinates );
  tessellator->setAddTangents( requiresTangents );
  tessellator->setTriangulationAlgorithm( Qgis::TriangulationAlgorithm::Earcut );
 
  outNormal.tessellator = std::move( tessellator );
 
  tessellator = std::make_unique<QgsTessellator>();
  tessellator->setOrigin( mChunkOrigin );
  tessellator->setAddNormals( true );
  tessellator->setInvertNormals( mSymbol->invertNormals() );
  tessellator->setBackFacesEnabled( mSymbol->addBackFaces() );
  tessellator->setExtrusionFaces( mSymbol->extrusionFaces() );
  tessellator->setAddTextureUVs( requiresTextureCoordinates );
  tessellator->setAddTangents( requiresTangents );
  tessellator->setTriangulationAlgorithm( Qgis::TriangulationAlgorithm::Earcut );
 
  outSelected.tessellator = std::move( tessellator );
 
  QSet<QString> attrs = mSymbol->dataDefinedProperties().referencedFields( context.expressionContext() );
  attributeNames.unite( attrs );
  attrs = materialSettings->dataDefinedProperties().referencedFields( context.expressionContext() );
  attributeNames.unite( attrs );
  return true;
}
 
static void addClosedRingEdges( QgsLineVertexData &edges, const QgsLineString &ring, float extraHeightOffset )
{
  std::unique_ptr<QgsLineString> openRing( ring.clone() );
  openRing->deleteVertex( QgsVertexId( 0, 0, openRing->numPoints() - 1 ) );
  edges.addLineString( *openRing, extraHeightOffset, true );
}
 
void QgsPolygon3DSymbolHandler::processPolygon(
  const QgsPolygon *poly,
  QgsFeatureId fid,
  float offset,
  float extrusionHeight,
  float dataDefinedTextureScale,
  float dataDefinedTextureRotation,
  float dataDefinedTextureOffsetX,
  float dataDefinedTextureOffsetY,
  const Qgs3DRenderContext &context,
  PolygonData &out
)
{
  std::unique_ptr<QgsPolygon> polyClone( poly->clone() );
 
  if ( mSymbol->edgesEnabled() )
  {
    // add edges before the polygon gets the Z values modified because addLineString() does its own altitude handling
    const QgsAbstractGeometry *exteriorRing = static_cast<const QgsLineString *>( polyClone->exteriorRing() );
 
    // This geometry will take ownership of the cleaned exteriorRing abstract geom.
    // We need this to live for as long as exteriorRing is used.
    QgsGeometry cleanedExteriorRingGeometry;
 
    if ( mWasClippedToExtent )
    {
      // if the polygon was clipped to the chunk extent, then we need to remove any part of the exterior ring that
      // overlaps the chunk extent line, otherwise the chunk extents will appear as edges. Any interior rings
      // that were intersected by the extent will now be part of the exterior ring of the clipped geometry.
      const QVector< QgsPointXY > extentPoints {
        { mChunkExtent.xMinimum(), mChunkExtent.yMinimum() },
        { mChunkExtent.xMaximum(), mChunkExtent.yMinimum() },
        { mChunkExtent.xMaximum(), mChunkExtent.yMaximum() },
        { mChunkExtent.xMinimum(), mChunkExtent.yMaximum() },
        { mChunkExtent.xMinimum(), mChunkExtent.yMinimum() }
      };
      auto extentLinestring = std::make_unique<QgsLineString>( extentPoints );
 
      const QgsGeometry exteriorRingGeometry( exteriorRing->clone() );
      // it should be safe to perform the diff without any tolerance, the extent line string is a simple rectangle (chunk perimeter)
      cleanedExteriorRingGeometry = exteriorRingGeometry.difference( QgsGeometry( extentLinestring.release() ) );
      // make sure the diff didn't produce some degenerate geometry
      ( void ) cleanedExteriorRingGeometry.convertGeometryCollectionToSubclass( Qgis::GeometryType::Line );
      exteriorRing = cleanedExteriorRingGeometry.constGet()->simplifiedTypeRef();
    }
 
    if ( const QgsLineString *line = qgsgeometry_cast<const QgsLineString *>( exteriorRing ) )
    {
      if ( mWasClippedToExtent )
        outEdges.addLineString( *line, offset );
      else
        addClosedRingEdges( outEdges, *line, offset );
    }
    // if geometry was clipped to the chunk extents, we might now have a multilinestring
    else if ( const QgsMultiLineString *mline = qgsgeometry_cast<const QgsMultiLineString *>( exteriorRing ) )
    {
      for ( int i = 0; i < mline->numGeometries(); ++i )
      {
        // these are always open arcs left over from clipping to the chunk extent, never closed rings
        const QgsLineString *line = mline->lineStringN( i );
        outEdges.addLineString( *line, offset );
      }
    }
 
    // if geometry was clipped to the chunk extents and the chunk extents intersected an interior ring, then
    // that ring is now part of the exterior ring, so remaining interior rings here are always complete,
    // unclipped closed rings
    for ( int i = 0; i < polyClone->numInteriorRings(); ++i )
      addClosedRingEdges( outEdges, *static_cast<const QgsLineString *>( polyClone->interiorRing( i ) ), offset );
 
    if ( extrusionHeight != 0.f )
    {
      // add roof and wall edges
 
      if ( const QgsLineString *line = qgsgeometry_cast<const QgsLineString *>( exteriorRing ) )
      {
        // when clipped to the chunk extent, this may now be an open arc rather than a closed ring
        if ( mWasClippedToExtent )
          outEdges.addLineString( *line, extrusionHeight + offset );
        else
          addClosedRingEdges( outEdges, *line, extrusionHeight + offset );
        outEdges.addVerticalLines( *line, extrusionHeight, offset );
      }
      // if geometry was clipped to the chunk extents, we might now have a multilinestring
      else if ( const QgsMultiLineString *mline = qgsgeometry_cast<const QgsMultiLineString *>( exteriorRing ) )
      {
        for ( int i = 0; i < mline->numGeometries(); ++i )
        {
          // these are always open arcs left over from clipping to the chunk extent, never closed rings
          const QgsLineString *line = mline->lineStringN( i );
          outEdges.addLineString( *line, extrusionHeight + offset );
          outEdges.addVerticalLines( *line, extrusionHeight, offset );
        }
      }
 
      // if geometry was clipped to the chunk extents and the chunk extents intersected an interior ring, then
      // that ring is now part of the exterior ring, so remaining interior rings here are always complete,
      // unclipped closed rings
      for ( int i = 0; i < polyClone->numInteriorRings(); ++i )
      {
        const QgsLineString *interior = static_cast<const QgsLineString *>( polyClone->interiorRing( i ) );
        addClosedRingEdges( outEdges, *interior, extrusionHeight + offset );
        outEdges.addVerticalLines( *interior, extrusionHeight, offset );
      }
    }
  }
 
  Qgs3DUtils::clampAltitudes( polyClone.get(), mSymbol->altitudeClamping(), mSymbol->altitudeBinding(), offset, context );
 
  Q_ASSERT( out.tessellator->dataVerticesCount() % 3 == 0 );
  const uint startingTriangleIndex = static_cast<uint>( out.tessellator->dataVerticesCount() / 3 );
  out.triangleIndexStartingIndices.append( startingTriangleIndex );
  out.triangleIndexFids.append( fid );
 
  const size_t oldVertexCount = out.tessellator->uniqueVertexCount();
  out.tessellator->addPolygon( *polyClone, extrusionHeight );
  if ( !out.tessellator->error().isEmpty() )
  {
    QgsMessageLog::logMessage( out.tessellator->error(), QObject::tr( "3D" ) );
  }
 
  const QgsPropertyCollection &dataDefinedProperties = mSymbol->materialSettings()->dataDefinedProperties();
  if ( dataDefinedProperties.hasActiveProperties() )
  {
    const uint newUniqueVertices = out.tessellator->uniqueVertexCount() - oldVertexCount;
    processMaterialDatadefined( newUniqueVertices, context.expressionContext(), out );
 
    if ( dataDefinedProperties.isActive( QgsAbstractMaterialSettings::Property::TextureScale )
         || dataDefinedProperties.isActive( QgsAbstractMaterialSettings::Property::TextureRotation )
         || dataDefinedProperties.isActive( QgsAbstractMaterialSettings::Property::TextureOffset ) )
    {
      for ( uint i = 0; i < newUniqueVertices; ++i )
      {
        out.ddTextureTransformData << dataDefinedTextureOffsetX << dataDefinedTextureOffsetY << dataDefinedTextureScale << dataDefinedTextureRotation;
      }
    }
  }
}
 
void QgsPolygon3DSymbolHandler::processMaterialDatadefined( uint verticesCount, const QgsExpressionContext &context, QgsPolygon3DSymbolHandler::PolygonData &out )
{
  QByteArray bytes;
  if ( const QgsAbstractMaterial3DHandler *handler = Qgs3D::handlerForMaterialSettings( mSymbol->materialSettings() ) )
  {
    bytes = handler->dataDefinedVertexColorsAsByte( mSymbol->materialSettings(), context );
  }
  out.materialDataDefined.append( bytes.repeated( verticesCount ) );
}
 
void QgsPolygon3DSymbolHandler::processFeature( const QgsFeature &f, const Qgs3DRenderContext &context )
{
  if ( f.geometry().isNull() )
    return;
 
  PolygonData &out = mSelectedIds.contains( f.id() ) ? outSelected : outNormal;
 
  QgsGeometry geom = f.geometry();
  mWasClippedToExtent = clipGeometryIfTooLarge( geom );
 
  if ( geom.isEmpty() )
    return;
 
  const QgsAbstractGeometry *g = geom.constGet()->simplifiedTypeRef();
 
  // segmentize curved geometries if necessary
  if ( QgsWkbTypes::isCurvedType( g->wkbType() ) )
  {
    geom = QgsGeometry( g->segmentize() );
    g = geom.constGet()->simplifiedTypeRef();
  }
 
  const QgsPropertyCollection &ddp = mSymbol->dataDefinedProperties();
  const bool hasDDHeight = ddp.isActive( QgsAbstract3DSymbol::Property::Height );
  const bool hasDDExtrusion = ddp.isActive( QgsAbstract3DSymbol::Property::ExtrusionHeight );
 
  float offset = mSymbol->offset();
  float extrusionHeight = mSymbol->extrusionHeight();
  if ( hasDDHeight )
    offset = static_cast<float>( ddp.valueAsDouble( QgsAbstract3DSymbol::Property::Height, context.expressionContext(), offset ) );
  if ( hasDDExtrusion )
    extrusionHeight = ddp.valueAsDouble( QgsAbstract3DSymbol::Property::ExtrusionHeight, context.expressionContext(), extrusionHeight );
 
  const QgsAbstractMaterialSettings *materialSettings = mSymbol->materialSettings();
  const bool hasTextureScale = materialSettings
                               && materialSettings->dataDefinedProperties().isActive( QgsAbstractMaterialSettings::Property::TextureScale )
                               && materialSettings->supportedProperties().contains( QgsAbstractMaterialSettings::Property::TextureScale );
  const bool hasTextureRotation = materialSettings
                                  && materialSettings->dataDefinedProperties().isActive( QgsAbstractMaterialSettings::Property::TextureRotation )
                                  && materialSettings->supportedProperties().contains( QgsAbstractMaterialSettings::Property::TextureRotation );
  const bool hasTextureOffset = materialSettings
                                && materialSettings->dataDefinedProperties().isActive( QgsAbstractMaterialSettings::Property::TextureOffset )
                                && materialSettings->supportedProperties().contains( QgsAbstractMaterialSettings::Property::TextureOffset );
  float dataDefinedTextureRotation = 0;
  float dataDefinedTextureScale = 1;
  float dataDefinedTextureOffsetX = 0;
  float dataDefinedTextureOffsetY = 0;
  if ( auto phongTexturedMaterial = dynamic_cast<const QgsPhongTexturedMaterialSettings * >( materialSettings ) )
  {
    dataDefinedTextureRotation = phongTexturedMaterial->textureRotation();
    dataDefinedTextureScale = phongTexturedMaterial->textureScale();
    dataDefinedTextureOffsetX = phongTexturedMaterial->textureOffset().x();
    dataDefinedTextureOffsetY = phongTexturedMaterial->textureOffset().y();
  }
  else if ( auto metalRoughTexturedMaterial = dynamic_cast<const QgsMetalRoughTexturedMaterialSettings * >( materialSettings ) )
  {
    dataDefinedTextureRotation = metalRoughTexturedMaterial->textureRotation();
    dataDefinedTextureScale = metalRoughTexturedMaterial->textureScale();
    dataDefinedTextureOffsetX = metalRoughTexturedMaterial->textureOffset().x();
    dataDefinedTextureOffsetY = metalRoughTexturedMaterial->textureOffset().y();
  }
 
  if ( hasTextureScale || hasTextureRotation || hasTextureOffset )
  {
    dataDefinedTextureRotation = static_cast< float >(
      materialSettings->dataDefinedProperties().valueAsDouble( QgsAbstractMaterialSettings::Property::TextureRotation, context.expressionContext(), dataDefinedTextureRotation )
    );
    dataDefinedTextureScale = static_cast< float >(
      100 / materialSettings->dataDefinedProperties().valueAsDouble( QgsAbstractMaterialSettings::Property::TextureScale, context.expressionContext(), 100 / dataDefinedTextureScale )
    );
 
    QVariant offsetValue = materialSettings->dataDefinedProperties().value( QgsAbstractMaterialSettings::Property::TextureOffset, context.expressionContext() );
    bool ok = false;
    const QPointF ddOffset = QgsSymbolLayerUtils::toPoint( offsetValue, &ok );
    if ( ok )
    {
      dataDefinedTextureOffsetX = static_cast< float >( ddOffset.x() );
      dataDefinedTextureOffsetY = static_cast< float >( ddOffset.y() );
    }
  }
 
  if ( const QgsPolygon *poly = qgsgeometry_cast<const QgsPolygon *>( g ) )
  {
    processPolygon( poly, f.id(), offset, extrusionHeight, dataDefinedTextureScale, dataDefinedTextureRotation, dataDefinedTextureOffsetX, dataDefinedTextureOffsetY, context, out );
  }
  else if ( const QgsMultiPolygon *mpoly = qgsgeometry_cast<const QgsMultiPolygon *>( g ) )
  {
    for ( int i = 0; i < mpoly->numGeometries(); ++i )
    {
      const QgsPolygon *poly = mpoly->polygonN( i );
      processPolygon( poly, f.id(), offset, extrusionHeight, dataDefinedTextureScale, dataDefinedTextureRotation, dataDefinedTextureOffsetX, dataDefinedTextureOffsetY, context, out );
    }
  }
  else if ( const QgsGeometryCollection *gc = qgsgeometry_cast<const QgsGeometryCollection *>( g ) )
  {
    for ( int i = 0; i < gc->numGeometries(); ++i )
    {
      const QgsAbstractGeometry *g2 = gc->geometryN( i );
      if ( QgsWkbTypes::flatType( g2->wkbType() ) == Qgis::WkbType::Polygon )
      {
        const QgsPolygon *poly = static_cast<const QgsPolygon *>( g2 );
        processPolygon( poly, f.id(), offset, extrusionHeight, dataDefinedTextureScale, dataDefinedTextureRotation, dataDefinedTextureOffsetX, dataDefinedTextureOffsetY, context, out );
      }
    }
  }
  else if ( const QgsPolyhedralSurface *polySurface = qgsgeometry_cast<const QgsPolyhedralSurface *>( g ) )
  {
    for ( int i = 0; i < polySurface->numPatches(); ++i )
    {
      const QgsPolygon *poly = polySurface->patchN( i );
      processPolygon( poly, f.id(), offset, extrusionHeight, dataDefinedTextureScale, dataDefinedTextureRotation, dataDefinedTextureOffsetX, dataDefinedTextureOffsetY, context, out );
    }
  }
  else
    qWarning() << "not a polygon";
 
  mFeatureCount++;
}
 
void QgsPolygon3DSymbolHandler::finalize( Qt3DCore::QEntity *parent, const Qgs3DRenderContext &context )
{
  // create entity for selected and not selected
  makeEntity( parent, context, outNormal, false );
  makeEntity( parent, context, outSelected, true );
 
  mZMin = std::min( outNormal.tessellator->zMinimum(), outSelected.tessellator->zMinimum() );
  mZMax = std::max( outNormal.tessellator->zMaximum(), outSelected.tessellator->zMaximum() );
 
  // add entity for edges, but not when doing highlighting
  if ( mSymbol->edgesEnabled() && !outEdges.pointsA.isEmpty() && !mHighlightingEnabled )
  {
    QgsLineMaterial *mat = new QgsLineMaterial;
    mat->setLineColor( mSymbol->edgeColor() );
    mat->setLineWidth( mSymbol->edgeWidth() );
 
    Qt3DCore::QEntity *entity = outEdges.createSegmentEntity( mat );
    entity->setObjectName( parent->objectName() + "_EDGES" );
 
    // add transform (our geometry has coordinates relative to mChunkOrigin)
    QgsGeoTransform *tr = new QgsGeoTransform;
    tr->setGeoTranslation( mChunkOrigin );
 
    entity->addComponent( tr );
    entity->setParent( parent );
 
    if ( Qt3DCore::QEntity *joinEntity = outEdges.createJoinEntity( mat ) )
    {
      joinEntity->setObjectName( parent->objectName() + "_EDGES_JOINS" );
      QgsGeoTransform *joinTr = new QgsGeoTransform;
      joinTr->setGeoTranslation( mChunkOrigin );
      joinEntity->addComponent( joinTr );
      joinEntity->setParent( parent );
    }
  }
}
 
 
void QgsPolygon3DSymbolHandler::makeEntity( Qt3DCore::QEntity *parent, const Qgs3DRenderContext &context, PolygonData &polyData, bool selected )
{
  if ( polyData.tessellator->dataVerticesCount() == 0 )
    return; // nothing to show - no need to create the entity
 
  QgsMaterial *mat = material( mSymbol.get(), selected, context );
 
  // extract vertex buffer data from tessellator
  const QByteArray vertexBuffer = polyData.tessellator->vertexBuffer();
  const QByteArray indexBuffer = polyData.tessellator->indexBuffer();
  const int vertexCount = polyData.tessellator->uniqueVertexCount();
  const size_t indexCount = polyData.tessellator->dataVerticesCount();
 
  QgsTessellatedPolygonGeometry *geometry = new QgsTessellatedPolygonGeometry(
    true,
    mSymbol->invertNormals(),
    mSymbol->addBackFaces(),
    mSymbol->materialSettings() && mSymbol->materialSettings()->requiresTextureCoordinates(),
    mSymbol->materialSettings() && mSymbol->materialSettings()->requiresTangents()
  );
 
  geometry->setVertexBufferData( vertexBuffer, vertexCount, polyData.triangleIndexFids, polyData.triangleIndexStartingIndices );
  geometry->setIndexBufferData( indexBuffer, indexCount );
 
  if ( mSymbol->materialSettings()->dataDefinedProperties().hasActiveProperties() )
  {
    if ( const QgsAbstractMaterial3DHandler *handler = Qgs3D::handlerForMaterialSettings( mSymbol->materialSettings() ) )
    {
      handler->applyDataDefinedToGeometry( mSymbol->materialSettings(), geometry, vertexCount, polyData.materialDataDefined );
    }
 
    if ( !polyData.ddTextureTransformData.isEmpty() )
    {
      auto textureTransformBuffer = new Qt3DCore::QBuffer( geometry );
 
      QByteArray byteArray(
        reinterpret_cast<const char *>( polyData.ddTextureTransformData.data() ),
        static_cast<int>( polyData.ddTextureTransformData.size() * sizeof( float ) )
      ); // makes a deep copy
      textureTransformBuffer->setData( byteArray );
      auto textureTransformAttribute = new Qt3DCore::QAttribute( geometry );
      textureTransformAttribute->setName( u"ddTextureTransform"_s );
      textureTransformAttribute->setVertexBaseType( Qt3DCore::QAttribute::Float );
      textureTransformAttribute->setVertexSize( 4 );
      textureTransformAttribute->setAttributeType( Qt3DCore::QAttribute::VertexAttribute );
      textureTransformAttribute->setBuffer( textureTransformBuffer );
      textureTransformAttribute->setByteStride( 4 * sizeof( float ) );
      textureTransformAttribute->setCount( vertexCount );
 
      geometry->addAttribute( textureTransformAttribute );
    }
  }
  Qt3DRender::QGeometryRenderer *renderer = new Qt3DRender::QGeometryRenderer;
  renderer->setGeometry( geometry );
 
  // add transform (our geometry has coordinates relative to mChunkOrigin)
  QgsGeoTransform *tr = new QgsGeoTransform;
  tr->setGeoTranslation( mChunkOrigin );
 
  // make entity
  Qt3DCore::QEntity *entity = new Qt3DCore::QEntity;
  entity->setObjectName( parent->objectName() + "_CHUNK_MESH" );
  entity->addComponent( renderer );
  entity->addComponent( mat );
  entity->addComponent( tr );
  entity->setParent( parent );
 
  if ( !selected )
    renderer->setProperty( Qgs3DTypes::PROP_NAME_3D_RENDERER_FLAG, Qgs3DTypes::Main3DRenderer ); // temporary measure to distinguish between "selected" and "main"
 
  // cppcheck wrongly believes entity will leak
  // cppcheck-suppress memleak
}
 
// front/back side culling
static void applyCullingMode( Qgs3DTypes::CullingMode cullingMode, QgsMaterial *material )
{
  const auto techniques = material->effect()->techniques();
  for ( auto tit = techniques.constBegin(); tit != techniques.constEnd(); ++tit )
  {
    auto renderPasses = ( *tit )->renderPasses();
    for ( auto rpit = renderPasses.begin(); rpit != renderPasses.end(); ++rpit )
    {
      Qt3DRender::QCullFace *cullFace = new Qt3DRender::QCullFace;
      cullFace->setMode( Qgs3DUtils::qt3DcullingMode( cullingMode ) );
      ( *rpit )->addRenderState( cullFace );
    }
  }
}
 
QgsMaterial *QgsPolygon3DSymbolHandler::material( const QgsPolygon3DSymbol *symbol, bool isSelected, const Qgs3DRenderContext &context ) const
{
  QgsMaterialContext materialContext = QgsMaterialContext::fromRenderContext( context );
  materialContext.setIsSelected( isSelected );
  materialContext.setIsHighlighted( mHighlightingEnabled );
 
  const bool dataDefined = mSymbol->materialSettings()->dataDefinedProperties().hasActiveProperties();
  QgsMaterial *material = Qgs3D::toMaterial( symbol->materialSettings(), dataDefined ? Qgis::MaterialRenderingTechnique::TrianglesDataDefined : Qgis::MaterialRenderingTechnique::Triangles, materialContext );
  applyCullingMode( symbol->cullingMode(), material );
  return material;
}
 
 
// --------------
 
 
namespace Qgs3DSymbolImpl
{
 
 
  QgsFeature3DHandler *handlerForPolygon3DSymbol( const QgsVectorLayer *layer, const QgsAbstract3DSymbol *symbol )
  {
    const QgsPolygon3DSymbol *polygonSymbol = dynamic_cast<const QgsPolygon3DSymbol *>( symbol );
    if ( !polygonSymbol )
      return nullptr;
 
    return new QgsPolygon3DSymbolHandler( polygonSymbol, layer->selectedFeatureIds() );
  }
} // namespace Qgs3DSymbolImpl