qquick3dgeometry.cpp

Go to the documentation of this file.

// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
#include "qquick3dgeometry_p.h"
#include "qquick3dscenemanager_p.h"
#include <QtQuick3DUtils/private/qssgutils_p.h>
 
QT_BEGIN_NAMESPACE
 
QQuick3DGeometryPrivate::QQuick3DGeometryPrivate()
    : QQuick3DObjectPrivate(QQuick3DObjectPrivate::Type::Geometry)
{
 
}
 
QQuick3DGeometry::QQuick3DGeometry(QQuick3DObject *parent)
    : QQuick3DObject(*new QQuick3DGeometryPrivate, parent)
{
 
}
 
QQuick3DGeometry::~QQuick3DGeometry()
{
 
}
 
QByteArray QQuick3DGeometry::vertexData() const
{
    const Q_D(QQuick3DGeometry);
    return d->m_vertexBuffer;
}
 
QByteArray QQuick3DGeometry::targetData() const
{
    const Q_D(QQuick3DGeometry);
    return d->m_targetBuffer;
}
 
QByteArray QQuick3DGeometry::indexData() const
{
    const Q_D(QQuick3DGeometry);
    return d->m_indexBuffer;
}
 
int QQuick3DGeometry::attributeCount() const
{
    const Q_D(QQuick3DGeometry);
    return d->m_attributeCount;
}
 
QQuick3DGeometry::Attribute QQuick3DGeometry::attribute(int index) const
{
    const Q_D(QQuick3DGeometry);
    return d->m_attributes[index];
}
 
int QQuick3DGeometry::targetAttributeCount() const
{
    const Q_D(QQuick3DGeometry);
    return d->m_targetAttributeCount;
}
 
QQuick3DGeometry::TargetAttribute QQuick3DGeometry::targetAttribute(int index) const
{
    const Q_D(QQuick3DGeometry);
    return d->m_targetAttributes[index];
}
 
QQuick3DGeometry::PrimitiveType QQuick3DGeometry::primitiveType() const
{
    const Q_D(QQuick3DGeometry);
    return d->m_primitiveType;
}
 
QVector3D QQuick3DGeometry::boundsMin() const
{
    const Q_D(QQuick3DGeometry);
    return d->m_min;
}
 
QVector3D QQuick3DGeometry::boundsMax() const
{
    const Q_D(QQuick3DGeometry);
    return d->m_max;
}
 
int QQuick3DGeometry::stride() const
{
    const Q_D(QQuick3DGeometry);
    return d->m_stride;
}
 
void QQuick3DGeometry::markAllDirty()
{
    QQuick3DObject::markAllDirty();
}
 
void QQuick3DGeometry::setVertexData(const QByteArray &data)
{
    Q_D(QQuick3DGeometry);
    d->m_vertexBuffer = data;
    d->m_geometryChanged = true;
}
 
void QQuick3DGeometry::setVertexData(int offset, const QByteArray &data)
{
    Q_D(QQuick3DGeometry);
    if (offset >= d->m_vertexBuffer.size())
        return;
 
    const size_t len = qMin(d->m_vertexBuffer.size() - offset, data.size());
    memcpy(d->m_vertexBuffer.data() + offset, data.data(), len);
 
    d->m_geometryChanged = true;
}
 
void QQuick3DGeometry::setTargetData(const QByteArray &data)
{
    Q_D(QQuick3DGeometry);
    d->m_targetBuffer = data;
    d->m_targetChanged = true;
}
 
void QQuick3DGeometry::setTargetData(int offset, const QByteArray &data)
{
    Q_D(QQuick3DGeometry);
    if (offset >= d->m_targetBuffer.size())
        return;
 
    const size_t len = qMin(d->m_targetBuffer.size() - offset, data.size());
    memcpy(d->m_targetBuffer.data() + offset, data.data(), len);
 
    d->m_targetChanged = true;
}
 
void QQuick3DGeometry::setIndexData(const QByteArray &data)
{
    Q_D(QQuick3DGeometry);
    d->m_indexBuffer = data;
    d->m_geometryChanged = true;
}
 
void QQuick3DGeometry::setIndexData(int offset, const QByteArray &data)
{
    Q_D(QQuick3DGeometry);
    if (offset >= d->m_indexBuffer.size())
        return;
 
    const size_t len = qMin(d->m_indexBuffer.size() - offset, data.size());
    memcpy(d->m_indexBuffer.data() + offset, data.data(), len);
 
    d->m_geometryChanged = true;
}
 
