Clean up qml type handling

Was duplicated code

Change-Id: If20893a53bd75784fb8a268573f39b25c53d3f7d
Pick-to: 6.0
Pick-to: 6.0.0
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>

4 files changed, 498 insertions, 1251 deletions

diff --git a/src/quick3d/quick3d/qt3dquick_global.cpp b/src/quick3d/quick3d/qt3dquick_global.cpp
index 2a07ba83d..209e5cae0 100644
--- a/src/quick3d/quick3d/qt3dquick_global.cpp
+++ b/src/quick3d/quick3d/qt3dquick_global.cpp
@@ -47,700 +47,9 @@
 
 QT_BEGIN_NAMESPACE
 
-namespace {
-
-template<typename T, int NumParams>
-QVariant createValueTypeFromNumberString(const QString &s)
-{
-    Q_STATIC_ASSERT_X(NumParams == 2 || NumParams == 3 || NumParams == 4 || NumParams == 16,
-                      "Unsupported number of params; add an additional case below if necessary.");
-
-    if (s.count(u',') != NumParams - 1)
-        return QVariant();
-
-    QVarLengthArray<float, NumParams> parameters;
-    bool ok = true;
-    for (qsizetype prev = 0, next = s.indexOf(u','), length = s.length(); ok && prev < length;) {
-        parameters.append(s.mid(prev, next - prev).toFloat(&ok));
-        prev = next + 1;
-        next = (parameters.length() == NumParams - 1) ? length : s.indexOf(u',', prev);
-    }
-
-    if (!ok)
-        return QVariant();
-
-    if constexpr (NumParams == 2) {
-        return T(parameters[0], parameters[1]);
-    } else if constexpr (NumParams == 3) {
-        return T(parameters[0], parameters[1], parameters[2]);
-    } else if constexpr (NumParams == 4) {
-        return T(parameters[0], parameters[1], parameters[2], parameters[3]);
-    } else if constexpr (NumParams == 16) {
-        return T(parameters[0], parameters[1], parameters[2], parameters[3],
-                 parameters[4], parameters[5], parameters[6], parameters[7],
-                 parameters[8], parameters[9], parameters[10], parameters[11],
-                 parameters[12], parameters[13], parameters[14], parameters[15]);
-    } else {
-        Q_UNREACHABLE();
-    }
-
-    return QVariant();
-}
-
-}
-
-
 namespace Qt3DCore {
 namespace Quick {
 
-QVariant QQuick3DColorValueType::create(const QJSValue &params)
-{
-    return params.isString() ? QColor(params.toString()) : QVariant();
-}
-
-QString QQuick3DColorValueType::toString() const
-{
-    return v.name(v.alpha() != 255 ? QColor::HexArgb : QColor::HexRgb);
-}
-
-QVariant QQuick3DColorValueType::lighter(qreal factor) const
-{
-    return QQml_colorProvider()->lighter(this->v, factor);
-}
-
-QVariant QQuick3DColorValueType::darker(qreal factor) const
-{
-    return QQml_colorProvider()->darker(this->v, factor);
-}
-
-QVariant QQuick3DColorValueType::alpha(qreal value) const
-{
-    return QQml_colorProvider()->alpha(this->v, value);
-}
-
-QVariant QQuick3DColorValueType::tint(QVariant tintColor) const
-{
-    return QQml_colorProvider()->tint(this->v, tintColor);
-}
-
-qreal QQuick3DColorValueType::r() const
-{
-    return v.redF();
-}
-
-qreal QQuick3DColorValueType::g() const
-{
-    return v.greenF();
-}
-
-qreal QQuick3DColorValueType::b() const
-{
-    return v.blueF();
-}
-
-qreal QQuick3DColorValueType::a() const
-{
-    return v.alphaF();
-}
-
-qreal QQuick3DColorValueType::hsvHue() const
-{
-    return v.hsvHueF();
-}
-
-qreal QQuick3DColorValueType::hsvSaturation() const
-{
-    return v.hsvSaturationF();
-}
-
-qreal QQuick3DColorValueType::hsvValue() const
-{
-    return v.valueF();
-}
-
-qreal QQuick3DColorValueType::hslHue() const
-{
-    return v.hslHueF();
-}
-
-qreal QQuick3DColorValueType::hslSaturation() const
-{
-    return v.hslSaturationF();
-}
-
-qreal QQuick3DColorValueType::hslLightness() const
-{
-    return v.lightnessF();
-}
-
-bool QQuick3DColorValueType::isValid() const
-{
-    return v.isValid();
-}
-
-void QQuick3DColorValueType::setR(qreal r)
-{
-    v.setRedF(r);
-}
-
-void QQuick3DColorValueType::setG(qreal g)
-{
-    v.setGreenF(g);
-}
-
-void QQuick3DColorValueType::setB(qreal b)
-{
-    v.setBlueF(b);
-}
-
-void QQuick3DColorValueType::setA(qreal a)
-{
-    v.setAlphaF(a);
-}
-
-void QQuick3DColorValueType::setHsvHue(qreal hsvHue)
-{
-    float hue, saturation, value, alpha;
-    v.getHsvF(&hue, &saturation, &value, &alpha);
-    v.setHsvF(hsvHue, saturation, value, alpha);
-}
-
-void QQuick3DColorValueType::setHsvSaturation(qreal hsvSaturation)
-{
-    float hue, saturation, value, alpha;
-    v.getHsvF(&hue, &saturation, &value, &alpha);
-    v.setHsvF(hue, hsvSaturation, value, alpha);
-}
-
-void QQuick3DColorValueType::setHsvValue(qreal hsvValue)
-{
-    float hue, saturation, value, alpha;
-    v.getHsvF(&hue, &saturation, &value, &alpha);
-    v.setHsvF(hue, saturation, hsvValue, alpha);
-}
-
-void QQuick3DColorValueType::setHslHue(qreal hslHue)
-{
-    float hue, saturation, lightness, alpha;
-    v.getHslF(&hue, &saturation, &lightness, &alpha);
-    v.setHslF(hslHue, saturation, lightness, alpha);
-}
-
-void QQuick3DColorValueType::setHslSaturation(qreal hslSaturation)
-{
-    float hue, saturation, lightness, alpha;
-    v.getHslF(&hue, &saturation, &lightness, &alpha);
-    v.setHslF(hue, hslSaturation, lightness, alpha);
-}
-
-void QQuick3DColorValueType::setHslLightness(qreal hslLightness)
-{
-    float hue, saturation, lightness, alpha;
-    v.getHslF(&hue, &saturation, &lightness, &alpha);
-    v.setHslF(hue, saturation, hslLightness, alpha);
-}
-
-QVariant QQuick3DMatrix4x4ValueType::create(const QJSValue &params)
-{
-    if (params.isNull() || params.isUndefined())
-        return QMatrix4x4();
-
-    if (params.isString())
-        return createValueTypeFromNumberString<QMatrix4x4, 16>(params.toString());
-
-    if (params.isArray() && params.property(QStringLiteral("length")).toInt() == 16) {
-        return QMatrix4x4(params.property(0).toNumber(),
-                          params.property(1).toNumber(),
-                          params.property(2).toNumber(),
-                          params.property(3).toNumber(),
-                          params.property(4).toNumber(),
-                          params.property(5).toNumber(),
-                          params.property(6).toNumber(),
-                          params.property(7).toNumber(),
-                          params.property(8).toNumber(),
-                          params.property(9).toNumber(),
-                          params.property(10).toNumber(),
-                          params.property(11).toNumber(),
-                          params.property(12).toNumber(),
-                          params.property(13).toNumber(),
-                          params.property(14).toNumber(),
-                          params.property(15).toNumber());
-    }
-
-    return {};
-}
-
-QMatrix4x4 QQuick3DMatrix4x4ValueType::times(const QMatrix4x4 &m) const
-{
-    return v * m;
-}
-
-QVector4D QQuick3DMatrix4x4ValueType::times(const QVector4D &vec) const
-{
-    return v * vec;
-}
-
-QVector3D QQuick3DMatrix4x4ValueType::times(const QVector3D &vec) const
-{
-    return v * vec;
-}
-
-QMatrix4x4 QQuick3DMatrix4x4ValueType::times(qreal factor) const
-{
-    return v * float(factor);
-}
-
-QMatrix4x4 QQuick3DMatrix4x4ValueType::plus(const QMatrix4x4 &m) const
-{
-    return v + m;
-}
-
-QMatrix4x4 QQuick3DMatrix4x4ValueType::minus(const QMatrix4x4 &m) const
-{
-    return v - m;
-}
-
-QVector4D QQuick3DMatrix4x4ValueType::row(int n) const
-{
-    return v.row(n);
-}
-
-QVector4D QQuick3DMatrix4x4ValueType::column(int m) const
-{
-    return v.column(m);
-}
-
-qreal QQuick3DMatrix4x4ValueType::determinant() const
-{
-    return v.determinant();
-}
-
-QMatrix4x4 QQuick3DMatrix4x4ValueType::inverted() const
-{
-    return v.inverted();
-}
-
-QMatrix4x4 QQuick3DMatrix4x4ValueType::transposed() const
-{
-    return v.transposed();
-}
-
-bool QQuick3DMatrix4x4ValueType::fuzzyEquals(const QMatrix4x4 &m, qreal epsilon) const
-{
-    qreal absEps = qAbs(epsilon);
-    for (int i = 0; i < 4; ++i) {
-        for (int j = 0; j < 4; ++j) {
-            if (qAbs(v(i,j) - m(i,j)) > absEps) {
-                return false;
-            }
-        }
-    }
-    return true;
-}
-
-bool QQuick3DMatrix4x4ValueType::fuzzyEquals(const QMatrix4x4 &m) const
-{
-    return qFuzzyCompare(v, m);
-}
-
-QVariant QQuick3DVector3DValueType::create(const QJSValue &params)
-{
-    if (params.isString())
-        return createValueTypeFromNumberString<QVector3D, 3>(params.toString());
-
-    if (params.isArray()) {
-        return QVector3D(params.property(0).toNumber(), params.property(1).toNumber(),
-                         params.property(2).toNumber());
-    }
-    return QVariant();
-}
-
-QString QQuick3DVector3DValueType::toString() const
-{
-    return QString(QLatin1String("QVector3D(%1, %2, %3)")).arg(v.x()).arg(v.y()).arg(v.z());
-}
-
-qreal QQuick3DVector3DValueType::x() const
-{
-    return qreal(v.x());
-}
-
-qreal QQuick3DVector3DValueType::y() const
-{
-    return qreal(v.y());
-}
-
-qreal QQuick3DVector3DValueType::z() const
-{
-    return qreal(v.z());
-}
-
-void QQuick3DVector3DValueType::setX(qreal x)
-{
-    v.setX(float(x));
-}
-
-void QQuick3DVector3DValueType::setY(qreal y)
-{
-    v.setY(float(y));
-}
-
-void QQuick3DVector3DValueType::setZ(qreal z)
-{
-    v.setZ(float(z));
-}
-
-QVector3D QQuick3DVector3DValueType::crossProduct(const QVector3D &vec) const
-{
-    return QVector3D::crossProduct(v, vec);
-}
-
-qreal QQuick3DVector3DValueType::dotProduct(const QVector3D &vec) const
-{
-    return qreal(QVector3D::dotProduct(v, vec));
-}
-
-QVector3D QQuick3DVector3DValueType::times(const QMatrix4x4 &m) const
-{
-    return v * m;
-}
-
-QVector3D QQuick3DVector3DValueType::times(const QVector3D &vec) const
-{
-    return v * vec;
-}
-
-QVector3D QQuick3DVector3DValueType::times(qreal scalar) const
-{
-    return v * float(scalar);
-}
-
-QVector3D QQuick3DVector3DValueType::plus(const QVector3D &vec) const
-{
-    return v + vec;
-}
-
-QVector3D QQuick3DVector3DValueType::minus(const QVector3D &vec) const
-{
-    return v - vec;
-}
-
-QVector3D QQuick3DVector3DValueType::normalized() const
-{
-    return v.normalized();
-}
-
-qreal QQuick3DVector3DValueType::length() const
-{
-    return qreal(v.length());
-}
-
-QVector2D QQuick3DVector3DValueType::toVector2d() const
-{
-    return v.toVector2D();
-}
-
-QVector4D QQuick3DVector3DValueType::toVector4d() const
-{
-    return v.toVector4D();
-}
-
-bool QQuick3DVector3DValueType::fuzzyEquals(const QVector3D &vec, qreal epsilon) const
-{
-    qreal absEps = qAbs(epsilon);
-    if (qAbs(v.x() - vec.x()) > absEps)
-        return false;
-    if (qAbs(v.y() - vec.y()) > absEps)
-        return false;
-    if (qAbs(v.z() - vec.z()) > absEps)
-        return false;
-    return true;
-}
-
-bool QQuick3DVector3DValueType::fuzzyEquals(const QVector3D &vec) const
-{
-    return qFuzzyCompare(v, vec);
-}
-
-QVariant QQuick3DVector2DValueType::create(const QJSValue &params)
-{
-    if (params.isString())
-        return createValueTypeFromNumberString<QVector2D, 2>(params.toString());
-    if (params.isArray())
-        return QVector2D(params.property(0).toNumber(), params.property(1).toNumber());
-    return QVariant();
-}
-
-QString QQuick3DVector2DValueType::toString() const
-{
-    return QString(QLatin1String("QVector2D(%1, %2)")).arg(v.x()).arg(v.y());
-}
-
-qreal QQuick3DVector2DValueType::x() const
-{
-    return v.x();
-}
-
-qreal QQuick3DVector2DValueType::y() const
-{
-    return v.y();
-}
-
-void QQuick3DVector2DValueType::setX(qreal x)
-{
-    v.setX(x);
-}
-
-void QQuick3DVector2DValueType::setY(qreal y)
-{
-    v.setY(y);
-}
-
-qreal QQuick3DVector2DValueType::dotProduct(const QVector2D &vec) const
-{
-    return QVector2D::dotProduct(v, vec);
-}
-
-QVector2D QQuick3DVector2DValueType::times(const QVector2D &vec) const
-{
-    return v * vec;
-}
-
-QVector2D QQuick3DVector2DValueType::times(qreal scalar) const
-{
-    return v * scalar;
-}
-
-QVector2D QQuick3DVector2DValueType::plus(const QVector2D &vec) const
-{
-    return v + vec;
-}
-
-QVector2D QQuick3DVector2DValueType::minus(const QVector2D &vec) const
-{
-    return v - vec;
-}
-
-QVector2D QQuick3DVector2DValueType::normalized() const
-{
-    return v.normalized();
-}
-
-qreal QQuick3DVector2DValueType::length() const
-{
-    return v.length();
-}
-
-QVector3D QQuick3DVector2DValueType::toVector3d() const
-{
-    return v.toVector3D();
-}
-
-QVector4D QQuick3DVector2DValueType::toVector4d() const
-{
-    return v.toVector4D();
-}
-
-bool QQuick3DVector2DValueType::fuzzyEquals(const QVector2D &vec, qreal epsilon) const
-{
-    qreal absEps = qAbs(epsilon);
-    if (qAbs(v.x() - vec.x()) > absEps)
-        return false;
-    if (qAbs(v.y() - vec.y()) > absEps)
-        return false;
-    return true;
-}
-
-bool QQuick3DVector2DValueType::fuzzyEquals(const QVector2D &vec) const
-{
-    return qFuzzyCompare(v, vec);
-}
-
-QVariant QQuick3DVector4DValueType::create(const QJSValue &params)
-{
-    if (params.isString())
-        return createValueTypeFromNumberString<QVector4D, 4>(params.toString());
-
-    if (params.isArray()) {
-        return QVector4D(params.property(0).toNumber(), params.property(1).toNumber(),
-                         params.property(2).toNumber(), params.property(3).toNumber());
-    }
-
-    return QVariant();
-}
-
-QString QQuick3DVector4DValueType::toString() const
-{
-    return QString(QLatin1String("QVector4D(%1, %2, %3, %4)")).arg(v.x()).arg(v.y()).arg(v.z()).arg(v.w());
-}
-
-qreal QQuick3DVector4DValueType::x() const
-{
-    return v.x();
-}
-
-qreal QQuick3DVector4DValueType::y() const
-{
-    return v.y();
-}
-
-qreal QQuick3DVector4DValueType::z() const
-{
-    return v.z();
-}
-
-qreal QQuick3DVector4DValueType::w() const
-{
-    return v.w();
-}
-
-void QQuick3DVector4DValueType::setX(qreal x)
-{
-    v.setX(x);
-}
-
-void QQuick3DVector4DValueType::setY(qreal y)
-{
-    v.setY(y);
-}
-
-void QQuick3DVector4DValueType::setZ(qreal z)
-{
-    v.setZ(z);
-}
-
-void QQuick3DVector4DValueType::setW(qreal w)
-{
-    v.setW(w);
-}
-
-qreal QQuick3DVector4DValueType::dotProduct(const QVector4D &vec) const
-{
-    return QVector4D::dotProduct(v, vec);
-}
-
-QVector4D QQuick3DVector4DValueType::times(const QVector4D &vec) const
-{
-    return v * vec;
-}
-
-QVector4D QQuick3DVector4DValueType::times(const QMatrix4x4 &m) const
-{
-    return v * m;
-}
-
-QVector4D QQuick3DVector4DValueType::times(qreal scalar) const
-{
-    return v * scalar;
-}
-
-QVector4D QQuick3DVector4DValueType::plus(const QVector4D &vec) const
-{
-    return v + vec;
-}
-
-QVector4D QQuick3DVector4DValueType::minus(const QVector4D &vec) const
-{
-    return v - vec;
-}
-
-QVector4D QQuick3DVector4DValueType::normalized() const
-{
-    return v.normalized();
-}
-
-qreal QQuick3DVector4DValueType::length() const
-{
-    return v.length();
-}
-
-QVector2D QQuick3DVector4DValueType::toVector2d() const
-{
-    return v.toVector2D();
-}
-
-QVector3D QQuick3DVector4DValueType::toVector3d() const
-{
-    return v.toVector3D();
-}
-
-bool QQuick3DVector4DValueType::fuzzyEquals(const QVector4D &vec, qreal epsilon) const
-{
-    qreal absEps = qAbs(epsilon);
-    if (qAbs(v.x() - vec.x()) > absEps)
-        return false;
-    if (qAbs(v.y() - vec.y()) > absEps)
-        return false;
-    if (qAbs(v.z() - vec.z()) > absEps)
-        return false;
-    if (qAbs(v.w() - vec.w()) > absEps)
-        return false;
-    return true;
-}
-
-bool QQuick3DVector4DValueType::fuzzyEquals(const QVector4D &vec) const
-{
-    return qFuzzyCompare(v, vec);
-}
-
-QVariant QQuick3DQuaternionValueType::create(const QJSValue &params)
-{
-    if (params.isString())
-        return createValueTypeFromNumberString<QQuaternion, 4>(params.toString());
-
-    if (params.isArray()) {
-        return QQuaternion(params.property(0).toNumber(), params.property(1).toNumber(),
-                           params.property(2).toNumber(), params.property(3).toNumber());
-    }
-
-    return QVariant();
-}
-
-QString QQuick3DQuaternionValueType::toString() const
-{
-    return QString(QLatin1String("QQuaternion(%1, %2, %3, %4)")).arg(v.scalar()).arg(v.x()).arg(v.y()).arg(v.z());
-}
-
-qreal QQuick3DQuaternionValueType::scalar() const
-{
-    return v.scalar();
-}
-
-qreal QQuick3DQuaternionValueType::x() const
-{
-    return v.x();
-}
-
-qreal QQuick3DQuaternionValueType::y() const
-{
-    return v.y();
-}
-
-qreal QQuick3DQuaternionValueType::z() const
-{
-    return v.z();
-}
-
-void QQuick3DQuaternionValueType::setScalar(qreal scalar)
-{
-    v.setScalar(scalar);
-}
-
-void QQuick3DQuaternionValueType::setX(qreal x)
-{
-    v.setX(x);
-}
-
-void QQuick3DQuaternionValueType::setY(qreal y)
-{
-    v.setY(y);
-}
-
-void QQuick3DQuaternionValueType::setZ(qreal z)
-{
-    v.setZ(z);
-}
-
 static QQmlPrivate::AutoParentResult qquick3ditem_autoParent(QObject *obj, QObject *parent)
 {
     // When setting a parent (especially during dynamic object creation) in QML,
diff --git a/src/quick3d/quick3d/qt3dquick_global_p.h b/src/quick3d/quick3d/qt3dquick_global_p.h
index 1931e5f4c..01f4657a7 100644
--- a/src/quick3d/quick3d/qt3dquick_global_p.h
+++ b/src/quick3d/quick3d/qt3dquick_global_p.h
@@ -77,288 +77,6 @@ template<class T, class E> void registerExtendedType(const char *className, cons
     Quick3D_registerType(className, quickName, major, minor);
 }
 
-class QQuick3DColorValueType
-{
-    QColor v;
-    Q_PROPERTY(qreal r READ r WRITE setR FINAL)
-    Q_PROPERTY(qreal g READ g WRITE setG FINAL)
-    Q_PROPERTY(qreal b READ b WRITE setB FINAL)
-    Q_PROPERTY(qreal a READ a WRITE setA FINAL)
-    Q_PROPERTY(qreal hsvHue READ hsvHue WRITE setHsvHue FINAL)
-    Q_PROPERTY(qreal hsvSaturation READ hsvSaturation WRITE setHsvSaturation FINAL)
-    Q_PROPERTY(qreal hsvValue READ hsvValue WRITE setHsvValue FINAL)
-    Q_PROPERTY(qreal hslHue READ hslHue WRITE setHslHue FINAL)
-    Q_PROPERTY(qreal hslSaturation READ hslSaturation WRITE setHslSaturation FINAL)
-    Q_PROPERTY(qreal hslLightness READ hslLightness WRITE setHslLightness FINAL)
-    Q_PROPERTY(bool valid READ isValid)
-    Q_GADGET
-    QML_ADDED_IN_VERSION(2, 0)
-    QML_FOREIGN(QColor)
-    QML_VALUE_TYPE(color)
-    QML_EXTENDED(QQuick3DColorValueType)
-
-public:
-    static QVariant create(const QJSValue &params);
-
-    Q_INVOKABLE QString toString() const;
-
-    Q_INVOKABLE QVariant alpha(qreal value) const;
-    Q_INVOKABLE QVariant lighter(qreal factor = 1.5) const;
-    Q_INVOKABLE QVariant darker(qreal factor = 2.0) const;
-    Q_INVOKABLE QVariant tint(QVariant factor) const;
-
-    qreal r() const;
-    qreal g() const;
-    qreal b() const;
-    qreal a() const;
-    qreal hsvHue() const;
-    qreal hsvSaturation() const;
-    qreal hsvValue() const;
-    qreal hslHue() const;
-    qreal hslSaturation() const;
-    qreal hslLightness() const;
-    bool isValid() const;
-    void setR(qreal);
-    void setG(qreal);
-    void setB(qreal);
-    void setA(qreal);
-    void setHsvHue(qreal);
-    void setHsvSaturation(qreal);
-    void setHsvValue(qreal);
-    void setHslHue(qreal);
-    void setHslSaturation(qreal);
-    void setHslLightness(qreal);
-};
-
-class QQuick3DMatrix4x4ValueType
-{
-    QMatrix4x4 v;
-    Q_PROPERTY(qreal m11 READ m11 WRITE setM11 FINAL)
-    Q_PROPERTY(qreal m12 READ m12 WRITE setM12 FINAL)
-    Q_PROPERTY(qreal m13 READ m13 WRITE setM13 FINAL)
-    Q_PROPERTY(qreal m14 READ m14 WRITE setM14 FINAL)
-    Q_PROPERTY(qreal m21 READ m21 WRITE setM21 FINAL)
-    Q_PROPERTY(qreal m22 READ m22 WRITE setM22 FINAL)
-    Q_PROPERTY(qreal m23 READ m23 WRITE setM23 FINAL)
-    Q_PROPERTY(qreal m24 READ m24 WRITE setM24 FINAL)
-    Q_PROPERTY(qreal m31 READ m31 WRITE setM31 FINAL)
-    Q_PROPERTY(qreal m32 READ m32 WRITE setM32 FINAL)
-    Q_PROPERTY(qreal m33 READ m33 WRITE setM33 FINAL)
-    Q_PROPERTY(qreal m34 READ m34 WRITE setM34 FINAL)
-    Q_PROPERTY(qreal m41 READ m41 WRITE setM41 FINAL)
-    Q_PROPERTY(qreal m42 READ m42 WRITE setM42 FINAL)
-    Q_PROPERTY(qreal m43 READ m43 WRITE setM43 FINAL)
-    Q_PROPERTY(qreal m44 READ m44 WRITE setM44 FINAL)
-    Q_GADGET
-    QML_ADDED_IN_VERSION(2, 0)
-    QML_FOREIGN(QMatrix4x4)
-    QML_VALUE_TYPE(matrix4x4)
-    QML_EXTENDED(QQuick3DMatrix4x4ValueType)
-
-public:
-    static QVariant create(const QJSValue &params);
-
-    qreal m11() const { return v(0, 0); }
-    qreal m12() const { return v(0, 1); }
-    qreal m13() const { return v(0, 2); }
-    qreal m14() const { return v(0, 3); }
-    qreal m21() const { return v(1, 0); }
-    qreal m22() const { return v(1, 1); }
-    qreal m23() const { return v(1, 2); }
-    qreal m24() const { return v(1, 3); }
-    qreal m31() const { return v(2, 0); }
-    qreal m32() const { return v(2, 1); }
-    qreal m33() const { return v(2, 2); }
-    qreal m34() const { return v(2, 3); }
-    qreal m41() const { return v(3, 0); }
-    qreal m42() const { return v(3, 1); }
-    qreal m43() const { return v(3, 2); }
-    qreal m44() const { return v(3, 3); }
-
-    void setM11(qreal value) { v(0, 0) = value; }
-    void setM12(qreal value) { v(0, 1) = value; }
-    void setM13(qreal value) { v(0, 2) = value; }
-    void setM14(qreal value) { v(0, 3) = value; }
-    void setM21(qreal value) { v(1, 0) = value; }
-    void setM22(qreal value) { v(1, 1) = value; }
-    void setM23(qreal value) { v(1, 2) = value; }
-    void setM24(qreal value) { v(1, 3) = value; }
-    void setM31(qreal value) { v(2, 0) = value; }
-    void setM32(qreal value) { v(2, 1) = value; }
-    void setM33(qreal value) { v(2, 2) = value; }
-    void setM34(qreal value) { v(2, 3) = value; }
-    void setM41(qreal value) { v(3, 0) = value; }
-    void setM42(qreal value) { v(3, 1) = value; }
-    void setM43(qreal value) { v(3, 2) = value; }
-    void setM44(qreal value) { v(3, 3) = value; }
-
-    Q_INVOKABLE void translate(const QVector3D &t) { v.translate(t); }
-    Q_INVOKABLE void rotate(float angle, const QVector3D &axis) { v.rotate(angle, axis); }
-    Q_INVOKABLE void scale(float s) { v.scale(s); }
-    Q_INVOKABLE void scale(float sx, float sy, float sz) { v.scale(sx, sy, sz); }
-    Q_INVOKABLE void scale(const QVector3D &s) { v.scale(s); }
-    Q_INVOKABLE void lookAt(const QVector3D &eye, const QVector3D &center, const QVector3D &up) { v.lookAt(eye, center, up); }
-
-    Q_INVOKABLE QMatrix4x4 times(const QMatrix4x4 &m) const;
-    Q_INVOKABLE QVector4D times(const QVector4D &vec) const;
-    Q_INVOKABLE QVector3D times(const QVector3D &vec) const;
-    Q_INVOKABLE QMatrix4x4 times(qreal factor) const;
-    Q_INVOKABLE QMatrix4x4 plus(const QMatrix4x4 &m) const;
-    Q_INVOKABLE QMatrix4x4 minus(const QMatrix4x4 &m) const;
-
-    Q_INVOKABLE QVector4D row(int n) const;
-    Q_INVOKABLE QVector4D column(int m) const;
-
-    Q_INVOKABLE qreal determinant() const;
-    Q_INVOKABLE QMatrix4x4 inverted() const;
-    Q_INVOKABLE QMatrix4x4 transposed() const;
-
-    Q_INVOKABLE bool fuzzyEquals(const QMatrix4x4 &m, qreal epsilon) const;
-    Q_INVOKABLE bool fuzzyEquals(const QMatrix4x4 &m) const;
-};
-
-class QQuick3DVector2DValueType
-{
-    QVector2D v;
-    Q_PROPERTY(qreal x READ x WRITE setX FINAL)
-    Q_PROPERTY(qreal y READ y WRITE setY FINAL)
-    Q_GADGET
-    QML_ADDED_IN_VERSION(2, 0)
-    QML_FOREIGN(QVector2D)
-    QML_VALUE_TYPE(vector2d)
-    QML_EXTENDED(QQuick3DVector2DValueType)
-
-public:
-    static QVariant create(const QJSValue &params);
-
-    Q_INVOKABLE QString toString() const;
-
-    qreal x() const;
-    qreal y() const;
-    void setX(qreal);
-    void setY(qreal);
-
-    Q_INVOKABLE qreal dotProduct(const QVector2D &vec) const;
-    Q_INVOKABLE QVector2D times(const QVector2D &vec) const;
-    Q_INVOKABLE QVector2D times(qreal scalar) const;
-    Q_INVOKABLE QVector2D plus(const QVector2D &vec) const;
-    Q_INVOKABLE QVector2D minus(const QVector2D &vec) const;
-    Q_INVOKABLE QVector2D normalized() const;
-    Q_INVOKABLE qreal length() const;
-    Q_INVOKABLE QVector3D toVector3d() const;
-    Q_INVOKABLE QVector4D toVector4d() const;
-    Q_INVOKABLE bool fuzzyEquals(const QVector2D &vec, qreal epsilon) const;
-    Q_INVOKABLE bool fuzzyEquals(const QVector2D &vec) const;
-};
-
-class QQuick3DVector3DValueType
-{
-    QVector3D v;
-    Q_PROPERTY(qreal x READ x WRITE setX FINAL)
-    Q_PROPERTY(qreal y READ y WRITE setY FINAL)
-    Q_PROPERTY(qreal z READ z WRITE setZ FINAL)
-    Q_GADGET
-    QML_ADDED_IN_VERSION(2, 0)
-    QML_FOREIGN(QVector3D)
-    QML_VALUE_TYPE(vector3d)
-    QML_EXTENDED(QQuick3DVector3DValueType)
-
-public:
-    static QVariant create(const QJSValue &params);
-
-    Q_INVOKABLE QString toString() const;
-
-    qreal x() const;
-    qreal y() const;
-    qreal z() const;
-    void setX(qreal);
-    void setY(qreal);
-    void setZ(qreal);
-
-    Q_INVOKABLE QVector3D crossProduct(const QVector3D &vec) const;
-    Q_INVOKABLE qreal dotProduct(const QVector3D &vec) const;
-    Q_INVOKABLE QVector3D times(const QMatrix4x4 &m) const;
-    Q_INVOKABLE QVector3D times(const QVector3D &vec) const;
-    Q_INVOKABLE QVector3D times(qreal scalar) const;
-    Q_INVOKABLE QVector3D plus(const QVector3D &vec) const;
-    Q_INVOKABLE QVector3D minus(const QVector3D &vec) const;
-    Q_INVOKABLE QVector3D normalized() const;
-    Q_INVOKABLE qreal length() const;
-    Q_INVOKABLE QVector2D toVector2d() const;
-    Q_INVOKABLE QVector4D toVector4d() const;
-    Q_INVOKABLE bool fuzzyEquals(const QVector3D &vec, qreal epsilon) const;
-    Q_INVOKABLE bool fuzzyEquals(const QVector3D &vec) const;
-};
-
-class QQuick3DVector4DValueType
-{
-    QVector4D v;
-    Q_PROPERTY(qreal x READ x WRITE setX FINAL)
-    Q_PROPERTY(qreal y READ y WRITE setY FINAL)
-    Q_PROPERTY(qreal z READ z WRITE setZ FINAL)
-    Q_PROPERTY(qreal w READ w WRITE setW FINAL)
-    Q_GADGET
-    QML_ADDED_IN_VERSION(2, 0)
-    QML_FOREIGN(QVector4D)
-    QML_VALUE_TYPE(vector4d)
-    QML_EXTENDED(QQuick3DVector4DValueType)
-
-public:
-    static QVariant create(const QJSValue &params);
-
-    Q_INVOKABLE QString toString() const;
-
-    qreal x() const;
-    qreal y() const;
-    qreal z() const;
-    qreal w() const;
-    void setX(qreal);
-    void setY(qreal);
-    void setZ(qreal);
-    void setW(qreal);
-
-    Q_INVOKABLE qreal dotProduct(const QVector4D &vec) const;
-    Q_INVOKABLE QVector4D times(const QVector4D &vec) const;
-    Q_INVOKABLE QVector4D times(const QMatrix4x4 &m) const;
-    Q_INVOKABLE QVector4D times(qreal scalar) const;
-    Q_INVOKABLE QVector4D plus(const QVector4D &vec) const;
-    Q_INVOKABLE QVector4D minus(const QVector4D &vec) const;
-    Q_INVOKABLE QVector4D normalized() const;
-    Q_INVOKABLE qreal length() const;
-    Q_INVOKABLE QVector2D toVector2d() const;
-    Q_INVOKABLE QVector3D toVector3d() const;
-    Q_INVOKABLE bool fuzzyEquals(const QVector4D &vec, qreal epsilon) const;
-    Q_INVOKABLE bool fuzzyEquals(const QVector4D &vec) const;
-};
-
-class QQuick3DQuaternionValueType
-{
-    QQuaternion v;
-    Q_PROPERTY(qreal scalar READ scalar WRITE setScalar)
-    Q_PROPERTY(qreal x READ x WRITE setX)
-    Q_PROPERTY(qreal y READ y WRITE setY)
-    Q_PROPERTY(qreal z READ z WRITE setZ)
-    Q_GADGET
-    QML_ADDED_IN_VERSION(2, 0)
-    QML_FOREIGN(QQuaternion)
-    QML_VALUE_TYPE(quaternion)
-    QML_EXTENDED(QQuick3DQuaternionValueType)
-
-public:
-    static QVariant create(const QJSValue &params);
-
-    Q_INVOKABLE QString toString() const;
-
-    qreal scalar() const;
-    qreal x() const;
-    qreal y() const;
-    qreal z() const;
-    void setScalar(qreal);
-    void setX(qreal);
-    void setY(qreal);
-    void setZ(qreal);
-};
-
 } // namespace Quick
 } // namespace Qt3DCore
 
diff --git a/src/quick3d/quick3d/qt3dquickvaluetypes.cpp b/src/quick3d/quick3d/qt3dquickvaluetypes.cpp
index 9326e8580..a4084fec3 100644
--- a/src/quick3d/quick3d/qt3dquickvaluetypes.cpp
+++ b/src/quick3d/quick3d/qt3dquickvaluetypes.cpp
@@ -42,303 +42,430 @@
 
 QT_BEGIN_NAMESPACE
 
+namespace {
+
+template<typename T, int NumParams>
+QVariant createValueTypeFromNumberString(const QString &s)
+{
+    Q_STATIC_ASSERT_X(NumParams == 2 || NumParams == 3 || NumParams == 4 || NumParams == 16,
+                      "Unsupported number of params; add an additional case below if necessary.");
+
+    if (s.count(u',') != NumParams - 1)
+        return QVariant();
+
+    QVarLengthArray<float, NumParams> parameters;
+    bool ok = true;
+    for (qsizetype prev = 0, next = s.indexOf(u','), length = s.length(); ok && prev < length;) {
+        parameters.append(s.mid(prev, next - prev).toFloat(&ok));
+        prev = next + 1;
+        next = (parameters.length() == NumParams - 1) ? length : s.indexOf(u',', prev);
+    }
+
+    if (!ok)
+        return QVariant();
+
+    if constexpr (NumParams == 2) {
+        return T(parameters[0], parameters[1]);
+    } else if constexpr (NumParams == 3) {
+        return T(parameters[0], parameters[1], parameters[2]);
+    } else if constexpr (NumParams == 4) {
+        return T(parameters[0], parameters[1], parameters[2], parameters[3]);
+    } else if constexpr (NumParams == 16) {
+        return T(parameters[0], parameters[1], parameters[2], parameters[3],
+                 parameters[4], parameters[5], parameters[6], parameters[7],
+                 parameters[8], parameters[9], parameters[10], parameters[11],
+                 parameters[12], parameters[13], parameters[14], parameters[15]);
+    } else {
+        Q_UNREACHABLE();
+    }
+
+    return QVariant();
+}
+
+}
+
 namespace Qt3DCore {
 namespace Quick {
 
-QString Quick3DColorValueType::toString() const
+QVariant QQuick3DColorValueType::create(const QJSValue &params)
+{
+    return params.isString() ? QColor(params.toString()) : QVariant();
+}
+
+QString QQuick3DColorValueType::toString() const
 {
     return v.name(v.alpha() != 255 ? QColor::HexArgb : QColor::HexRgb);
 }
 
-qreal Quick3DColorValueType::r() const
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+QVariant QQuick3DColorValueType::lighter(qreal factor) const
+{
+    return QQml_colorProvider()->lighter(this->v, factor);
+}
+
+QVariant QQuick3DColorValueType::darker(qreal factor) const
+{
+    return QQml_colorProvider()->darker(this->v, factor);
+}
+
+QVariant QQuick3DColorValueType::alpha(qreal value) const
+{
+    return QQml_colorProvider()->alpha(this->v, value);
+}
+
+QVariant QQuick3DColorValueType::tint(QVariant tintColor) const
+{
+    return QQml_colorProvider()->tint(this->v, tintColor);
+}
+#endif
+
+qreal QQuick3DColorValueType::r() const
 {
     return v.redF();
 }
 
-qreal Quick3DColorValueType::g() const
+qreal QQuick3DColorValueType::g() const
 {
     return v.greenF();
 }
 
-qreal Quick3DColorValueType::b() const
+qreal QQuick3DColorValueType::b() const
 {
     return v.blueF();
 }
 
-qreal Quick3DColorValueType::a() const
+qreal QQuick3DColorValueType::a() const
 {
     return v.alphaF();
 }
 
-qreal Quick3DColorValueType::hsvHue() const
+qreal QQuick3DColorValueType::hsvHue() const
 {
     return v.hsvHueF();
 }
 
-qreal Quick3DColorValueType::hsvSaturation() const
+qreal QQuick3DColorValueType::hsvSaturation() const
 {
     return v.hsvSaturationF();
 }
 
-qreal Quick3DColorValueType::hsvValue() const
+qreal QQuick3DColorValueType::hsvValue() const
 {
     return v.valueF();
 }
 
-qreal Quick3DColorValueType::hslHue() const
+qreal QQuick3DColorValueType::hslHue() const
 {
     return v.hslHueF();
 }
 
-qreal Quick3DColorValueType::hslSaturation() const
+qreal QQuick3DColorValueType::hslSaturation() const
 {
     return v.hslSaturationF();
 }
 
-qreal Quick3DColorValueType::hslLightness() const
+qreal QQuick3DColorValueType::hslLightness() const
 {
     return v.lightnessF();
 }
 
-void Quick3DColorValueType::setR(qreal r)
+bool QQuick3DColorValueType::isValid() const
+{
+    return v.isValid();
+}
+
+void QQuick3DColorValueType::setR(qreal r)
 {
     v.setRedF(r);
 }
 
-void Quick3DColorValueType::setG(qreal g)
+void QQuick3DColorValueType::setG(qreal g)
 {
     v.setGreenF(g);
 }
 
-void Quick3DColorValueType::setB(qreal b)
+void QQuick3DColorValueType::setB(qreal b)
 {
     v.setBlueF(b);
 }
 
-void Quick3DColorValueType::setA(qreal a)
+void QQuick3DColorValueType::setA(qreal a)
 {
     v.setAlphaF(a);
 }
 
-void Quick3DColorValueType::setHsvHue(qreal hsvHue)
+void QQuick3DColorValueType::setHsvHue(qreal hsvHue)
 {
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
     float hue, saturation, value, alpha;
+#else
+    qreal hue, saturation, value, alpha;
+#endif
     v.getHsvF(&hue, &saturation, &value, &alpha);
     v.setHsvF(hsvHue, saturation, value, alpha);
 }
 
-void Quick3DColorValueType::setHsvSaturation(qreal hsvSaturation)
+void QQuick3DColorValueType::setHsvSaturation(qreal hsvSaturation)
 {
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
     float hue, saturation, value, alpha;
+#else
+    qreal hue, saturation, value, alpha;
+#endif
     v.getHsvF(&hue, &saturation, &value, &alpha);
     v.setHsvF(hue, hsvSaturation, value, alpha);
 }
 
-void Quick3DColorValueType::setHsvValue(qreal hsvValue)
+void QQuick3DColorValueType::setHsvValue(qreal hsvValue)
 {
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
     float hue, saturation, value, alpha;
+#else
+    qreal hue, saturation, value, alpha;
+#endif
     v.getHsvF(&hue, &saturation, &value, &alpha);
     v.setHsvF(hue, saturation, hsvValue, alpha);
 }
 
-void Quick3DColorValueType::setHslHue(qreal hslHue)
+void QQuick3DColorValueType::setHslHue(qreal hslHue)
 {
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
     float hue, saturation, lightness, alpha;
+#else
+    qreal hue, saturation, lightness, alpha;
+#endif
     v.getHslF(&hue, &saturation, &lightness, &alpha);
     v.setHslF(hslHue, saturation, lightness, alpha);
 }
 
-void Quick3DColorValueType::setHslSaturation(qreal hslSaturation)
+void QQuick3DColorValueType::setHslSaturation(qreal hslSaturation)
 {
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
     float hue, saturation, lightness, alpha;
+#else
+    qreal hue, saturation, lightness, alpha;
+#endif
     v.getHslF(&hue, &saturation, &lightness, &alpha);
     v.setHslF(hue, hslSaturation, lightness, alpha);
 }
 
-void Quick3DColorValueType::setHslLightness(qreal hslLightness)
+void QQuick3DColorValueType::setHslLightness(qreal hslLightness)
 {
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
     float hue, saturation, lightness, alpha;
+#else
+    qreal hue, saturation, lightness, alpha;
+#endif
     v.getHslF(&hue, &saturation, &lightness, &alpha);
     v.setHslF(hue, saturation, hslLightness, alpha);
 }
 
-QString Quick3DVector2DValueType::toString() const
-{
-    return QString(QLatin1String("QVector2D(%1, %2)")).arg(v.x()).arg(v.y());
-}
-
-qreal Quick3DVector2DValueType::x() const
-{
-    return v.x();
-}
+QVariant QQuick3DMatrix4x4ValueType::create(const QJSValue &params)
+{
+    if (params.isNull() || params.isUndefined())
+        return QMatrix4x4();
+
+    if (params.isString())
+        return createValueTypeFromNumberString<QMatrix4x4, 16>(params.toString());
+
+    if (params.isArray() && params.property(QStringLiteral("length")).toInt() == 16) {
+        return QMatrix4x4(params.property(0).toNumber(),
+                          params.property(1).toNumber(),
+                          params.property(2).toNumber(),
+                          params.property(3).toNumber(),
+                          params.property(4).toNumber(),
+                          params.property(5).toNumber(),
+                          params.property(6).toNumber(),
+                          params.property(7).toNumber(),
+                          params.property(8).toNumber(),
+                          params.property(9).toNumber(),
+                          params.property(10).toNumber(),
+                          params.property(11).toNumber(),
+                          params.property(12).toNumber(),
+                          params.property(13).toNumber(),
+                          params.property(14).toNumber(),
+                          params.property(15).toNumber());
+    }
 
-qreal Quick3DVector2DValueType::y() const
-{
-    return v.y();
+    return {};
 }
 
-void Quick3DVector2DValueType::setX(qreal x)
+QMatrix4x4 QQuick3DMatrix4x4ValueType::times(const QMatrix4x4 &m) const
 {
-    v.setX(x);
+    return v * m;
 }
 
-void Quick3DVector2DValueType::setY(qreal y)
+QVector4D QQuick3DMatrix4x4ValueType::times(const QVector4D &vec) const
 {
-    v.setY(y);
+    return v * vec;
 }
 
-qreal Quick3DVector2DValueType::dotProduct(const QVector2D &vec) const
+QVector3D QQuick3DMatrix4x4ValueType::times(const QVector3D &vec) const
 {
-    return QVector2D::dotProduct(v, vec);
+    return v * vec;
 }
 
-QVector2D Quick3DVector2DValueType::times(const QVector2D &vec) const
+QMatrix4x4 QQuick3DMatrix4x4ValueType::times(qreal factor) const
 {
-    return v * vec;
+    return v * float(factor);
 }
 
-QVector2D Quick3DVector2DValueType::times(qreal scalar) const
+QMatrix4x4 QQuick3DMatrix4x4ValueType::plus(const QMatrix4x4 &m) const
 {
-    return v * scalar;
+    return v + m;
 }
 
-QVector2D Quick3DVector2DValueType::plus(const QVector2D &vec) const
+QMatrix4x4 QQuick3DMatrix4x4ValueType::minus(const QMatrix4x4 &m) const
 {
-    return v + vec;
+    return v - m;
 }
 
-QVector2D Quick3DVector2DValueType::minus(const QVector2D &vec) const
+QVector4D QQuick3DMatrix4x4ValueType::row(int n) const
 {
-    return v - vec;
+    return v.row(n);
 }
 
-QVector2D Quick3DVector2DValueType::normalized() const
+QVector4D QQuick3DMatrix4x4ValueType::column(int m) const
 {
-    return v.normalized();
+    return v.column(m);
 }
 
-qreal Quick3DVector2DValueType::length() const
+qreal QQuick3DMatrix4x4ValueType::determinant() const
 {
-    return v.length();
+    return v.determinant();
 }
 
-QVector3D Quick3DVector2DValueType::toVector3d() const
+QMatrix4x4 QQuick3DMatrix4x4ValueType::inverted() const
 {
-    return v.toVector3D();
+    return v.inverted();
 }
 
-QVector4D Quick3DVector2DValueType::toVector4d() const
+QMatrix4x4 QQuick3DMatrix4x4ValueType::transposed() const
 {
-    return v.toVector4D();
+    return v.transposed();
 }
 
-bool Quick3DVector2DValueType::fuzzyEquals(const QVector2D &vec, qreal epsilon) const
+bool QQuick3DMatrix4x4ValueType::fuzzyEquals(const QMatrix4x4 &m, qreal epsilon) const
 {
     qreal absEps = qAbs(epsilon);
-    if (qAbs(v.x() - vec.x()) > absEps)
-        return false;
-    if (qAbs(v.y() - vec.y()) > absEps)
-        return false;
+    for (int i = 0; i < 4; ++i) {
+        for (int j = 0; j < 4; ++j) {
+            if (qAbs(v(i,j) - m(i,j)) > absEps) {
+                return false;
+            }
+        }
+    }
     return true;
 }
 
-bool Quick3DVector2DValueType::fuzzyEquals(const QVector2D &vec) const
+bool QQuick3DMatrix4x4ValueType::fuzzyEquals(const QMatrix4x4 &m) const
 {
-    return qFuzzyCompare(v, vec);
+    return qFuzzyCompare(v, m);
 }
 
+QVariant QQuick3DVector3DValueType::create(const QJSValue &params)
+{
+    if (params.isString())
+        return createValueTypeFromNumberString<QVector3D, 3>(params.toString());
+
+    if (params.isArray()) {
+        return QVector3D(params.property(0).toNumber(), params.property(1).toNumber(),
+                         params.property(2).toNumber());
+    }
+    return QVariant();
+}
 
-QString Quick3DVector3DValueType::toString() const
+QString QQuick3DVector3DValueType::toString() const
 {
     return QString(QLatin1String("QVector3D(%1, %2, %3)")).arg(v.x()).arg(v.y()).arg(v.z());
 }
 
-qreal Quick3DVector3DValueType::x() const
+qreal QQuick3DVector3DValueType::x() const
 {
-    return v.x();
+    return qreal(v.x());
 }
 
-qreal Quick3DVector3DValueType::y() const
+qreal QQuick3DVector3DValueType::y() const
 {
-    return v.y();
+    return qreal(v.y());
 }
 
-qreal Quick3DVector3DValueType::z() const
+qreal QQuick3DVector3DValueType::z() const
 {
-    return v.z();
+    return qreal(v.z());
 }
 
-void Quick3DVector3DValueType::setX(qreal x)
+void QQuick3DVector3DValueType::setX(qreal x)
 {
-    v.setX(x);
+    v.setX(float(x));
 }
 
-void Quick3DVector3DValueType::setY(qreal y)
+void QQuick3DVector3DValueType::setY(qreal y)
 {
-    v.setY(y);
+    v.setY(float(y));
 }
 
-void Quick3DVector3DValueType::setZ(qreal z)
+void QQuick3DVector3DValueType::setZ(qreal z)
 {
-    v.setZ(z);
+    v.setZ(float(z));
 }
 
-QVector3D Quick3DVector3DValueType::crossProduct(const QVector3D &vec) const
+QVector3D QQuick3DVector3DValueType::crossProduct(const QVector3D &vec) const
 {
     return QVector3D::crossProduct(v, vec);
 }
 
-qreal Quick3DVector3DValueType::dotProduct(const QVector3D &vec) const
+qreal QQuick3DVector3DValueType::dotProduct(const QVector3D &vec) const
 {
-    return QVector3D::dotProduct(v, vec);
+    return qreal(QVector3D::dotProduct(v, vec));
 }
 
-QVector3D Quick3DVector3DValueType::times(const QMatrix4x4 &m) const
+QVector3D QQuick3DVector3DValueType::times(const QMatrix4x4 &m) const
 {
     return v * m;
 }
 
-QVector3D Quick3DVector3DValueType::times(const QVector3D &vec) const
+QVector3D QQuick3DVector3DValueType::times(const QVector3D &vec) const
 {
     return v * vec;
 }
 
-QVector3D Quick3DVector3DValueType::times(qreal scalar) const
+QVector3D QQuick3DVector3DValueType::times(qreal scalar) const
 {
-    return v * scalar;
+    return v * float(scalar);
 }
 
-QVector3D Quick3DVector3DValueType::plus(const QVector3D &vec) const
+QVector3D QQuick3DVector3DValueType::plus(const QVector3D &vec) const
 {
     return v + vec;
 }
 
-QVector3D Quick3DVector3DValueType::minus(const QVector3D &vec) const
+QVector3D QQuick3DVector3DValueType::minus(const QVector3D &vec) const
 {
     return v - vec;
 }
 
-QVector3D Quick3DVector3DValueType::normalized() const
+QVector3D QQuick3DVector3DValueType::normalized() const
 {
     return v.normalized();
 }
 
-qreal Quick3DVector3DValueType::length() const
+qreal QQuick3DVector3DValueType::length() const
 {
-    return v.length();
+    return qreal(v.length());
 }
 
-QVector2D Quick3DVector3DValueType::toVector2d() const
+QVector2D QQuick3DVector3DValueType::toVector2d() const
 {
     return v.toVector2D();
 }
 
-QVector4D Quick3DVector3DValueType::toVector4d() const
+QVector4D QQuick3DVector3DValueType::toVector4d() const
 {
     return v.toVector4D();
 }
 
-bool Quick3DVector3DValueType::fuzzyEquals(const QVector3D &vec, qreal epsilon) const
+bool QQuick3DVector3DValueType::fuzzyEquals(const QVector3D &vec, qreal epsilon) const
 {
     qreal absEps = qAbs(epsilon);
     if (qAbs(v.x() - vec.x()) > absEps)
@@ -350,253 +477,288 @@ bool Quick3DVector3DValueType::fuzzyEquals(const QVector3D &vec, qreal epsilon)
     return true;
 }
 
-bool Quick3DVector3DValueType::fuzzyEquals(const QVector3D &vec) const
+bool QQuick3DVector3DValueType::fuzzyEquals(const QVector3D &vec) const
 {
     return qFuzzyCompare(v, vec);
 }
 
-
-QString Quick3DVector4DValueType::toString() const
+QVariant QQuick3DVector2DValueType::create(const QJSValue &params)
 {
-    return QString(QLatin1String("QVector4D(%1, %2, %3, %4)")).arg(v.x()).arg(v.y()).arg(v.z()).arg(v.w());
+    if (params.isString())
+        return createValueTypeFromNumberString<QVector2D, 2>(params.toString());
+    if (params.isArray())
+        return QVector2D(params.property(0).toNumber(), params.property(1).toNumber());
+    return QVariant();
 }
 
-qreal Quick3DVector4DValueType::x() const
+QString QQuick3DVector2DValueType::toString() const
 {
-    return v.x();
-}
-
-qreal Quick3DVector4DValueType::y() const
-{
-    return v.y();
+    return QString(QLatin1String("QVector2D(%1, %2)")).arg(v.x()).arg(v.y());
 }
 
-qreal Quick3DVector4DValueType::z() const
+qreal QQuick3DVector2DValueType::x() const
 {
-    return v.z();
+    return v.x();
 }
 
-qreal Quick3DVector4DValueType::w() const
+qreal QQuick3DVector2DValueType::y() const
 {
-    return v.w();
+    return v.y();
 }
 
-void Quick3DVector4DValueType::setX(qreal x)
+void QQuick3DVector2DValueType::setX(qreal x)
 {
     v.setX(x);
 }
 
-void Quick3DVector4DValueType::setY(qreal y)
+void QQuick3DVector2DValueType::setY(qreal y)
 {
     v.setY(y);
 }
 
-void Quick3DVector4DValueType::setZ(qreal z)
-{
-    v.setZ(z);
-}
-
-void Quick3DVector4DValueType::setW(qreal w)
+qreal QQuick3DVector2DValueType::dotProduct(const QVector2D &vec) const
 {
-    v.setW(w);
-}
-
-qreal Quick3DVector4DValueType::dotProduct(const QVector4D &vec) const
-{
-    return QVector4D::dotProduct(v, vec);
+    return QVector2D::dotProduct(v, vec);
 }
 
-QVector4D Quick3DVector4DValueType::times(const QVector4D &vec) const
+QVector2D QQuick3DVector2DValueType::times(const QVector2D &vec) const
 {
     return v * vec;
 }
 
-QVector4D Quick3DVector4DValueType::times(const QMatrix4x4 &m) const
-{
-    return v * m;
-}
-
-QVector4D Quick3DVector4DValueType::times(qreal scalar) const
+QVector2D QQuick3DVector2DValueType::times(qreal scalar) const
 {
     return v * scalar;
 }
 
-QVector4D Quick3DVector4DValueType::plus(const QVector4D &vec) const
+QVector2D QQuick3DVector2DValueType::plus(const QVector2D &vec) const
 {
     return v + vec;
 }
 
-QVector4D Quick3DVector4DValueType::minus(const QVector4D &vec) const
+QVector2D QQuick3DVector2DValueType::minus(const QVector2D &vec) const
 {
     return v - vec;
 }
 
-QVector4D Quick3DVector4DValueType::normalized() const
+QVector2D QQuick3DVector2DValueType::normalized() const
 {
     return v.normalized();
 }
 
-qreal Quick3DVector4DValueType::length() const
+qreal QQuick3DVector2DValueType::length() const
 {
     return v.length();
 }
 
-QVector2D Quick3DVector4DValueType::toVector2d() const
+QVector3D QQuick3DVector2DValueType::toVector3d() const
 {
-    return v.toVector2D();
+    return v.toVector3D();
 }
 
-QVector3D Quick3DVector4DValueType::toVector3d() const
+QVector4D QQuick3DVector2DValueType::toVector4d() const
 {
-    return v.toVector3D();
+    return v.toVector4D();
 }
 
-bool Quick3DVector4DValueType::fuzzyEquals(const QVector4D &vec, qreal epsilon) const
+bool QQuick3DVector2DValueType::fuzzyEquals(const QVector2D &vec, qreal epsilon) const
 {
     qreal absEps = qAbs(epsilon);
     if (qAbs(v.x() - vec.x()) > absEps)
         return false;
     if (qAbs(v.y() - vec.y()) > absEps)
         return false;
-    if (qAbs(v.z() - vec.z()) > absEps)
-        return false;
-    if (qAbs(v.w() - vec.w()) > absEps)
-        return false;
     return true;
 }
 
-bool Quick3DVector4DValueType::fuzzyEquals(const QVector4D &vec) const
+bool QQuick3DVector2DValueType::fuzzyEquals(const QVector2D &vec) const
 {
     return qFuzzyCompare(v, vec);
 }
 
-
-QString Quick3DQuaternionValueType::toString() const
+QVariant QQuick3DVector4DValueType::create(const QJSValue &params)
 {
-    return QString(QLatin1String("QQuaternion(%1, %2, %3, %4)")).arg(v.scalar()).arg(v.x()).arg(v.y()).arg(v.z());
+    if (params.isString())
+        return createValueTypeFromNumberString<QVector4D, 4>(params.toString());
+
+    if (params.isArray()) {
+        return QVector4D(params.property(0).toNumber(), params.property(1).toNumber(),
+                         params.property(2).toNumber(), params.property(3).toNumber());
+    }
+
+    return QVariant();
 }
 
-qreal Quick3DQuaternionValueType::scalar() const
+QString QQuick3DVector4DValueType::toString() const
 {
-    return v.scalar();
+    return QString(QLatin1String("QVector4D(%1, %2, %3, %4)")).arg(v.x()).arg(v.y()).arg(v.z()).arg(v.w());
 }
 
-qreal Quick3DQuaternionValueType::x() const
+qreal QQuick3DVector4DValueType::x() const
 {
     return v.x();
 }
 
-qreal Quick3DQuaternionValueType::y() const
+qreal QQuick3DVector4DValueType::y() const
 {
     return v.y();
 }
 
-qreal Quick3DQuaternionValueType::z() const
+qreal QQuick3DVector4DValueType::z() const
 {
     return v.z();
 }
 
-void Quick3DQuaternionValueType::setScalar(qreal scalar)
+qreal QQuick3DVector4DValueType::w() const
 {
-    v.setScalar(scalar);
+    return v.w();
 }
 
-void Quick3DQuaternionValueType::setX(qreal x)
+void QQuick3DVector4DValueType::setX(qreal x)
 {
     v.setX(x);
 }
 
-void Quick3DQuaternionValueType::setY(qreal y)
+void QQuick3DVector4DValueType::setY(qreal y)
 {
     v.setY(y);
 }
 
-void Quick3DQuaternionValueType::setZ(qreal z)
+void QQuick3DVector4DValueType::setZ(qreal z)
 {
     v.setZ(z);
 }
 
-
-QMatrix4x4 Quick3DMatrix4x4ValueType::times(const QMatrix4x4 &m) const
+void QQuick3DVector4DValueType::setW(qreal w)
 {
-    return v * m;
+    v.setW(w);
 }
 
-QVector4D Quick3DMatrix4x4ValueType::times(const QVector4D &vec) const
+qreal QQuick3DVector4DValueType::dotProduct(const QVector4D &vec) const
 {
-    return v * vec;
+    return QVector4D::dotProduct(v, vec);
 }
 
-QVector3D Quick3DMatrix4x4ValueType::times(const QVector3D &vec) const
+QVector4D QQuick3DVector4DValueType::times(const QVector4D &vec) const
 {
     return v * vec;
 }
 
-QMatrix4x4 Quick3DMatrix4x4ValueType::times(qreal factor) const
+QVector4D QQuick3DVector4DValueType::times(const QMatrix4x4 &m) const
 {
-    return v * factor;
+    return v * m;
 }
 
-QMatrix4x4 Quick3DMatrix4x4ValueType::plus(const QMatrix4x4 &m) const
+QVector4D QQuick3DVector4DValueType::times(qreal scalar) const
 {
-    return v + m;
+    return v * scalar;
 }
 
-QMatrix4x4 Quick3DMatrix4x4ValueType::minus(const QMatrix4x4 &m) const
+QVector4D QQuick3DVector4DValueType::plus(const QVector4D &vec) const
 {
-    return v - m;
+    return v + vec;
 }
 
-QVector4D Quick3DMatrix4x4ValueType::row(int n) const
+QVector4D QQuick3DVector4DValueType::minus(const QVector4D &vec) const
 {
-    return v.row(n);
+    return v - vec;
 }
 
-QVector4D Quick3DMatrix4x4ValueType::column(int m) const
+QVector4D QQuick3DVector4DValueType::normalized() const
 {
-    return v.column(m);
+    return v.normalized();
 }
 
-qreal Quick3DMatrix4x4ValueType::determinant() const
+qreal QQuick3DVector4DValueType::length() const
 {
-    return v.determinant();
+    return v.length();
 }
 
-QMatrix4x4 Quick3DMatrix4x4ValueType::inverted() const
+QVector2D QQuick3DVector4DValueType::toVector2d() const
 {
-    return v.inverted();
+    return v.toVector2D();
 }
 
-QMatrix4x4 Quick3DMatrix4x4ValueType::transposed() const
+QVector3D QQuick3DVector4DValueType::toVector3d() const
 {
-    return v.transposed();
+    return v.toVector3D();
 }
 
-bool Quick3DMatrix4x4ValueType::fuzzyEquals(const QMatrix4x4 &m, qreal epsilon) const
+bool QQuick3DVector4DValueType::fuzzyEquals(const QVector4D &vec, qreal epsilon) const
 {
     qreal absEps = qAbs(epsilon);
-    for (int i = 0; i < 4; ++i) {
-        for (int j = 0; j < 4; ++j) {
-            if (qAbs(v(i,j) - m(i,j)) > absEps) {
-                return false;
-            }
-        }
-    }
+    if (qAbs(v.x() - vec.x()) > absEps)
+        return false;
+    if (qAbs(v.y() - vec.y()) > absEps)
+        return false;
+    if (qAbs(v.z() - vec.z()) > absEps)
+        return false;
+    if (qAbs(v.w() - vec.w()) > absEps)
+        return false;
     return true;
 }
 
-bool Quick3DMatrix4x4ValueType::fuzzyEquals(const QMatrix4x4 &m) const
+bool QQuick3DVector4DValueType::fuzzyEquals(const QVector4D &vec) const
 {
-    return qFuzzyCompare(v, m);
+    return qFuzzyCompare(v, vec);
+}
+
+QVariant QQuick3DQuaternionValueType::create(const QJSValue &params)
+{
+    if (params.isString())
+        return createValueTypeFromNumberString<QQuaternion, 4>(params.toString());
+
+    if (params.isArray()) {
+        return QQuaternion(params.property(0).toNumber(), params.property(1).toNumber(),
+                           params.property(2).toNumber(), params.property(3).toNumber());
+    }
+
+    return QVariant();
+}
+
+QString QQuick3DQuaternionValueType::toString() const
+{
+    return QString(QLatin1String("QQuaternion(%1, %2, %3, %4)")).arg(v.scalar()).arg(v.x()).arg(v.y()).arg(v.z());
+}
+
+qreal QQuick3DQuaternionValueType::scalar() const
+{
+    return v.scalar();
 }
 
-QString Quick3DMatrix4x4ValueType::toString() const
+qreal QQuick3DQuaternionValueType::x() const
 {
-    return QString(QLatin1String("QMatrix4x4(%1, %2, %3, %4, %5, %6, %7, %8, %9, %10, %11, %12, %13, %14, %15, %16)"))
-            .arg(v(0, 0)).arg(v(0, 1)).arg(v(0, 2)).arg(v(0, 3))
-            .arg(v(1, 0)).arg(v(1, 1)).arg(v(1, 2)).arg(v(1, 3))
-            .arg(v(2, 0)).arg(v(2, 1)).arg(v(2, 2)).arg(v(2, 3))
-            .arg(v(3, 0)).arg(v(3, 1)).arg(v(3, 2)).arg(v(3, 3));
+    return v.x();
+}
+
+qreal QQuick3DQuaternionValueType::y() const
+{
+    return v.y();
+}
+
+qreal QQuick3DQuaternionValueType::z() const
+{
+    return v.z();
+}
+
+void QQuick3DQuaternionValueType::setScalar(qreal scalar)
+{
+    v.setScalar(scalar);
+}
+
+void QQuick3DQuaternionValueType::setX(qreal x)
+{
+    v.setX(x);
+}
+
+void QQuick3DQuaternionValueType::setY(qreal y)
+{
+    v.setY(y);
+}
+
+void QQuick3DQuaternionValueType::setZ(qreal z)
+{
+    v.setZ(z);
 }
 
 } // namespace Quick
diff --git a/src/quick3d/quick3d/qt3dquickvaluetypes_p.h b/src/quick3d/quick3d/qt3dquickvaluetypes_p.h
index 4b6f08393..6c9e7ac97 100644
--- a/src/quick3d/quick3d/qt3dquickvaluetypes_p.h
+++ b/src/quick3d/quick3d/qt3dquickvaluetypes_p.h
@@ -67,7 +67,12 @@ QT_BEGIN_NAMESPACE
 namespace Qt3DCore {
 namespace Quick {
 
-class Q_3DQUICKSHARED_PRIVATE_EXPORT Quick3DColorValueType
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
+#define QML_ADDED_IN_VERSION(major, minor) QML_ADDED_IN_MINOR_VERSION(minor)
+#define QML_VALUE_TYPE(v)
+#endif
+
+class Q_3DQUICKSHARED_PRIVATE_EXPORT QQuick3DColorValueType
 {
     QColor v;
     Q_PROPERTY(qreal r READ r WRITE setR FINAL)
@@ -80,10 +85,25 @@ class Q_3DQUICKSHARED_PRIVATE_EXPORT Quick3DColorValueType
     Q_PROPERTY(qreal hslHue READ hslHue WRITE setHslHue FINAL)
     Q_PROPERTY(qreal hslSaturation READ hslSaturation WRITE setHslSaturation FINAL)
     Q_PROPERTY(qreal hslLightness READ hslLightness WRITE setHslLightness FINAL)
+    Q_PROPERTY(bool valid READ isValid)
     Q_GADGET
+    QML_ADDED_IN_VERSION(2, 0)
+    QML_FOREIGN(QColor)
+    QML_VALUE_TYPE(color)
+    QML_EXTENDED(QQuick3DColorValueType)
+
 public:
+    static QVariant create(const QJSValue &params);
+
     Q_INVOKABLE QString toString() const;
 
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    Q_INVOKABLE QVariant alpha(qreal value) const;
+    Q_INVOKABLE QVariant lighter(qreal factor = 1.5) const;
+    Q_INVOKABLE QVariant darker(qreal factor = 2.0) const;
+    Q_INVOKABLE QVariant tint(QVariant factor) const;
+#endif
+
     qreal r() const;
     qreal g() const;
     qreal b() const;
@@ -94,6 +114,7 @@ public:
     qreal hslHue() const;
     qreal hslSaturation() const;
     qreal hslLightness() const;
+    bool isValid() const;
     void setR(qreal);
     void setG(qreal);
     void setB(qreal);
@@ -106,13 +127,107 @@ public:
     void setHslLightness(qreal);
 };
 
-class Q_3DQUICKSHARED_PRIVATE_EXPORT Quick3DVector2DValueType
+class Q_3DQUICKSHARED_PRIVATE_EXPORT QQuick3DMatrix4x4ValueType
+{
+    QMatrix4x4 v;
+    Q_PROPERTY(qreal m11 READ m11 WRITE setM11 FINAL)
+    Q_PROPERTY(qreal m12 READ m12 WRITE setM12 FINAL)
+    Q_PROPERTY(qreal m13 READ m13 WRITE setM13 FINAL)
+    Q_PROPERTY(qreal m14 READ m14 WRITE setM14 FINAL)
+    Q_PROPERTY(qreal m21 READ m21 WRITE setM21 FINAL)
+    Q_PROPERTY(qreal m22 READ m22 WRITE setM22 FINAL)
+    Q_PROPERTY(qreal m23 READ m23 WRITE setM23 FINAL)
+    Q_PROPERTY(qreal m24 READ m24 WRITE setM24 FINAL)
+    Q_PROPERTY(qreal m31 READ m31 WRITE setM31 FINAL)
+    Q_PROPERTY(qreal m32 READ m32 WRITE setM32 FINAL)
+    Q_PROPERTY(qreal m33 READ m33 WRITE setM33 FINAL)
+    Q_PROPERTY(qreal m34 READ m34 WRITE setM34 FINAL)
+    Q_PROPERTY(qreal m41 READ m41 WRITE setM41 FINAL)
+    Q_PROPERTY(qreal m42 READ m42 WRITE setM42 FINAL)
+    Q_PROPERTY(qreal m43 READ m43 WRITE setM43 FINAL)
+    Q_PROPERTY(qreal m44 READ m44 WRITE setM44 FINAL)
+    Q_GADGET
+    QML_ADDED_IN_VERSION(2, 0)
+    QML_FOREIGN(QMatrix4x4)
+    QML_VALUE_TYPE(matrix4x4)
+    QML_EXTENDED(QQuick3DMatrix4x4ValueType)
+
+public:
+    static QVariant create(const QJSValue &params);
+
+    qreal m11() const { return v(0, 0); }
+    qreal m12() const { return v(0, 1); }
+    qreal m13() const { return v(0, 2); }
+    qreal m14() const { return v(0, 3); }
+    qreal m21() const { return v(1, 0); }
+    qreal m22() const { return v(1, 1); }
+    qreal m23() const { return v(1, 2); }
+    qreal m24() const { return v(1, 3); }
+    qreal m31() const { return v(2, 0); }
+    qreal m32() const { return v(2, 1); }
+    qreal m33() const { return v(2, 2); }
+    qreal m34() const { return v(2, 3); }
+    qreal m41() const { return v(3, 0); }
+    qreal m42() const { return v(3, 1); }
+    qreal m43() const { return v(3, 2); }
+    qreal m44() const { return v(3, 3); }
+
+    void setM11(qreal value) { v(0, 0) = value; }
+    void setM12(qreal value) { v(0, 1) = value; }
+    void setM13(qreal value) { v(0, 2) = value; }
+    void setM14(qreal value) { v(0, 3) = value; }
+    void setM21(qreal value) { v(1, 0) = value; }
+    void setM22(qreal value) { v(1, 1) = value; }
+    void setM23(qreal value) { v(1, 2) = value; }
+    void setM24(qreal value) { v(1, 3) = value; }
+    void setM31(qreal value) { v(2, 0) = value; }
+    void setM32(qreal value) { v(2, 1) = value; }
+    void setM33(qreal value) { v(2, 2) = value; }
+    void setM34(qreal value) { v(2, 3) = value; }
+    void setM41(qreal value) { v(3, 0) = value; }
+    void setM42(qreal value) { v(3, 1) = value; }
+    void setM43(qreal value) { v(3, 2) = value; }
+    void setM44(qreal value) { v(3, 3) = value; }
+
+    Q_INVOKABLE void translate(const QVector3D &t) { v.translate(t); }
+    Q_INVOKABLE void rotate(float angle, const QVector3D &axis) { v.rotate(angle, axis); }
+    Q_INVOKABLE void scale(float s) { v.scale(s); }
+    Q_INVOKABLE void scale(float sx, float sy, float sz) { v.scale(sx, sy, sz); }
+    Q_INVOKABLE void scale(const QVector3D &s) { v.scale(s); }
+    Q_INVOKABLE void lookAt(const QVector3D &eye, const QVector3D &center, const QVector3D &up) { v.lookAt(eye, center, up); }
+
+    Q_INVOKABLE QMatrix4x4 times(const QMatrix4x4 &m) const;
+    Q_INVOKABLE QVector4D times(const QVector4D &vec) const;
+    Q_INVOKABLE QVector3D times(const QVector3D &vec) const;
+    Q_INVOKABLE QMatrix4x4 times(qreal factor) const;
+    Q_INVOKABLE QMatrix4x4 plus(const QMatrix4x4 &m) const;
+    Q_INVOKABLE QMatrix4x4 minus(const QMatrix4x4 &m) const;
+
+    Q_INVOKABLE QVector4D row(int n) const;
+    Q_INVOKABLE QVector4D column(int m) const;
+
+    Q_INVOKABLE qreal determinant() const;
+    Q_INVOKABLE QMatrix4x4 inverted() const;
+    Q_INVOKABLE QMatrix4x4 transposed() const;
+
+    Q_INVOKABLE bool fuzzyEquals(const QMatrix4x4 &m, qreal epsilon) const;
+    Q_INVOKABLE bool fuzzyEquals(const QMatrix4x4 &m) const;
+};
+
+class Q_3DQUICKSHARED_PRIVATE_EXPORT QQuick3DVector2DValueType
 {
     QVector2D v;
     Q_PROPERTY(qreal x READ x WRITE setX FINAL)
     Q_PROPERTY(qreal y READ y WRITE setY FINAL)
     Q_GADGET
+    QML_ADDED_IN_VERSION(2, 0)
+    QML_FOREIGN(QVector2D)
+    QML_VALUE_TYPE(vector2d)
+    QML_EXTENDED(QQuick3DVector2DValueType)
+
 public:
+    static QVariant create(const QJSValue &params);
+
     Q_INVOKABLE QString toString() const;
 
     qreal x() const;
@@ -133,14 +248,21 @@ public:
     Q_INVOKABLE bool fuzzyEquals(const QVector2D &vec) const;
 };
 
-class Q_3DQUICKSHARED_PRIVATE_EXPORT Quick3DVector3DValueType
+class Q_3DQUICKSHARED_PRIVATE_EXPORT QQuick3DVector3DValueType
 {
     QVector3D v;
     Q_PROPERTY(qreal x READ x WRITE setX FINAL)
     Q_PROPERTY(qreal y READ y WRITE setY FINAL)
     Q_PROPERTY(qreal z READ z WRITE setZ FINAL)
     Q_GADGET
+    QML_ADDED_IN_VERSION(2, 0)
+    QML_FOREIGN(QVector3D)
+    QML_VALUE_TYPE(vector3d)
+    QML_EXTENDED(QQuick3DVector3DValueType)
+
 public:
+    static QVariant create(const QJSValue &params);
+
     Q_INVOKABLE QString toString() const;
 
     qreal x() const;
@@ -165,7 +287,7 @@ public:
     Q_INVOKABLE bool fuzzyEquals(const QVector3D &vec) const;
 };
 
-class Q_3DQUICKSHARED_PRIVATE_EXPORT Quick3DVector4DValueType
+class Q_3DQUICKSHARED_PRIVATE_EXPORT QQuick3DVector4DValueType
 {
     QVector4D v;
     Q_PROPERTY(qreal x READ x WRITE setX FINAL)
@@ -173,7 +295,14 @@ class Q_3DQUICKSHARED_PRIVATE_EXPORT Quick3DVector4DValueType
     Q_PROPERTY(qreal z READ z WRITE setZ FINAL)
     Q_PROPERTY(qreal w READ w WRITE setW FINAL)
     Q_GADGET
+    QML_ADDED_IN_VERSION(2, 0)
+    QML_FOREIGN(QVector4D)
+    QML_VALUE_TYPE(vector4d)
+    QML_EXTENDED(QQuick3DVector4DValueType)
+
 public:
+    static QVariant create(const QJSValue &params);
+
     Q_INVOKABLE QString toString() const;
 
     qreal x() const;
@@ -199,7 +328,7 @@ public:
     Q_INVOKABLE bool fuzzyEquals(const QVector4D &vec) const;
 };
 
-class Q_3DQUICKSHARED_PRIVATE_EXPORT Quick3DQuaternionValueType
+class Q_3DQUICKSHARED_PRIVATE_EXPORT QQuick3DQuaternionValueType
 {
     QQuaternion v;
     Q_PROPERTY(qreal scalar READ scalar WRITE setScalar)
@@ -207,7 +336,14 @@ class Q_3DQUICKSHARED_PRIVATE_EXPORT Quick3DQuaternionValueType
     Q_PROPERTY(qreal y READ y WRITE setY)
     Q_PROPERTY(qreal z READ z WRITE setZ)
     Q_GADGET
+    QML_ADDED_IN_VERSION(2, 0)
+    QML_FOREIGN(QQuaternion)
+    QML_VALUE_TYPE(quaternion)
+    QML_EXTENDED(QQuick3DQuaternionValueType)
+
 public:
+    static QVariant create(const QJSValue &params);
+
     Q_INVOKABLE QString toString() const;
 
     qreal scalar() const;
@@ -220,88 +356,10 @@ public:
     void setZ(qreal);
 };
 
-class Q_3DQUICKSHARED_PRIVATE_EXPORT Quick3DMatrix4x4ValueType
-{
-    QMatrix4x4 v;
-    Q_PROPERTY(qreal m11 READ m11 WRITE setM11 FINAL)
-    Q_PROPERTY(qreal m12 READ m12 WRITE setM12 FINAL)
-    Q_PROPERTY(qreal m13 READ m13 WRITE setM13 FINAL)
-    Q_PROPERTY(qreal m14 READ m14 WRITE setM14 FINAL)
-    Q_PROPERTY(qreal m21 READ m21 WRITE setM21 FINAL)
-    Q_PROPERTY(qreal m22 READ m22 WRITE setM22 FINAL)
-    Q_PROPERTY(qreal m23 READ m23 WRITE setM23 FINAL)
-    Q_PROPERTY(qreal m24 READ m24 WRITE setM24 FINAL)
-    Q_PROPERTY(qreal m31 READ m31 WRITE setM31 FINAL)
-    Q_PROPERTY(qreal m32 READ m32 WRITE setM32 FINAL)
-    Q_PROPERTY(qreal m33 READ m33 WRITE setM33 FINAL)
-    Q_PROPERTY(qreal m34 READ m34 WRITE setM34 FINAL)
-    Q_PROPERTY(qreal m41 READ m41 WRITE setM41 FINAL)
-    Q_PROPERTY(qreal m42 READ m42 WRITE setM42 FINAL)
-    Q_PROPERTY(qreal m43 READ m43 WRITE setM43 FINAL)
-    Q_PROPERTY(qreal m44 READ m44 WRITE setM44 FINAL)
-    Q_GADGET
-public:
-    Q_INVOKABLE QString toString() const;
-
-    qreal m11() const { return v(0, 0); }
-    qreal m12() const { return v(0, 1); }
-    qreal m13() const { return v(0, 2); }
-    qreal m14() const { return v(0, 3); }
-    qreal m21() const { return v(1, 0); }
-    qreal m22() const { return v(1, 1); }
-    qreal m23() const { return v(1, 2); }
-    qreal m24() const { return v(1, 3); }
-    qreal m31() const { return v(2, 0); }
-    qreal m32() const { return v(2, 1); }
-    qreal m33() const { return v(2, 2); }
-    qreal m34() const { return v(2, 3); }
-    qreal m41() const { return v(3, 0); }
-    qreal m42() const { return v(3, 1); }
-    qreal m43() const { return v(3, 2); }
-    qreal m44() const { return v(3, 3); }
-
-    void setM11(qreal value) { v(0, 0) = value; }
-    void setM12(qreal value) { v(0, 1) = value; }
-    void setM13(qreal value) { v(0, 2) = value; }
-    void setM14(qreal value) { v(0, 3) = value; }
-    void setM21(qreal value) { v(1, 0) = value; }
-    void setM22(qreal value) { v(1, 1) = value; }
-    void setM23(qreal value) { v(1, 2) = value; }
-    void setM24(qreal value) { v(1, 3) = value; }
-    void setM31(qreal value) { v(2, 0) = value; }
-    void setM32(qreal value) { v(2, 1) = value; }
-    void setM33(qreal value) { v(2, 2) = value; }
-    void setM34(qreal value) { v(2, 3) = value; }
-    void setM41(qreal value) { v(3, 0) = value; }
-    void setM42(qreal value) { v(3, 1) = value; }
-    void setM43(qreal value) { v(3, 2) = value; }
-    void setM44(qreal value) { v(3, 3) = value; }
-
-    Q_INVOKABLE void translate(float x, float y, float z) { v.translate(x, y, z); }
-    Q_INVOKABLE void translate(const QVector3D &t) { v.translate(t); }
-    Q_INVOKABLE void rotate(float angle, const QVector3D &axis) { v.rotate(angle, axis); }
-    Q_INVOKABLE void scale(float s) { v.scale(s); }
-    Q_INVOKABLE void scale(float sx, float sy, float sz) { v.scale(sx, sy, sz); }
-    Q_INVOKABLE void scale(const QVector3D &s) { v.scale(s); }
-    Q_INVOKABLE void lookAt(const QVector3D &eye, const QVector3D &center, const QVector3D &up) { v.lookAt(eye, center, up); }
-
-    Q_INVOKABLE QMatrix4x4 times(const QMatrix4x4 &m) const;
-    Q_INVOKABLE QVector4D times(const QVector4D &vec) const;
-    Q_INVOKABLE QVector3D times(const QVector3D &vec) const;
-    Q_INVOKABLE QMatrix4x4 times(qreal factor) const;
-    Q_INVOKABLE QMatrix4x4 plus(const QMatrix4x4 &m) const;
-    Q_INVOKABLE QMatrix4x4 minus(const QMatrix4x4 &m) const;
-
-    Q_INVOKABLE QVector4D row(int n) const;
-    Q_INVOKABLE QVector4D column(int m) const;
-
-    Q_INVOKABLE qreal determinant() const;
-    Q_INVOKABLE QMatrix4x4 inverted() const;
-    Q_INVOKABLE QMatrix4x4 transposed() const;
-
-    Q_INVOKABLE bool fuzzyEquals(const QMatrix4x4 &m, qreal epsilon) const;
-    Q_INVOKABLE bool fuzzyEquals(const QMatrix4x4 &m) const;
-};
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
+#undef QML_ADDED_IN_VERSION
+#undef QML_VALUE_TYPE
+#endif
 
 } // namespace Quick
 } // namespace Qt3DCore