planegeometry.cpp - mozsearch

++ // Copyright (C) 2024 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

++ // Qt-Security score:significant reason:default

++

++

++ #include "planegeometry_p.h"

++ #include <limits>

++

++ #if QT_CONFIG(concurrent)

++ #include <QtConcurrentRun>

++ #endif

++

++ QT_BEGIN_NAMESPACE

++

++ /*!

++     \qmltype PlaneGeometry

++     \inqmlmodule QtQuick3D.Helpers

++     \inherits Geometry

++     \since 6.9

++     \brief Provides geometry for a plane.

++

++     PlaneGeometry is a geometry type that represents a plane. The plane's size is

++     defined by its height and width properties. The topology of the plane is defined by

++     the meshResolution property. The orientation of the plane is defined by the plane property.

++ */

++

++ /*!

++     \qmlproperty real PlaneGeometry::width

++     The width of the plane. The default value is 100.0.

++ */

++

++ /*!

++     \qmlproperty real PlaneGeometry::height

++     The height of the plane. The default value is 100.0.

++ */

++

++

++ /*!

++     \qmlproperty size PlaneGeometry::meshResolution

++     The resolution of the plane. The default value is QSize(2, 2).

++ */

++

++ /*!

++     \qmlproperty PlaneGeometry::Plane PlaneGeometry::plane

++     The orientation of the plane. The default value is PlaneGeometry.XY.

++     All geometry will be created along the selected plane, and the front

++     face and normal will point towards the remaining positive axis, unless

++     reversed is true.

++

++     \value PlaneGeometry.XY The plane is oriented along the XY plane.

++     \value PlaneGeometry.XZ The plane is oriented along the XZ plane.

++     \value PlaneGeometry.ZY The plane is oriented along the ZY plane.

++ */

++

++ /*!

++     \qmlproperty bool PlaneGeometry::reversed

++     This property holds whether the plane is flipped. This changes both the normal as

++     well as the winding order of the plane.  The default value is false, which means that

++     when a Plane is created with the XY orientation, the normal will point in the positive

++     Z direction and the winding order will be counter-clockwise. When reversed is true,

++     the normal will point in the negative Z direction and the winding order will be clockwise.

++ */

++

++ /*!

++     \qmlproperty bool PlaneGeometry::mirrored

++     This property holds whether the UV coordinates of the plane are flipped vertically.

++ */

++

++ /*!

++     \qmlproperty bool PlaneGeometry::asynchronous

++

++     This property holds whether the geometry generation should be asynchronous.

++ */

++

++ /*!

++     \qmlproperty bool PlaneGeometry::status

++     \readonly

++

++     This property holds the status of the geometry generation when asynchronous is true.

++

++     \value PlaneGeometry.Null The geometry generation has not started

++     \value PlaneGeometry.Ready The geometry generation is complete.

++     \value PlaneGeometry.Loading The geometry generation is in progress.

++     \value PlaneGeometry.Error The geometry generation failed.

++ */

++

++ PlaneGeometry::PlaneGeometry(QQuick3DObject *parent)

++     : QQuick3DGeometry(parent)

++ {

++ #if QT_CONFIG(concurrent)

++     connect(&m_geometryDataWatcher, &QFutureWatcher<GeometryData>::finished, this, &PlaneGeometry::requestFinished);

++ #endif

++     scheduleGeometryUpdate();

++ }

++

++ PlaneGeometry::~PlaneGeometry()

++ {

++

++ }

++

++ float PlaneGeometry::width() const

++ {

++     return m_width;

++ }

++

++ void PlaneGeometry::setWidth(float newWidth)

++ {

++     if (qFuzzyCompare(m_width, newWidth))

++         return;

++     m_width = newWidth;

++     emit widthChanged();

++     scheduleGeometryUpdate();

++ }

++

++ float PlaneGeometry::height() const

++ {

++     return m_height;

++ }

++

++ void PlaneGeometry::setHeight(float newHeight)

++ {

++     if (qFuzzyCompare(m_height, newHeight))

++         return;

++     m_height = newHeight;

++     emit heightChanged();

++     scheduleGeometryUpdate();

++ }

++

++ QSize PlaneGeometry::meshResolution() const

++ {

++     return m_meshResolution;

++ }

++

++ void PlaneGeometry::setMeshResolution(const QSize &newMeshResolution)

++ {

++     if (m_meshResolution == newMeshResolution)

++         return;

++     m_meshResolution = newMeshResolution;

++     emit meshResolutionChanged();

++     scheduleGeometryUpdate();

++ }

++

++ PlaneGeometry::Plane PlaneGeometry::plane() const

++ {

++     return m_plane;

++ }

++

++ void PlaneGeometry::setPlane(Plane newPlane)

++ {

++     if (m_plane == newPlane)

++         return;

++     m_plane = newPlane;

++     emit planeChanged();

++     scheduleGeometryUpdate();

++ }

++

++ bool PlaneGeometry::reversed() const

++ {

++     return m_reversed;

++ }

++