void QQuick3DGeometry::setStride(int stride)
{
    Q_D(QQuick3DGeometry);
    if (stride != d->m_stride) {
        d->m_stride = stride;
        d->m_geometryChanged = true;
    }
}
 
void QQuick3DGeometry::setBounds(const QVector3D &min, const QVector3D &max)
{
    Q_D(QQuick3DGeometry);
    d->m_max = max;
    d->m_min = min;
    d->m_geometryBoundsChanged = true;
}
 
void QQuick3DGeometry::setPrimitiveType(PrimitiveType type)
{
    Q_D(QQuick3DGeometry);
    if (d->m_primitiveType != type) {
        d->m_primitiveType = type;
        d->m_geometryChanged = true;
    }
}
 
void QQuick3DGeometry::addAttribute(Attribute::Semantic semantic, int offset,
                  Attribute::ComponentType componentType)
{
    Q_D(QQuick3DGeometry);
    if (semantic != Attribute::TargetPositionSemantic
            && semantic != Attribute::TargetNormalSemantic
            && semantic != Attribute::TargetTangentSemantic
            && semantic != Attribute::TargetBinormalSemantic) {
        if (d->m_attributeCount >= QQuick3DGeometryPrivate::MAX_ATTRIBUTE_COUNT)
            return;
        d->m_attributes[d->m_attributeCount].semantic = semantic;
        d->m_attributes[d->m_attributeCount].offset = offset;
        d->m_attributes[d->m_attributeCount].componentType = componentType;
        d->m_attributeCount++;
        d->m_geometryChanged = true;
    } else {
        if (d->m_targetAttributeCount >= QQuick3DGeometryPrivate::MAX_TARGET_ATTRIBUTE_COUNT)
            return;
        d->m_targetAttributes[d->m_targetAttributeCount].targetId = 0;
        d->m_targetAttributes[d->m_targetAttributeCount].attr.semantic = semantic;
        d->m_targetAttributes[d->m_targetAttributeCount].attr.offset = offset;
        // m_stride and m_vertexBuffer will be used for targetBuffer.
        d->m_targetAttributeCount++;
        d->m_targetChanged = true;
        d->m_usesOldTargetSemantics = true;
    }
}
 
void QQuick3DGeometry::addAttribute(const Attribute &attribute)
{
    Q_D(QQuick3DGeometry);
    if (d->m_attributeCount >= QQuick3DGeometryPrivate::MAX_ATTRIBUTE_COUNT)
        return;
    d->m_attributes[d->m_attributeCount++] = attribute;
    d->m_geometryChanged = true;
}
 
void QQuick3DGeometry::addTargetAttribute(quint32 targetId,
                                          Attribute::Semantic semantic, int offset,
                                          int stride)
{
    Q_D(QQuick3DGeometry);
    if (d->m_targetAttributeCount >= QQuick3DGeometryPrivate::MAX_TARGET_ATTRIBUTE_COUNT)
        return;
    if (semantic == Attribute::IndexSemantic
            || semantic == Attribute::JointSemantic
            || semantic == Attribute::WeightSemantic)
        return;
    d->m_targetAttributes[d->m_targetAttributeCount].targetId = targetId;
    d->m_targetAttributes[d->m_targetAttributeCount].attr.semantic = semantic;
    d->m_targetAttributes[d->m_targetAttributeCount].attr.offset = offset;
    d->m_targetAttributes[d->m_targetAttributeCount].stride = stride;
    d->m_targetAttributeCount++;
    d->m_targetChanged = true;
}
 
void QQuick3DGeometry::addTargetAttribute(const TargetAttribute &attribute)
{
    Q_D(QQuick3DGeometry);
    if (d->m_targetAttributeCount >= QQuick3DGeometryPrivate::MAX_TARGET_ATTRIBUTE_COUNT)
        return;
    if (attribute.attr.semantic == Attribute::IndexSemantic ||
            attribute.attr.semantic == Attribute::JointSemantic ||
            attribute.attr.semantic == Attribute::WeightSemantic)
        return;
    d->m_targetAttributes[d->m_targetAttributeCount++] = attribute;
    d->m_targetChanged = true;
}
 
void QQuick3DGeometry::clear()
{
    Q_D(QQuick3DGeometry);
    d->m_vertexBuffer.clear();
    d->m_targetBuffer.clear();
    d->m_indexBuffer.clear();
    d->m_attributeCount = 0;
    d->m_targetAttributeCount = 0;
    d->m_subsets.clear();
    d->m_primitiveType = PrimitiveType::Triangles;
    d->m_geometryChanged = true;
    d->m_targetChanged = true;
    d->m_min = {};
    d->m_max = {};
}
 
