qssgrtutilities.cpp

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
 
 
#include "qssgrtutilities_p.h"
 
#include "qssgqmlutilities_p.h"
#include "qssgscenedesc_p.h"
 
#include <QtCore/qurl.h>
#include <QtCore/qbuffer.h>
 
#include <QtGui/qimage.h>
#include <QtGui/qimagereader.h>
#include <QtGui/qimagewriter.h>
#include <QtGui/qquaternion.h>
 
#include <QtQuick3DRuntimeRender/private/qssgrenderbuffermanager_p.h>
 
QT_BEGIN_NAMESPACE
 
 
// Actually set the property on node->obj, using QMetaProperty::write()
void QSSGRuntimeUtils::applyPropertyValue(const QSSGSceneDesc::Node *node, QObject *o, QSSGSceneDesc::Property *property)
{
    auto *obj = qobject_cast<QQuick3DObject *>(o ? o : node->obj);
    if (!obj)
        return;
 
    auto *metaObj = obj->metaObject();
    int propertyIndex = metaObj->indexOfProperty(property->name);
    if (propertyIndex < 0) {
        qWarning() << "QSSGSceneDesc: could not find property" << property->name << "in" << obj;
        return;
    }
    auto metaProp = metaObj->property(propertyIndex);
    QVariant value;
 
    auto metaId = property->value.metaType().id();
    auto *scene = node->scene;
 
    if (metaId == qMetaTypeId<QSSGSceneDesc::Node *>()) {
        const auto *valueNode = qvariant_cast<QSSGSceneDesc::Node *>(property->value);
        QObject *obj = valueNode ? valueNode->obj : nullptr;
        value = QVariant::fromValue(obj);
    } else if (metaId == qMetaTypeId<QSSGSceneDesc::Mesh *>()) { // Special handling for mesh nodes.
        // Mesh nodes does not have an equivalent in the QtQuick3D scene, but is registered
        // as a source property in the intermediate scene we therefore need to convert it to
        // be a usable source url now.
        const auto meshNode = qvariant_cast<const QSSGSceneDesc::Mesh *>(property->value);
        const auto url = meshNode ? QUrl(QSSGBufferManager::runtimeMeshSourceName(node->scene->id, meshNode->idx)) : QUrl{};
        value = QVariant::fromValue(url);
    } else if (metaId == qMetaTypeId<QUrl>()) {
        const auto url = qvariant_cast<QUrl>(property->value);
        // TODO: Use QUrl::resolved() instead??
        QString workingDir = scene->sourceDir;
        const QUrl qurl = url.isValid() ? QUrl::fromUserInput(url.path(), workingDir) : QUrl{};
        value = QVariant::fromValue(qurl);
    } else if (metaId == qMetaTypeId<QSSGSceneDesc::Flag>() && property->call) {
        // If we have a QSSGSceneDesc::Flag variant, then it came from setProperty(), and the setter function is defined.
        const auto flag = qvariant_cast<QSSGSceneDesc::Flag>(property->value);
        property->call->set(*obj, property->name, flag.value);
        qDebug() << "Flag special case, probably shouldn't happen" << node->name << property->name << property->value << flag.value;
        return;
    } else {
        value = property->value;
    }
 
    if (value.metaType().id() == qMetaTypeId<QString>()) {
        auto str = value.toString();
        auto propType = metaProp.metaType();
        if (propType.id() == qMetaTypeId<QVector3D>()) {
            QStringList l = str.split(u',');
            if (l.length() != 3) {
                qWarning() << "Wrong format for QVector3D:" << str;
            } else {
                QVector3D vec3(l.at(0).toFloat(), l.at(1).toFloat(), l.at(2).toFloat());
                value = QVariant::fromValue(vec3);
            }
        } else if (propType.id() == qMetaTypeId<QVector2D>()) {
            QStringList l = str.split(u',');
            if (l.length() != 2) {
                qWarning() << "Wrong format for QVector2D:" << str;
            } else {
                QVector2D vec(l.at(0).toFloat(), l.at(1).toFloat());
                value = QVariant::fromValue(vec);
            }
        } else if (propType.id() == qMetaTypeId<QVector4D>()) {
            QStringList l = str.split(u',');
            if (l.length() != 2) {
                qWarning() << "Wrong format for QVector4D:" << str;
            } else {
                QVector4D vec(l.at(0).toFloat(), l.at(1).toFloat(), l.at(2).toFloat(), l.at(3).toFloat());
                value = QVariant::fromValue(vec);
            }
        } else if (propType.id() == qMetaTypeId<QQuaternion>()) {
            QStringList l = str.split(u',');
            if (l.length() != 4) {
                qWarning() << "Wrong format for QQuaternion:" << str;
            } else {
                QQuaternion quat(l.at(0).toFloat(), l.at(1).toFloat(), l.at(2).toFloat(), l.at(3).toFloat());
                value = QVariant::fromValue(quat);
            }
        } else {
            // All other strings are supposed to be in QML-compatible format, so they can be written out directly
        }
    } else if (value.metaType().id() == qMetaTypeId<QSSGSceneDesc::NodeList*>()) {
        auto qmlListVar = metaProp.read(obj);
        // We have to write explicit code for each list property type, since metatype can't
        // tell us if we have a QQmlListProperty (if we had known, we could have made a naughty
        // hack and just static_cast to QQmlListProperty<QObject>
        if (qmlListVar.metaType().id() == qMetaTypeId<QQmlListProperty<QQuick3DMaterial>>()) {
            auto qmlList = qvariant_cast<QQmlListProperty<QQuick3DMaterial>>(qmlListVar);
            auto nodeList = qvariant_cast<QSSGSceneDesc::NodeList*>(value);
            auto head = reinterpret_cast<QSSGSceneDesc::Node **>(nodeList->head);
 
            for (int i = 0, end = nodeList->count; i != end; ++i)
                qmlList.append(&qmlList, qobject_cast<QQuick3DMaterial *>((*(head + i))->obj));
 
        } else {
            qWarning() << "Can't handle list property type" << qmlListVar.metaType();
        }
        return; //In any case, we can't send NodeList to QMetaProperty::write()
    }
 
    // qobject_cast doesn't work on nullptr, so we must convert the pointer manually
    if ((metaProp.metaType().flags() & QMetaType::PointerToQObject) && value.isNull())
        value.convert(metaProp.metaType()); //This will return false, but convert to the type anyway
 
    // Q_ENUMS with '|' is explicitly handled, otherwise uses QVariant::convert. This means
    // we get implicit qobject_cast and string to:
    //    QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::QColor, QMetaType::QDate, QMetaType::QDateTime,
    //    QMetaType::Double, QMetaType::QFont, QMetaType::Int, QMetaType::QKeySequence, QMetaType::LongLong,
    //    QMetaType::QStringList, QMetaType::QTime, QMetaType::UInt, QMetaType::ULongLong, QMetaType::QUuid
 
    bool success = metaProp.write(obj, value);
 
    if (!success) {
        qWarning() << "Failure when setting property" << property->name << "to" << property->value << "maps to" << value
                   << "property metatype:" << metaProp.typeName();
    }
}
 
 
static void setProperties(QQuick3DObject &obj, const QSSGSceneDesc::Node &node, const QString &workingDir = {})
{
    using namespace QSSGSceneDesc;
    const auto &properties = node.properties;
    auto it = properties.begin();
    const auto end = properties.end();
    for (; it != end; ++it) {
        const auto &v = *it;
        if (!v->call) {
            QSSGRuntimeUtils::applyPropertyValue(&node, &obj, v);
            continue;
        }
        const auto &var = v->value;
        if (var.metaType().id() == qMetaTypeId<Node *>()) {
            const auto *node = qvariant_cast<Node *>(var);
            v->call->set(obj, v->name, node ? node->obj : nullptr);
        } else if (var.metaType() == QMetaType::fromType<Mesh *>()) { // Special handling for mesh nodes.
            // Mesh nodes does not have an equivalent in the QtQuick3D scene, but is registered
            // as a source property in the intermediate scene we therefore need to convert it to
            // be a usable source url now.
            const auto meshNode = qvariant_cast<const Mesh *>(var);
            const auto url = meshNode ? QUrl(QSSGBufferManager::runtimeMeshSourceName(node.scene->id, meshNode->idx)) : QUrl{};
            v->call->set(obj, v->name, &url);
        } else if (var.metaType() == QMetaType::fromType<QUrl>()) {
            const auto url = qvariant_cast<QUrl>(var);
            // TODO: Use QUrl::resolved() instead
            const QUrl qurl = url.isValid() ? QUrl::fromUserInput(url.toString(), workingDir) : QUrl{};
            v->call->set(obj, v->name, &qurl);
        } else if (var.metaType().id() == qMetaTypeId<QSSGSceneDesc::Flag>()) {
            const auto flag = qvariant_cast<QSSGSceneDesc::Flag>(var);
            v->call->set(obj, v->name, flag.value);
        } else {
            v->call->set(obj, v->name, var);
        }
    }
}
 
