Revision control
++ // 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 "cuboidgeometry_p.h"
++
++ #if QT_CONFIG(concurrent)
++ #include <QtConcurrentRun>
++ #endif
++
++ QT_BEGIN_NAMESPACE
++
++ /*!
++ \qmltype CuboidGeometry
++ \inqmlmodule QtQuick3D.Helpers
++ \inherits Geometry
++ \since 6.9
++ \brief Provides geometry for a cuboid.
++
++ CuboidGeometry is a geometry type that represents a cuboid. The cuboid's size is
++ defined by its xExtent, yExtent, and zExtent properties. The topology of the plane is defined by
++ the yzMeshResolution, xzMeshResolution, and xyMeshResolution properties.
++ */
++
++ /*!
++ \qmlproperty real CuboidGeometry::xExtent
++ The x extent of the cuboid. The default value is 100.0.
++ */
++
++ /*!
++ \qmlproperty real CuboidGeometry::yExtent
++ The y extent of the cuboid. The default value is 100.0.
++ */
++
++ /*!
++ \qmlproperty real CuboidGeometry::zExtent
++ The z extent of the cuboid. The default value is 100.0.
++ */
++
++ /*!
++ \qmlproperty size CuboidGeometry::yzMeshResolution
++ The number of segments in the y and z direction. The default value is 2x2.
++ */
++
++ /*!
++ \qmlproperty size CuboidGeometry::xzMeshResolution
++ The number of segments in the x and z direction. The default value is 2x2.
++ */
++
++ /*!
++ \qmlproperty size CuboidGeometry::xyMeshResolution
++ The number of segments in the x and y direction. The default value is 2x2.
++ */
++
++ /*!
++ \qmlproperty bool CuboidGeometry::asynchronous
++
++ This property holds whether the geometry generation should be asynchronous.
++ */
++
++ /*!
++ \qmlproperty bool CuboidGeometry::status
++ \readonly
++
++ This property holds the status of the geometry generation when asynchronous is true.
++
++ \value CuboidGeometry.Null The geometry generation has not started
++ \value CuboidGeometry.Ready The geometry generation is complete.
++ \value CuboidGeometry.Loading The geometry generation is in progress.
++ \value CuboidGeometry.Error The geometry generation failed.
++ */
++
++
++ CuboidGeometry::CuboidGeometry(QQuick3DObject *parent)
++ : QQuick3DGeometry(parent)
++ {
++ #if QT_CONFIG(concurrent)
++ connect(&m_geometryDataWatcher, &QFutureWatcher<GeometryData>::finished, this, &CuboidGeometry::requestFinished);
++ #endif
++ scheduleGeometryUpdate();
++ }
++
++ CuboidGeometry::~CuboidGeometry()
++ {
++
++ }
++
++ float CuboidGeometry::xExtent() const
++ {
++ return m_xExtent;
++ }
++
++ void CuboidGeometry::setXExtent(float newXExtent)
++ {
++ if (qFuzzyCompare(m_xExtent, newXExtent))
++ return;
++ m_xExtent = newXExtent;
++ emit xExtentChanged();
++ scheduleGeometryUpdate();
++ }
++
++ float CuboidGeometry::yExtent() const
++ {
++ return m_yExtent;
++ }
++
++ void CuboidGeometry::setYExtent(float newYExtent)
++ {
++ if (qFuzzyCompare(m_yExtent, newYExtent))
++ return;
++ m_yExtent = newYExtent;
++ emit yExtentChanged();
++ scheduleGeometryUpdate();
++ }
++
++ float CuboidGeometry::zExtent() const
++ {
++ return m_zExtent;
++ }
++
++ void CuboidGeometry::setZExtent(float newZExtent)
++ {
++ if (qFuzzyCompare(m_zExtent, newZExtent))
++ return;
++ m_zExtent = newZExtent;
++ emit zExtentChanged();
++ scheduleGeometryUpdate();
++ }
++
++ QSize CuboidGeometry::yzMeshResolution() const
++ {
++ return m_yzMeshResolution;
++ }
++
++ void CuboidGeometry::setYzMeshResolution(const QSize &newYzMeshResolution)
++ {
++ if (m_yzMeshResolution == newYzMeshResolution)
++ return;
++ m_yzMeshResolution = newYzMeshResolution;
++ emit yzMeshResolutionChanged();
++ scheduleGeometryUpdate();
++ }
++
++ QSize CuboidGeometry::xzMeshResolution() const
++ {
++ return m_xzMeshResolution;
++ }
++
++ void CuboidGeometry::setXzMeshResolution(const QSize &newXzMeshResolution)
++ {
++ if (m_xzMeshResolution == newXzMeshResolution)
++ return;
++ m_xzMeshResolution = newXzMeshResolution;
++ emit xzMeshResolutionChanged();
++ scheduleGeometryUpdate();
++ }
++
++ QSize CuboidGeometry::xyMeshResolution() const
++ {
++ return m_xyMeshResolution;
++ }
++
++ void CuboidGeometry::setXyMeshResolution(const QSize &newXyMeshResolution)
++ {
++ if (m_xyMeshResolution == newXyMeshResolution)
++ return;
++ m_xyMeshResolution = newXyMeshResolution;
++ emit xyMeshResolutionChanged();
++ scheduleGeometryUpdate();
++ }
++
++ bool CuboidGeometry::asynchronous() const
++ {
++ return m_asynchronous;
++ }
++
++ void CuboidGeometry::setAsynchronous(bool newAsynchronous)
++ {
++ if (m_asynchronous == newAsynchronous)
++ return;
++ m_asynchronous = newAsynchronous;
++ emit asynchronousChanged();
++ }
++
++ CuboidGeometry::Status CuboidGeometry::status() const
++ {
++ return m_status;
++ }
++
++ void CuboidGeometry::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_xExtent <= 0 || m_yExtent <= 0 || m_yExtent <= 0) {
++ clear();
++ update();
++ return;
++ }
++
++ #if QT_CONFIG(concurrent)
++ if (m_asynchronous) {
++ m_geometryDataFuture = QtConcurrent::run(generateCuboidGeometryAsync,
++ m_xExtent,
++ m_yExtent,
++ m_zExtent,
++ m_yzMeshResolution,
++ m_xzMeshResolution,
++ m_xyMeshResolution);
++ m_geometryDataWatcher.setFuture(m_geometryDataFuture);
++ m_status = Status::Loading;
++ Q_EMIT statusChanged();
++ } else {
++ #else
++ {
++
++ #endif // QT_CONFIG(concurrent)
++ updateGeometry(generateCuboidGeometry(m_xExtent,
++ m_yExtent,
++ m_zExtent,
++ m_yzMeshResolution,
++ m_xzMeshResolution,
++ m_xyMeshResolution));
++ }
++ }
++
++ void CuboidGeometry::requestFinished()
++ {
++ #if QT_CONFIG(concurrent)
++ const auto output = m_geometryDataFuture.takeResult();
++ updateGeometry(output);
++ #endif
++ }
++
++ void CuboidGeometry::scheduleGeometryUpdate()
++ {
++ if (!m_geometryUpdateRequested) {
++ QMetaObject::invokeMethod(this, "doUpdateGeometry", Qt::QueuedConnection);
++ m_geometryUpdateRequested = true;
++ }
++ }
++
++ void CuboidGeometry::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();
++ }
++
++ CuboidGeometry::GeometryData CuboidGeometry::generateCuboidGeometry(float xExtent, float yExtent, float zExtent, QSize yzMeshResolution, QSize xzMeshResolution, QSize xyMeshResolution)
++ {
++ GeometryData geometryData;
++
++ const float halfXExtent = xExtent / 2.0f;
++ const float halfYExtent = yExtent / 2.0f;
++ const float halfZExtent = zExtent / 2.0f;
++ geometryData.boundsMin = QVector3D(-halfXExtent, -halfYExtent, -halfZExtent);
++ geometryData.boundsMax = QVector3D(halfXExtent, halfYExtent, halfZExtent);
++
++ // Total number of vertices and indices required
++ int numVertices = (yzMeshResolution.width() + 1) * (yzMeshResolution.height() + 1) * 2 +
++ (xzMeshResolution.width() + 1) * (xzMeshResolution.height() + 1) * 2 +
++ (xyMeshResolution.width() + 1) * (xyMeshResolution.height() + 1) * 2;
++
++ int numIndices = yzMeshResolution.width() * yzMeshResolution.height() * 6 * 2 +
++ xzMeshResolution.width() * xzMeshResolution.height() * 6 * 2 +
++ xyMeshResolution.width() * xyMeshResolution.height() * 6 * 2;
++
++ const int vertexStride = sizeof(float) * (3 + 2 + 3); // vec3 (position), vec2 (uv), vec3 (normal)
++ const int indexStride = sizeof(uint16_t); // 16-bit index
++
++ // Allocate memory for vertex and index data
++ geometryData.vertexData.resize(numVertices * vertexStride);
++ geometryData.indexData.resize(numIndices * indexStride);
++
++ // Set up raw pointers for direct memory manipulation
++ float* vertexPtr = reinterpret_cast<float*>(geometryData.vertexData.data());
++ uint16_t* indexPtr = reinterpret_cast<uint16_t*>(geometryData.indexData.data());
++
++ // Inline lambda for plane generation
++ auto generatePlane = [](float* &vertexPtr, uint16_t* &indexPtr, uint16_t &indexOffset, float width, float height, const QVector3D& origin, const QVector3D& right, const QVector3D& up, const QVector3D& normal, QSize resolution, bool flipWinding = false) {
++ const int quadsX = resolution.width();
++ const int quadsY = resolution.height();
++ const float halfWidth = width / 2.0f;
++ const float halfHeight = height / 2.0f;
++ quint16 vertexCount = 0;
++
++ // Generate vertices
++ 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;
++
++ // Compute the position of the vertex
++ QVector3D position = origin + right * (u * width - halfWidth) + up * (v * height - halfHeight);
++
++ // 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();
++
++ ++vertexCount;
++ }
++ }
++
++ // Generate indices
++ for (int y = 0; y < quadsY; ++y) {
++ for (int x = 0; x < quadsX; ++x) {
++ uint16_t a = indexOffset + 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 (!flipWinding) {
++ // First triangle (a, d, b)
++ *indexPtr++ = a;
++ *indexPtr++ = d;
++ *indexPtr++ = b;
++
++ // Second triangle (b, d, c)
++ *indexPtr++ = b;
++ *indexPtr++ = d;
++ *indexPtr++ = c;
++ } else {
++ *indexPtr++ = a;
++ *indexPtr++ = b;
++ *indexPtr++ = d;
++
++ *indexPtr++ = b;
++ *indexPtr++ = c;
++ *indexPtr++ = d;
++ }
++ }
++ }
++ indexOffset += vertexCount;
++ };
++
++ // Generate the 6 faces of the cuboid
++ // Right and Left (YZ plane)
++ uint16_t indexOffset = 0;
++ generatePlane(vertexPtr, indexPtr, indexOffset, zExtent, yExtent, QVector3D(halfXExtent, 0, 0), QVector3D(0, 0, -1), QVector3D(0, 1, 0), QVector3D(1, 0, 0), yzMeshResolution);
++ generatePlane(vertexPtr, indexPtr, indexOffset, zExtent, yExtent, QVector3D(-halfXExtent, 0, 0), QVector3D(0, 0, 1), QVector3D(0, 1, 0), QVector3D(-1, 0, 0), yzMeshResolution);
++
++
++ // Top and Bottom (XZ plane)
++ generatePlane(vertexPtr, indexPtr, indexOffset, xExtent, zExtent, QVector3D(0, halfYExtent, 0), QVector3D(-1, 0, 0), QVector3D(0, 0, 1), QVector3D(0, 1, 0), xzMeshResolution);
++ generatePlane(vertexPtr, indexPtr, indexOffset, xExtent, zExtent, QVector3D(0, -halfYExtent, 0), QVector3D(1, 0, 0), QVector3D(0, 0, 1), QVector3D(0, -1, 0), xzMeshResolution);
++
++ // Front and Back (XY plane)
++ generatePlane(vertexPtr, indexPtr, indexOffset, xExtent, yExtent, QVector3D(0, 0, halfZExtent), QVector3D(1, 0, 0), QVector3D(0, 1, 0), QVector3D(0, 0, 1), xyMeshResolution);
++ generatePlane(vertexPtr, indexPtr, indexOffset, xExtent, yExtent, QVector3D(0, 0, -halfZExtent), QVector3D(-1, 0, 0), QVector3D(0, 1, 0), QVector3D(0, 0, -1), xyMeshResolution);
++
++ // Return the geometry data
++ return geometryData;
++ }
++
++ #if QT_CONFIG(concurrent)
++ void CuboidGeometry::generateCuboidGeometryAsync(QPromise<CuboidGeometry::GeometryData> &promise,
++ float xExtent,
++ float yExtent,
++ float zExtent,
++ QSize yzMeshResolution,
++ QSize xzMeshResolution,
++ QSize xyMeshResolution)
++ {
++ auto output = generateCuboidGeometry(xExtent, yExtent, zExtent, yzMeshResolution, xzMeshResolution, xyMeshResolution);
++ promise.addResult(output);
++ }
++ #endif
++
++ QT_END_NAMESPACE