int QQuick3DGeometry::subsetCount() const
{
    Q_D(const QQuick3DGeometry);
    return d->m_subsets.size();
}
 
QVector3D QQuick3DGeometry::subsetBoundsMin(int subset) const
{
    Q_D(const QQuick3DGeometry);
    if (subset >= 0 && subset < d->m_subsets.size())
        return d->m_subsets[subset].boundsMin;
    return {};
}
 
QVector3D QQuick3DGeometry::subsetBoundsMax(int subset) const
{
    Q_D(const QQuick3DGeometry);
    if (subset >= 0 && subset < d->m_subsets.size())
        return d->m_subsets[subset].boundsMax;
    return {};
}
 
int QQuick3DGeometry::subsetOffset(int subset) const
{
    Q_D(const QQuick3DGeometry);
    if (subset >= 0 && subset < d->m_subsets.size())
        return d->m_subsets[subset].offset;
    return 0;
}
 
int QQuick3DGeometry::subsetCount(int subset) const
{
    Q_D(const QQuick3DGeometry);
    if (subset >= 0 && subset < d->m_subsets.size())
        return d->m_subsets[subset].count;
    return 0;
}
 
QString QQuick3DGeometry::subsetName(int subset) const
{
    Q_D(const QQuick3DGeometry);
    if (subset >= 0 && subset < d->m_subsets.size())
        return d->m_subsets[subset].name;
    return {};
}
 
void QQuick3DGeometry::addSubset(int offset, int count, const QVector3D &boundsMin, const QVector3D &boundsMax, const QString &name)
{
    Q_D(QQuick3DGeometry);
    d->m_subsets.append({name, boundsMin, boundsMax, quint32(offset), quint32(count)});
    d->m_geometryChanged = true;
}
 
static inline QSSGMesh::Mesh::DrawMode mapPrimitiveType(QQuick3DGeometry::PrimitiveType t)
{
    switch (t) {
    case QQuick3DGeometry::PrimitiveType::Points:
        return QSSGMesh::Mesh::DrawMode::Points;
    case QQuick3DGeometry::PrimitiveType::LineStrip:
        return QSSGMesh::Mesh::DrawMode::LineStrip;
    case QQuick3DGeometry::PrimitiveType::Lines:
        return QSSGMesh::Mesh::DrawMode::Lines;
    case QQuick3DGeometry::PrimitiveType::TriangleStrip:
        return QSSGMesh::Mesh::DrawMode::TriangleStrip;
    case QQuick3DGeometry::PrimitiveType::TriangleFan:
        return QSSGMesh::Mesh::DrawMode::TriangleFan;
    case QQuick3DGeometry::PrimitiveType::Triangles:
        return QSSGMesh::Mesh::DrawMode::Triangles;
    }
 
    Q_UNREACHABLE_RETURN(QSSGMesh::Mesh::DrawMode::Triangles);
}
 
static inline QSSGMesh::RuntimeMeshData::Attribute::Semantic mapSemantic(QQuick3DGeometry::Attribute::Semantic s)
{
    switch (s) {
    case QQuick3DGeometry::Attribute::IndexSemantic:
        return QSSGMesh::RuntimeMeshData::Attribute::IndexSemantic;
    case QQuick3DGeometry::Attribute::PositionSemantic:
        return QSSGMesh::RuntimeMeshData::Attribute::PositionSemantic;
    case QQuick3DGeometry::Attribute::NormalSemantic:
        return QSSGMesh::RuntimeMeshData::Attribute::NormalSemantic;
    case QQuick3DGeometry::Attribute::TexCoord0Semantic:
        return QSSGMesh::RuntimeMeshData::Attribute::TexCoord0Semantic;
    case QQuick3DGeometry::Attribute::TexCoord1Semantic:
        return QSSGMesh::RuntimeMeshData::Attribute::TexCoord1Semantic;
    case QQuick3DGeometry::Attribute::TangentSemantic:
        return QSSGMesh::RuntimeMeshData::Attribute::TangentSemantic;
    case QQuick3DGeometry::Attribute::BinormalSemantic:
        return QSSGMesh::RuntimeMeshData::Attribute::BinormalSemantic;
    case QQuick3DGeometry::Attribute::JointSemantic:
        return QSSGMesh::RuntimeMeshData::Attribute::JointSemantic;
    case QQuick3DGeometry::Attribute::WeightSemantic:
        return QSSGMesh::RuntimeMeshData::Attribute::WeightSemantic;
    case QQuick3DGeometry::Attribute::ColorSemantic:
        return QSSGMesh::RuntimeMeshData::Attribute::ColorSemantic;
    case QQuick3DGeometry::Attribute::TargetPositionSemantic:
        return QSSGMesh::RuntimeMeshData::Attribute::PositionSemantic;
    case QQuick3DGeometry::Attribute::TargetNormalSemantic:
        return QSSGMesh::RuntimeMeshData::Attribute::NormalSemantic;
    case QQuick3DGeometry::Attribute::TargetTangentSemantic:
        return QSSGMesh::RuntimeMeshData::Attribute::TangentSemantic;
    case QQuick3DGeometry::Attribute::TargetBinormalSemantic:
        return QSSGMesh::RuntimeMeshData::Attribute::BinormalSemantic;
    }
 
    Q_UNREACHABLE_RETURN(QSSGMesh::RuntimeMeshData::Attribute::PositionSemantic);
}
 