template<typename GraphObjectType, typename NodeType>
GraphObjectType *createRuntimeObject(NodeType &node, QQuick3DObject &parent)
{
    GraphObjectType *obj = qobject_cast<GraphObjectType *>(node.obj);
    if (!obj) {
        node.obj = qobject_cast<QQuick3DObject *>(obj = new GraphObjectType);
        QString name = QString::fromUtf8(node.name);
        if (name.isEmpty())
            name = QString::fromUtf8(QSSGQmlUtilities::getQmlElementName(node));
        obj->setObjectName(name);
        obj->setParent(&parent);
        obj->setParentItem(&parent);
    }
    Q_ASSERT(obj == node.obj);
 
    return obj;
}
 
template<>
QQuick3DTextureData *createRuntimeObject<QQuick3DTextureData>(QSSGSceneDesc::TextureData &node, QQuick3DObject &parent)
{
    QQuick3DTextureData *obj = qobject_cast<QQuick3DTextureData *>(node.obj);
    if (!obj) {
        node.obj = qobject_cast<QQuick3DObject *>(obj = new QQuick3DTextureData);
        obj->setObjectName(node.name);
        obj->setParent(&parent);
        obj->setParentItem(&parent);
 
        const auto &texData = node.data;
        const bool isCompressed = ((node.flgs & quint8(QSSGSceneDesc::TextureData::Flags::Compressed)) != 0);
 
        if (!texData.isEmpty()) {
            QImage image;
            if (isCompressed) {
                QByteArray data = texData;
                QBuffer readBuffer(&data);
                QImageReader imageReader(&readBuffer, node.fmt);
                image = imageReader.read();
                if (image.isNull())
                    qWarning() << imageReader.errorString();
            } else {
                const auto &size = node.sz;
                image = QImage(reinterpret_cast<const uchar *>(texData.data()), size.width(), size.height(), QImage::Format::Format_RGBA8888);
            }
 
            if (!image.isNull()) {
                const QPixelFormat pixFormat = image.pixelFormat();
                QImage::Format targetFormat = QImage::Format_RGBA8888_Premultiplied;
                QQuick3DTextureData::Format textureFormat = QQuick3DTextureData::Format::RGBA8;
                if (image.colorCount()) { // a palleted image
                    targetFormat = QImage::Format_RGBA8888;
                } else if (pixFormat.channelCount() == 1) {
                    targetFormat = QImage::Format_Grayscale8;
                    textureFormat = QQuick3DTextureData::Format::R8;
                } else if (pixFormat.alphaUsage() == QPixelFormat::IgnoresAlpha) {
                    targetFormat = QImage::Format_RGBX8888;
                } else if (pixFormat.premultiplied() == QPixelFormat::NotPremultiplied) {
                    targetFormat = QImage::Format_RGBA8888;
                }
 
                image.convertTo(targetFormat); // convert to a format mappable to QRhiTexture::Format
                image.flip(); // Flip vertically to the conventional Y-up orientation
 
                const auto bytes = image.sizeInBytes();
                obj->setSize(image.size());
                obj->setFormat(textureFormat);
                obj->setTextureData(QByteArray(reinterpret_cast<const char *>(image.constBits()), bytes));
            }
        }
    }
 
    return obj;
}
 
 
// Resources may refer to other resources and/or nodes, so we first generate all the resources without setting properties,
// then all the nodes with properties, and finally we set properties for the resources
// TODO: split this into different functions
 
