Fix QtQml integration for basic types

Adds registration for QVector2D, QVector3D, QVector4D, QQuaternion,
QMatrix4x4 and QColor types so that QML API can be used without
requiring to import QtQuick.

Replaces old private API with registered extension classes.

Change-Id: Id5e98175c986bf125e4c3c9476a09e438793bad2
Task-number: QTBUG-87184
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

4 files changed, 937 insertions, 292 deletions

diff --git a/src/quick3d/quick3d/CMakeLists.txt b/src/quick3d/quick3d/CMakeLists.txt
index 18fb5f530..a8dc96233 100644
--- a/src/quick3d/quick3d/CMakeLists.txt
+++ b/src/quick3d/quick3d/CMakeLists.txt
@@ -54,3 +54,13 @@ qt_extend_target(3DQuick CONDITION gcov
         "-fprofile-arcs"
         "-ftest-coverage"
 )
+
+set_target_properties(3DQuick PROPERTIES
+    QT_QML_MODULE_VERSION ${CMAKE_PROJECT_VERSION}
+    QT_QML_MODULE_URI Qt3D.Core
+    QT_QML_MODULE_INSTALL_QMLTYPES TRUE
+    QT_QMLTYPES_FILENAME plugins.qmltypes
+    QT_QML_MODULE_INSTALL_DIR "${INSTALL_QMLDIR}/Qt3D/Core"
+)
+
+qt6_qml_type_registration(3DQuick)
diff --git a/src/quick3d/quick3d/qt3dquick_global.cpp b/src/quick3d/quick3d/qt3dquick_global.cpp
index 6eba9db29..2a07ba83d 100644
--- a/src/quick3d/quick3d/qt3dquick_global.cpp
+++ b/src/quick3d/quick3d/qt3dquick_global.cpp
@@ -47,349 +47,698 @@
 
 QT_BEGIN_NAMESPACE
 
