qssgscenedesc_p.h - mozsearch

qt/qtquick3d/src/assetutils/qssgscenedesc_p.h

Enable keyboard shortcuts

Revision control

Copy as Markdown

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

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

// Qt-Security score:significant reason:default

#ifndef QSSGSCENEDESCRIPTION_P_H

#define QSSGSCENEDESCRIPTION_P_H

#include <QtQuick3DAssetUtils/private/qtquick3dassetutilsglobal_p.h>

#include <QtQuick3DRuntimeRender/private/qssgrendergraphobject_p.h>

#include <QtQuick3DRuntimeRender/private/qssgperframeallocator_p.h>

#include <QtQuick3DUtils/private/qssgmesh_p.h>

#include <QtCore/qlist.h>

#include <QtCore/qhash.h>

#include <QtCore/qvariant.h>

#include <QtCore/qflags.h>

#include <QtQml/qqmllist.h>

// QtQuick3D

#include <QtQuick3D/private/qquick3dobject_p.h>

// Materials

#include <QtQuick3D/private/qquick3dcustommaterial_p.h>

#include <QtQuick3D/private/qquick3ddefaultmaterial_p.h>

#include <QtQuick3D/private/qquick3dprincipledmaterial_p.h>

#include <QtQuick3D/private/qquick3dspecularglossymaterial_p.h>

#include <QtQuick3D/private/qquick3dmodel_p.h>

// cameras

#include <QtQuick3D/private/qquick3dorthographiccamera_p.h>

#include <QtQuick3D/private/qquick3dperspectivecamera_p.h>

#include <QtQuick3D/private/qquick3dcustomcamera_p.h>

// Lights

#include <QtQuick3D/private/qquick3ddirectionallight_p.h>

#include <QtQuick3D/private/qquick3dpointlight_p.h>

#include <QtQuick3D/private/qquick3dspotlight_p.h>

// Texture

#include <QtQuick3D/private/qquick3dtexture_p.h>

#include <QtQuick3D/private/qquick3dcubemaptexture_p.h>

#include <QtQuick3D/private/qquick3dtexturedata_p.h>

//

#include <QtQuick3D/private/qquick3dskeleton_p.h>

#include <QtQuick3D/private/qquick3djoint_p.h>

#include <QtQuick3D/private/qquick3dinstancing_p.h>

#include <qmetatype.h>

#include <QtQuick3DUtils/private/qssginvasivelinkedlist_p.h>

#include <QtGui/qquaternion.h>

QT_BEGIN_NAMESPACE

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

namespace QSSGSceneDesc

struct Node;

struct Animation;

template<typename T>

using rm_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;

struct Q_QUICK3DASSETUTILS_EXPORT Scene

    using ResourceNodes = QVarLengthArray<Node *>;

    using MeshStorage = QVector<QSSGMesh::Mesh>;

    using Animations = QVector<Animation *>;

    // Root node, usually an empty 'transform' node.

    Node *root = nullptr;

    QString id; // Don't make any assumption about the content of this id...

    ResourceNodes resources;

    MeshStorage meshStorage;

    Animations animations;

    QString sourceDir;

    QStringList materialVariants; // names of the asset's material variants, if any

    mutable quint16 nodeId = 0;

    void reset();

    void cleanup();

};

struct Q_QUICK3DASSETUTILS_EXPORT PropertyCall

    virtual ~PropertyCall() = default;

    virtual bool set(QQuick3DObject &, const char *, const void *) = 0;

    virtual bool set(QQuick3DObject &, const char *, const QVariant &) = 0;

    virtual bool get(const QQuick3DObject &, const void *[]) const = 0;

};

Q_QUICK3DASSETUTILS_EXPORT void destructValue(QVariant &value);

struct Flag

    QMetaEnum me;

    int value;

};

struct Property

    ~Property();

    enum class Type { Static, Dynamic };

    QVariant value;

    QByteArray name;

    QSSGSceneDesc::PropertyCall *call = nullptr;

    Type type = Type::Static;

};

inline Property::~Property()

    delete call;

    destructValue(value);

Q_QUICK3DASSETUTILS_EXPORT void destructNode(QSSGSceneDesc::Node &node);