void QSSGRuntimeUtils::createGraphObject(QSSGSceneDesc::Node &node,
                                         QQuick3DObject &parent,
                                         QString path,
                                         QSSGRuntimeObjectNameMap *objectMap,
                                         QSSGRuntimeObjectTypeMap *typeMap,
                                         bool traverseChildrenAndSetProperties)
{
    using namespace QSSGSceneDesc;
 
    QQuick3DObject *obj = nullptr;
    switch (node.nodeType) {
    case Node::Type::Skeleton:
        // Skeleton is a resource that also needs to be in the node tree. We don't do that anymore.
        qWarning("Skeleton runtime import not supported");
 
        // NOTE: The skeleton is special as it's a resource and a node, the
        // hierarchical parent is therefore important here.
        if (!node.obj) {// 1st Phase : 'create Resources'
            obj = createRuntimeObject<QQuick3DSkeleton>(static_cast<Skeleton &>(node), parent);
        } else { // 2nd Phase : setParent for the Node hierarchy.
            obj = qobject_cast<QQuick3DSkeleton *>(node.obj);
            obj->setParent(&parent);
            obj->setParentItem(&parent);
        }
        break;
    case Node::Type::Joint:
        obj = createRuntimeObject<QQuick3DJoint>(static_cast<Joint &>(node), parent);
        break;
    case Node::Type::Skin:
        obj = createRuntimeObject<QQuick3DSkin>(static_cast<Skin &>(node), parent);
        break;
    case Node::Type::MorphTarget:
        obj = createRuntimeObject<QQuick3DMorphTarget>(static_cast<MorphTarget &>(node), parent);
        break;
    case Node::Type::Light:
    {
        auto &light = static_cast<Light &>(node);
        if (light.runtimeType == Node::RuntimeType::DirectionalLight)
            obj = createRuntimeObject<QQuick3DDirectionalLight>(light, parent);
        else if (light.runtimeType == Node::RuntimeType::PointLight)
            obj = createRuntimeObject<QQuick3DPointLight>(light, parent);
        else if (light.runtimeType == Node::RuntimeType::SpotLight)
            obj = createRuntimeObject<QQuick3DSpotLight>(light, parent);
        else
            Q_UNREACHABLE();
    }
        break;
    case Node::Type::Transform:
        obj = createRuntimeObject<QQuick3DNode>(node, parent);
        break;
    case Node::Type::Camera:
    {
        auto &camera = static_cast<Camera &>(node);
        if (camera.runtimeType == Node::RuntimeType::OrthographicCamera)
            obj = createRuntimeObject<QQuick3DOrthographicCamera>(camera, parent);
        else if (camera.runtimeType == Node::RuntimeType::PerspectiveCamera)
            obj = createRuntimeObject<QQuick3DPerspectiveCamera>(camera, parent);
        else if (camera.runtimeType == Node::RuntimeType::CustomCamera)
            obj = createRuntimeObject<QQuick3DCustomCamera>(camera, parent);
        else
            Q_UNREACHABLE();
    }
        break;
    case Node::Type::Model:
        obj = createRuntimeObject<QQuick3DModel>(static_cast<Model &>(node), parent);
        break;
    case Node::Type::Texture:
        if (node.runtimeType == Node::RuntimeType::TextureData)
            obj = createRuntimeObject<QQuick3DTextureData>(static_cast<TextureData &>(node), parent);
        else if (node.runtimeType == Node::RuntimeType::Image2D)
            obj = createRuntimeObject<QQuick3DTexture>(static_cast<Texture &>(node), parent);
        else if (node.runtimeType == Node::RuntimeType::ImageCube)
            obj = createRuntimeObject<QQuick3DCubeMapTexture>(static_cast<Texture &>(node), parent);
        else
            Q_UNREACHABLE();
        break;
    case Node::Type::Material:
    {
        if (node.runtimeType == Node::RuntimeType::PrincipledMaterial)
            obj = createRuntimeObject<QQuick3DPrincipledMaterial>(static_cast<Material &>(node), parent);
        else if (node.runtimeType == Node::RuntimeType::CustomMaterial)
            obj = createRuntimeObject<QQuick3DCustomMaterial>(static_cast<Material &>(node), parent);
        else if (node.runtimeType == Node::RuntimeType::SpecularGlossyMaterial)
            obj = createRuntimeObject<QQuick3DSpecularGlossyMaterial>(static_cast<Material &>(node), parent);
        else
            Q_UNREACHABLE();
    }
        break;
    case Node::Type::Mesh:
        // There's no runtime object for this type, but we need to register the mesh with the
        // buffer manager (this will happen once the mesh property is processed on the model).
        break;
    }
 
    if (obj) {
        const QString keyName = obj->objectName().isEmpty()
            ? QString::fromUtf8(QSSGQmlUtilities::getQmlElementName(node))
            : obj->objectName();
        path += QStringLiteral("/") + keyName;
        if (objectMap)
            objectMap->insert({ keyName, path }, obj);
        if (typeMap)
            typeMap->insert(QSSGRenderGraphObjectUtils::getBaseType(node.runtimeType), obj);
    }
 
    if (obj && traverseChildrenAndSetProperties) {
        setProperties(*obj, node);
        for (auto &chld : node.children)
            createGraphObject(*chld, *obj, path, objectMap, typeMap);
    }
}
 