-namespace Qt3DCore {
-namespace Quick {
+namespace {
 
-class Quick3DColorProvider : public QQmlColorProvider
+template<typename T, int NumParams>
+QVariant createValueTypeFromNumberString(const QString &s)
 {
-public:
-    QVariant colorFromString(const QString &s, bool *ok) override
-    {
-        QColor c(s);
-        if (c.isValid()) {
-            if (ok) *ok = true;
-            return QVariant(c);
-        }
+    Q_STATIC_ASSERT_X(NumParams == 2 || NumParams == 3 || NumParams == 4 || NumParams == 16,
+                      "Unsupported number of params; add an additional case below if necessary.");
 
-        if (ok) *ok = false;
+    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);
     }
 
-    unsigned rgbaFromString(const QString &s, bool *ok) override
-    {
-        QColor c(s);
-        if (c.isValid()) {
-            if (ok) *ok = true;
-            return c.rgba();
-        }
+    if (!ok)
+        return QVariant();
 
-        if (ok) *ok = false;
-        return 0;
+    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();
     }
 
-    QString stringFromRgba(unsigned rgba)
-    {
-        QColor c(QColor::fromRgba(rgba));
-        if (c.isValid()) {
-            return QVariant(c).toString();
-        }
+    return QVariant();
+}
 
-        return QString();
-    }
+}
 
-    QVariant fromRgbF(double r, double g, double b, double a) override
-    {
-        return QVariant(QColor::fromRgbF(r, g, b, a));
-    }
 
-    QVariant fromHslF(double h, double s, double l, double a) override
-    {
-        return QVariant(QColor::fromHslF(h, s, l, a));
-    }
+namespace Qt3DCore {
+namespace Quick {
 
-    QVariant fromHsvF(double h, double s, double v, double a) override
-    {
-        return QVariant(QColor::fromHsvF(h, s, v, a));
-    }
+QVariant QQuick3DColorValueType::create(const QJSValue &params)
+{
+    return params.isString() ? QColor(params.toString()) : QVariant();
+}
 
-    QVariant lighter(const QVariant &var, qreal factor) override
-    {
-        QColor color = var.value<QColor>();
-        color = color.lighter(int(qRound(factor*100.)));
-        return QVariant::fromValue(color);
-    }
+QString QQuick3DColorValueType::toString() const
+{
+    return v.name(v.alpha() != 255 ? QColor::HexArgb : QColor::HexRgb);
+}
 
-    QVariant darker(const QVariant &var, qreal factor) override
-    {
-        QColor color = var.value<QColor>();
-        color = color.darker(int(qRound(factor*100.)));
-        return QVariant::fromValue(color);
-    }
+QVariant QQuick3DColorValueType::lighter(qreal factor) const
+{
+    return QQml_colorProvider()->lighter(this->v, factor);
+}
 
-    QVariant tint(const QVariant &baseVar, const QVariant &tintVar) override
-    {
-        QColor tintColor = tintVar.value<QColor>();
+QVariant QQuick3DColorValueType::darker(qreal factor) const
+{
+    return QQml_colorProvider()->darker(this->v, factor);
+}
 
-        int tintAlpha = tintColor.alpha();
-        if (tintAlpha == 0xFF) {
-            return tintVar;
-        } else if (tintAlpha == 0x00) {
-            return baseVar;
-        }
+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();
+}
 
-        // tint the base color and return the final color
-        QColor baseColor = baseVar.value<QColor>();
-        qreal a = tintColor.alphaF();
-        qreal inv_a = 1.0 - a;
+qreal QQuick3DColorValueType::g() const
+{
+    return v.greenF();
+}
 
-        qreal r = tintColor.redF() * a + baseColor.redF() * inv_a;
-        qreal g = tintColor.greenF() * a + baseColor.greenF() * inv_a;
-        qreal b = tintColor.blueF() * a + baseColor.blueF() * inv_a;
+qreal QQuick3DColorValueType::b() const
+{
+    return v.blueF();
+}
 
-        return QVariant::fromValue(QColor::fromRgbF(r, g, b, a + inv_a * baseColor.alphaF()));
-    }
-};
+qreal QQuick3DColorValueType::a() const
+{
+    return v.alphaF();
+}
+
+qreal QQuick3DColorValueType::hsvHue() const
+{
+    return v.hsvHueF();
+}
 
+qreal QQuick3DColorValueType::hsvSaturation() const
+{
+    return v.hsvSaturationF();
+}
 
-// Note: The functions in this class provide handling only for the types
-// that the QML engine will currently actually call them for, so many
-// appear incompletely implemented.  For some functions, the implementation
-// would be obvious, but for others (particularly create and createFromString)
-// the exact semantics are unknown.  For this reason unused functionality
-// has been omitted.
+qreal QQuick3DColorValueType::hsvValue() const
+{
+    return v.valueF();
+}
 
-class Quick3DValueTypeProvider : public QQmlValueTypeProvider
+qreal QQuick3DColorValueType::hslHue() const
 {
-public:
+    return v.hslHueF();
+}
 
-#if defined(QT_NO_DEBUG) && !defined(QT_FORCE_ASSERTS)
-    #define ASSERT_VALID_SIZE(size, min) Q_UNUSED(size);
-#else
-    #define ASSERT_VALID_SIZE(size, min) Q_ASSERT(size >= min)
-#endif
+qreal QQuick3DColorValueType::hslSaturation() const
+{
+    return v.hslSaturationF();
+}
+
+qreal QQuick3DColorValueType::hslLightness() const
+{
+    return v.lightnessF();
+}
 
-    static QVector2D vector2DFromString(const QString &s, bool *ok)
-    {
-        if (s.count(QLatin1Char(',')) == 1) {
-            int index = s.indexOf(QLatin1Char(','));
+bool QQuick3DColorValueType::isValid() const
+{
+    return v.isValid();
+}
 
-            bool xGood, yGood;
-            float xCoord = QStringView{s}.left(index).toFloat(&xGood);
-            float yCoord = QStringView{s}.mid(index + 1).toFloat(&yGood);
+void QQuick3DColorValueType::setR(qreal r)
+{
+    v.setRedF(r);
+}
 
-            if (xGood && yGood) {
-                if (ok) *ok = true;
-                return QVector2D(xCoord, yCoord);
-            }
-        }
+void QQuick3DColorValueType::setG(qreal g)
+{
+    v.setGreenF(g);
+}
 
-        if (ok) *ok = false;
-        return QVector2D();
-    }
+void QQuick3DColorValueType::setB(qreal b)
+{
+    v.setBlueF(b);
+}
 
-    static QVector3D vector3DFromString(const QString &s, bool *ok)
-    {
-        if (s.count(QLatin1Char(',')) == 2) {
-            int index = s.indexOf(QLatin1Char(','));
-            int index2 = s.indexOf(QLatin1Char(','), index+1);
+void QQuick3DColorValueType::setA(qreal a)
+{
+    v.setAlphaF(a);
+}
 
-            bool xGood, yGood, zGood;
-            float xCoord = QStringView{s}.left(index).toFloat(&xGood);
-            float yCoord = QStringView{s}.mid(index + 1, index2 - index - 1).toFloat(&yGood);
-            float zCoord = QStringView{s}.mid(index2 + 1).toFloat(&zGood);
+void QQuick3DColorValueType::setHsvHue(qreal hsvHue)
+{
+    float hue, saturation, value, alpha;
+    v.getHsvF(&hue, &saturation, &value, &alpha);
+    v.setHsvF(hsvHue, saturation, value, alpha);
+}
 
-            if (xGood && yGood && zGood) {
-                if (ok) *ok = true;
-                return QVector3D(xCoord, yCoord, zCoord);
-            }
-        }
+void QQuick3DColorValueType::setHsvSaturation(qreal hsvSaturation)
+{
+    float hue, saturation, value, alpha;
+    v.getHsvF(&hue, &saturation, &value, &alpha);
+    v.setHsvF(hue, hsvSaturation, value, alpha);
+}
 
-        if (ok) *ok = false;
-        return QVector3D();
-    }
+void QQuick3DColorValueType::setHsvValue(qreal hsvValue)
+{
+    float hue, saturation, value, alpha;
+    v.getHsvF(&hue, &saturation, &value, &alpha);
+    v.setHsvF(hue, saturation, hsvValue, alpha);
+}
 
-    static QVector4D vector4DFromString(const QString &s, bool *ok)
-    {
-        if (s.count(QLatin1Char(',')) == 3) {
-            int index = s.indexOf(QLatin1Char(','));
-            int index2 = s.indexOf(QLatin1Char(','), index+1);
-            int index3 = s.indexOf(QLatin1Char(','), index2+1);
-
-            bool xGood, yGood, zGood, wGood;
-            float xCoord = QStringView{s}.left(index).toFloat(&xGood);
-            float yCoord = QStringView{s}.mid(index + 1, index2 - index - 1).toFloat(&yGood);
-            float zCoord = QStringView{s}.mid(index2 + 1, index3 - index2 - 1).toFloat(&zGood);
-            float wCoord = QStringView{s}.mid(index3 + 1).toFloat(&wGood);
-
-            if (xGood && yGood && zGood && wGood) {
-                if (ok) *ok = true;
-                return QVector4D(xCoord, yCoord, zCoord, wCoord);
-            }
-        }
+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 (ok) *ok = false;
-        return QVector4D();
+    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());
     }
 
