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; }

    Q_DECL_DEPRECATED void setTextureRotation( float rotation ) SIP_DEPRECATED;

    Q_DECL_DEPRECATED float textureRotation() const SIP_DEPRECATED { return 0; }

    void setAddTextureUVs( bool addTextureUVs );

    bool hasTextureUVs() const { return mAddTextureCoords; }

    void setAddNormals( bool addNormals );

    bool hasNormals() const { return mAddNormals; }

    void setAddTangents( bool addTangents );

    bool hasTangents() const { return mAddTangents; }

    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; }

    Q_DECL_DEPRECATED void setOutputZUp( bool zUp ) SIP_DEPRECATED;

    Q_DECL_DEPRECATED bool isOutputZUp() const SIP_DEPRECATED { return true; }

    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;
        QVector4D tangent;
 
        inline bool operator==( const VertexPoint &other ) const { return position == other.position && normal == other.normal && tangent == other.tangent; }
    };
 
    friend uint qHash( const VertexPoint &key, size_t seed )
    {
      return qHashMulti( seed, key.position.x(), key.position.y(), key.position.z(), key.normal.x(), key.normal.y(), key.normal.z(), key.tangent.x(), key.tangent.y(), key.tangent.z(), key.tangent.w() );
    }
 
    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,
      const QVector4D &tangent,
      float extrusionHeight,
      QMatrix4x4 *transformMatrix,
      const QgsPoint *originOffset,
      QHash<VertexPoint, unsigned int> *vertexBuffer,
      const size_t &vertexBufferOffset,
      bool isFloor = false
    );
    void addVertex( const QVector3D &point, const QVector3D &normal, const QVector4D &tangent, float extrusionHeight, QMatrix4x4 *transformMatrix, const QgsPoint *originOffset, bool isFloor = false );
    void makeWalls( const QgsLineString &ring, bool ccw, float extrusionHeight );
    void addExtrusionWallQuad( const QVector3D &pt1, const QVector3D &pt2, float height, float u1, float u2 );
    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 mAddTangents = false;
    bool mInvertNormals = false;
    bool mAddBackFaces = false;
    bool mAddTextureCoords = 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 mScale = 1.0f;
    QString mError;
 
    float mZMin = std::numeric_limits<float>::max();
    float mZMax = -std::numeric_limits<float>::max();
};
 
 
#endif // QGSTESSELLATOR_H