/*
 
Node {
    name: "root"
    children: [
        Node {
            name: "child1"
            children: [
                Node {
                    name: "grandchild1"
                }
            ]
        }
    ]
}
 
We'll create a map of all nodes using the path as key, so we can easily get any node by providing the path.
Since the node names aren't unique, we'll insert each node both by name and by path. If there are multiple
nodes with the same name, we'll just overwrite the previous one.
 
 
*/
 
QQuick3DNode *QSSGRuntimeUtils::createScene(QQuick3DNode &parent, const QSSGSceneDesc::Scene &scene, QSSGRuntimeObjectNameMap *objectMap, QSSGRuntimeObjectTypeMap *typeMap)
{
    if (!scene.root) {
        qWarning("Incomplete scene description (missing plugin?)");
        return nullptr;
    }
 
    Q_ASSERT(QQuick3DObjectPrivate::get(&parent)->sceneManager);
 
    QSSGBufferManager::registerMeshData(scene.id, scene.meshStorage);
 
    auto root = scene.root;
 
    for (const auto &resource : scene.resources)
        createGraphObject(*resource, parent, {}, objectMap, typeMap, false);
 
    createGraphObject(*root, parent, {}, objectMap, typeMap);
 
    // Some resources such as Skin have properties related with the node
    // hierarchy. Therefore, resources are handled after nodes.
    for (const auto &resource : scene.resources) {
        if (resource->obj != nullptr) // A mesh node has no runtime object.
            setProperties(static_cast<QQuick3DObject &>(*resource->obj), *resource, scene.sourceDir);
    }
 
    // Usually it makes sense to only enable 1 timeline at a time
    // so for now we just enable the first one.
    bool isFirstAnimation = true;
    for (const auto &anim: scene.animations) {
        QSSGQmlUtilities::createTimelineAnimation(*anim, root->obj, isFirstAnimation);
        if (isFirstAnimation)
            isFirstAnimation = false;
    }
 
    return qobject_cast<QQuick3DNode *>(scene.root->obj);
}
 
QT_END_NAMESPACE