qssgscenedesc.cpp - mozsearch

Enable keyboard shortcuts

// Copyright (C) 2022 The Qt Company Ltd.

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

// Qt-Security score:significant reason:default

#include "qssgscenedesc_p.h"

QT_BEGIN_NAMESPACE

bool QSSGSceneDesc::PropertyCall::set(QQuick3DObject &, const char *, const void *) { return false; }

bool QSSGSceneDesc::PropertyCall::get(const QQuick3DObject &, const void *[]) const { return false; }

static inline quint16 getNextNodeId(QSSGSceneDesc::Scene &scene)

    /* root node uses the default value 0 */

    return ++scene.nodeId;

void QSSGSceneDesc::addNode(QSSGSceneDesc::Node &parent, QSSGSceneDesc::Node &node)

    Q_ASSERT(parent.scene);

    node.scene = parent.scene;

    node.id = getNextNodeId(*parent.scene);

    if (QSSGRenderGraphObject::isResource(node.runtimeType) || node.nodeType == Node::Type::Mesh || node.nodeType == Node::Type::Skeleton)

        node.scene->resources.push_back(&node);

    else // Here goes nothing: kick all the resources out of the tree...

        parent.children.push_back(&node);

void QSSGSceneDesc::addNode(QSSGSceneDesc::Scene &scene, QSSGSceneDesc::Node &node)

    if (scene.root) {

        addNode(*scene.root, node);

    } else {

        Q_ASSERT(node.id == 0);

        node.scene = &scene;

        scene.root = &node;

void QSSGSceneDesc::Scene::reset()

    id.clear();

    nodeId = 0;

    root = nullptr;

    resources.clear();

    meshStorage.clear();

    materialVariants.clear();

void QSSGSceneDesc::Scene::cleanup()

    id.clear();

    nodeId = 0;

    // An import that failed before building anything leaves no root, and

    // releasing such a scene has to be allowed

    if (root) {

        root->cleanupChildren();

        delete root;

        root = nullptr;

    qDeleteAll(resources);

    resources.clear();

    for (auto *anim : std::as_const(animations)) {

        for (auto *ch : std::as_const(anim->channels)) {

            qDeleteAll(ch->keys);

            ch->keys.clear();

            delete ch;

        delete anim;

    animations.clear();

QMetaType QSSGSceneDesc::listViewMetaType()

    return QMetaType::fromType<QSSGSceneDesc::ListView *>();

void QSSGSceneDesc::destructValue(QVariant &value)

    if (!value.isValid())

        return;

    if (value.metaType() == QMetaType::fromType<QSSGSceneDesc::NodeList *>())

        delete value.value<NodeList *>();

    else if (value.metaType() == QMetaType::fromType<QSSGSceneDesc::ListView *>())

        delete value.value<ListView *>();

    // Non-pointer types are destructed by ~QVariant

    else if ((value.metaType().flags() & QMetaType::TypeFlag::IsPointer)

            // Mesh node will be deleted when cleaning up resources.

            && (value.metaType() != QMetaType::fromType<QSSGSceneDesc::Mesh *>())

            // Referencing nodes will not be deleted here.

            // They should be deleted in the node hierarchy or resources.

            && (value.metaType().id() != qMetaTypeId<QSSGSceneDesc::Node *>())) {

        qWarning() << value.metaType().name() << " was not destroyed correctly.";

void QSSGSceneDesc::destructNode(Node &node)

    for (auto *prop : std::as_const(node.properties))

        delete prop;

    // Not necessary to clear the list as long as we only call this from the destructor

QSSGSceneDesc::Node::~Node() { destructNode(*this); }

void QSSGSceneDesc::Node::cleanupChildren()

    auto firstIt = children.begin();

    auto lastIt = children.end();

    for (auto it = firstIt; it != lastIt; ++it) {

        Node *node = *it;

        node->cleanupChildren();

        delete node;

QSSGSceneDesc::Property *QSSGSceneDesc::setProperty(Node &node, const char *name, QVariant &&value)

    Q_ASSERT(node.scene);

    QSSGSceneDesc::Property *prop = new QSSGSceneDesc::Property;

    prop->name = name;

    prop->call = nullptr;

    prop->value = value;

    node.properties.push_back(prop);

    return prop;

QSSGSceneDesc::Model::Model() : Node(Node::Type::Model, Node::RuntimeType::Model) {}

QSSGSceneDesc::Camera::Camera(RuntimeType rt) : Node(Node::Type::Camera, rt) {}

QSSGSceneDesc::Light::Light(RuntimeType rt) : Node(Node::Type::Light, rt) {}

QSSGSceneDesc::Skin::Skin() : Node(Node::Type::Skin, Node::RuntimeType::Skin) {}

QSSGSceneDesc::Skeleton::Skeleton() : Node(Node::Type::Skeleton, Node::RuntimeType::Skeleton) {}

QSSGSceneDesc::Joint::Joint() : Node(Node::Type::Joint, Node::RuntimeType::Joint) {}

QSSGSceneDesc::MorphTarget::MorphTarget() : Node(Node::Type::MorphTarget, Node::RuntimeType::MorphTarget) {}

QSSGSceneDesc::Instancing::Instancing() : Node(Node::Type::Instancing, Node::RuntimeType::ModelInstance) {}

QSSGSceneDesc::Material::Material(RuntimeType rt) : Node(Node::Type::Material, rt) {}

QSSGSceneDesc::Texture::Texture(RuntimeType rt, const QByteArray &name)

    : Node(name, Node::Type::Texture, rt)

QSSGSceneDesc::TextureData::TextureData(const QByteArray &textureData, QSize size, const QByteArray &format, quint8 flags, QByteArray name)

    : Node(name, Node::Type::Texture, RuntimeType::TextureData)

    , data(textureData)

    , sz(size)

    , fmt(format)

    , flgs(flags)

{}

QSSGSceneDesc::Mesh::Mesh(QByteArray name, qsizetype index)

    : Node(name, Node::Type::Mesh, RuntimeType::Node)

    , idx(index)

{}

QT_END_NAMESPACE