diff options
21 files changed, 574 insertions, 143 deletions
diff --git a/src/core/nodes/qnode.cpp b/src/core/nodes/qnode.cpp index c3c28b85d..6219790e6 100644 --- a/src/core/nodes/qnode.cpp +++ b/src/core/nodes/qnode.cpp @@ -73,7 +73,7 @@ QNodePrivate::QNodePrivate() , m_blockNotifications(false) , m_hasBackendNode(false) , m_enabled(true) - , m_propertyTrackMode(QNode::DefaultTrackMode) + , m_defaultPropertyTrackMode(QNode::TrackFinalValues) , m_propertyChangesSetup(false) , m_signals(this) { @@ -608,9 +608,9 @@ void QNodePrivate::updatePropertyTrackMode() { if (m_scene != nullptr) { QScene::NodePropertyTrackData trackData; - trackData.updateMode = m_propertyTrackMode; - trackData.namedProperties = m_trackedProperties; - m_scene->setPropertyTrackDataForNode(m_id,trackData); + trackData.defaultTrackMode = m_defaultPropertyTrackMode; + trackData.trackedPropertiesOverrides = m_trackedPropertiesOverrides; + m_scene->setPropertyTrackDataForNode(m_id, trackData); } } @@ -803,30 +803,16 @@ void QNode::setEnabled(bool isEnabled) emit enabledChanged(isEnabled); } -void QNode::setPropertyTrackMode(QNode::PropertyTrackMode mode) +void QNode::setDefaultPropertyTrackingMode(QNode::PropertyTrackingMode mode) { Q_D(QNode); - if (d->m_propertyTrackMode == mode) + if (d->m_defaultPropertyTrackMode == mode) return; - d->m_propertyTrackMode = mode; + d->m_defaultPropertyTrackMode = mode; // The backend doesn't care about such notification const bool blocked = blockNotifications(true); - emit propertyUpdateModeChanged(mode); - blockNotifications(blocked); - d->updatePropertyTrackMode(); -} - -void QNode::setTrackedProperties(const QStringList &trackedProperties) -{ - Q_D(QNode); - if (d->m_trackedProperties == trackedProperties) - return; - - d->m_trackedProperties = trackedProperties; - // The backend doesn't care about such notification - const bool blocked = blockNotifications(true); - emit trackedPropertiesChanged(trackedProperties); + emit defaultPropertyTrackingModeChanged(mode); blockNotifications(blocked); d->updatePropertyTrackMode(); } @@ -848,29 +834,45 @@ bool QNode::isEnabled() const } /*! - \property Qt3DCore::QNode::propertyTrackMode + \property Qt3DCore::QNode::defaultPropertyTrackingMode - Holds the property track mode which determines whether a QNode should - be listening for property updates + Holds the default property tracking mode which determines whether a QNode should + be listening for property updates. This only applies to properties which + haven't been overridden by a call to setPropertyTracking. - By default it is set to QNode::DontTrackProperties + By default it is set to QNode::TrackFinalValues */ -QNode::PropertyTrackMode QNode::propertyTrackMode() const +QNode::PropertyTrackingMode QNode::defaultPropertyTrackingMode() const { Q_D(const QNode); - return d->m_propertyTrackMode; + return d->m_defaultPropertyTrackMode; } -/*! - \property Qt3DCore::QNode::trackedProperties +void QNode::setPropertyTracking(const QString &propertyName, QNode::PropertyTrackingMode trackMode) +{ + Q_D(QNode); + d->m_trackedPropertiesOverrides.insert(propertyName, trackMode); + d->updatePropertyTrackMode(); +} - Holds the names of the properties to be tracked when propertyTrackMode is - set to TrackNamedProperties. -*/ -QStringList QNode::trackedProperties() const +QNode::PropertyTrackingMode QNode::propertyTracking(const QString &propertyName) const { Q_D(const QNode); - return d->m_trackedProperties; + return d->m_trackedPropertiesOverrides.value(propertyName, d->m_defaultPropertyTrackMode); +} + +void QNode::clearPropertyTracking(const QString &propertyName) +{ + Q_D(QNode); + d->m_trackedPropertiesOverrides.remove(propertyName); + d->updatePropertyTrackMode(); +} + +void QNode::clearPropertyTrackings() +{ + Q_D(QNode); + d->m_trackedPropertiesOverrides.clear(); + d->updatePropertyTrackMode(); } QNodeCreatedChangeBasePtr QNode::createNodeCreationChange() const diff --git a/src/core/nodes/qnode.h b/src/core/nodes/qnode.h index 56c92da7f..818d6a722 100644 --- a/src/core/nodes/qnode.h +++ b/src/core/nodes/qnode.h @@ -69,16 +69,15 @@ class QT3DCORESHARED_EXPORT QNode : public QObject Q_OBJECT Q_PROPERTY(Qt3DCore::QNode *parent READ parentNode WRITE setParent NOTIFY parentChanged) Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged) - Q_PROPERTY(PropertyTrackMode propertyTrackMode READ propertyTrackMode WRITE setPropertyTrackMode NOTIFY propertyUpdateModeChanged REVISION 9) - Q_PROPERTY(QStringList trackedProperties READ trackedProperties WRITE setTrackedProperties NOTIFY trackedPropertiesChanged REVISION 9) + Q_PROPERTY(PropertyTrackingMode defaultPropertyTrackingMode READ defaultPropertyTrackingMode WRITE setDefaultPropertyTrackingMode NOTIFY defaultPropertyTrackingModeChanged REVISION 9) public: - enum PropertyTrackMode { - DefaultTrackMode, - TrackNamedPropertiesMode, - TrackAllPropertiesMode + enum PropertyTrackingMode { + TrackFinalValues, + DontTrackValues, + TrackAllValues }; - Q_ENUM(PropertyTrackMode) + Q_ENUM(PropertyTrackingMode) explicit QNode(QNode *parent = nullptr); virtual ~QNode(); @@ -92,20 +91,22 @@ public: QNodeVector childNodes() const; bool isEnabled() const; - PropertyTrackMode propertyTrackMode() const; - QStringList trackedProperties() const; + PropertyTrackingMode defaultPropertyTrackingMode() const; + + void setPropertyTracking(const QString &propertyName, PropertyTrackingMode trackMode); + PropertyTrackingMode propertyTracking(const QString &propertyName) const; + void clearPropertyTracking(const QString &propertyName); + void clearPropertyTrackings(); public Q_SLOTS: void setParent(QNode *parent); void setEnabled(bool isEnabled); - void setPropertyTrackMode(PropertyTrackMode mode); - void setTrackedProperties(const QStringList &trackedProperties); + void setDefaultPropertyTrackingMode(PropertyTrackingMode mode); Q_SIGNALS: void parentChanged(QObject *parent); void enabledChanged(bool enabled); - void propertyUpdateModeChanged(PropertyTrackMode mode); - void trackedPropertiesChanged(const QStringList &trackedProperties); + void defaultPropertyTrackingModeChanged(PropertyTrackingMode mode); void nodeDestroyed(); protected: diff --git a/src/core/nodes/qnode_p.h b/src/core/nodes/qnode_p.h index d4a48aa1e..bfac1cbe1 100644 --- a/src/core/nodes/qnode_p.h +++ b/src/core/nodes/qnode_p.h @@ -98,8 +98,8 @@ public: bool m_blockNotifications; bool m_hasBackendNode; bool m_enabled; - QNode::PropertyTrackMode m_propertyTrackMode; - QStringList m_trackedProperties; + QNode::PropertyTrackingMode m_defaultPropertyTrackMode; + QHash<QString, QNode::PropertyTrackingMode> m_trackedPropertiesOverrides; static QNodePrivate *get(QNode *q); static void nodePtrDeleter(QNode *q); diff --git a/src/core/qpostman.cpp b/src/core/qpostman.cpp index 206399070..db7a9500e 100644 --- a/src/core/qpostman.cpp +++ b/src/core/qpostman.cpp @@ -117,15 +117,19 @@ bool QPostman::shouldNotifyFrontend(const QSceneChangePtr &e) const QPropertyUpdatedChangePtr propertyChange = qSharedPointerDynamicCast<QPropertyUpdatedChange>(e); if (Q_LIKELY(d->m_scene != nullptr) && !propertyChange.isNull()) { const QScene::NodePropertyTrackData propertyTrackData - = d->m_scene->lookupNodePropertyTrackData(e->subjectId()); - switch (propertyTrackData.updateMode) { - case QNode::TrackAllPropertiesMode: + = d->m_scene->lookupNodePropertyTrackData(e->subjectId()); + + const QNode::PropertyTrackingMode trackMode = propertyTrackData.trackedPropertiesOverrides.value(QLatin1String(propertyChange->propertyName()), + propertyTrackData.defaultTrackMode); + + switch (trackMode) { + case QNode::TrackAllValues: return true; - case QNode::TrackNamedPropertiesMode: - return propertyTrackData.namedProperties.contains(QLatin1String(propertyChange->propertyName())); + case QNode::DontTrackValues: + return false; - case QNode::DefaultTrackMode: { + case QNode::TrackFinalValues: { const bool isIntermediate = QPropertyUpdatedChangeBasePrivate::get(propertyChange.data())->m_isIntermediate; return !isIntermediate; diff --git a/src/core/qscene_p.h b/src/core/qscene_p.h index fdcb23edb..d200abf42 100644 --- a/src/core/qscene_p.h +++ b/src/core/qscene_p.h @@ -97,8 +97,8 @@ public: // Node -> Property Update Data struct NodePropertyTrackData { - QNode::PropertyTrackMode updateMode = QNode::DefaultTrackMode; - QStringList namedProperties; + QNode::PropertyTrackingMode defaultTrackMode = QNode::TrackFinalValues; + QHash<QString, QNode::PropertyTrackingMode> trackedPropertiesOverrides; }; NodePropertyTrackData lookupNodePropertyTrackData(QNodeId id) const; void setPropertyTrackDataForNode(QNodeId id, const NodePropertyTrackData &data); diff --git a/src/quick3d/imports/core/qt3dquick3dcoreplugin.cpp b/src/quick3d/imports/core/qt3dquick3dcoreplugin.cpp index 8f470518c..51509f4ab 100644 --- a/src/quick3d/imports/core/qt3dquick3dcoreplugin.cpp +++ b/src/quick3d/imports/core/qt3dquick3dcoreplugin.cpp @@ -42,6 +42,7 @@ #include <private/quick3dentity_p.h> #include <private/quick3dentityloader_p.h> #include <private/quick3dnodeinstantiator_p.h> +#include <Qt3DQuick/private/quick3dnodev9_p.h> #include <private/qquaternionanimation_p.h> #include <private/qt3dquick_global_p.h> #include <QtCore/qvariantanimation.h> @@ -65,7 +66,7 @@ void Qt3DQuick3DCorePlugin::registerTypes(const char *uri) // Ideally we want to make Node an uncreatable type // We would need qmlRegisterUncreatableExtendedType for that qmlRegisterExtendedUncreatableType<Qt3DCore::QNode, Qt3DCore::Quick::Quick3DNode>(uri, 2, 0, "Node", QStringLiteral("Node is a base class")); - qmlRegisterExtendedUncreatableType<Qt3DCore::QNode, Qt3DCore::Quick::Quick3DNode, 9>(uri, 2, 9, "Node", QStringLiteral("Node is a base class")); + qmlRegisterExtendedUncreatableType<Qt3DCore::QNode, Qt3DCore::Quick::Quick3DNodeV9, 9>(uri, 2, 9, "Node", QStringLiteral("Node is a base class")); } QT_END_NAMESPACE diff --git a/src/quick3d/quick3d/items/items.pri b/src/quick3d/quick3d/items/items.pri index 4c5e93fb2..4749c83cf 100644 --- a/src/quick3d/quick3d/items/items.pri +++ b/src/quick3d/quick3d/items/items.pri @@ -3,12 +3,14 @@ HEADERS += \ $$PWD/quick3dentity_p.h \ $$PWD/quick3dentityloader_p_p.h \ $$PWD/quick3dentityloader_p.h \ - $$PWD/quick3dnode_p.h + $$PWD/quick3dnode_p.h \ + $$PWD/quick3dnodev9_p.h SOURCES += \ $$PWD/quick3dnode.cpp \ $$PWD/quick3dentity.cpp \ $$PWD/quick3dentityloader.cpp \ - $$PWD/quick3dnodeinstantiator.cpp + $$PWD/quick3dnodeinstantiator.cpp \ + $$PWD/quick3dnodev9.cpp INCLUDEPATH += $$PWD diff --git a/src/quick3d/quick3d/items/quick3dnodev9.cpp b/src/quick3d/quick3d/items/quick3dnodev9.cpp new file mode 100644 index 000000000..d1a9011b5 --- /dev/null +++ b/src/quick3d/quick3d/items/quick3dnodev9.cpp @@ -0,0 +1,203 @@ +/**************************************************************************** +** +** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB). +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the Qt3D module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "quick3dnodev9_p.h" +#include <QtQml/QJSValueIterator> + +QT_BEGIN_NAMESPACE + +namespace Qt3DCore { +namespace Quick { + +Quick3DNodeV9::Quick3DNodeV9(QObject *parent) + : QObject(parent) +{ +} + +/*! + \qmlproperty QJSValue Qt3DCore::Node::propertyTrackingOverrides + \default {} + + Assuming a Qt3DCore::Node needs to override the PropertyTrackingMode on two + properties (enabled and displacement), the value should be set as shown + below. + + \badcode + propertyTrackingOverrides: { + "enabled": Entity.DontTrackValues, + "displacement": Entity.TrackFinalValues + } + \endcode + + \since 2.9 +*/ + +QJSValue Quick3DNodeV9::propertyTrackingOverrides() const +{ + return m_propertyTrackingOverrides; +} + +void Quick3DNodeV9::setPropertyTrackingOverrides(const QJSValue &value) +{ + m_propertyTrackingOverrides = value; + + QNode *parentNode = this->parentNode(); + parentNode->clearPropertyTrackings(); + + if (value.isObject()) { + QJSValueIterator it(value); + while (it.hasNext()) { + it.next(); + parentNode->setPropertyTracking(it.name(), static_cast<QNode::PropertyTrackingMode>(it.value().toInt())); + } + } + emit propertyTrackingOverridesChanged(value); +} + +/*! + \qmlproperty list<QtQml::QtObject> Qt3DCore::Node::data + \default +*/ + +QQmlListProperty<QObject> Quick3DNodeV9::data() +{ + return QQmlListProperty<QObject>(this, 0, + Quick3DNodeV9::appendData, + Quick3DNodeV9::dataCount, + Quick3DNodeV9::dataAt, + Quick3DNodeV9::clearData); +} + +/*! + \qmlproperty list<Node> Qt3DCore::Node::childNodes + \readonly +*/ + +QQmlListProperty<QNode> Quick3DNodeV9::childNodes() +{ + return QQmlListProperty<QNode>(this, 0, + Quick3DNodeV9::appendChild, + Quick3DNodeV9::childCount, + Quick3DNodeV9::childAt, + Quick3DNodeV9::clearChildren); +} + +void Quick3DNodeV9::appendData(QQmlListProperty<QObject> *list, QObject *obj) +{ + if (!obj) + return; + + Quick3DNodeV9 *self = static_cast<Quick3DNodeV9 *>(list->object); + self->childAppended(0, obj); +} + +QObject *Quick3DNodeV9::dataAt(QQmlListProperty<QObject> *list, int index) +{ + Quick3DNodeV9 *self = static_cast<Quick3DNodeV9 *>(list->object); + return self->parentNode()->children().at(index); +} + +int Quick3DNodeV9::dataCount(QQmlListProperty<QObject> *list) +{ + Quick3DNodeV9 *self = static_cast<Quick3DNodeV9 *>(list->object); + return self->parentNode()->children().count(); +} + +void Quick3DNodeV9::clearData(QQmlListProperty<QObject> *list) +{ + Quick3DNodeV9 *self = static_cast<Quick3DNodeV9 *>(list->object); + for (QObject *const child : self->parentNode()->children()) + self->childRemoved(0, child); +} + +void Quick3DNodeV9::appendChild(QQmlListProperty<Qt3DCore::QNode> *list, Qt3DCore::QNode *obj) +{ + if (!obj) + return; + + Quick3DNodeV9 *self = static_cast<Quick3DNodeV9 *>(list->object); + Q_ASSERT(!self->parentNode()->children().contains(obj)); + + self->childAppended(0, obj); +} + +Qt3DCore::QNode *Quick3DNodeV9::childAt(QQmlListProperty<Qt3DCore::QNode> *list, int index) +{ + Quick3DNodeV9 *self = static_cast<Quick3DNodeV9 *>(list->object); + return qobject_cast<QNode *>(self->parentNode()->children().at(index)); +} + +int Quick3DNodeV9::childCount(QQmlListProperty<Qt3DCore::QNode> *list) +{ + Quick3DNodeV9 *self = static_cast<Quick3DNodeV9 *>(list->object); + return self->parentNode()->children().count(); +} + +void Quick3DNodeV9::clearChildren(QQmlListProperty<Qt3DCore::QNode> *list) +{ + Quick3DNodeV9 *self = static_cast<Quick3DNodeV9 *>(list->object); + for (QObject *const child : self->parentNode()->children()) + self->childRemoved(0, child); +} + +void Quick3DNodeV9::childAppended(int, QObject *obj) +{ + QNode *parentNode = this->parentNode(); + if (obj->parent() == parentNode) + obj->setParent(0); + // Set after otherwise addChild might not work + if (QNode *n = qobject_cast<QNode *>(obj)) + n->setParent(parentNode); + else + obj->setParent(parentNode); +} + +void Quick3DNodeV9::childRemoved(int, QObject *obj) +{ + if (QNode *n = qobject_cast<QNode *>(obj)) + n->setParent(Q_NODE_NULLPTR); + else + obj->setParent(nullptr); +} + + +} // namespace Quick +} // namespace Qt3DCore + +QT_END_NAMESPACE diff --git a/src/quick3d/quick3d/items/quick3dnodev9_p.h b/src/quick3d/quick3d/items/quick3dnodev9_p.h new file mode 100644 index 000000000..d969c4b64 --- /dev/null +++ b/src/quick3d/quick3d/items/quick3dnodev9_p.h @@ -0,0 +1,109 @@ +/**************************************************************************** +** +** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB). +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the Qt3D module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QT3D_QUICK_QUICK3DNODEV9_P_H +#define QT3D_QUICK_QUICK3DNODEV9_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists for the convenience +// of other Qt classes. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <QtQml/QJSValue> +#include <QQmlListProperty> +#include <Qt3DCore/qnode.h> +#include <Qt3DQuick/private/qt3dquick_global_p.h> + +QT_BEGIN_NAMESPACE + +namespace Qt3DCore { +namespace Quick { + +class QT3DQUICKSHARED_PRIVATE_EXPORT Quick3DNodeV9 : public QObject +{ + Q_OBJECT + Q_PROPERTY(QJSValue propertyTrackingOverrides READ propertyTrackingOverrides WRITE setPropertyTrackingOverrides NOTIFY propertyTrackingOverridesChanged) + Q_PROPERTY(QQmlListProperty<QObject> data READ data) + Q_PROPERTY(QQmlListProperty<Qt3DCore::QNode> childNodes READ childNodes) + Q_CLASSINFO("DefaultProperty", "data") + +public: + explicit Quick3DNodeV9(QObject *parent = nullptr); + + QJSValue propertyTrackingOverrides() const; + QQmlListProperty<QObject> data(); + QQmlListProperty<Qt3DCore::QNode> childNodes(); + + inline QNode *parentNode() const { return qobject_cast<QNode*>(parent()); } + +Q_SIGNALS: + void propertyTrackingOverridesChanged(const QJSValue &value); + +private Q_SLOTS: + void setPropertyTrackingOverrides(const QJSValue &value); + void childAppended(int idx, QObject *child); + void childRemoved(int idx, QObject *child); + +private: + static void appendData(QQmlListProperty<QObject> *list, QObject *obj); + static QObject *dataAt(QQmlListProperty<QObject> *list, int index); + static int dataCount(QQmlListProperty<QObject> *list); + static void clearData(QQmlListProperty<QObject> *list); + + static void appendChild(QQmlListProperty<Qt3DCore::QNode> *list, Qt3DCore::QNode *obj); + static QNode *childAt(QQmlListProperty<Qt3DCore::QNode> *list, int index); + static int childCount(QQmlListProperty<Qt3DCore::QNode> *list); + static void clearChildren(QQmlListProperty<Qt3DCore::QNode> *list); + + QJSValue m_propertyTrackingOverrides; +}; + +} // namespace Quick +} // namespace Qt3DCore + +QT_END_NAMESPACE + + +#endif // QT3D_QUICK_QUICK3DNODEV9_P_H diff --git a/tests/auto/core/nodes/tst_nodes.cpp b/tests/auto/core/nodes/tst_nodes.cpp index 90e0084e8..89d396931 100644 --- a/tests/auto/core/nodes/tst_nodes.cpp +++ b/tests/auto/core/nodes/tst_nodes.cpp @@ -250,7 +250,7 @@ public: void tst_Nodes::initTestCase() { - qRegisterMetaType<Qt3DCore::QNode::PropertyTrackMode>("PropertyTrackMode"); + qRegisterMetaType<Qt3DCore::QNode::PropertyTrackingMode>("PropertyTrackingMode"); } void tst_Nodes::defaultNodeConstruction() @@ -969,8 +969,7 @@ void tst_Nodes::checkDefaultConstruction() // THEN QCOMPARE(node.parentNode(), nullptr); QCOMPARE(node.isEnabled(), true); - QCOMPARE(node.propertyTrackMode(), Qt3DCore::QNode::DefaultTrackMode); - QCOMPARE(node.trackedProperties(), QStringList()); + QCOMPARE(node.defaultPropertyTrackingMode(), Qt3DCore::QNode::TrackFinalValues); } void tst_Nodes::checkPropertyChanges() @@ -1019,41 +1018,37 @@ void tst_Nodes::checkPropertyChanges() } { // WHEN - QSignalSpy spy(&node, SIGNAL(propertyUpdateModeChanged(PropertyTrackMode))); - const Qt3DCore::QNode::PropertyTrackMode newValue = Qt3DCore::QNode::TrackAllPropertiesMode; - node.setPropertyTrackMode(newValue); + QSignalSpy spy(&node, SIGNAL(defaultPropertyTrackingModeChanged(PropertyTrackingMode))); + const Qt3DCore::QNode::PropertyTrackingMode newValue = Qt3DCore::QNode::TrackAllValues; + node.setDefaultPropertyTrackingMode(newValue); // THEN QVERIFY(spy.isValid()); - QCOMPARE(node.propertyTrackMode(), newValue); + QCOMPARE(node.defaultPropertyTrackingMode(), newValue); QCOMPARE(spy.count(), 1); // WHEN spy.clear(); - node.setPropertyTrackMode(newValue); + node.setDefaultPropertyTrackingMode(newValue); // THEN - QCOMPARE(node.propertyTrackMode(), newValue); + QCOMPARE(node.defaultPropertyTrackingMode(), newValue); QCOMPARE(spy.count(), 0); } { // WHEN - QSignalSpy spy(&node, SIGNAL(trackedPropertiesChanged(const QStringList &))); - const QStringList newValue = QStringList() << QStringLiteral("C1") << QStringLiteral("C2") << QStringLiteral("C3"); - node.setTrackedProperties(newValue); + const QString enabledPropertyName = QStringLiteral("enabled"); + node.setDefaultPropertyTrackingMode(Qt3DCore::QNode::DontTrackValues); + node.setPropertyTracking(enabledPropertyName, Qt3DCore::QNode::TrackAllValues); // THEN - QVERIFY(spy.isValid()); - QCOMPARE(node.trackedProperties(), newValue); - QCOMPARE(spy.count(), 1); + QCOMPARE(node.propertyTracking(enabledPropertyName), Qt3DCore::QNode::TrackAllValues); // WHEN - spy.clear(); - node.setTrackedProperties(newValue); + node.clearPropertyTracking(enabledPropertyName); // THEN - QCOMPARE(node.trackedProperties(), newValue); - QCOMPARE(spy.count(), 0); + QCOMPARE(node.propertyTracking(enabledPropertyName), Qt3DCore::QNode::DontTrackValues); } } @@ -1065,9 +1060,9 @@ void tst_Nodes::checkCreationData() node.setParent(&root); node.setEnabled(true); - node.setPropertyTrackMode(Qt3DCore::QNode::TrackNamedPropertiesMode); - const QStringList trackedPropertyNames = QStringList() << QStringLiteral("327"); - node.setTrackedProperties(trackedPropertyNames); + const QString enabledPropertyName = QStringLiteral("enabled"); + node.setDefaultPropertyTrackingMode(Qt3DCore::QNode::DontTrackValues); + node.setPropertyTracking(enabledPropertyName, Qt3DCore::QNode::TrackAllValues); // WHEN QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges; @@ -1152,7 +1147,7 @@ void tst_Nodes::checkPropertyTrackModeUpdate() { // WHEN - node.setPropertyTrackMode(Qt3DCore::QNode::TrackAllPropertiesMode); + node.setDefaultPropertyTrackingMode(Qt3DCore::QNode::TrackAllValues); QCoreApplication::processEvents(); // THEN -> this properties is non notifying @@ -1161,7 +1156,7 @@ void tst_Nodes::checkPropertyTrackModeUpdate() { // WHEN - node.setPropertyTrackMode(Qt3DCore::QNode::TrackAllPropertiesMode); + node.setDefaultPropertyTrackingMode(Qt3DCore::QNode::TrackAllValues); QCoreApplication::processEvents(); // THEN @@ -1176,11 +1171,10 @@ void tst_Nodes::checkTrackedPropertyNamesUpdate() TestArbiter arbiter; Qt3DCore::QNode node; arbiter.setArbiterOnNode(&node); - const QStringList newValue = QStringList() << QStringLiteral("883") << QStringLiteral("454"); { // WHEN - node.setTrackedProperties(newValue); + node.setPropertyTracking(QStringLiteral("883"), Qt3DCore::QNode::TrackAllValues); QCoreApplication::processEvents(); // THEN -> this properties is non notifying @@ -1189,7 +1183,7 @@ void tst_Nodes::checkTrackedPropertyNamesUpdate() { // WHEN - node.setTrackedProperties(newValue); + node.setPropertyTracking(QStringLiteral("883"), Qt3DCore::QNode::DontTrackValues); QCoreApplication::processEvents(); // THEN diff --git a/tests/auto/core/qpostman/tst_qpostman.cpp b/tests/auto/core/qpostman/tst_qpostman.cpp index 1dabf143f..612db6257 100644 --- a/tests/auto/core/qpostman/tst_qpostman.cpp +++ b/tests/auto/core/qpostman/tst_qpostman.cpp @@ -174,7 +174,7 @@ private Q_SLOTS: { // WHEN - receiverNode->setPropertyTrackMode(QNode::TrackAllPropertiesMode); + receiverNode->setDefaultPropertyTrackingMode(QNode::TrackAllValues); auto updateChange = QPropertyUpdatedChangePtr::create(receiverNode->id()); updateChange->setValue(1584); @@ -189,8 +189,8 @@ private Q_SLOTS: { // GIVEN - receiverNode->setPropertyTrackMode(QNode::TrackNamedPropertiesMode); - receiverNode->setTrackedProperties(QStringList() << QStringLiteral("vette")); + receiverNode->setDefaultPropertyTrackingMode(QNode::DontTrackValues); + receiverNode->setPropertyTracking(QStringLiteral("vette"), Qt3DCore::QNode::TrackAllValues); { // WHEN @@ -220,8 +220,8 @@ private Q_SLOTS: { // GIVEN - receiverNode->setTrackedProperties(QStringList() << QStringLiteral("vette")); - receiverNode->setPropertyTrackMode(QNode::TrackAllPropertiesMode); + receiverNode->setPropertyTracking(QStringLiteral("vette"), Qt3DCore::QNode::TrackAllValues); + receiverNode->setDefaultPropertyTrackingMode(QNode::TrackAllValues); { // WHEN @@ -246,8 +246,8 @@ private Q_SLOTS: { // GIVEN - receiverNode->setTrackedProperties(QStringList()); - receiverNode->setPropertyTrackMode(QNode::DefaultTrackMode); + receiverNode->clearPropertyTrackings(); + receiverNode->setDefaultPropertyTrackingMode(QNode::TrackFinalValues); { // WHEN @@ -279,8 +279,8 @@ private Q_SLOTS: { // GIVEN - receiverNode->setTrackedProperties(QStringList()); - receiverNode->setPropertyTrackMode(QNode::DefaultTrackMode); + receiverNode->clearPropertyTrackings(); + receiverNode->setDefaultPropertyTrackingMode(QNode::TrackFinalValues); { // WHEN diff --git a/tests/auto/core/qscene/tst_qscene.cpp b/tests/auto/core/qscene/tst_qscene.cpp index 485143041..f4b04362d 100644 --- a/tests/auto/core/qscene/tst_qscene.cpp +++ b/tests/auto/core/qscene/tst_qscene.cpp @@ -487,36 +487,37 @@ void tst_QScene::setPropertyTrackData() // GIVEN Qt3DCore::QNodeId fakeNodeId = Qt3DCore::QNodeId::createId(); QScopedPointer<Qt3DCore::QScene> scene(new Qt3DCore::QScene); - const QStringList propertyNamesList = QStringList() << QStringLiteral("1340"); + QHash<QString, Qt3DCore::QNode::PropertyTrackingMode> overridenTrackedProperties; + overridenTrackedProperties.insert(QStringLiteral("1340"), Qt3DCore::QNode::TrackAllValues); // WHEN { Qt3DCore::QScene::NodePropertyTrackData trackData; - trackData.namedProperties = propertyNamesList; - trackData.updateMode = Qt3DCore::QNode::TrackNamedPropertiesMode; + trackData.trackedPropertiesOverrides = overridenTrackedProperties; + trackData.defaultTrackMode = Qt3DCore::QNode::DontTrackValues; scene->setPropertyTrackDataForNode(fakeNodeId, trackData); } // THEN { Qt3DCore::QScene::NodePropertyTrackData trackData = scene->lookupNodePropertyTrackData(fakeNodeId); - QCOMPARE(trackData.namedProperties, propertyNamesList); - QCOMPARE(trackData.updateMode, Qt3DCore::QNode::TrackNamedPropertiesMode); + QCOMPARE(trackData.trackedPropertiesOverrides, overridenTrackedProperties); + QCOMPARE(trackData.defaultTrackMode, Qt3DCore::QNode::DontTrackValues); } // WHEN { Qt3DCore::QScene::NodePropertyTrackData trackData; - trackData.namedProperties = propertyNamesList; - trackData.updateMode = Qt3DCore::QNode::DefaultTrackMode; + trackData.trackedPropertiesOverrides.clear(); + trackData.defaultTrackMode = Qt3DCore::QNode::TrackFinalValues; scene->setPropertyTrackDataForNode(fakeNodeId, trackData); } // THEN { Qt3DCore::QScene::NodePropertyTrackData trackData = scene->lookupNodePropertyTrackData(fakeNodeId); - QCOMPARE(trackData.namedProperties, propertyNamesList); - QCOMPARE(trackData.updateMode, Qt3DCore::QNode::DefaultTrackMode); + QCOMPARE(trackData.trackedPropertiesOverrides.size(), 0); + QCOMPARE(trackData.defaultTrackMode, Qt3DCore::QNode::TrackFinalValues); } } @@ -525,21 +526,20 @@ void tst_QScene::lookupNodePropertyTrackData() // GIVEN QScopedPointer<Qt3DCore::QScene> scene(new Qt3DCore::QScene); Qt3DCore::QNodeId fakeNodeId = Qt3DCore::QNodeId::createId(); - const QStringList propertyNamesList = QStringList() << QStringLiteral("383"); // THEN -> default value for non existent id Qt3DCore::QScene::NodePropertyTrackData trackData = scene->lookupNodePropertyTrackData(fakeNodeId); - QCOMPARE(trackData.namedProperties, QStringList()); - QCOMPARE(trackData.updateMode, Qt3DCore::QNode::DefaultTrackMode); + QCOMPARE(trackData.trackedPropertiesOverrides.size(), 0); + QCOMPARE(trackData.defaultTrackMode, Qt3DCore::QNode::TrackFinalValues); // WHEN - trackData.namedProperties = propertyNamesList; - trackData.updateMode = Qt3DCore::QNode::TrackNamedPropertiesMode; + trackData.trackedPropertiesOverrides.insert(QStringLiteral("383"), Qt3DCore::QNode::TrackAllValues); + trackData.defaultTrackMode = Qt3DCore::QNode::DontTrackValues; scene->setPropertyTrackDataForNode(fakeNodeId, trackData); trackData = scene->lookupNodePropertyTrackData(fakeNodeId); - QCOMPARE(trackData.namedProperties, propertyNamesList); - QCOMPARE(trackData.updateMode, Qt3DCore::QNode::TrackNamedPropertiesMode); + QCOMPARE(trackData.trackedPropertiesOverrides.size(), 1); + QCOMPARE(trackData.defaultTrackMode, Qt3DCore::QNode::DontTrackValues); } void tst_QScene::removePropertyTrackData() @@ -550,15 +550,15 @@ void tst_QScene::removePropertyTrackData() // WHEN Qt3DCore::QScene::NodePropertyTrackData trackData; - trackData.namedProperties = QStringList() << QStringLiteral("1584"); - trackData.updateMode = Qt3DCore::QNode::TrackNamedPropertiesMode; + trackData.trackedPropertiesOverrides.insert(QStringLiteral("1584"), Qt3DCore::QNode::TrackAllValues); + trackData.defaultTrackMode = Qt3DCore::QNode::DontTrackValues; scene->setPropertyTrackDataForNode(fakeNodeId, trackData); scene->removePropertyTrackDataForNode(fakeNodeId); // THEN -> default value for non existent id trackData = scene->lookupNodePropertyTrackData(fakeNodeId); - QCOMPARE(trackData.namedProperties, QStringList()); - QCOMPARE(trackData.updateMode, Qt3DCore::QNode::DefaultTrackMode); + QCOMPARE(trackData.trackedPropertiesOverrides.size(), 0); + QCOMPARE(trackData.defaultTrackMode, Qt3DCore::QNode::TrackFinalValues); } void tst_QScene::nodeSetAndUnsetPropertyTrackData() @@ -569,9 +569,8 @@ void tst_QScene::nodeSetAndUnsetPropertyTrackData() Qt3DCore::QNodePrivate::get(&parentNode)->setScene(scene.data()); Qt3DCore::QNode *childNode = new Qt3DCore::QNode(); - const QStringList propertyNamesList = QStringList() << QStringLiteral("883"); - childNode->setTrackedProperties(propertyNamesList); - childNode->setPropertyTrackMode(Qt3DCore::QNode::TrackNamedPropertiesMode); + childNode->setPropertyTracking(QStringLiteral("883"), Qt3DCore::QNode::TrackAllValues); + childNode->setDefaultPropertyTrackingMode(Qt3DCore::QNode::DontTrackValues); // WHEN childNode->setParent(&parentNode); @@ -580,8 +579,9 @@ void tst_QScene::nodeSetAndUnsetPropertyTrackData() // THEN QCOMPARE(Qt3DCore::QNodePrivate::get(childNode)->m_scene, scene.data()); Qt3DCore::QScene::NodePropertyTrackData trackData = scene->lookupNodePropertyTrackData(childNode->id()); - QCOMPARE(trackData.updateMode, Qt3DCore::QNode::TrackNamedPropertiesMode); - QCOMPARE(trackData.namedProperties, propertyNamesList); + QCOMPARE(trackData.defaultTrackMode, Qt3DCore::QNode::DontTrackValues); + QCOMPARE(trackData.trackedPropertiesOverrides.size(), 1); + QCOMPARE(trackData.trackedPropertiesOverrides[QStringLiteral("883")], Qt3DCore::QNode::TrackAllValues); // WHEN const Qt3DCore::QNodeId childNodeId = childNode->id(); @@ -590,8 +590,8 @@ void tst_QScene::nodeSetAndUnsetPropertyTrackData() // THEN -> default value for non existent id trackData = scene->lookupNodePropertyTrackData(childNodeId); - QCOMPARE(trackData.namedProperties, QStringList()); - QCOMPARE(trackData.updateMode, Qt3DCore::QNode::DefaultTrackMode); + QCOMPARE(trackData.trackedPropertiesOverrides.size(), 0); + QCOMPARE(trackData.defaultTrackMode, Qt3DCore::QNode::TrackFinalValues); } void tst_QScene::nodeUpdatePropertyTrackData() @@ -602,9 +602,9 @@ void tst_QScene::nodeUpdatePropertyTrackData() Qt3DCore::QNodePrivate::get(&parentNode)->setScene(scene.data()); Qt3DCore::QNode *childNode = new Qt3DCore::QNode(); - const QStringList propertyNamesList = QStringList() << QStringLiteral("883"); - childNode->setTrackedProperties(propertyNamesList); - childNode->setPropertyTrackMode(Qt3DCore::QNode::TrackNamedPropertiesMode); + const QString propertyName = QStringLiteral("883"); + childNode->setPropertyTracking(propertyName, Qt3DCore::QNode::TrackFinalValues); + childNode->setDefaultPropertyTrackingMode(Qt3DCore::QNode::DontTrackValues); // WHEN childNode->setParent(&parentNode); @@ -613,23 +613,26 @@ void tst_QScene::nodeUpdatePropertyTrackData() // THEN QCOMPARE(Qt3DCore::QNodePrivate::get(childNode)->m_scene, scene.data()); Qt3DCore::QScene::NodePropertyTrackData trackData = scene->lookupNodePropertyTrackData(childNode->id()); - QCOMPARE(trackData.updateMode, Qt3DCore::QNode::TrackNamedPropertiesMode); - QCOMPARE(trackData.namedProperties, propertyNamesList); + QCOMPARE(trackData.defaultTrackMode, Qt3DCore::QNode::DontTrackValues); + QCOMPARE(trackData.trackedPropertiesOverrides.size(), 1); + QCOMPARE(trackData.trackedPropertiesOverrides[propertyName], Qt3DCore::QNode::TrackFinalValues); // WHEN - childNode->setPropertyTrackMode(Qt3DCore::QNode::TrackAllPropertiesMode); + childNode->setDefaultPropertyTrackingMode(Qt3DCore::QNode::TrackAllValues); // THEN trackData = scene->lookupNodePropertyTrackData(childNode->id()); - QCOMPARE(trackData.updateMode, Qt3DCore::QNode::TrackAllPropertiesMode); + QCOMPARE(trackData.defaultTrackMode, Qt3DCore::QNode::TrackAllValues); // WHEN - const QStringList propertyNamesList2 = QStringList() << QStringLiteral("Viper"); - childNode->setTrackedProperties(propertyNamesList2); + const QString propertyName2 = QStringLiteral("Viper"); + childNode->setPropertyTracking(propertyName2, Qt3DCore::QNode::DontTrackValues); // THEN trackData = scene->lookupNodePropertyTrackData(childNode->id()); - QCOMPARE(trackData.namedProperties, propertyNamesList2); + QCOMPARE(trackData.trackedPropertiesOverrides.size(), 2); + QCOMPARE(trackData.trackedPropertiesOverrides[propertyName], Qt3DCore::QNode::TrackFinalValues); + QCOMPARE(trackData.trackedPropertiesOverrides[propertyName2], Qt3DCore::QNode::DontTrackValues); } QTEST_MAIN(tst_QScene) diff --git a/tests/auto/quick3d/3dcore/3dcore.qml b/tests/auto/quick3d/3dcore/3dcore.qml index 1d9d885ff..df9dd429b 100644 --- a/tests/auto/quick3d/3dcore/3dcore.qml +++ b/tests/auto/quick3d/3dcore/3dcore.qml @@ -28,6 +28,7 @@ import Qt3D.Core 2.0 as QQ3Core20 +import Qt3D.Core 2.9 as QQ3Core29 import QtQuick 2.0 Item { @@ -40,4 +41,5 @@ Item { QQ3Core20.Transform {} //Qt3DCore::QTransform QQ3Core20.QuaternionAnimation {} //Qt3DCore::Quick::QQuaternionAnimation + QQ3Core29.Entity {} //Qt3DCore::QEntity, Qt3DCore::Quick::Quick3DEntity } diff --git a/tests/auto/quick3d/quick3d.pro b/tests/auto/quick3d/quick3d.pro index 8abe04550..dd67a3ef4 100644 --- a/tests/auto/quick3d/quick3d.pro +++ b/tests/auto/quick3d/quick3d.pro @@ -7,5 +7,6 @@ qtConfig(private_tests) { 3drender \ 3dinput \ 3dcore \ - quick3dbuffer + quick3dbuffer \ + quick3dnode } diff --git a/tests/auto/quick3d/quick3dnode/quick3dnode.pro b/tests/auto/quick3d/quick3dnode/quick3dnode.pro new file mode 100644 index 000000000..5b3038c42 --- /dev/null +++ b/tests/auto/quick3d/quick3dnode/quick3dnode.pro @@ -0,0 +1,13 @@ +TEMPLATE = app + +TARGET = tst_quick3dnode + +QT += 3dcore 3dcore-private 3drender 3drender-private 3dquick 3dquick-private 3dquickrender-private testlib + +CONFIG += testcase + +include(../../render/qmlscenereader/qmlscenereader.pri) + +SOURCES += tst_quick3dnode.cpp + +RESOURCES += quick3dnode.qrc diff --git a/tests/auto/quick3d/quick3dnode/quick3dnode.qrc b/tests/auto/quick3d/quick3dnode/quick3dnode.qrc new file mode 100644 index 000000000..afdbbbb66 --- /dev/null +++ b/tests/auto/quick3d/quick3dnode/quick3dnode.qrc @@ -0,0 +1,5 @@ +<RCC> + <qresource prefix="/"> + <file>quick3dnodev9.qml</file> + </qresource> +</RCC> diff --git a/tests/auto/quick3d/quick3dnode/quick3dnodev9.qml b/tests/auto/quick3d/quick3dnode/quick3dnodev9.qml new file mode 100644 index 000000000..5429faf4e --- /dev/null +++ b/tests/auto/quick3d/quick3dnode/quick3dnodev9.qml @@ -0,0 +1,36 @@ +/**************************************************************************** +** +** Copyright (C) 2017 Paul Lemire <paul.lemire350@gmail.com> +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the Qt3D module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +import Qt3D.Core 2.9 + +Entity { + propertyTrackingOverrides: { + "enabled": Entity.DontTrackValues, + "displacement": Entity.TrackFinalValues + } +} diff --git a/tests/auto/quick3d/quick3dnode/tst_quick3dnode.cpp b/tests/auto/quick3d/quick3dnode/tst_quick3dnode.cpp new file mode 100644 index 000000000..38bf46a7a --- /dev/null +++ b/tests/auto/quick3d/quick3dnode/tst_quick3dnode.cpp @@ -0,0 +1,55 @@ +/**************************************************************************** +** +** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB). +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the Qt3D module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:GPL-EXCEPT$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 as published by the Free Software +** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QtTest/QTest> +#include <Qt3DQuick/private/quick3dnode_p.h> +#include <QObject> +#include <qmlscenereader.h> + +class tst_Quick3DNode : public QObject +{ + Q_OBJECT + +private Q_SLOTS: + + void checkPropertyTrackingOverrides_V9() + { + // GIVEN + QmlSceneReader sceneReader(QUrl("qrc:/quick3dnodev9.qml")); + + // THEN + QVERIFY(sceneReader.root() != nullptr); + Qt3DCore::QNode *node = static_cast<Qt3DCore::QNode *>(sceneReader.root()); + QCOMPARE(node->propertyTracking(QLatin1String("enabled")), Qt3DCore::QNode::DontTrackValues); + QCOMPARE(node->propertyTracking(QLatin1String("displacement")), Qt3DCore::QNode::TrackFinalValues); + } +}; + +QTEST_MAIN(tst_Quick3DNode) + +#include "tst_quick3dnode.moc" diff --git a/tests/auto/render/updateshaderdatatransformjob/test_scene_model_to_eye.qml b/tests/auto/render/updateshaderdatatransformjob/test_scene_model_to_eye.qml index 20585b5de..3b21b08ba 100644 --- a/tests/auto/render/updateshaderdatatransformjob/test_scene_model_to_eye.qml +++ b/tests/auto/render/updateshaderdatatransformjob/test_scene_model_to_eye.qml @@ -48,9 +48,9 @@ ** ****************************************************************************/ -import Qt3D.Core 2.0 -import Qt3D.Render 2.0 -import Qt3D.Extras 2.0 +import Qt3D.Core 2.9 +import Qt3D.Render 2.9 +import Qt3D.Extras 2.9 import QtQuick.Window 2.0 Entity { diff --git a/tests/auto/render/updateshaderdatatransformjob/test_scene_model_to_world.qml b/tests/auto/render/updateshaderdatatransformjob/test_scene_model_to_world.qml index d3e766021..59ccdd27f 100644 --- a/tests/auto/render/updateshaderdatatransformjob/test_scene_model_to_world.qml +++ b/tests/auto/render/updateshaderdatatransformjob/test_scene_model_to_world.qml @@ -48,9 +48,9 @@ ** ****************************************************************************/ -import Qt3D.Core 2.0 -import Qt3D.Render 2.0 -import Qt3D.Extras 2.0 +import Qt3D.Core 2.9 +import Qt3D.Render 2.9 +import Qt3D.Extras 2.9 import QtQuick.Window 2.0 Entity { diff --git a/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp b/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp index 9b53d1f65..c076aa21e 100644 --- a/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp +++ b/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp @@ -165,7 +165,7 @@ private Q_SLOTS: Qt3DRender::Render::ShaderData *backendShaderData = collection.backendShaderData.first(); // THEN - QCOMPARE(backendShaderData->properties().size(), 2); + QCOMPARE(backendShaderData->properties().size(), 3); QVERIFY(backendShaderData->properties().contains(QLatin1String("eyePosition"))); QVERIFY(backendShaderData->properties().contains(QLatin1String("eyePositionTransformed"))); @@ -205,7 +205,7 @@ private Q_SLOTS: Qt3DRender::Render::ShaderData *backendShaderData = collection.backendShaderData.first(); // THEN - QCOMPARE(backendShaderData->properties().size(), 2); + QCOMPARE(backendShaderData->properties().size(), 3); QVERIFY(backendShaderData->properties().contains(QLatin1String("position"))); QVERIFY(backendShaderData->properties().contains(QLatin1String("positionTransformed"))); |