struct NodeList

    NodeList(void * const *data, qsizetype n)

        const auto size = sizeof(Node *) * n;

        head = reinterpret_cast<Node **>(malloc(size));

        memcpy(head, data, size);

        count = n;

    ~NodeList() { if (head) free(head); }

    Node **head = nullptr;

    qsizetype count = -1;

};

struct Q_QUICK3DASSETUTILS_EXPORT Node

    // Node type

    enum class Type : quint8

        Transform,

        Camera,

        Model,

        Texture,

        Material,

        Light,

        Mesh,

        Skin,

        Skeleton,

        Joint,

        MorphTarget,

        Instancing

};

    using type = QQuick3DNode;

    // Runtime type type mapping between this type and the QtQuick3D type

    using RuntimeType = QSSGRenderGraphObject::Type;

    explicit Node(QByteArray name, Node::Type type, Node::RuntimeType rt)

        : name(name)

        , runtimeType(rt)

        , nodeType(type) {}

    explicit Node(Node::Type type, Node::RuntimeType rt)

        : Node(nullptr, type, rt) {}

    virtual ~Node();

    void cleanupChildren();

    QByteArray name;

    Scene *scene = nullptr;

    QObject *obj = nullptr;

    using ChildList = QList<Node *>;

    using PropertyList = QList<Property *>;

    ChildList children;

    PropertyList properties;

    quint16 id = 0;

    RuntimeType runtimeType;

    Type nodeType;

};

template<typename T>

static constexpr bool is_node_v = std::is_base_of_v<Node, T>;

// Set up type mapping from a QQuick3D type to a SceneDesc type

template <typename T> struct TypeMap {};

#define QSSG_DECLARE_NODE(NODE) \

static_assert(is_node_v<NODE>, #NODE " - does not inherit from Node!"); \

template <> struct TypeMap<NODE::type> { using type = QSSGSceneDesc::NODE; };

template<typename T>

using as_scene_type_t = typename T::type;

template<typename T>

using as_node_type_t = typename TypeMap<T>::type;

QSSG_DECLARE_NODE(Node)

struct Q_QUICK3DASSETUTILS_EXPORT Texture : Node

    using type = QQuick3DTexture;

    explicit Texture(Node::RuntimeType rt, const QByteArray &name = {});

};

QSSG_DECLARE_NODE(Texture)

struct Q_QUICK3DASSETUTILS_EXPORT TextureData : Node

    using type = QQuick3DTextureData;

    enum class Flags : quint8

        Compressed = 0x1

};

    explicit TextureData(const QByteArray &textureData, QSize size, const QByteArray &format, quint8 flags = 0, QByteArray name = {});

    QByteArray data;

    QSize sz;

    QByteArray fmt;

    quint8 flgs;

};

QSSG_DECLARE_NODE(TextureData)

struct Q_QUICK3DASSETUTILS_EXPORT Material : Node

    using type = QQuick3DMaterial;

    explicit Material(Node::RuntimeType rt);

};

QSSG_DECLARE_NODE(Material)

// The mesh is a special node, as it's not really a node type but

// a handle to a mesh that will be turned into a source URL...

struct Q_QUICK3DASSETUTILS_EXPORT Mesh : Node

    explicit Mesh(QByteArray name, qsizetype index);

    qsizetype idx; // idx to the mesh data in the mesh data storage (see Scene).

};

struct Q_QUICK3DASSETUTILS_EXPORT Model : Node

    using type = QQuick3DModel;

    Model();

    // One list per Scene::materialVariants entry, empty if not switchable

    QList<QList<Node *>> variantMaterials;

    QList<Node *> defaultMaterials;

};

QSSG_DECLARE_NODE(Model)

struct Q_QUICK3DASSETUTILS_EXPORT Camera : Node

    using type = QQuick3DCamera;

    explicit Camera(RuntimeType rt);

};

QSSG_DECLARE_NODE(Camera)

struct Q_QUICK3DASSETUTILS_EXPORT Light : Node

    using type = QQuick3DAbstractLight;

    explicit Light(RuntimeType rt);

};

QSSG_DECLARE_NODE(Light)

struct Q_QUICK3DASSETUTILS_EXPORT Skin : Node

    using type = QQuick3DSkin;

    Skin();

};

QSSG_DECLARE_NODE(Skin)