static inline QSSGMesh::Mesh::ComponentType mapComponentType(QQuick3DGeometry::Attribute::ComponentType t)
{
    switch (t) {
    case QQuick3DGeometry::Attribute::U16Type:
        return QSSGMesh::Mesh::ComponentType::UnsignedInt16;
    case QQuick3DGeometry::Attribute::U32Type:
        return QSSGMesh::Mesh::ComponentType::UnsignedInt32;
    case QQuick3DGeometry::Attribute::I32Type:
        return QSSGMesh::Mesh::ComponentType::Int32;
    case QQuick3DGeometry::Attribute::F32Type:
        return QSSGMesh::Mesh::ComponentType::Float32;
    }
 
    Q_UNREACHABLE_RETURN(QSSGMesh::Mesh::ComponentType::Float32);
}
 
QSSGRenderGraphObject *QQuick3DGeometry::updateSpatialNode(QSSGRenderGraphObject *node)
{
    Q_D(QQuick3DGeometry);
    if (!node) {
        markAllDirty();
        node = new QSSGRenderGeometry();
        emit geometryNodeDirty();
    }
    QQuick3DObject::updateSpatialNode(node);
    QSSGRenderGeometry *geometry = static_cast<QSSGRenderGeometry *>(node);
    if (d->m_geometryChanged) {
        geometry->clearVertexAndIndex();
        geometry->setBounds(d->m_min, d->m_max);
        geometry->setStride(d->m_stride);
        // If there is vertex data but no stride is set, the user likely forgot to set the stride.
        if (d->m_stride < 1 && !d->m_vertexBuffer.isEmpty())
            qWarning("%d is an invalid stride, was QQuick3DGeometry::setStride() called?", d->m_stride);
        geometry->setIndexData(d->m_indexBuffer);
        geometry->setVertexData(d->m_vertexBuffer);
        geometry->setPrimitiveType(mapPrimitiveType(d->m_primitiveType));
        quint32 indexBufferComponentSize = 0;
        for (int i = 0; i < d->m_attributeCount; ++i) {
            const auto componentType = mapComponentType(d->m_attributes[i].componentType);
            geometry->addAttribute(mapSemantic(d->m_attributes[i].semantic),
                                   d->m_attributes[i].offset,
                                   componentType);
            if (d->m_attributes[i].semantic == Attribute::IndexSemantic) {
                if (componentType != QSSGMesh::Mesh::ComponentType::UnsignedInt16
                        && componentType != QSSGMesh::Mesh::ComponentType::UnsignedInt32)
                {
                    qWarning("Index data can only be uint16 or uint32");
                }
                indexBufferComponentSize = QSSGMesh::MeshInternal::byteSizeForComponentType(componentType);
            } else if (componentType == QSSGMesh::Mesh::ComponentType::UnsignedInt16) {
                qWarning("Attributes cannot be uint16, only index data");
            }
        }
        if (!d->m_indexBuffer.isEmpty() && !indexBufferComponentSize) {
            qWarning("IndexData has been set, but no index attribute found.");
            geometry->setIndexData({});
        }
        // Implicitely add subset if none set for backwards compatibility
        if (d->m_subsets.isEmpty()) {
            quint32 offset = 0;
            quint32 count = 0;
            if (!d->m_indexBuffer.isEmpty() && indexBufferComponentSize)
                count = d->m_indexBuffer.size() / indexBufferComponentSize;
            else if (d->m_stride)
                count = d->m_vertexBuffer.size() / d->m_stride;
            geometry->addSubset(offset, count, d->m_min, d->m_max);
        } else {
            for (auto &s : d->m_subsets)
                geometry->addSubset(s.offset, s.count, s.boundsMin, s.boundsMax, s.name);
        }
        d->m_geometryChanged = false;
        emit geometryChanged();
    }
    if (d->m_geometryBoundsChanged) {
        geometry->setBounds(d->m_min, d->m_max);
        emit geometryNodeDirty();
        d->m_geometryBoundsChanged = false;
    }
    if (d->m_targetChanged) {
        geometry->clearTarget();
        geometry->setTargetData(d->m_usesOldTargetSemantics ? d->m_vertexBuffer : d->m_targetBuffer);
        for (int i = 0; i < d->m_targetAttributeCount; ++i) {
            geometry->addTargetAttribute(d->m_targetAttributes[i].targetId,
                                         mapSemantic(d->m_targetAttributes[i].attr.semantic),
                                         d->m_targetAttributes[i].attr.offset,
                                         d->m_usesOldTargetSemantics ? d->m_stride : d->m_targetAttributes[i].stride);
        }
        d->m_targetChanged = false;
    }
 
    DebugViewHelpers::ensureDebugObjectName(geometry, this);
 
    return node;
}
 
