Make gui/math3d classes use float rather than qreal

This corrects the mismatch between using floats for internal storage
and qreal in the API of QVector*D which leads to lots of implicit
casts between double and float.

This change also stops users from being surprised by the loss of
precision when using these classes on desktop platforms and removes
the need for the private constructors taking a dummy int as the final
argument.

The QMatrix4x4 and QQuaternion classes have been changed to use float
for their internal storage since these are meant to be used in
conjunction with the QVector*D classes. This is to prevent unexpected
loss of precision and to improve performance.

The on-disk format has also been changed from double to float thereby
reducing the storage required when streaming vectors and matrices. This
is potentially a large saving when working with complex 3D meshes etc.

This also has a significant performance improvement when passing
matrices to QOpenGLShaderProgram (and QGLShaderProgram) as we no
longer have to iterate and convert the data to floats. This is
an operation that could easily be needed many times per frame.

This change also opens the door for further optimisations of these
classes to be implemented by using SIMD intrinsics.

This needs to be applied in conjunction with

https://codereview.qt-project.org/#change,33548

Task-number: QTBUG-21035
Task-number: QTBUG-20661
Change-Id: I9321b06040ffb93ae1cbd72fd2013267ac901b2e
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>

1 files changed, 40 insertions, 44 deletions

diff --git a/src/gui/math3d/qvector4d.h b/src/gui/math3d/qvector4d.h
index 384dd6a2a6..c793c4ef37 100644
--- a/src/gui/math3d/qvector4d.h
+++ b/src/gui/math3d/qvector4d.h
@@ -60,53 +60,53 @@ class Q_GUI_EXPORT QVector4D
 {
 public:
     QVector4D();
-    QVector4D(qreal xpos, qreal ypos, qreal zpos, qreal wpos);
+    QVector4D(float xpos, float ypos, float zpos, float wpos);
     explicit QVector4D(const QPoint& point);
     explicit QVector4D(const QPointF& point);
 #ifndef QT_NO_VECTOR2D
     QVector4D(const QVector2D& vector);
-    QVector4D(const QVector2D& vector, qreal zpos, qreal wpos);
+    QVector4D(const QVector2D& vector, float zpos, float wpos);
 #endif
 #ifndef QT_NO_VECTOR3D
     QVector4D(const QVector3D& vector);
-    QVector4D(const QVector3D& vector, qreal wpos);
+    QVector4D(const QVector3D& vector, float wpos);
 #endif
 
     bool isNull() const;
 
-    qreal x() const;
-    qreal y() const;
-    qreal z() const;
-    qreal w() const;
+    float x() const;
+    float y() const;
+    float z() const;
+    float w() const;
 
-    void setX(qreal x);
-    void setY(qreal y);
-    void setZ(qreal z);
-    void setW(qreal w);
+    void setX(float x);
+    void setY(float y);
+    void setZ(float z);
+    void setW(float w);
 
-    qreal length() const;
-    qreal lengthSquared() const;
+    float length() const;
+    float lengthSquared() const;
 
     QVector4D normalized() const;
     void normalize();
 
     QVector4D &operator+=(const QVector4D &vector);
     QVector4D &operator-=(const QVector4D &vector);
-    QVector4D &operator*=(qreal factor);
+    QVector4D &operator*=(float factor);
     QVector4D &operator*=(const QVector4D &vector);
-    QVector4D &operator/=(qreal divisor);
+    QVector4D &operator/=(float divisor);
 
-    static qreal dotProduct(const QVector4D& v1, const QVector4D& v2);
+    static float dotProduct(const QVector4D& v1, const QVector4D& v2);
 
     friend inline bool operator==(const QVector4D &v1, const QVector4D &v2);
     friend inline bool operator!=(const QVector4D &v1, const QVector4D &v2);
     friend inline const QVector4D operator+(const QVector4D &v1, const QVector4D &v2);
     friend inline const QVector4D operator-(const QVector4D &v1, const QVector4D &v2);
-    friend inline const QVector4D operator*(qreal factor, const QVector4D &vector);
-    friend inline const QVector4D operator*(const QVector4D &vector, qreal factor);
+    friend inline const QVector4D operator*(float factor, const QVector4D &vector);
+    friend inline const QVector4D operator*(const QVector4D &vector, float factor);
     friend inline const QVector4D operator*(const QVector4D &v1, const QVector4D& v2);
     friend inline const QVector4D operator-(const QVector4D &vector);
-    friend inline const QVector4D operator/(const QVector4D &vector, qreal divisor);
+    friend inline const QVector4D operator/(const QVector4D &vector, float divisor);
 
     friend inline bool qFuzzyCompare(const QVector4D& v1, const QVector4D& v2);
 
@@ -127,8 +127,6 @@ public:
 private:
     float xp, yp, zp, wp;
 
-    QVector4D(float xpos, float ypos, float zpos, float wpos, int dummy);
-
     friend class QVector2D;
     friend class QVector3D;
 #ifndef QT_NO_MATRIX4X4
@@ -141,9 +139,7 @@ Q_DECLARE_TYPEINFO(QVector4D, Q_MOVABLE_TYPE);
 
 inline QVector4D::QVector4D() : xp(0.0f), yp(0.0f), zp(0.0f), wp(0.0f) {}
 
-inline QVector4D::QVector4D(qreal xpos, qreal ypos, qreal zpos, qreal wpos) : xp(xpos), yp(ypos), zp(zpos), wp(wpos) {}
-
-inline QVector4D::QVector4D(float xpos, float ypos, float zpos, float wpos, int) : xp(xpos), yp(ypos), zp(zpos), wp(wpos) {}
+inline QVector4D::QVector4D(float xpos, float ypos, float zpos, float wpos) : xp(xpos), yp(ypos), zp(zpos), wp(wpos) {}
 
 inline QVector4D::QVector4D(const QPoint& point) : xp(point.x()), yp(point.y()), zp(0.0f), wp(0.0f) {}
 
@@ -154,15 +150,15 @@ inline bool QVector4D::isNull() const
     return qIsNull(xp) && qIsNull(yp) && qIsNull(zp) && qIsNull(wp);
 }
 