struct Q_QUICK3DASSETUTILS_EXPORT Skeleton : Node

    using type = QQuick3DSkeleton;

    Skeleton();

    // Skeleton is a virtual node, which is added for the start of the joint heirarchy.

    // parent - joint 1     ->      parent - skeleton - joint 1

    //        - joint 2                               - joint 2

    //        - model 1                    - model 1

    //        - camera 1                   - camera 1

    size_t maxIndex = 0;

};

QSSG_DECLARE_NODE(Skeleton)

struct Q_QUICK3DASSETUTILS_EXPORT Joint : Node

    using type = QQuick3DJoint;

    Joint();

};

QSSG_DECLARE_NODE(Joint)

struct Q_QUICK3DASSETUTILS_EXPORT MorphTarget : Node

    using type = QQuick3DMorphTarget;

    MorphTarget();

};

QSSG_DECLARE_NODE(MorphTarget)

struct Q_QUICK3DASSETUTILS_EXPORT Instancing : Node

    using type = QQuick3DInstancing;

    Instancing();

    QByteArray instanceData; // QQuick3DInstancing::InstanceTableEntry array

    qsizetype instanceCount = 0;

};

QSSG_DECLARE_NODE(Instancing)

// We keep our own list data structure, since Qt does not have a variant list where all the

// elements have the same type, and using a list of QVariant is very inefficient

struct ListView

    ~ListView() { if (data) free(data); }

    QMetaType mt;

    void *data = nullptr;

    qsizetype count = -1;

};

Q_QUICK3DASSETUTILS_EXPORT QMetaType listViewMetaType();

struct Animation

    struct KeyPosition

        enum class KeyType : quint16

            Frame = 0x100,

            Time = 0x200

};

        enum class ValueType : quint8

            Number,

            Vec2,

            Vec3,

            Vec4,

            Quaternion

};

        ValueType getValueType() const { return ValueType(0xf & flag); }

        KeyType getKeyType() const { return KeyType(0xf00 & flag); }

        QVariant getValue() const {

            switch (getValueType()) {

            case ValueType::Number:

                return value.x();

            case ValueType::Vec2:

                return value.toVector2D();

            case ValueType::Vec3:

                return value.toVector3D();

            case ValueType::Vec4:

                return value;

            case ValueType::Quaternion:

                return QQuaternion(value);

            return value;

        QMetaType::Type getValueQMetaType() const {

            switch (getValueType()) {

            case ValueType::Number:

                return QMetaType::Float;

            case ValueType::Vec2:

                return QMetaType::QVector2D;

            case ValueType::Vec3:

                return QMetaType::QVector3D;

            case ValueType::Vec4:

                return QMetaType::QVector4D;

            case ValueType::Quaternion:

                return QMetaType::QQuaternion;

            return QMetaType::QVector4D;

        QVector4D value;

        float time = 0.0f;

        quint16 flag = 0;

};

    using Keys = QList<Animation::KeyPosition *>;

    struct Channel

        enum class TargetType : quint8

            Property

};

        // This is a bit simplistic, but is all we support so let's keep simple.

        enum class TargetProperty : quint8

            Unknown,

            Position,

            Rotation,

            Scale,

            Weight // for MorphMesh

};

        Node *target = nullptr;

        Keys keys;

        TargetType targetType = TargetType::Property;

        TargetProperty targetProperty = TargetProperty::Unknown;

};

    using Channels = QList<Animation::Channel *>;

    Channels channels;

    // It stores the length of this Animation, every keys in every channels in

    // an animation will have the same KeyType and it will be a type of

    // the length

    float length = 0.0f;

    float framesPerSecond = 0.0f; // for translation back to frames

    QByteArray name;

};

// Add a child node to parent node.

Q_QUICK3DASSETUTILS_EXPORT void addNode(Node &parent, Node &node);

// Add node to the scene, if a node is already set the new node will

// become a child of the root node.

Q_QUICK3DASSETUTILS_EXPORT void addNode(Scene &scene, Node &node);

template<typename> struct ListParam { enum { value = 0 }; };

template<typename T> struct ListParam<QList<T>>

    using type = T;

    enum { value = 1 };

};

template <typename T>

using listParam_t = typename ListParam<rm_cvref_t<T>>::type;

template <typename T>

struct FuncType

    enum { value = 0 };

};