-    static QQuaternion quaternionFromString(const QString &s, bool *ok)
-    {
-        if (s.count(QLatin1Char(',')) == 3) {
-            int index = s.indexOf(QLatin1Char(','));
-            int index2 = s.indexOf(QLatin1Char(','), index+1);
-            int index3 = s.indexOf(QLatin1Char(','), index2+1);
-
-            bool sGood, xGood, yGood, zGood;
-            qreal sCoord = QStringView{s}.left(index).toDouble(&sGood);
-            qreal xCoord = QStringView{s}.mid(index+1, index2-index-1).toDouble(&xGood);
-            qreal yCoord = QStringView{s}.mid(index2+1, index3-index2-1).toDouble(&yGood);
-            qreal zCoord = QStringView{s}.mid(index3+1).toDouble(&zGood);
-
-            if (sGood && xGood && yGood && zGood) {
-                if (ok) *ok = true;
-                return QQuaternion(sCoord, xCoord, yCoord, zCoord);
+    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 (ok) *ok = false;
-        return QQuaternion();
+    if (params.isArray()) {
+        return QVector3D(params.property(0).toNumber(), params.property(1).toNumber(),
+                         params.property(2).toNumber());
     }
+    return QVariant();
+}
 
-    static QMatrix4x4 matrix4x4FromString(const QString &s, bool *ok)
-    {
-        if (s.count(QLatin1Char(',')) == 15) {
-            float matValues[16];
-            bool vOK = true;
-            QStringView mutableStr(s);
-            for (int i = 0; vOK && i < 16; ++i) {
-                int cidx = mutableStr.indexOf(QLatin1Char(','));
-                matValues[i] = mutableStr.left(cidx).toDouble(&vOK);
-                mutableStr = mutableStr.mid(cidx + 1);
-            }
+QString QQuick3DVector3DValueType::toString() const
+{
+    return QString(QLatin1String("QVector3D(%1, %2, %3)")).arg(v.x()).arg(v.y()).arg(v.z());
+}
 
-            if (vOK) {
-                if (ok) *ok = true;
-                return QMatrix4x4(matValues);
-            }
-        }
+qreal QQuick3DVector3DValueType::x() const
+{
+    return qreal(v.x());
+}
 
-        if (ok) *ok = false;
-        return QMatrix4x4();
+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());
     }
 
-    bool create(int type, const QJSValue &params, QVariant *v) override
-    {
-        switch (type) {
-        case QMetaType::QColor:
-            if (params.isString()) {
-                *v = QVariant(QColor(params.toString()));
-                return true;
-            }
-            break;
-        case QMetaType::QVector2D:
-            if (params.isArray()) {
-                *v = QVariant(QVector2D(params.property(0).toNumber(),
-                                        params.property(1).toNumber()));
-                return true;
-            } else if (params.isString()) {
-                bool ok = false;
-                auto vector = vector2DFromString(params.toString(), &ok);
-                if (ok) {
-                    *v = QVariant(vector);
-                    return true;
-                }
-            }
-            break;
-        case QMetaType::QVector3D:
-            if (params.isArray()) {
-                *v = QVariant(QVector3D(params.property(0).toNumber(),
-                                        params.property(1).toNumber(),
-                                        params.property(2).toNumber()));
-                return true;
-            } else if (params.isString()) {
-                bool ok = false;
-                auto vector = vector3DFromString(params.toString(), &ok);
-                if (ok) {
-                    *v = QVariant(vector);
-                    return true;
-                }
-            }
-            break;
-        case QMetaType::QVector4D:
-            if (params.isArray()) {
-                *v = QVariant(QVector4D(params.property(0).toNumber(),
-                                        params.property(1).toNumber(),
-                                        params.property(2).toNumber(),
-                                        params.property(3).toNumber()));
-                return true;
-            } else if (params.isString()) {
-                bool ok = false;
-                auto vector = vector4DFromString(params.toString(), &ok);
-                if (ok) {
-                    *v = QVariant(vector);
-                    return true;
-                }
-            }
-            break;
-        case QMetaType::QQuaternion:
-            if (params.isArray()) {
-                *v = QVariant(QQuaternion(params.property(0).toNumber(),
-                                          params.property(1).toNumber(),
-                                          params.property(2).toNumber(),
-                                          params.property(3).toNumber()));
-                return true;
-            } else if (params.isString()) {
-                bool ok = false;
-                auto vector = quaternionFromString(params.toString(), &ok);
-                if (ok) {
-                    *v = QVariant(vector);
-                    return true;
-                }
-            }
-            break;
-        case QMetaType::QMatrix4x4:
-            if (params.isNull() || params.isUndefined()) {
-                QMatrix4x4 m;
-                *v = QVariant(m);
-                return true;
-            } else if (params.isArray()
-                       && params.property(QStringLiteral("length")).toInt() == 16) {
-                *v = QVariant(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 true;
-            } else if (params.isString()) {
-                bool ok = false;
-                auto vector = matrix4x4FromString(params.toString(), &ok);
-                if (ok) {
-                    *v = QVariant(vector);
-                    return true;
-                }
-            }
-            break;
-        default: break;
-        }
+    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());
     }
 
-#undef ASSERT_VALID_SIZE
-};
+    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);
+}
 