++ void PlaneGeometry::setReversed(bool newReversed)

++ {

++     if (m_reversed == newReversed)

++         return;

++     m_reversed = newReversed;

++     emit reversedChanged();

++     scheduleGeometryUpdate();

++ }

++

++ bool PlaneGeometry::mirrored() const

++ {

++     return m_mirrored;

++ }

++

++ void PlaneGeometry::setMirrored(bool newMirrored)

++ {

++     if (m_mirrored == newMirrored)

++         return;

++     m_mirrored = newMirrored;

++     emit mirroredChanged();

++     scheduleGeometryUpdate();

++ }

++

++ bool PlaneGeometry::asynchronous() const

++ {

++     return m_asynchronous;

++ }

++

++ void PlaneGeometry::setAsynchronous(bool newAsynchronous)

++ {

++     if (m_asynchronous == newAsynchronous)

++         return;

++     m_asynchronous = newAsynchronous;

++     emit asynchronousChanged();

++ }

++

++ PlaneGeometry::Status PlaneGeometry::status() const

++ {

++     return m_status;

++ }

++

++ void PlaneGeometry::doUpdateGeometry()

++ {

++     // reset the flag since we are processing the update

++     m_geometryUpdateRequested = false;

++

++ #if QT_CONFIG(concurrent)

++     if (m_geometryDataFuture.isRunning()) {

++         m_pendingAsyncUpdate = true;

++         return;

++     }

++ #endif

++

++     // Check validity of the geometry parameters

++     if (m_width <= 0 || m_height <= 0 || m_meshResolution.width() <= 0 || m_meshResolution.height() <= 0) {

++         clear();

++         update();

++         return;

++     }

++

++ #if QT_CONFIG(concurrent)

++     if (m_asynchronous) {

++         m_geometryDataFuture = QtConcurrent::run(generatePlaneGeometryAsync,

++                                                  m_width,

++                                                  m_height,

++                                                  m_meshResolution,

++                                                  m_plane,

++                                                  m_reversed,

++                                                  m_mirrored);

++         m_geometryDataWatcher.setFuture(m_geometryDataFuture);

++         m_status = Status::Loading;

++         Q_EMIT statusChanged();

++     } else {

++ #else

++     {

++

++ #endif // QT_CONFIG(concurrent)

++         updateGeometry(generatePlaneGeometry(m_width, m_height, m_meshResolution, m_plane, m_reversed, m_mirrored));

++     }

++ }

++

++ void PlaneGeometry::requestFinished()

++ {

++ #if QT_CONFIG(concurrent)

++     const auto output = m_geometryDataFuture.takeResult();

++     updateGeometry(output);

++ #endif

++ }

++

++ void PlaneGeometry::scheduleGeometryUpdate()

++ {

++     if (!m_geometryUpdateRequested) {

++         QMetaObject::invokeMethod(this, "doUpdateGeometry", Qt::QueuedConnection);

++         m_geometryUpdateRequested = true;

++     }

++ }

++

++ void PlaneGeometry::updateGeometry(const GeometryData &geometryData)

++ {

++     clear();

++     setStride(sizeof(float) * 8); // 3 for position, 2 for uv0, 3 for normal

++     setPrimitiveType(QQuick3DGeometry::PrimitiveType::Triangles);

++     addAttribute(QQuick3DGeometry::Attribute::PositionSemantic,

++                  0,

++                  QQuick3DGeometry::Attribute::F32Type);

++     addAttribute(QQuick3DGeometry::Attribute::TexCoord0Semantic,

++                  3 * sizeof(float),

++                  QQuick3DGeometry::Attribute::F32Type);

++     addAttribute(QQuick3DGeometry::Attribute::NormalSemantic,

++                  5 * sizeof(float),

++                  QQuick3DGeometry::Attribute::F32Type);

++     addAttribute(QQuick3DGeometry::Attribute::IndexSemantic,

++                  0,

++                  QQuick3DGeometry::Attribute::U16Type);

++

++     setBounds(geometryData.boundsMin, geometryData.boundsMax);

++     setVertexData(geometryData.vertexData);

++     setIndexData(geometryData.indexData);

++

++     // If the geometry update was requested while the geometry was being generated asynchronously,

++     // we need to schedule another geometry update now that the geometry is ready.

++     if (m_pendingAsyncUpdate) {

++         m_pendingAsyncUpdate = false;

++         scheduleGeometryUpdate();

++     } else {

++         m_status = Status::Ready;

++         Q_EMIT statusChanged();

++     }

++     update();

++     emit geometryChanged();

++ }

++

++ PlaneGeometry::GeometryData PlaneGeometry::generatePlaneGeometry(float width, float height, QSize meshResolution, Plane plane, bool reversed, bool mirrored)

++ {

++     GeometryData geometryData;

++

++     int quadsX = meshResolution.width();

++     int quadsY = meshResolution.height();

++

++     const int numVertices = (quadsX + 1) * (quadsY + 1);

++     const int numIndices = quadsX * quadsY * 6; // Two triangles per quad

++

++     const int vertexStride = sizeof(float) * (3 + 2 + 3); // vec3 (position), vec2 (uv), vec3 (normal)

++     const int indexStride = sizeof(uint16_t); // 16-bit index

++

++     geometryData.vertexData.resize(numVertices * vertexStride);

++     geometryData.indexData.resize(numIndices * indexStride);

++

++     QVector3D boundsMin(std::numeric_limits<float>::max(),

++                         std::numeric_limits<float>::max(),

++                         std::numeric_limits<float>::max());

++

++     QVector3D boundsMax(std::numeric_limits<float>::lowest(),

++                         std::numeric_limits<float>::lowest(),

++                         std::numeric_limits<float>::lowest());

++

++     float* vertexPtr = reinterpret_cast<float*>(geometryData.vertexData.data());

++     uint16_t* indexPtr = reinterpret_cast<uint16_t*>(geometryData.indexData.data());

++

++     QVector3D normal;

++     switch (plane) {

++     case Plane::XY:

++         normal = QVector3D(0, 0, 1);

++         break;

++     case Plane::XZ:

++         normal = QVector3D(0, 1, 0);

++         break;

++     case Plane::ZY:

++         normal = QVector3D(1, 0, 0);

++         break;

++     }

++

++     // Flip normal if the plane is reversed

++     if (reversed)

++         normal = -normal;

++

++     for (int y = 0; y <= quadsY; ++y) {

++         for (int x = 0; x <= quadsX; ++x) {

++             // Normalized UV coordinates

++             float u = static_cast<float>(x) / quadsX;

++             float v = static_cast<float>(y) / quadsY;

++

++             // Position in local space based on plane orientation

++             float posX = width * (u - 0.5f);

++             float posY = height * (v - 0.5f);

++

++             if (mirrored)

++                 v = 1.0f - v;

++

++             if (reversed)

++                 u = 1.0f - u;

++

++

++             QVector3D position;

++             switch (plane) {

++             case Plane::XY:

++                 position = QVector3D(posX, posY, 0.0f);

++                 break;

++             case Plane::XZ:

++                 position = QVector3D(posX, 0.0f, -posY);

++                 break;

++             case Plane::ZY:

++                 position = QVector3D(0.0f, posY, -posX);

++                 break;

++             }

++

++             // Write position

++             *vertexPtr++ = position.x();

++             *vertexPtr++ = position.y();

++             *vertexPtr++ = position.z();

++

++             // Write UV coordinates

++             *vertexPtr++ = u;

++             *vertexPtr++ = v;

++

++             // Write normal

++             *vertexPtr++ = normal.x();

++             *vertexPtr++ = normal.y();

++             *vertexPtr++ = normal.z();

++

++             // Update bounds

++             boundsMin.setX(std::min(boundsMin.x(), position.x()));

++             boundsMin.setY(std::min(boundsMin.y(), position.y()));

++             boundsMin.setZ(std::min(boundsMin.z(), position.z()));

++

++             boundsMax.setX(std::max(boundsMax.x(), position.x()));

++             boundsMax.setY(std::max(boundsMax.y(), position.y()));

++             boundsMax.setZ(std::max(boundsMax.z(), position.z()));

++         }

++     }

++

++     // Generate indices

++     for (int y = 0; y < quadsY; ++y) {

++         for (int x = 0; x < quadsX; ++x) {

++             uint16_t a = static_cast<uint16_t>(y * (quadsX + 1) + x);

++             uint16_t b = static_cast<uint16_t>(a + quadsX + 1);

++             uint16_t c = static_cast<uint16_t>(b + 1);

++             uint16_t d = static_cast<uint16_t>(a + 1);

++

++             if (reversed) {

++                 // Reverse the triangle winding order

++                 *indexPtr++ = a;

++                 *indexPtr++ = b;

++                 *indexPtr++ = d;

++

++                 *indexPtr++ = b;

++                 *indexPtr++ = c;

++                 *indexPtr++ = d;

++             } else {

++                 // Normal winding order

++                 *indexPtr++ = a;

++                 *indexPtr++ = d;

++                 *indexPtr++ = b;

++

++                 *indexPtr++ = b;

++                 *indexPtr++ = d;

++                 *indexPtr++ = c;

++             }

++         }

++     }

++

++     // Return the geometry data

++     geometryData.boundsMax = boundsMax;

++     geometryData.boundsMin = boundsMin;

++

++     return geometryData;

++ }

++

++ #if QT_CONFIG(concurrent)

++ void PlaneGeometry::generatePlaneGeometryAsync(QPromise<PlaneGeometry::GeometryData> &promise,

++                                                float width,

++                                                float height,

++                                                QSize meshResolution,

++                                                Plane plane,

++                                                bool reversed,

++                                                bool mirrored)

++ {

++     auto output = generatePlaneGeometry(width, height, meshResolution, plane, reversed, mirrored);

++     promise.addResult(output);

++ }

++ #endif

++

++ QT_END_NAMESPACE

Revision control