template <typename R, typename... A>

struct FuncType<R (*)(A...)>

    enum { value = sizeof...(A) == 3 };

    using Ret = R;

    using Arg0 = std::tuple_element_t<0, std::tuple<A...>>;

    using Arg1 = std::tuple_element_t<1, std::tuple<A...>>;

    using Arg2 = std::tuple_element_t<2, std::tuple<A...>>;

    using Arg2Base = rm_cvref_t<Arg2>;

};

template <typename R, typename C, typename... A>

struct FuncType<R (C::*)(A...)>

    enum { value = sizeof... (A) == 1 };

    using Ret = R;

    using Class = C;

    // For now we only care about single argument functions

    using Arg0 = std::tuple_element_t<0, std::tuple<A...>>;

    using Arg0Base = rm_cvref_t<Arg0>;

};

template <typename T, typename C>

struct FuncType<QQmlListProperty<T> (C::*)()>

    enum { value = 2 };

    using Ret = QQmlListProperty<T>;

    using Class = C;

    using Arg0 = void;

    using Arg0Base = Arg0;

};

template <typename Ret, typename Arg>

struct PropertyProxySetter : PropertyCall

    using Setter = Ret (*)(QQuick3DObject &, const char *, Arg);

    constexpr explicit PropertyProxySetter(Setter fn) : call(fn) {}

    Setter call = nullptr;

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

    bool set(QQuick3DObject &that, const char *name, const void *value) override

        if constexpr (std::is_pointer_v<typename FuncType<Setter>::Arg2>)

            call(that, name, reinterpret_cast<typename FuncType<Setter>::Arg2>(const_cast<void *>(value)));

        else

            call(that, name, *reinterpret_cast<typename FuncType<Setter>::Arg2Base *>(const_cast<void *>(value)));

        return true;

    bool set(QQuick3DObject &that, const char *name, const QVariant &var) override

        call(that, name, qvariant_cast<typename FuncType<Setter>::Arg2Base>(var));

        return true;

};

template <typename Ret, typename Class, typename Arg>

struct PropertySetter : PropertyCall

    using Setter = Ret (Class::*)(Arg);

    constexpr explicit PropertySetter(Setter fn) : call(fn) {}

    Setter call = nullptr;

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

    bool set(QQuick3DObject &that, const char *, const void *value) override

        if constexpr (std::is_pointer_v<typename FuncType<Setter>::Arg0>)

            (qobject_cast<Class *>(&that)->*call)(reinterpret_cast<typename FuncType<Setter>::Arg0>(const_cast<void *>(value)));

        else {

            (qobject_cast<Class *>(&that)->*call)(*reinterpret_cast<typename FuncType<Setter>::Arg0Base *>(const_cast<void *>(value)));

        return true;

    bool set(QQuick3DObject &that, const char *, const QVariant &var) override

        (qobject_cast<Class *>(&that)->*call)(qvariant_cast<typename FuncType<Setter>::Arg0Base>(var));

        return true;

};

template <typename Ret, typename Class, typename Arg>