-Quick3DValueTypeProvider *valueTypeProvider = nullptr;
-static Quick3DValueTypeProvider *getValueTypeProvider()
+void QQuick3DQuaternionValueType::setY(qreal y)
 {
-    if (valueTypeProvider == nullptr)
-        valueTypeProvider = new Quick3DValueTypeProvider();
-    return valueTypeProvider;
+    v.setY(y);
 }
 
-static Quick3DColorProvider *getColorProvider()
+void QQuick3DQuaternionValueType::setZ(qreal z)
 {
-    static Quick3DColorProvider colorProvider;
-    return &colorProvider;
+    v.setZ(z);
 }
 
 static QQmlPrivate::AutoParentResult qquick3ditem_autoParent(QObject *obj, QObject *parent)
@@ -412,8 +761,6 @@ static QQmlPrivate::AutoParentResult qquick3ditem_autoParent(QObject *obj, QObje
 
 void Quick3D_initialize()
 {
-    QQml_addValueTypeProvider(getValueTypeProvider());
-    QQml_setColorProvider(getColorProvider());
     QAbstractNodeFactory::registerNodeFactory(QuickNodeFactory::instance());
 
     // Register a hook called when we do component.create() that sets the
@@ -428,8 +775,6 @@ void Quick3D_initialize()
 
 void Quick3D_uninitialize()
 {
-    delete valueTypeProvider;
-    valueTypeProvider = nullptr;
 }
 
 void Quick3D_registerType(const char *className, const char *quickName, int major, int minor)
diff --git a/src/quick3d/quick3d/qt3dquick_global_p.h b/src/quick3d/quick3d/qt3dquick_global_p.h
index 87fd4764c..1931e5f4c 100644
--- a/src/quick3d/quick3d/qt3dquick_global_p.h
+++ b/src/quick3d/quick3d/qt3dquick_global_p.h
@@ -54,6 +54,11 @@
 #include <Qt3DQuick/qt3dquick_global.h>
 #include <QtQml/qqml.h>
 
+#include <QColor>
+#include <QMatrix4x4>
+#include <QVector2D>
+#include <QVector3D>
+
 #define Q_3DQUICKSHARED_PRIVATE_EXPORT Q_3DQUICKSHARED_EXPORT
 
 QT_BEGIN_NAMESPACE
@@ -72,6 +77,288 @@ 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/quick3d.pro b/src/quick3d/quick3d/quick3d.pro
index b7edec507..befe45c25 100644
--- a/src/quick3d/quick3d/quick3d.pro
+++ b/src/quick3d/quick3d/quick3d.pro
@@ -26,4 +26,7 @@ SOURCES += \
 
 include(./items/items.pri)
 
+QML_IMPORT_NAME = Qt3DQuick
+QML_IMPORT_MAJOR_VERSION = 1
+
 load(qt_module)