QQuick3DGeometry::Attribute::Semantic QQuick3DGeometryPrivate::semanticFromName(const QByteArray &name)
{
    static QMap<const QByteArray, QQuick3DGeometry::Attribute::Semantic> semanticMap;
    if (semanticMap.isEmpty()) {
        semanticMap[QSSGMesh::MeshInternal::getPositionAttrName()] = QQuick3DGeometry::Attribute::PositionSemantic;
        semanticMap[QSSGMesh::MeshInternal::getNormalAttrName()] = QQuick3DGeometry::Attribute::NormalSemantic;
        semanticMap[QSSGMesh::MeshInternal::getUV0AttrName()] = QQuick3DGeometry::Attribute::TexCoord0Semantic;
        semanticMap[QSSGMesh::MeshInternal::getUV1AttrName()] = QQuick3DGeometry::Attribute::TexCoord1Semantic;
        semanticMap[QSSGMesh::MeshInternal::getTexTanAttrName()] = QQuick3DGeometry::Attribute::TangentSemantic;
        semanticMap[QSSGMesh::MeshInternal::getTexBinormalAttrName()] = QQuick3DGeometry::Attribute::BinormalSemantic;
        semanticMap[QSSGMesh::MeshInternal::getColorAttrName()] = QQuick3DGeometry::Attribute::ColorSemantic;
        semanticMap[QSSGMesh::MeshInternal::getWeightAttrName()] = QQuick3DGeometry::Attribute::WeightSemantic;
        semanticMap[QSSGMesh::MeshInternal::getJointAttrName()] = QQuick3DGeometry::Attribute::JointSemantic;
    }
    return semanticMap[name];
}
 
QQuick3DGeometry::Attribute::ComponentType QQuick3DGeometryPrivate::toComponentType(QSSGMesh::Mesh::ComponentType ctype)
{
    switch (ctype) {
    case QSSGMesh::Mesh::ComponentType::Float32:
        return QQuick3DGeometry::Attribute::F32Type;
    case QSSGMesh::Mesh::ComponentType::Int32:
        return QQuick3DGeometry::Attribute::I32Type;
    case QSSGMesh::Mesh::ComponentType::UnsignedInt16:
        return QQuick3DGeometry::Attribute::U16Type;
    case QSSGMesh::Mesh::ComponentType::UnsignedInt32:
        return QQuick3DGeometry::Attribute::U32Type;
 
    case QSSGMesh::Mesh::ComponentType::Float16:
    case QSSGMesh::Mesh::ComponentType::Float64:
    case QSSGMesh::Mesh::ComponentType::UnsignedInt8:
    case QSSGMesh::Mesh::ComponentType::Int8:
    case QSSGMesh::Mesh::ComponentType::Int16:
    case QSSGMesh::Mesh::ComponentType::UnsignedInt64:
    case QSSGMesh::Mesh::ComponentType::Int64:
    default:
        Q_ASSERT_X(0, "Incorrect datatype", "QQuick3DGeometryPrivate::toComponentType");
        break;
    }
    return QQuick3DGeometry::Attribute::F32Type;
}
 
QT_END_NAMESPACE