struct PropertyListSetter : PropertyCall

    using Setter = Ret (Class::*)(Arg);

    using ListT = typename FuncType<Setter>::Arg0Base;

    using It = listParam_t<ListT>;

    constexpr explicit PropertyListSetter(Setter fn) : call(fn) {}

    Setter call = nullptr;

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

    bool set(QQuick3DObject &that, const char *, const void *value) override

        if (const auto listView = reinterpret_cast<const ListView *>(value)) {

            if (listView->count > 0) {

                const auto begin = reinterpret_cast<It *>(listView->data);

                const auto end = reinterpret_cast<It *>(listView->data) + listView->count;

                (qobject_cast<Class *>(&that)->*call)(ListT{begin, end});

            } else {

                (qobject_cast<Class *>(&that)->*call)(ListT{});

            return true;

        return false;

    bool set(QQuick3DObject &that, const char *, const QVariant &var) override

        if (const auto listView = qvariant_cast<const ListView *>(var)) {

            if (listView->count > 0) {

                const auto begin = reinterpret_cast<It *>(listView->data);

                const auto end = reinterpret_cast<It *>(listView->data) + listView->count;

                (qobject_cast<Class *>(&that)->*call)(ListT{begin, end});

            } else {

                (qobject_cast<Class *>(&that)->*call)(ListT{});

        return false;

};

template <typename Class, typename T, template <typename> typename List>

struct PropertyList : PropertyCall

    using ListType = List<T>;

    using ListFunc = ListType (Class::*)();

    constexpr explicit PropertyList(ListFunc fn) : listfn(fn) {}

    ListFunc listfn = nullptr;

    static_assert(std::is_same_v<ListType, QQmlListProperty<T>>, "Expected QQmlListProperty!");

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

    void doSet(QQuick3DObject &that, const QSSGSceneDesc::NodeList &nodeList)

        ListType list = (qobject_cast<Class *>(&that)->*listfn)();

        auto head = reinterpret_cast<as_node_type_t<T> **>(nodeList.head);

        for (int i = 0, end = nodeList.count; i != end; ++i)

            list.append(&list, qobject_cast<T *>((*(head + i))->obj));

    bool set(QQuick3DObject &that, const char *, const void *value) override

        if (value) {

            const auto &nodeList = *reinterpret_cast<const QSSGSceneDesc::NodeList *>(value);

            doSet(that, nodeList);

            return true;

        return false;

    bool set(QQuick3DObject &that, const char *, const QVariant &var) override

        const auto *nodeList = qvariant_cast<const QSSGSceneDesc::NodeList *>(var);

        if (nodeList) {

            doSet(that, *nodeList);

            return true;

        return false;

};

template <typename NodeT>

using if_node = typename std::enable_if_t<is_node_v<NodeT>, bool>;

template <typename Setter, typename Value>

using if_compatible_t = typename std::enable_if_t<std::is_same_v<typename FuncType<Setter>::Arg0Base, rm_cvref_t<Value>>, bool>;

template <typename Setter, typename T>

using if_compatible_node_list_t = typename std::enable_if_t<std::is_same_v<typename FuncType<Setter>::Ret, QQmlListProperty<as_scene_type_t<T>>>, bool>;

template <typename Setter, typename Value>

using if_compatible_proxy_t = typename std::enable_if_t<std::is_same_v<typename FuncType<Setter>::Arg2Base, rm_cvref_t<Value>>, bool>;

// Sets a property on a node, the property is a name map to struct containing a pointer to the value and a function

// to set the value on an runtime object (QtQuick3DObject). The type is verified at compile-time, so we can assume

// the value is of the right type when setting it at run-time.

template<typename Setter, typename T, if_compatible_t<Setter, T> = false>

static void setProperty(QSSGSceneDesc::Node &node, const char *name, Setter setter, T &&value)

     Q_ASSERT(node.scene);

    auto prop = new Property;

    prop->name = name;

    prop->call = new PropertySetter(setter);

    prop->value = QVariant::fromValue(std::forward<T>(value));

    node.properties.push_back(prop);

template<typename Setter, typename T, if_compatible_t<Setter, QFlags<T>> = false>

static void setProperty(QSSGSceneDesc::Node &node, const char *name, Setter setter, QFlags<T> value)

    Q_ASSERT(node.scene);

    auto prop = new Property;

    prop->name = name;

    prop->call = new PropertySetter(setter);

    prop->value = QVariant::fromValue(Flag{ QMetaEnum::fromType<rm_cvref_t<T>>(), value.toInt() });

    node.properties.push_back(prop);

template<typename Setter, typename T, if_compatible_t<Setter, QList<T>> = false>

static void setProperty(QSSGSceneDesc::Node &node, const char *name, Setter setter, QList<T> value)

    Q_ASSERT(node.scene);

    static_assert(!std::is_pointer_v<T>, "Type cannot be a pointer!");

    static_assert(std::is_trivially_destructible_v<T> && std::is_trivially_copy_constructible_v<T>,

            "List parameter type needs to be trivially constructable and trivially destructible!");

    const auto count = value.size();

    void *data = nullptr;

    if (count) {

        const auto asize = count * sizeof(T);

        data = malloc(asize); // is freed in ~ListView

        memcpy(data, value.constData(), asize);

    auto prop = new Property;

    prop->name = name;

    prop->call = new PropertyListSetter(setter);

    prop->value = QVariant::fromValue(new ListView{ QMetaType::fromType<rm_cvref_t<T>>(), data, count });

    node.properties.push_back(prop);

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

// Calling this will omit any type checking, so make sure the type is handled correctly

// when it gets used later!

template<typename Setter>

static void setProperty(QSSGSceneDesc::Node &node, const char *name, Setter setter, QVariant &&value)

    Q_ASSERT(node.scene);

    Property *prop = new Property;

    prop->name = name;

    prop->call = new PropertySetter(setter);

    prop->value = value;

    node.properties.push_back(prop);

template<typename Setter, typename Value, if_compatible_proxy_t<Setter, Value> = true>

static void setProperty(QSSGSceneDesc::Node &node, const char *name, Setter setter, Value &&value, QSSGSceneDesc::Property::Type type = QSSGSceneDesc::Property::Type::Static)

    Q_ASSERT(node.scene);

    static_assert(std::is_trivially_destructible_v<rm_cvref_t<Value>>, "Value needs to be trivially destructible!");

    Property *prop = new Property;

    prop->name = name;

    prop->call = new PropertyProxySetter(setter);

    prop->value = QVariant::fromValue(value);

    prop->type = type;

    node.properties.push_back(prop);

template<typename Setter, typename ViewValue, if_compatible_t<Setter, typename ViewValue::type> = false>

static void setProperty(QSSGSceneDesc::Node &node, const char *name, Setter setter, ViewValue view)

    Q_ASSERT(node.scene);

    static_assert(std::is_same_v<typename ViewValue::type, typename FuncType<Setter>::Arg0Base>, "Type cannot be mapped to slot argument");

    Property *prop = new Property;

    prop->name = name;

    prop->call = new PropertySetter(setter);

    prop->value = QVariant::fromValue(view);

    node.properties.push_back(prop);

template<typename Setter, typename Value, if_compatible_t<Setter, as_scene_type_t<Value> *> = true>

static void setProperty(QSSGSceneDesc::Node &node, const char *name, Setter setter, Value *value)

    Q_ASSERT(node.scene);

    Property *prop = new Property;

    prop->name = name;

    prop->call = new PropertySetter(setter);

    // Always 'Node', the Node class itself contains more fine grain type information.

    prop->value = QVariant::fromValue(static_cast<Node *>(value));

    node.properties.push_back(prop);

// Overloaded function for setting a type to a property that's a QQmlListProperty.

template<typename Setter, typename NodeT, qsizetype Prealloc, if_compatible_node_list_t<Setter, NodeT> = true>

static void setProperty(QSSGSceneDesc::Node &node, const char *name, Setter setter, const QVarLengthArray<NodeT *, Prealloc> &list)

    Q_ASSERT(node.scene);

    if (!list.isEmpty()) {

        NodeList *l = new NodeList(reinterpret_cast<void * const*>(list.constData()), list.count());

        Property *prop = new Property;

        prop->name = name;

        prop->call = new PropertyList(setter);

        prop->value = QVariant::fromValue(l);

        node.properties.push_back(prop);

} // QSSGSceneDesc

QT_END_NAMESPACE

Q_DECLARE_METATYPE(QSSGSceneDesc::Node)

Q_DECLARE_METATYPE(QSSGSceneDesc::Texture)

Q_DECLARE_METATYPE(QSSGSceneDesc::Material)

Q_DECLARE_METATYPE(QSSGSceneDesc::Mesh)

Q_DECLARE_METATYPE(QSSGSceneDesc::Model)

Q_DECLARE_METATYPE(QSSGSceneDesc::Camera)

Q_DECLARE_METATYPE(QSSGSceneDesc::Light)

Q_DECLARE_METATYPE(QSSGSceneDesc::Skin)

Q_DECLARE_METATYPE(QSSGSceneDesc::Skeleton)

Q_DECLARE_METATYPE(QSSGSceneDesc::Joint)

Q_DECLARE_METATYPE(QSSGSceneDesc::MorphTarget)

Q_DECLARE_METATYPE(QSSGSceneDesc::NodeList)

Q_DECLARE_METATYPE(QSSGSceneDesc::Animation)

Q_DECLARE_METATYPE(QSSGSceneDesc::ListView)

Q_DECLARE_METATYPE(QSSGSceneDesc::Flag)

#endif // QSSGSCENEDESCRIPTION_P_H