-inline qreal QVector4D::x() const { return qreal(xp); }
-inline qreal QVector4D::y() const { return qreal(yp); }
-inline qreal QVector4D::z() const { return qreal(zp); }
-inline qreal QVector4D::w() const { return qreal(wp); }
+inline float QVector4D::x() const { return xp; }
+inline float QVector4D::y() const { return yp; }
+inline float QVector4D::z() const { return zp; }
+inline float QVector4D::w() const { return wp; }
 
-inline void QVector4D::setX(qreal aX) { xp = aX; }
-inline void QVector4D::setY(qreal aY) { yp = aY; }
-inline void QVector4D::setZ(qreal aZ) { zp = aZ; }
-inline void QVector4D::setW(qreal aW) { wp = aW; }
+inline void QVector4D::setX(float aX) { xp = aX; }
+inline void QVector4D::setY(float aY) { yp = aY; }
+inline void QVector4D::setZ(float aZ) { zp = aZ; }
+inline void QVector4D::setW(float aW) { wp = aW; }
 
 inline QVector4D &QVector4D::operator+=(const QVector4D &vector)
 {
@@ -182,7 +178,7 @@ inline QVector4D &QVector4D::operator-=(const QVector4D &vector)
     return *this;
 }
 
-inline QVector4D &QVector4D::operator*=(qreal factor)
+inline QVector4D &QVector4D::operator*=(float factor)
 {
     xp *= factor;
     yp *= factor;
@@ -200,7 +196,7 @@ inline QVector4D &QVector4D::operator*=(const QVector4D &vector)
     return *this;
 }
 
-inline QVector4D &QVector4D::operator/=(qreal divisor)
+inline QVector4D &QVector4D::operator/=(float divisor)
 {
     xp /= divisor;
     yp /= divisor;
@@ -221,37 +217,37 @@ inline bool operator!=(const QVector4D &v1, const QVector4D &v2)
 
 inline const QVector4D operator+(const QVector4D &v1, const QVector4D &v2)
 {
-    return QVector4D(v1.xp + v2.xp, v1.yp + v2.yp, v1.zp + v2.zp, v1.wp + v2.wp, 1);
+    return QVector4D(v1.xp + v2.xp, v1.yp + v2.yp, v1.zp + v2.zp, v1.wp + v2.wp);
 }
 
 inline const QVector4D operator-(const QVector4D &v1, const QVector4D &v2)
 {
-    return QVector4D(v1.xp - v2.xp, v1.yp - v2.yp, v1.zp - v2.zp, v1.wp - v2.wp, 1);
+    return QVector4D(v1.xp - v2.xp, v1.yp - v2.yp, v1.zp - v2.zp, v1.wp - v2.wp);
 }
 
-inline const QVector4D operator*(qreal factor, const QVector4D &vector)
+inline const QVector4D operator*(float factor, const QVector4D &vector)
 {
-    return QVector4D(vector.xp * factor, vector.yp * factor, vector.zp * factor, vector.wp * factor, 1);
+    return QVector4D(vector.xp * factor, vector.yp * factor, vector.zp * factor, vector.wp * factor);
 }
 
-inline const QVector4D operator*(const QVector4D &vector, qreal factor)
+inline const QVector4D operator*(const QVector4D &vector, float factor)
 {
-    return QVector4D(vector.xp * factor, vector.yp * factor, vector.zp * factor, vector.wp * factor, 1);
+    return QVector4D(vector.xp * factor, vector.yp * factor, vector.zp * factor, vector.wp * factor);
 }
 
 inline const QVector4D operator*(const QVector4D &v1, const QVector4D& v2)
 {
-    return QVector4D(v1.xp * v2.xp, v1.yp * v2.yp, v1.zp * v2.zp, v1.wp * v2.wp, 1);
+    return QVector4D(v1.xp * v2.xp, v1.yp * v2.yp, v1.zp * v2.zp, v1.wp * v2.wp);
 }
 
 inline const QVector4D operator-(const QVector4D &vector)
 {
-    return QVector4D(-vector.xp, -vector.yp, -vector.zp, -vector.wp, 1);
+    return QVector4D(-vector.xp, -vector.yp, -vector.zp, -vector.wp);
 }
 
-inline const QVector4D operator/(const QVector4D &vector, qreal divisor)
+inline const QVector4D operator/(const QVector4D &vector, float divisor)
 {
-    return QVector4D(vector.xp / divisor, vector.yp / divisor, vector.zp / divisor, vector.wp / divisor, 1);
+    return QVector4D(vector.xp / divisor, vector.yp / divisor, vector.zp / divisor, vector.wp / divisor);
 }
 
 inline bool qFuzzyCompare(const QVector4D& v1, const QVector4D& v2)