qgstessellator.h

Go to the documentation of this file.

/***************************************************************************
  qgstessellator.h
  --------------------------------------
  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.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSTESSELLATOR_H
#define QGSTESSELLATOR_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsrectangle.h"
 
class QgsPolygon;
class QgsMultiPolygon;
class QgsLineString;
 
#include <QVector>
#include <memory>

class CORE_EXPORT QgsTessellator
{
  public:
    QgsTessellator();

    Q_DECL_DEPRECATED QgsTessellator(
      double originX, double originY, bool addNormals, bool invertNormals = false, bool addBackFaces = false, bool noZ = false, bool addTextureCoords = false, int facade = 3, float textureRotation = 0.0f
    ) SIP_DEPRECATED;

    Q_DECL_DEPRECATED QgsTessellator(
      const QgsRectangle &bounds, bool addNormals, bool invertNormals = false, bool addBackFaces = false, bool noZ = false, bool addTextureCoords = false, int facade = 3, float textureRotation = 0.0f
    ) SIP_DEPRECATED;

    void setOrigin( const QgsVector3D &origin );

    QgsVector3D origin() const { return mOrigin; }

    void setBounds( const QgsRectangle &bounds );

    void setInputZValueIgnored( bool ignore );

    bool isZValueIgnored() const { return mInputZValueIgnored; }

    void setExtrusionFaces( Qgis::ExtrusionFaces faces );

    Qgis::ExtrusionFaces extrusionFaces() const { return mExtrusionFaces; }

    void setTextureRotation( float rotation );

    float textureRotation() const { return mTextureRotation; }

    void setAddTextureUVs( bool addTextureUVs );

    bool hasTextureUVs() const { return mAddTextureCoords; }

    void setAddNormals( bool addNormals );

    bool hasNormals() const { return mAddNormals; }

    void setBackFacesEnabled( bool addBackFaces );

    bool hasBackFacesEnabled() const { return mAddBackFaces; }

    void setInvertNormals( bool invertNormals );

    bool hasInvertedNormals() const { return mInvertNormals; }

    void setTriangulationAlgorithm( Qgis::TriangulationAlgorithm algorithm );

    Qgis::TriangulationAlgorithm triangulationAlgorithm() const { return mTriangulationAlgorithm; }

    void setOutputZUp( bool zUp ) { mOutputZUp = zUp; }

    bool isOutputZUp() const { return mOutputZUp; }

    void addPolygon( const QgsPolygon &polygon, float extrusionHeight );

    Q_DECL_DEPRECATED QVector<float> data() const SIP_DEPRECATED;

    QByteArray indexBuffer() const;

    QByteArray vertexBuffer() const;

    int dataVerticesCount() const;

    int stride() const { return mStride; }

    int indexStride() const { return sizeof( uint32_t ); }

    std::unique_ptr< QgsMultiPolygon > asMultiPolygon() const SIP_SKIP;

    float zMinimum() const { return mZMin; }

    float zMaximum() const { return mZMax; }

    QString error() const { return mError; }

    int uniqueVertexCount() const;
 
  private:
    struct VertexPoint
    {
        QVector3D position;
        QVector3D normal;
 
        inline bool operator==( const VertexPoint &other ) const { return position == other.position && normal == other.normal; }
    };
 
    friend uint qHash( const VertexPoint &key )
    {
      return qHash( key.position.x() ) ^ qHash( key.position.y() ) ^ qHash( key.position.z() ) ^ qHash( key.normal.x() ) ^ qHash( key.normal.y() ) ^ qHash( key.normal.z() );
    }
 
    QVector<uint32_t> mIndexBuffer;
 
    void updateStride();
    void setExtrusionFacesLegacy( int facade );
    void calculateBaseTransform( const QVector3D &pNormal, QMatrix4x4 *base ) const;
    QVector3D applyTransformWithExtrusion( const QVector3D point, float extrusionHeight, QMatrix4x4 *transformMatrix, const QgsPoint *originOffset );
    void addVertex(
      const QVector3D &point, const QVector3D &normal, float extrusionHeight, QMatrix4x4 *transformMatrix, const QgsPoint *originOffset, QHash<VertexPoint, unsigned int> *vertexBuffer, const size_t &vertexBufferOffset
    );
    void addVertex( const QVector3D &point, const QVector3D &normal, float extrusionHeight, QMatrix4x4 *transformMatrix, const QgsPoint *originOffset );
    void makeWalls( const QgsLineString &ring, bool ccw, float extrusionHeight );
    void addExtrusionWallQuad( const QVector3D &pt1, const QVector3D &pt2, float height );
    void ringToEarcutPoints( const QgsLineString *ring, std::vector<std::array<double, 2>> &polyline, QHash<std::array<double, 2> *, float> *zHash );
    std::vector<QVector3D> generateConstrainedDelaunayTriangles( const QgsPolygon *polygonNew );
    std::vector<QVector3D> generateEarcutTriangles( const QgsPolygon *polygonNew );
 
    QgsVector3D mOrigin = QgsVector3D( 0, 0, 0 );
    bool mAddNormals = false;
    bool mInvertNormals = false;
    bool mAddBackFaces = false;
    bool mAddTextureCoords = false;
    bool mOutputZUp = false;
    QVector<float> mData;
    int mStride = 3 * sizeof( float );
    bool mInputZValueIgnored = false;
    Qgis::ExtrusionFaces mExtrusionFaces = Qgis::ExtrusionFace::Walls | Qgis::ExtrusionFace::Roof;
    Qgis::TriangulationAlgorithm mTriangulationAlgorithm = Qgis::TriangulationAlgorithm::ConstrainedDelaunay;
    float mTextureRotation = 0.0f;
    float mScale = 1.0f;
    QString mError;
 
    float mZMin = std::numeric_limits<float>::max();
    float mZMax = -std::numeric_limits<float>::max();
};
 
 
#endif // QGSTESSELLATOR_H