Remove fixed-point support from math3d

The main use case for fixed-point support is to build large
arrays of vertices.  This can be handled using qvertextype or
something similar at higher levels.  So it isn't worth risking
numerical instability in the core classes.

Reviewed-by: trustme

28 files changed, 391 insertions, 2953 deletions

diff --git a/src/gui/math3d/math3d.pri b/src/gui/math3d/math3d.pri
index 581adbd..e4dd53a 100644
--- a/src/gui/math3d/math3d.pri
+++ b/src/gui/math3d/math3d.pri
@@ -1,8 +1,5 @@
 HEADERS += \
-    math3d/qfixedpt.h \
     math3d/qgenericmatrix.h \
-    math3d/qmath3dglobal.h \
-    math3d/qmath3dutil_p.h \
     math3d/qmatrix4x4.h \
     math3d/qquaternion.h \
     math3d/qvector2d.h \
@@ -10,9 +7,7 @@ HEADERS += \
     math3d/qvector4d.h
 
 SOURCES += \
-    math3d/qfixedpt.cpp \
     math3d/qgenericmatrix.cpp \
-    math3d/qmath3dutil.cpp \
     math3d/qmatrix4x4.cpp \
     math3d/qquaternion.cpp \
     math3d/qvector2d.cpp \
diff --git a/src/gui/math3d/qfixedpt.cpp b/src/gui/math3d/qfixedpt.cpp
deleted file mode 100644
index 93f2150..0000000
--- a/src/gui/math3d/qfixedpt.cpp
+++ /dev/null
@@ -1,711 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
-**
-** This file is part of the $MODULE$ of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the either Technology Preview License Agreement or the
-** Beta Release License Agreement.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qfixedpt.h"
-
-QT_BEGIN_NAMESPACE
-
-/*!
-    \internal
-    Returns the fixed-point square root of \a value.
-*/
-qint64 qt_math3d_fixed_sqrt(qint64 value)
-{
-    qint64 result = 0;
-    qint64 bit = ((qint64)1) << 62;
-    while (bit > value)
-        bit >>= 2;
-    while (bit != 0) {
-        if (value >= (result + bit)) {
-            value -= result + bit;
-            result += (bit << 1);
-        }
-        result >>= 1;
-        bit >>= 2;
-    }
-    return result;
-}
-
-/*!
-    \class QFixedPt
-    \brief The QFixedPt class represents fixed-point numbers within a 32-bit integer with a configurable precision.
-
-    The template parameter is the number of bits of precision after
-    the decimal point.  For example, QFixedPt<5> indicates that there
-    are 27 bits before the decimal point, and 5 bits of precision after
-    the decimal point.
-*/
-
-/*!
-    \fn QFixedPt::QFixedPt()
-
-    Constructs a default fixed-point number.  The initial value
-    is undefined.
-*/
-
-/*!
-    \fn QFixedPt::QFixedPt(int value)
-
-    Constructs a fixed-point number from the integer \a value.
-*/
-
-/*!
-    \fn QFixedPt::QFixedPt(qreal value)
-
-    Constructs a fixed-point number from the floating-point \a value.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits>& QFixedPt::operator=(int value)
-
-    Assigns the integer \a value to this fixed-point variable.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits>& QFixedPt::operator=(qreal value)
-
-    Assigns the floating-point \a value to this fixed-point variable.
-*/
-
-/*!
-    \fn int QFixedPt::bits() const
-
-    Returns the raw bits that represent the fixed-point value of this object.
-
-    \sa setBits()
-*/
-
-/*!
-    \fn void QFixedPt::setBits(int value)
-
-    Sets the raw bits that represent the fixed-point value of
-    this object to \a value.
-
-    \sa bits()
-*/
-
-#if !defined(QT_NO_MEMBER_TEMPLATES) || defined(Q_QDOC)
-
-/*!
-    \fn QFixedPt<Prec> QFixedPt::toPrecision() const
-
-    Returns this fixed-point number, converted to the new fixed-point
-    precision Prec.
-
-    \sa qFixedPtToPrecision()
-*/
-
-#endif
-
-/*!
-    \fn QFixedPt<Prec> qFixedPtToPrecision(const QFixedPt<PrecBits>& value)
-
-    Returns the fixed-point number \a value, converted to the new fixed-point
-    precision Prec.
-
-    \sa QFixedPt::toPrecision()
-*/
-
-/*!
-    \fn QFixedPt<PrecBits>& QFixedPt::operator+=(const QFixedPt<PrecBits>& value)
-
-    Adds \a value to this fixed-point number.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits>& QFixedPt::operator+=(int value)
-
-    Adds an integer \a value to this fixed-point number.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits>& QFixedPt::operator+=(qreal value)
-
-    Adds a floating-point \a value to this fixed-point number.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits>& QFixedPt::operator-=(const QFixedPt<PrecBits>& value)
-
-    Subtracts \a value from this fixed-point number.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits>& QFixedPt::operator-=(int value)
-
-    Subtracts an integer \a value from this fixed-point number.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits>& QFixedPt::operator-=(qreal value)
-
-    Subtracts a floating-point \a value from this fixed-point number.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits>& QFixedPt::operator*=(const QFixedPt<PrecBits>& value)
-
-    Multiplies this fixed-point number by \a value.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits>& QFixedPt::operator*=(int value)
-
-    Multiplies this fixed-point number by an integer \a value.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits>& QFixedPt::operator*=(qreal value)
-
-    Multiplies this fixed-point number by a floating-point \a value.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits>& QFixedPt::operator/=(const QFixedPt<PrecBits>& value)
-
-    Divides this fixed-point number by \a value.  Division by zero
-    will result in zero.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits>& QFixedPt::operator/=(int value)
-
-    Divides this fixed-point number by an integer \a value.  Division
-    by zero will result in zero.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits>& QFixedPt::operator/=(qreal value)
-
-    Divides this fixed-point number by a floating-point \a value.  Division
-    by zero will result in zero.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits>& QFixedPt::operator<<=(int value)
-
-    Shifts this fixed-point number left by \a value bits.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits>& QFixedPt::operator>>=(int value)
-
-    Shifts this fixed-point number right by \a value bits.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::operator<<(int value) const
-
-    Returns the result of shifting this fixed-point number
-    left by \a value bits.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::operator>>(int value) const
-
-    Returns the result of shifting this fixed-point number
-    right by \a value bits.
-*/
-
-/*!
-    \fn bool QFixedPt::operator==(const QFixedPt<PrecBits>& value) const
-
-    Returns true if this fixed-point number is equal to \a value;
-    false otherwise.
-*/
-
-/*!
-    \fn bool operator==(const QFixedPt<PrecBits>& v1, int v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is equal to \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator==(int v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is equal to \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator==(const QFixedPt<PrecBits>& v1, qreal v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is equal to \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator==(qreal v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is equal to \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool QFixedPt::operator!=(const QFixedPt<PrecBits>& value) const
-
-    Returns true if this fixed-point number is not equal to \a value;
-    false otherwise.
-*/
-
-/*!
-    \fn bool operator!=(const QFixedPt<PrecBits>& v1, int v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is not equal to \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator!=(int v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is not equal to \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator!=(const QFixedPt<PrecBits>& v1, qreal v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is not equal to \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator!=(qreal v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is not equal to \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool QFixedPt::operator<=(const QFixedPt<PrecBits>& value) const
-
-    Returns true if this fixed-point number is less than or equal to
-    \a value; false otherwise.
-*/
-
-/*!
-    \fn bool operator<=(const QFixedPt<PrecBits>& v1, int v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is less than or equal to \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator<=(int v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is less than or equal to \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator<=(const QFixedPt<PrecBits>& v1, qreal v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is less than or equal to \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator<=(qreal v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is less than or equal to \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool QFixedPt::operator<(const QFixedPt<PrecBits>& value) const
-
-    Returns true if this fixed-point number is less than \a value;
-    false otherwise.
-*/
-
-/*!
-    \fn bool operator<(const QFixedPt<PrecBits>& v1, int v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is less than \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator<(int v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is less than \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator<(const QFixedPt<PrecBits>& v1, qreal v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is less than \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator<(qreal v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is less than \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool QFixedPt::operator>=(const QFixedPt<PrecBits>& value) const
-
-    Returns true if this fixed-point number is greater than or equal to
-    \a value; false otherwise.
-*/
-
-/*!
-    \fn bool operator>=(const QFixedPt<PrecBits>& v1, int v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is greater than or equal to \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator>=(int v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is greater than or equal to \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator>=(const QFixedPt<PrecBits>& v1, qreal v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is greater than or equal to \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator>=(qreal v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is greater than or equal to \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool QFixedPt::operator>(const QFixedPt<PrecBits>& value) const
-
-    Returns true if this fixed-point number is greater than \a value;
-    false otherwise.
-*/
-
-/*!
-    \fn bool operator>(const QFixedPt<PrecBits>& v1, int v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is greater than \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator>(int v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is greater than \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator>(const QFixedPt<PrecBits>& v1, qreal v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is greater than \a v2; false otherwise.
-*/
-
-/*!
-    \fn bool operator>(qreal v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns true if \a v1 is greater than \a v2; false otherwise.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::operator+(const QFixedPt<PrecBits>& value) const
-
-    Returns the result of adding this fixed-point number and \a value.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::operator+(int value) const
-
-    Returns the result of adding this fixed-point number and \a value.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::operator+(qreal value) const
-
-    Returns the result of adding this fixed-point number and \a value.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> operator+(int v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns the result of adding \a v1 and \a v2.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> operator+(qreal v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns the result of adding \a v1 and \a v2.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::operator-(const QFixedPt<PrecBits>& value) const
-
-    Returns the result of subtracting \a value from this fixed-point number.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::operator-(int value) const
-
-    Returns the result of subtracting \a value from this fixed-point number.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::operator-(qreal value) const
-
-    Returns the result of subtracting \a value from this fixed-point number.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> operator-(int v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns the result of subtracting \a v2 from \a v1.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> operator-(qreal v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns the result of subtracting \a v2 from \a v1.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::operator*(const QFixedPt<PrecBits>& value) const
-
-    Returns the result of multiplying this fixed-point number by \a value.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::operator*(int value) const
-
-    Returns the result of multiplying this fixed-point number by \a value.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::operator*(qreal value) const
-
-    Returns the result of multiplying this fixed-point number by \a value.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> operator*(int v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns the result of multiplying \a v1 by \a v2.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> operator*(qreal v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns the result of multiplying \a v1 by \a v2.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::operator/(const QFixedPt<PrecBits>& value) const
-
-    Returns the result of dividing this fixed-point number by \a value.
-    Division by zero will result in zero.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::operator/(int value) const
-
-    Returns the result of dividing this fixed-point number by \a value.
-    Division by zero will result in zero.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::operator/(qreal value) const
-
-    Returns the result of dividing this fixed-point number by \a value.
-    Division by zero will result in zero.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> operator/(int v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns the result of dividing \a v1 by \a v2.  Division by zero will
-    result in zero.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> operator/(qreal v1, const QFixedPt<PrecBits>& v2)
-    \relates QFixedPt
-
-    Returns the result of dividing \a v1 by \a v2.  Division by zero will
-    result in zero.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::operator-() const
-
-    Returns the negation of this fixed-point number.
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::sqrt() const
-
-    Returns the square root of this fixed-point number.
-
-    \sa sqrtF()
-*/
-
-/*!
-    \fn qreal QFixedPt::sqrtF() const
-
-    Return the square root of this fixed-point number as a
-    floating-point value.
-
-    \sa sqrt()
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::round() const
-
-    Returns this fixed-point number, rounded to the nearest integer.
-
-    \sa floor(), ceil(), truncate()
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::floor() const;
-
-    Returns the largest integer that is less than or equal to
-    this fixed-point number.
-
-    \sa round(), ceil(), truncate()
-*/
-
-/*!
-    \fn QFixedPt<PrecBits> QFixedPt::ceil() const
-
-    Returns the smallest integer that is greater than or equal to
-    this fixed-point number.
-
-    \sa round(), floor(), truncate()
-*/
-
-/*!
-    \fn int QFixedPt::truncate() const
-
-    Returns this fixed-point number with the bits after the
-    decimal point truncated.
-
-    \sa round(), floor(), ceil()
-*/
-
-/*!
-    \fn int QFixedPt::toInt() const
-
-    Returns this fixed-point number, rounded to the nearest integer.
-
-    \sa toReal()
-*/
-
-/*!
-    \fn qreal QFixedPt::toReal() const
-
-    Returns this fixed-point number as a floating-point value.
-
-    \sa toInt()
-*/
-
-/*!
-    \fn int qCeil(const QFixedPt<PrecBits>& value)
-    \relates QFixedPt
-
-    Returns the smallest integer that is greater than or equal to
-    \a value.
-
-    \sa qFloor(), qRound(), QFixedPt::ceil()
-*/
-
-/*!
-    \fn int qFloor(const QFixedPt<PrecBits>& value)
-    \relates QFixedPt
-
-    Returns the largest integer that is less than or equal to
-    \a value.
-
-    \sa qCeil(), qRound(), QFixedPt::floor()
-*/
-
-/*!
-    \fn int qRound(const QFixedPt<PrecBits>& value)
-    \relates QFixedPt
-
-    Returns \a value, rounded to the nearest integer.
-
-    \sa qCeil(), qFloor(), QFixedPt::round()
-*/
-
-/*!
-    \fn bool qFuzzyCompare(const QFixedPt<PrecBits>& v1, const QFixedPt<PrecBits>& v2, int compareBits)
-    \relates QFixedPt
-
-    Returns true if \a v1 is almost equal to \a v2; false otherwise.
-    The \a compareBits parameter specifies the number of bits of precision
-    that should be considered relevant when performing the comparison.
-    By default, \a compareBits is PrecBits / 4.
-*/
-
-/*!
-    \fn bool qIsNull(const QFixedPt<PrecBits>& v)
-    \relates QFixedPt
-
-    Returns true if \a v is zero; false otherwise.
-*/
-
-QT_END_NAMESPACE
diff --git a/src/gui/math3d/qfixedpt.h b/src/gui/math3d/qfixedpt.h
deleted file mode 100644
index 142f62f..0000000
--- a/src/gui/math3d/qfixedpt.h
+++ /dev/null
@@ -1,551 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
-**
-** This file is part of the $MODULE$ of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the either Technology Preview License Agreement or the
-** Beta Release License Agreement.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QFIXEDPT_H
-#define QFIXEDPT_H
-
-#include <QtCore/qglobal.h>
-#include <QtCore/qdebug.h>
-
-QT_BEGIN_HEADER
-
-QT_BEGIN_NAMESPACE
-
-QT_MODULE(Gui)
-
-Q_GUI_EXPORT qint64 qt_math3d_fixed_sqrt(qint64 value);
-
-// Should be called QFixed or QFixedPoint, but both of those
-// are already in use in src/gui/painting/qfixed_p.h.
-template <int PrecBits>
-class QFixedPt
-{
-public:
-    inline QFixedPt() {} // Deliberately not initialized - don't change this.
-    inline QFixedPt(int value) : val(value << PrecBits) {}
-    inline QFixedPt(qreal value) : val(int(value * (1 << PrecBits))) {}
-
-    inline QFixedPt<PrecBits>& operator=(int value)
-        { val = value << PrecBits; return *this; }
-    inline QFixedPt<PrecBits>& operator=(qreal value)
-        { val = int(value * (1 << PrecBits)); return *this; }
-
-    inline int bits() const { return val; }
-    inline void setBits(int value) { val = value; }
-
-#if !defined(QT_NO_MEMBER_TEMPLATES) || defined(Q_QDOC)
-    template <int Prec>
-    inline QFixedPt<Prec> toPrecision() const
-    {
-        QFixedPt<Prec> result;
-        if (Prec < PrecBits)
-            result.setBits(shiftRight(val, (PrecBits - Prec)));
-        else
-            result.setBits(shiftLeft(val, (Prec - PrecBits)));
-        return result;
-    }
-#endif
-
-    inline QFixedPt<PrecBits>& operator+=(const QFixedPt<PrecBits>& value)
-        { val += value.val; return *this; }
-    inline QFixedPt<PrecBits>& operator+=(int value)
-        { val += (value << PrecBits); return *this; }
-    inline QFixedPt<PrecBits>& operator+=(qreal value)
-        { val += int(value * (1 << PrecBits)); return *this; }
-
-    inline QFixedPt<PrecBits>& operator-=(const QFixedPt<PrecBits>& value)
-        { val -= value.val; return *this; }
-    inline QFixedPt<PrecBits>& operator-=(int value)
-        { val -= (value << PrecBits); return *this; }
-    inline QFixedPt<PrecBits>& operator-=(qreal value)
-        { val -= int(value * (1 << PrecBits)); return *this; }
-
-    inline QFixedPt<PrecBits>& operator*=(const QFixedPt<PrecBits>& value)
-        { val = mul(val, value.val); return *this; }
-    inline QFixedPt<PrecBits>& operator*=(int value)
-        { val = mul(val, (value << PrecBits)); return *this; }
-    inline QFixedPt<PrecBits>& operator*=(qreal value)
-        { val = mul(val, int(value * (1 << PrecBits))); return *this; }
-
-    inline QFixedPt<PrecBits>& operator/=(const QFixedPt<PrecBits>& value)
-        { val = div(val, value.val); return *this; }
-    inline QFixedPt<PrecBits>& operator/=(int value)
-        { val = div(val, (value << PrecBits)); return *this; }
-    inline QFixedPt<PrecBits>& operator/=(qreal value)
-        { val = div(val, int(value * (1 << PrecBits))); return *this; }
-
-    inline QFixedPt<PrecBits>& operator<<=(int value)
-        { val <<= value; return *this; }
-    inline QFixedPt<PrecBits>& operator>>=(int value)
-        { val >>= value; return *this; }
-
-    inline QFixedPt<PrecBits> operator<<(int value) const
-        { QFixedPt<PrecBits> result; result.val = val << value; return result; }
-    inline QFixedPt<PrecBits> operator>>(int value) const
-        { QFixedPt<PrecBits> result; result.val = val >> value; return result; }
-
-    inline bool operator==(const QFixedPt<PrecBits>& value) const
-        { return val == value.val; }
-    inline bool operator!=(const QFixedPt<PrecBits>& value) const
-        { return val != value.val; }
-    inline bool operator<=(const QFixedPt<PrecBits>& value) const
-        { return val <= value.val; }
-    inline bool operator<(const QFixedPt<PrecBits>& value) const
-        { return val < value.val; }
-    inline bool operator>=(const QFixedPt<PrecBits>& value) const
-        { return val >= value.val; }
-    inline bool operator>(const QFixedPt<PrecBits>& value) const
-        { return val > value.val; }
-
-    inline QFixedPt<PrecBits> operator+(const QFixedPt<PrecBits>& value) const
-        { QFixedPt<PrecBits> result;
-          result.val = val + value.val; return result; }
-    inline QFixedPt<PrecBits> operator+(int value) const
-        { QFixedPt<PrecBits> result;
-          result.val = val + (value << PrecBits); return result; }
-    inline QFixedPt<PrecBits> operator+(qreal value) const
-        { QFixedPt<PrecBits> result;
-          result.val = val + int(value * (1 << PrecBits)); return result; }
-
-    inline QFixedPt<PrecBits> operator-(const QFixedPt<PrecBits>& value) const
-        { QFixedPt<PrecBits> result;
-          result.val = val - value.val; return result; }
-    inline QFixedPt<PrecBits> operator-(int value) const
-        { QFixedPt<PrecBits> result;
-          result.val = val - (value << PrecBits); return result; }
-    inline QFixedPt<PrecBits> operator-(qreal value) const
-        { QFixedPt<PrecBits> result;
-          result.val = val - int(value * (1 << PrecBits)); return result; }
-
-    inline QFixedPt<PrecBits> operator*(const QFixedPt<PrecBits>& value) const
-        { QFixedPt<PrecBits> result;
-          result.val = mul(val, value.val); return result; }
-    inline QFixedPt<PrecBits> operator*(int value) const
-        { QFixedPt<PrecBits> result;
-          result.val = mul(val, (value << PrecBits)); return result; }
-    inline QFixedPt<PrecBits> operator*(qreal value) const
-        { QFixedPt<PrecBits> result;
-          result.val = mul(val, int(value * (1 << PrecBits))); return result; }
-
-    inline QFixedPt<PrecBits> operator/(const QFixedPt<PrecBits>& value) const
-        { QFixedPt<PrecBits> result;
-          result.val = div(val, value.val); return result; }
-    inline QFixedPt<PrecBits> operator/(int value) const
-        { QFixedPt<PrecBits> result;
-          result.val = div(val, (value << PrecBits)); return result; }
-    inline QFixedPt<PrecBits> operator/(qreal value) const
-        { QFixedPt<PrecBits> result;
-          result.val = div(val, int(value * (1 << PrecBits))); return result; }
-
-    inline QFixedPt<PrecBits> operator-() const
-        { QFixedPt<PrecBits> result; result.val = -val; return result; }
-
-    inline QFixedPt<PrecBits> sqrt() const;
-    inline qreal sqrtF() const;
-    inline QFixedPt<PrecBits> round() const;
-    inline QFixedPt<PrecBits> floor() const;
-    inline QFixedPt<PrecBits> ceil() const;
-    inline int truncate() const { return val >> PrecBits; }
-
-    inline int toInt() const { return (val + (1 << (PrecBits - 1))) >> PrecBits; }
-    inline qreal toReal() const { return qreal(val) / qreal(1 << PrecBits); }
-
-#if !defined(Q_NO_TEMPLATE_FRIENDS)
-    template <int Prec>
-    friend QFixedPt<Prec> operator/(int v1, const QFixedPt<Prec>& v2);
-    template <int Prec>
-    friend QFixedPt<Prec> operator/(qreal v1, const QFixedPt<Prec>& v2);
-
-private:
-#endif
-    int val;
-
-    inline static int mul(int v1, int v2)
-    {
-        return int((qint64(v1) * qint64(v2)) >> PrecBits);
-    }
-
-    inline static int div(int v1, int v2)
-    {
-        if (v2)
-            return int((qint64(v1) << PrecBits) / qint64(v2));
-        else
-            return 0;
-    }
-
-    // These are used by toPrecision() to avoid a silly gcc compiler warning
-    // related to negative shift values that will never actually be used.
-    inline static int shiftRight(int val, int shift)
-    {
-        return val >> shift;
-    }
-    inline static int shiftLeft(int val, int shift)
-    {
-        return val << shift;
-    }
-
-#if !defined(Q_NO_TEMPLATE_FRIENDS)
-    template <int Prec, int Prec2>
-    friend QFixedPt<Prec> qFixedPtToPrecision(const QFixedPt<Prec2>& value);
-#endif
-};
-
-template <int PrecBits>
-inline bool operator==(const QFixedPt<PrecBits>& v1, int v2)
-{
-    return v1.bits() == (v2 << PrecBits);
-}
-
-template <int PrecBits>
-inline bool operator==(int v1, const QFixedPt<PrecBits>& v2)
-{
-    return (v1 << PrecBits) == v2.bits();
-}
-
-template <int PrecBits>
-inline bool operator==(const QFixedPt<PrecBits>& v1, qreal v2)
-{
-    return v1.bits() == int(v2 * (1 << PrecBits));
-}
-
-template <int PrecBits>
-inline bool operator==(qreal v1, const QFixedPt<PrecBits>& v2)
-{
-    return int(v1 * (1 << PrecBits)) == v2.bits();
-}
-
-template <int PrecBits>
-inline bool operator!=(const QFixedPt<PrecBits>& v1, int v2)
-{
-    return v1.bits() != (v2 << PrecBits);
-}
-
-template <int PrecBits>
-inline bool operator!=(int v1, const QFixedPt<PrecBits>& v2)
-{
-    return (v1 << PrecBits) != v2.bits();
-}
-
-template <int PrecBits>
-inline bool operator!=(const QFixedPt<PrecBits>& v1, qreal v2)
-{
-    return v1.bits() != int(v2 * (1 << PrecBits));
-}
-
-template <int PrecBits>
-inline bool operator!=(qreal v1, const QFixedPt<PrecBits>& v2)
-{
-    return int(v1 * (1 << PrecBits)) != v2.bits();
-}
-
-template <int PrecBits>
-inline bool operator<=(const QFixedPt<PrecBits>& v1, int v2)
-{
-    return v1.bits() <= (v2 << PrecBits);
-}
-
-template <int PrecBits>
-inline bool operator<=(int v1, const QFixedPt<PrecBits>& v2)
-{
-    return (v1 << PrecBits) <= v2.bits();
-}
-
-template <int PrecBits>
-inline bool operator<=(const QFixedPt<PrecBits>& v1, qreal v2)
-{
-    return v1.bits() <= int(v2 * (1 << PrecBits));
-}
-
-template <int PrecBits>
-inline bool operator<=(qreal v1, const QFixedPt<PrecBits>& v2)
-{
-    return int(v1 * (1 << PrecBits)) <= v2.bits();
-}
-
-template <int PrecBits>
-inline bool operator<(const QFixedPt<PrecBits>& v1, int v2)
-{
-    return v1.bits() < (v2 << PrecBits);
-}
-
-template <int PrecBits>
-inline bool operator<(int v1, const QFixedPt<PrecBits>& v2)
-{
-    return (v1 << PrecBits) < v2.bits();
-}
-
-template <int PrecBits>
-inline bool operator<(const QFixedPt<PrecBits>& v1, qreal v2)
-{
-    return v1.bits() < int(v2 * (1 << PrecBits));
-}
-
-template <int PrecBits>
-inline bool operator<(qreal v1, const QFixedPt<PrecBits>& v2)
-{
-    return int(v1 * (1 << PrecBits)) < v2.bits();
-}
-
-template <int PrecBits>
-inline bool operator>=(const QFixedPt<PrecBits>& v1, int v2)
-{
-    return v1.bits() >= (v2 << PrecBits);
-}
-
-template <int PrecBits>
-inline bool operator>=(int v1, const QFixedPt<PrecBits>& v2)
-{
-    return (v1 << PrecBits) >= v2.bits();
-}
-
-template <int PrecBits>
-inline bool operator>=(const QFixedPt<PrecBits>& v1, qreal v2)
-{
-    return v1.bits() >= int(v2 * (1 << PrecBits));
-}
-
-template <int PrecBits>
-inline bool operator>=(qreal v1, const QFixedPt<PrecBits>& v2)
-{
-    return int(v1 * (1 << PrecBits)) >= v2.bits();
-}
-
-template <int PrecBits>
-inline bool operator>(const QFixedPt<PrecBits>& v1, int v2)
-{
-    return v1.bits() > (v2 << PrecBits);
-}
-
-template <int PrecBits>
-inline bool operator>(int v1, const QFixedPt<PrecBits>& v2)
-{
-    return (v1 << PrecBits) > v2.bits();
-}
-
-template <int PrecBits>
-inline bool operator>(const QFixedPt<PrecBits>& v1, qreal v2)
-{
-    return v1.bits() > int(v2 * (1 << PrecBits));
-}
-
-template <int PrecBits>
-inline bool operator>(qreal v1, const QFixedPt<PrecBits>& v2)
-{
-    return int(v1 * (1 << PrecBits)) > v2.bits();
-}
-
-template <int PrecBits>
-inline QFixedPt<PrecBits> operator+(int v1, const QFixedPt<PrecBits>& v2)
-{
-    return v2 + v1;
-}
-
-template <int PrecBits>
-inline QFixedPt<PrecBits> operator+(qreal v1, const QFixedPt<PrecBits>& v2)
-{
-    return v2 + v1;
-}
-
-template <int PrecBits>
-inline QFixedPt<PrecBits> operator-(int v1, const QFixedPt<PrecBits>& v2)
-{
-    return -(v2 - v1);
-}
-
-template <int PrecBits>
-inline QFixedPt<PrecBits> operator-(qreal v1, const QFixedPt<PrecBits>& v2)
-{
-    return -(v2 - v1);
-}
-
-template <int PrecBits>
-inline QFixedPt<PrecBits> operator*(int v1, const QFixedPt<PrecBits>& v2)
-{
-    return v2 * v1;
-}
-
-template <int PrecBits>
-inline QFixedPt<PrecBits> operator*(qreal v1, const QFixedPt<PrecBits>& v2)
-{
-    return v2 * v1;
-}
-
-template <int PrecBits>
-inline QFixedPt<PrecBits> operator/(int v1, const QFixedPt<PrecBits>& v2)
-{
-    QFixedPt<PrecBits> result;
-    result.val = QFixedPt<PrecBits>::div(v1 << PrecBits, v2.val);
-    return result;
-}
-
-template <int PrecBits>
-inline QFixedPt<PrecBits> operator/(qreal v1, const QFixedPt<PrecBits>& v2)
-{
-    QFixedPt<PrecBits> result;
-    result.val = QFixedPt<PrecBits>::div(int(v1 * (1 << PrecBits)), v2.val);
-    return result;
-}
-
-template <int PrecBits>
-inline QFixedPt<PrecBits> QFixedPt<PrecBits>::sqrt() const
-{
-    QFixedPt<PrecBits> result;
-    result.val = int(qt_math3d_fixed_sqrt
-        (qint64(val) << (PrecBits * 2)) >> (PrecBits / 2));
-    return result;
-}
-
-template <int PrecBits>
-inline qreal QFixedPt<PrecBits>::sqrtF() const
-{
-    return qt_math3d_fixed_sqrt
-        (qint64(val) << (PrecBits * 2)) / (qreal)(1 << (PrecBits + (PrecBits / 2)));
-}
-
-template <int PrecBits>
-inline QFixedPt<PrecBits> QFixedPt<PrecBits>::round() const
-{
-    QFixedPt<PrecBits> result;
-    result.val = (val + (1 << (PrecBits - 1))) & ~((1 << PrecBits) - 1);
-    return result;
-}
-
-template <int PrecBits>
-inline QFixedPt<PrecBits> QFixedPt<PrecBits>::floor() const
-{
-    QFixedPt<PrecBits> result;
-    result.val = val & ~((1 << PrecBits) - 1);
-    return result;
-}
-
-template <int PrecBits>
-inline QFixedPt<PrecBits> QFixedPt<PrecBits>::ceil() const
-{
-    QFixedPt<PrecBits> result;
-    result.val = (val + (1 << PrecBits) - 1) & ~((1 << PrecBits) - 1);
-    return result;
-}
-
-template <int PrecBits>
-inline int qCeil(const QFixedPt<PrecBits>& value)
-{
-    return value.ceil().bits() >> PrecBits;
-}
-
-template <int PrecBits>
-inline int qFloor(const QFixedPt<PrecBits>& value)
-{
-    return value.floor().bits() >> PrecBits;
-}
-
-template <int PrecBits>
-inline int qRound(const QFixedPt<PrecBits>& value)
-{
-    return value.round().bits() >> PrecBits;
-}
-
-template <int PrecBits>
-inline bool qFuzzyCompare(const QFixedPt<PrecBits>& v1, const QFixedPt<PrecBits>& v2, int compareBits = (PrecBits / 4))
-{
-    return ((v1.bits() ^ v2.bits()) & ~((1 << compareBits) - 1)) == 0;
-}
-
-template <int PrecBits>
-inline bool qIsNull(const QFixedPt<PrecBits>& v)
-{
-    return v.bits() == 0;
-}
-
-template <int Prec, int PrecBits>
-QFixedPt<Prec> qFixedPtToPrecision(const QFixedPt<PrecBits>& value)
-{
-    QFixedPt<Prec> result;
-    if (Prec < PrecBits)
-        result.setBits(QFixedPt<PrecBits>::shiftRight(value.bits(), (PrecBits - Prec)));
-    else
-        result.setBits(QFixedPt<PrecBits>::shiftLeft(value.bits(), (Prec - PrecBits)));
-    return result;
-}
-
-template <int PrecBits>
-inline QDebug &operator<<(QDebug &dbg, const QFixedPt<PrecBits> &f)
-{
-    return dbg << f.toReal();
-}
-
-Q_DECLARE_TYPEINFO(QFixedPt<0>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<1>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<2>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<3>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<4>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<5>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<6>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<7>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<8>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<9>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<10>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<11>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<12>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<13>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<14>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<15>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<16>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<17>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<18>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<19>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<20>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<21>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<22>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<23>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<24>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<25>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<26>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<27>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<28>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<29>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<30>, Q_PRIMITIVE_TYPE);
-Q_DECLARE_TYPEINFO(QFixedPt<31>, Q_PRIMITIVE_TYPE);
-
-QT_END_NAMESPACE
-
-QT_END_HEADER
-
-#endif
diff --git a/src/gui/math3d/qgenericmatrix.h b/src/gui/math3d/qgenericmatrix.h
index dbeaaf3..d0b22de 100644
--- a/src/gui/math3d/qgenericmatrix.h
+++ b/src/gui/math3d/qgenericmatrix.h
@@ -42,8 +42,8 @@
 #ifndef QGENERICMATRIX_H
 #define QGENERICMATRIX_H
 
-#include <QtGui/qmath3dglobal.h>
 #include <QtCore/qmetatype.h>
+#include <QtCore/qdebug.h>
 
 QT_BEGIN_HEADER
 
@@ -134,7 +134,7 @@ template <int N, int M, typename T, typename InnerT>
 Q_INLINE_TEMPLATE T QGenericMatrix<N, M, T, InnerT>::operator()(int row, int column) const
 {
     Q_ASSERT(row >= 0 && row < M && column >= 0 && column < N);
-    return qt_math3d_convert<T, InnerT>(m[column][row]);
+    return T(m[column][row]);
 }
 
 template <int N, int M, typename T, typename InnerT>
@@ -323,18 +323,18 @@ Q_OUTOFLINE_TEMPLATE void QGenericMatrix<N, M, T, InnerT>::toValueArray(T *value
 {
     for (int col = 0; col < N; ++col)
         for (int row = 0; row < M; ++row)
-            values[row * N + col] = qt_math3d_convert<T, InnerT>(m[col][row]);
+            values[row * N + col] = T(m[col][row]);
 }
 
 // Define aliases for the useful variants of QGenericMatrix.
-typedef QGenericMatrix<2, 2, qreal, qrealinner> QMatrix2x2;
-typedef QGenericMatrix<2, 3, qreal, qrealinner> QMatrix2x3;
-typedef QGenericMatrix<2, 4, qreal, qrealinner> QMatrix2x4;
-typedef QGenericMatrix<3, 2, qreal, qrealinner> QMatrix3x2;
-typedef QGenericMatrix<3, 3, qreal, qrealinner> QMatrix3x3;
-typedef QGenericMatrix<3, 4, qreal, qrealinner> QMatrix3x4;
-typedef QGenericMatrix<4, 2, qreal, qrealinner> QMatrix4x2;
-typedef QGenericMatrix<4, 3, qreal, qrealinner> QMatrix4x3;
+typedef QGenericMatrix<2, 2, qreal, float> QMatrix2x2;
+typedef QGenericMatrix<2, 3, qreal, float> QMatrix2x3;
+typedef QGenericMatrix<2, 4, qreal, float> QMatrix2x4;
+typedef QGenericMatrix<3, 2, qreal, float> QMatrix3x2;
+typedef QGenericMatrix<3, 3, qreal, float> QMatrix3x3;
+typedef QGenericMatrix<3, 4, qreal, float> QMatrix3x4;
+typedef QGenericMatrix<4, 2, qreal, float> QMatrix4x2;
+typedef QGenericMatrix<4, 3, qreal, float> QMatrix4x3;
 
 #ifndef QT_NO_DEBUG_STREAM
 
diff --git a/src/gui/math3d/qmath3dglobal.h b/src/gui/math3d/qmath3dglobal.h
deleted file mode 100644
index c2f7184..0000000
--- a/src/gui/math3d/qmath3dglobal.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
-**
-** This file is part of the $MODULE$ of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the either Technology Preview License Agreement or the
-** Beta Release License Agreement.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QMATH3DGLOBAL_H
-#define QMATH3DGLOBAL_H
-
-#include <QtCore/qglobal.h>
-#include <QtGui/qfixedpt.h>
-
-QT_BEGIN_HEADER
-
-QT_BEGIN_NAMESPACE
-
-QT_MODULE(Gui)
-
-// Detect the presence of a fixed-point OpenGL implementation.
-#if defined(QT_OPENGL_ES_1_CL) || defined(QT_NO_GL_FLOAT)
-#ifndef QT_GL_FIXED_PREFERRED
-#define QT_GL_FIXED_PREFERRED 1
-#endif
-#endif
-
-// QT_GL_FIXED_PREFERRED indicates that fixed-point should be
-// preferred over floating-point for operations requiring high performance.
-//
-// qreal is the floating-point type that should be used in
-// user-visible functions.  qrealinner is used internally where
-// values may be stored as either floating-point or fixed-point.
-// qrealinner will typically be the same size as GLfloat or GLfixed.
-#if defined(QT_GL_FIXED_PREFERRED)
-typedef QFixedPt<16> qrealinner;
-#else
-typedef float qrealinner;
-#endif
-
-// Explicit conversion operator, primarily for converting from
-// fixed point back to floating-point.  This is safer than
-// declaring conversion operators in the QFixedPt class.
-template <typename T1, typename T2>
-T1 qt_math3d_convert(T2 v)
-{
-    return T1(v);
-}
-template <>
-inline float qt_math3d_convert< float, QFixedPt<16> >(QFixedPt<16> v)
-{
-    return float(v.toReal());
-}
-template <>
-inline double qt_math3d_convert< double, QFixedPt<16> >(QFixedPt<16> v)
-{
-    return double(v.toReal());
-}
-template <>
-inline int qt_math3d_convert< int, QFixedPt<16> >(QFixedPt<16> v)
-{
-    return v.toInt();
-}
-
-QT_END_NAMESPACE
-
-QT_END_HEADER
-
-#endif
diff --git a/src/gui/math3d/qmath3dutil.cpp b/src/gui/math3d/qmath3dutil.cpp
deleted file mode 100644
index ad84162..0000000
--- a/src/gui/math3d/qmath3dutil.cpp
+++ /dev/null
@@ -1,194 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
-**
-** This file is part of the $MODULE$ of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the either Technology Preview License Agreement or the
-** Beta Release License Agreement.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qmath3dutil_p.h"
-
-QT_BEGIN_NAMESPACE
-
-#ifdef QT_GL_FIXED_PREFERRED
-
-// The table that follows was automatically generated by the following code:
-//
-//#include <math.h>
-//#include <stdio.h>
-//
-//int main()
-//{
-//    double angle;
-//    int count = 0;
-//    for (angle = 0.0; angle < 360.0; angle += 1.0) {
-//        if ((count % 4) == 0)
-//            printf("   ");
-//        printf(" qf2vt(%f)", sin(angle * M_PI / 180.0));
-//        ++count;
-//        if (count != 360)
-//            printf(",");
-//        if ((count % 4) == 0)
-//            printf("\n");
-//    }
-//    return 0;
-//}
-
-#define qf2vt(x) (int((x) * 65536.0))
-
-static int const sinTable[360] = {
-    qf2vt(0.000000), qf2vt(0.017452), qf2vt(0.034899), qf2vt(0.052336),
-    qf2vt(0.069756), qf2vt(0.087156), qf2vt(0.104528), qf2vt(0.121869),
-    qf2vt(0.139173), qf2vt(0.156434), qf2vt(0.173648), qf2vt(0.190809),
-    qf2vt(0.207912), qf2vt(0.224951), qf2vt(0.241922), qf2vt(0.258819),
-    qf2vt(0.275637), qf2vt(0.292372), qf2vt(0.309017), qf2vt(0.325568),
-    qf2vt(0.342020), qf2vt(0.358368), qf2vt(0.374607), qf2vt(0.390731),
-    qf2vt(0.406737), qf2vt(0.422618), qf2vt(0.438371), qf2vt(0.453990),
-    qf2vt(0.469472), qf2vt(0.484810), qf2vt(0.500000), qf2vt(0.515038),
-    qf2vt(0.529919), qf2vt(0.544639), qf2vt(0.559193), qf2vt(0.573576),
-    qf2vt(0.587785), qf2vt(0.601815), qf2vt(0.615661), qf2vt(0.629320),
-    qf2vt(0.642788), qf2vt(0.656059), qf2vt(0.669131), qf2vt(0.681998),
-    qf2vt(0.694658), qf2vt(0.707107), qf2vt(0.719340), qf2vt(0.731354),
-    qf2vt(0.743145), qf2vt(0.754710), qf2vt(0.766044), qf2vt(0.777146),
-    qf2vt(0.788011), qf2vt(0.798636), qf2vt(0.809017), qf2vt(0.819152),
-    qf2vt(0.829038), qf2vt(0.838671), qf2vt(0.848048), qf2vt(0.857167),
-    qf2vt(0.866025), qf2vt(0.874620), qf2vt(0.882948), qf2vt(0.891007),
-    qf2vt(0.898794), qf2vt(0.906308), qf2vt(0.913545), qf2vt(0.920505),
-    qf2vt(0.927184), qf2vt(0.933580), qf2vt(0.939693), qf2vt(0.945519),
-    qf2vt(0.951057), qf2vt(0.956305), qf2vt(0.961262), qf2vt(0.965926),
-    qf2vt(0.970296), qf2vt(0.974370), qf2vt(0.978148), qf2vt(0.981627),
-    qf2vt(0.984808), qf2vt(0.987688), qf2vt(0.990268), qf2vt(0.992546),
-    qf2vt(0.994522), qf2vt(0.996195), qf2vt(0.997564), qf2vt(0.998630),
-    qf2vt(0.999391), qf2vt(0.999848), qf2vt(1.000000), qf2vt(0.999848),
-    qf2vt(0.999391), qf2vt(0.998630), qf2vt(0.997564), qf2vt(0.996195),
-    qf2vt(0.994522), qf2vt(0.992546), qf2vt(0.990268), qf2vt(0.987688),
-    qf2vt(0.984808), qf2vt(0.981627), qf2vt(0.978148), qf2vt(0.974370),
-    qf2vt(0.970296), qf2vt(0.965926), qf2vt(0.961262), qf2vt(0.956305),
-    qf2vt(0.951057), qf2vt(0.945519), qf2vt(0.939693), qf2vt(0.933580),
-    qf2vt(0.927184), qf2vt(0.920505), qf2vt(0.913545), qf2vt(0.906308),
-    qf2vt(0.898794), qf2vt(0.891007), qf2vt(0.882948), qf2vt(0.874620),
-    qf2vt(0.866025), qf2vt(0.857167), qf2vt(0.848048), qf2vt(0.838671),
-    qf2vt(0.829038), qf2vt(0.819152), qf2vt(0.809017), qf2vt(0.798636),
-    qf2vt(0.788011), qf2vt(0.777146), qf2vt(0.766044), qf2vt(0.754710),
-    qf2vt(0.743145), qf2vt(0.731354), qf2vt(0.719340), qf2vt(0.707107),
-    qf2vt(0.694658), qf2vt(0.681998), qf2vt(0.669131), qf2vt(0.656059),
-    qf2vt(0.642788), qf2vt(0.629320), qf2vt(0.615661), qf2vt(0.601815),
-    qf2vt(0.587785), qf2vt(0.573576), qf2vt(0.559193), qf2vt(0.544639),
-    qf2vt(0.529919), qf2vt(0.515038), qf2vt(0.500000), qf2vt(0.484810),
-    qf2vt(0.469472), qf2vt(0.453990), qf2vt(0.438371), qf2vt(0.422618),
-    qf2vt(0.406737), qf2vt(0.390731), qf2vt(0.374607), qf2vt(0.358368),
-    qf2vt(0.342020), qf2vt(0.325568), qf2vt(0.309017), qf2vt(0.292372),
-    qf2vt(0.275637), qf2vt(0.258819), qf2vt(0.241922), qf2vt(0.224951),
-    qf2vt(0.207912), qf2vt(0.190809), qf2vt(0.173648), qf2vt(0.156434),
-    qf2vt(0.139173), qf2vt(0.121869), qf2vt(0.104528), qf2vt(0.087156),
-    qf2vt(0.069756), qf2vt(0.052336), qf2vt(0.034899), qf2vt(0.017452),
-    qf2vt(0.000000), qf2vt(-0.017452), qf2vt(-0.034899), qf2vt(-0.052336),
-    qf2vt(-0.069756), qf2vt(-0.087156), qf2vt(-0.104528), qf2vt(-0.121869),
-    qf2vt(-0.139173), qf2vt(-0.156434), qf2vt(-0.173648), qf2vt(-0.190809),
-    qf2vt(-0.207912), qf2vt(-0.224951), qf2vt(-0.241922), qf2vt(-0.258819),
-    qf2vt(-0.275637), qf2vt(-0.292372), qf2vt(-0.309017), qf2vt(-0.325568),
-    qf2vt(-0.342020), qf2vt(-0.358368), qf2vt(-0.374607), qf2vt(-0.390731),
-    qf2vt(-0.406737), qf2vt(-0.422618), qf2vt(-0.438371), qf2vt(-0.453990),
-    qf2vt(-0.469472), qf2vt(-0.484810), qf2vt(-0.500000), qf2vt(-0.515038),
-    qf2vt(-0.529919), qf2vt(-0.544639), qf2vt(-0.559193), qf2vt(-0.573576),
-    qf2vt(-0.587785), qf2vt(-0.601815), qf2vt(-0.615661), qf2vt(-0.629320),
-    qf2vt(-0.642788), qf2vt(-0.656059), qf2vt(-0.669131), qf2vt(-0.681998),
-    qf2vt(-0.694658), qf2vt(-0.707107), qf2vt(-0.719340), qf2vt(-0.731354),
-    qf2vt(-0.743145), qf2vt(-0.754710), qf2vt(-0.766044), qf2vt(-0.777146),
-    qf2vt(-0.788011), qf2vt(-0.798636), qf2vt(-0.809017), qf2vt(-0.819152),
-    qf2vt(-0.829038), qf2vt(-0.838671), qf2vt(-0.848048), qf2vt(-0.857167),
-    qf2vt(-0.866025), qf2vt(-0.874620), qf2vt(-0.882948), qf2vt(-0.891007),
-    qf2vt(-0.898794), qf2vt(-0.906308), qf2vt(-0.913545), qf2vt(-0.920505),
-    qf2vt(-0.927184), qf2vt(-0.933580), qf2vt(-0.939693), qf2vt(-0.945519),
-    qf2vt(-0.951057), qf2vt(-0.956305), qf2vt(-0.961262), qf2vt(-0.965926),
-    qf2vt(-0.970296), qf2vt(-0.974370), qf2vt(-0.978148), qf2vt(-0.981627),
-    qf2vt(-0.984808), qf2vt(-0.987688), qf2vt(-0.990268), qf2vt(-0.992546),
-    qf2vt(-0.994522), qf2vt(-0.996195), qf2vt(-0.997564), qf2vt(-0.998630),
-    qf2vt(-0.999391), qf2vt(-0.999848), qf2vt(-1.000000), qf2vt(-0.999848),
-    qf2vt(-0.999391), qf2vt(-0.998630), qf2vt(-0.997564), qf2vt(-0.996195),
-    qf2vt(-0.994522), qf2vt(-0.992546), qf2vt(-0.990268), qf2vt(-0.987688),
-    qf2vt(-0.984808), qf2vt(-0.981627), qf2vt(-0.978148), qf2vt(-0.974370),
-    qf2vt(-0.970296), qf2vt(-0.965926), qf2vt(-0.961262), qf2vt(-0.956305),
-    qf2vt(-0.951057), qf2vt(-0.945519), qf2vt(-0.939693), qf2vt(-0.933580),
-    qf2vt(-0.927184), qf2vt(-0.920505), qf2vt(-0.913545), qf2vt(-0.906308),
-    qf2vt(-0.898794), qf2vt(-0.891007), qf2vt(-0.882948), qf2vt(-0.874620),
-    qf2vt(-0.866025), qf2vt(-0.857167), qf2vt(-0.848048), qf2vt(-0.838671),
-    qf2vt(-0.829038), qf2vt(-0.819152), qf2vt(-0.809017), qf2vt(-0.798636),
-    qf2vt(-0.788011), qf2vt(-0.777146), qf2vt(-0.766044), qf2vt(-0.754710),
-    qf2vt(-0.743145), qf2vt(-0.731354), qf2vt(-0.719340), qf2vt(-0.707107),
-    qf2vt(-0.694658), qf2vt(-0.681998), qf2vt(-0.669131), qf2vt(-0.656059),
-    qf2vt(-0.642788), qf2vt(-0.629320), qf2vt(-0.615661), qf2vt(-0.601815),
-    qf2vt(-0.587785), qf2vt(-0.573576), qf2vt(-0.559193), qf2vt(-0.544639),
-    qf2vt(-0.529919), qf2vt(-0.515038), qf2vt(-0.500000), qf2vt(-0.484810),
-    qf2vt(-0.469472), qf2vt(-0.453990), qf2vt(-0.438371), qf2vt(-0.422618),
-    qf2vt(-0.406737), qf2vt(-0.390731), qf2vt(-0.374607), qf2vt(-0.358368),
-    qf2vt(-0.342020), qf2vt(-0.325568), qf2vt(-0.309017), qf2vt(-0.292372),
-    qf2vt(-0.275637), qf2vt(-0.258819), qf2vt(-0.241922), qf2vt(-0.224951),
-    qf2vt(-0.207912), qf2vt(-0.190809), qf2vt(-0.173648), qf2vt(-0.156434),
-    qf2vt(-0.139173), qf2vt(-0.121869), qf2vt(-0.104528), qf2vt(-0.087156),
-    qf2vt(-0.069756), qf2vt(-0.052336), qf2vt(-0.034899), qf2vt(-0.017452)
-};
-
-void qt_math3d_sincos(qreal angle, qrealinner *s, qrealinner *c)
-{
-    if (angle == qFloor(angle)) {
-        // The angle is an integer number of degrees, so look up the results.
-        int a = (int)angle;
-        if (a >= 0)
-            a = (a % 360);
-        else
-            a = 360 - (-a % 360);
-        s->setBits(sinTable[a]);
-        c->setBits(sinTable[(a + 90) % 360]);
-    } else {
-        qreal a = angle * M_PI / 180.0f;
-        *s = qSin(a);
-        *c = qCos(a);
-    }
-}
-
-#else
-
-void qt_math3d_sincos(qreal angle, qrealinner *s, qrealinner *c)
-{
-    qreal a = angle * M_PI / 180.0f;
-    *s = qSin(a);
-    *c = qCos(a);
-}
-
-#endif
-
-QT_END_NAMESPACE
diff --git a/src/gui/math3d/qmath3dutil_p.h b/src/gui/math3d/qmath3dutil_p.h
deleted file mode 100644
index fa4c156..0000000
--- a/src/gui/math3d/qmath3dutil_p.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
-**
-** This file is part of the $MODULE$ of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the either Technology Preview License Agreement or the
-** Beta Release License Agreement.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QMATH3DUTIL_P_H
-#define QMATH3DUTIL_P_H
-
-#include <QtGui/qmath3dglobal.h>
-#include <QtCore/qmath.h>
-
-QT_BEGIN_NAMESPACE
-
-#ifdef QT_GL_FIXED_PREFERRED
-#define qvtsqrt(x)  ((x).sqrtF())
-#else
-#define qvtsqrt(x)  qSqrt((x))
-#endif
-
-#ifndef M_PI
-#define M_PI 3.14159265358979323846
-#endif
-
-void qt_math3d_sincos(qreal degrees, qrealinner *s, qrealinner *c);
-
-#ifdef QT_GL_FIXED_PREFERRED
-
-inline qrealinner qf2vt_round(qreal x)
-{
-    QFixedPt<16> result;
-    if (x >= 0.0f)
-        result.setBits(int(x * 65536.0f + 0.5f));
-    else
-        result.setBits(int(x * 65536.0f - 0.5f));
-    return result;
-}
-
-// Helper macros for computing dot products without losing precision.
-// In fixed-point mode, a 64-bit intermediate result is used.
-#define qvtmul64(x,y)   ((qint64((x).bits())) * (qint64((y).bits())))
-#define qvtsqrt64(x)    \
-    (qt_math3d_fixed_sqrt((x) << 16) / (qreal)(1 << 24))
-#define qvtdot64(x)     ((x) / (qreal)(((qint64)1) << 32))
-
-#else
-
-inline qrealinner qf2vt_round(qreal x)
-{
-    return x;
-}
-
-#define qvtmul64(x,y)   ((x) * (y))
-#define qvtsqrt64(x)    (qvtsqrt((x)))
-#define qvtdot64(x)     ((x))
-
-#endif
-
-QT_END_NAMESPACE
-
-#endif
diff --git a/src/gui/math3d/qmatrix4x4.cpp b/src/gui/math3d/qmatrix4x4.cpp
index bcb3066..c2873e0 100644
--- a/src/gui/math3d/qmatrix4x4.cpp
+++ b/src/gui/math3d/qmatrix4x4.cpp
@@ -40,7 +40,6 @@
 ****************************************************************************/
 
 #include "qmatrix4x4.h"
-#include "qmath3dutil_p.h"
 #include <QtCore/qmath.h>
 #include <QtGui/qmatrix.h>
 #include <QtGui/qtransform.h>
@@ -106,7 +105,7 @@ QMatrix4x4::QMatrix4x4(const qreal *values)
 #if !defined(QT_NO_MEMBER_TEMPLATES) || defined(Q_QDOC)
 
 /*!
-    \fn QMatrix4x4::QMatrix4x4(const QGenericMatrix<N, M, qreal, qrealinner>& matrix)
+    \fn QMatrix4x4::QMatrix4x4(const QGenericMatrix<N, M, qreal, float>& matrix)
 
     Constructs a 4x4 matrix from the left-most 4 columns and top-most
     4 rows of \a matrix.  If \a matrix has less than 4 columns or rows,
@@ -117,7 +116,7 @@ QMatrix4x4::QMatrix4x4(const qreal *values)
 */
 
 /*!
-    \fn QGenericMatrix<N, M, qreal, qrealinner> QMatrix4x4::toGenericMatrix() const
+    \fn QGenericMatrix<N, M, qreal, float> QMatrix4x4::toGenericMatrix() const
 
     Constructs a NxM generic matrix from the left-most N columns and
     top-most M rows of this 4x4 matrix.  If N or M is greater than 4,
@@ -130,7 +129,7 @@ QMatrix4x4::QMatrix4x4(const qreal *values)
 #endif
 
 /*!
-    \fn QMatrix4x4 qGenericMatrixToMatrix4x4(const QGenericMatrix<N, M, qreal, qrealinner>& matrix)
+    \fn QMatrix4x4 qGenericMatrixToMatrix4x4(const QGenericMatrix<N, M, qreal, float>& matrix)
     \relates QMatrix4x4
 
     Returns a 4x4 matrix constructed from the left-most 4 columns and
@@ -142,7 +141,7 @@ QMatrix4x4::QMatrix4x4(const qreal *values)
 */
 
 /*!
-    \fn QGenericMatrix<N, M, qreal, qrealinner> qGenericMatrixFromMatrix4x4(const QMatrix4x4& matrix)
+    \fn QGenericMatrix<N, M, qreal, float> qGenericMatrixFromMatrix4x4(const QMatrix4x4& matrix)
     \relates QMatrix4x4
 
     Returns a NxM generic matrix constructed from the left-most N columns
@@ -156,7 +155,7 @@ QMatrix4x4::QMatrix4x4(const qreal *values)
 /*!
     \internal
 */
-QMatrix4x4::QMatrix4x4(const qrealinner *values, int cols, int rows)
+QMatrix4x4::QMatrix4x4(const float *values, int cols, int rows)
 {
     for (int col = 0; col < 4; ++col) {
         for (int row = 0; row < 4; ++row) {
@@ -244,7 +243,7 @@ QMatrix4x4::QMatrix4x4(const QTransform& transform)
 */
 
 /*!
-    \fn qrealinner& QMatrix4x4::operator()(int row, int column)
+    \fn float& QMatrix4x4::operator()(int row, int column)
 
     Returns a reference to the element at position (\a row, \a column)
     in this matrix so that the element can be assigned to.
@@ -316,8 +315,8 @@ QMatrix4x4::QMatrix4x4(const QTransform& transform)
 //     | A B C |
 // M = | D E F |   det(M) = A * (EI - HF) - B * (DI - GF) + C * (DH - GE)
 //     | G H I |
-static inline qrealinner matrixDet3
-    (const qrealinner m[4][4], int col0, int col1, int col2,
+static inline float matrixDet3
+    (const float m[4][4], int col0, int col1, int col2,
      int row0, int row1, int row2)
 {
     return m[col0][row0] *
@@ -332,9 +331,9 @@ static inline qrealinner matrixDet3
 }
 
 // Calculate the determinant of a 4x4 matrix.
-static inline qrealinner matrixDet4(const qrealinner m[4][4])
+static inline float matrixDet4(const float m[4][4])
 {
-    qrealinner det;
+    float det;
     det  = m[0][0] * matrixDet3(m, 1, 2, 3, 1, 2, 3);
     det -= m[1][0] * matrixDet3(m, 0, 2, 3, 1, 2, 3);
     det += m[2][0] * matrixDet3(m, 0, 1, 3, 1, 2, 3);
@@ -347,7 +346,7 @@ static inline qrealinner matrixDet4(const qrealinner m[4][4])
 */
 qreal QMatrix4x4::determinant() const
 {
-    return qt_math3d_convert<qreal, qrealinner>(matrixDet4(m));
+    return qreal(matrixDet4(m));
 }
 
 /*!
@@ -386,13 +385,13 @@ QMatrix4x4 QMatrix4x4::inverted(bool *invertible) const
 
     QMatrix4x4 inv(1); // The "1" says to not load the identity.
 
-    qrealinner det = matrixDet4(m);
+    float det = matrixDet4(m);
     if (det == 0.0f) {
         if (invertible)
             *invertible = false;
         return QMatrix4x4();
     }
-    det = qrealinner(1.0f) / det;
+    det = 1.0f / det;
 
     inv.m[0][0] =  matrixDet3(m, 1, 2, 3, 1, 2, 3) * det;
     inv.m[0][1] = -matrixDet3(m, 0, 2, 3, 1, 2, 3) * det;
@@ -434,18 +433,18 @@ QMatrix3x3 QMatrix4x4::normalMatrix() const
     } else if (flagBits == Scale || flagBits == (Translation | Scale)) {
         if (m[0][0] == 0.0f || m[1][1] == 0.0f || m[2][2] == 0.0f)
             return inv;
-        inv.data()[0] = qrealinner(1.0f) / m[0][0];
-        inv.data()[4] = qrealinner(1.0f) / m[1][1];
-        inv.data()[8] = qrealinner(1.0f) / m[2][2];
+        inv.data()[0] = 1.0f / m[0][0];
+        inv.data()[4] = 1.0f / m[1][1];
+        inv.data()[8] = 1.0f / m[2][2];
         return inv;
     }
 
-    qrealinner det = matrixDet3(m, 0, 1, 2, 0, 1, 2);
+    float det = matrixDet3(m, 0, 1, 2, 0, 1, 2);
     if (det == 0.0f)
         return inv;
-    det = qrealinner(1.0f) / det;
+    det = 1.0f / det;
 
-    qrealinner *invm = inv.data();
+    float *invm = inv.data();
 
     // Invert and transpose in a single step.
     invm[0 + 0 * 3] =  (m[1][1] * m[2][2] - m[2][1] * m[1][2]) * det;
@@ -507,23 +506,22 @@ QMatrix4x4 QMatrix4x4::transposed() const
 */
 QMatrix4x4& QMatrix4x4::operator/=(qreal divisor)
 {
-    qrealinner d(divisor);
-    m[0][0] /= d;
-    m[0][1] /= d;
-    m[0][2] /= d;
-    m[0][3] /= d;
-    m[1][0] /= d;
-    m[1][1] /= d;
-    m[1][2] /= d;
-    m[1][3] /= d;
-    m[2][0] /= d;
-    m[2][1] /= d;
-    m[2][2] /= d;
-    m[2][3] /= d;
-    m[3][0] /= d;
-    m[3][1] /= d;
-    m[3][2] /= d;
-    m[3][3] /= d;
+    m[0][0] /= divisor;
+    m[0][1] /= divisor;
+    m[0][2] /= divisor;
+    m[0][3] /= divisor;
+    m[1][0] /= divisor;
+    m[1][1] /= divisor;
+    m[1][2] /= divisor;
+    m[1][3] /= divisor;
+    m[2][0] /= divisor;
+    m[2][1] /= divisor;
+    m[2][2] /= divisor;
+    m[2][3] /= divisor;
+    m[3][0] /= divisor;
+    m[3][1] /= divisor;
+    m[3][2] /= divisor;
+    m[3][3] /= divisor;
     flagBits = General;
     return *this;
 }
@@ -665,23 +663,22 @@ QMatrix4x4& QMatrix4x4::operator/=(qreal divisor)
 QMatrix4x4 operator/(const QMatrix4x4& matrix, qreal divisor)
 {
     QMatrix4x4 m(1); // The "1" says to not load the identity.
-    qrealinner d(divisor);
-    m.m[0][0] = matrix.m[0][0] / d;
-    m.m[0][1] = matrix.m[0][1] / d;
-    m.m[0][2] = matrix.m[0][2] / d;
-    m.m[0][3] = matrix.m[0][3] / d;
-    m.m[1][0] = matrix.m[1][0] / d;
-    m.m[1][1] = matrix.m[1][1] / d;
-    m.m[1][2] = matrix.m[1][2] / d;
-    m.m[1][3] = matrix.m[1][3] / d;
-    m.m[2][0] = matrix.m[2][0] / d;
-    m.m[2][1] = matrix.m[2][1] / d;
-    m.m[2][2] = matrix.m[2][2] / d;
-    m.m[2][3] = matrix.m[2][3] / d;
-    m.m[3][0] = matrix.m[3][0] / d;
-    m.m[3][1] = matrix.m[3][1] / d;
-    m.m[3][2] = matrix.m[3][2] / d;
-    m.m[3][3] = matrix.m[3][3] / d;
+    m.m[0][0] = matrix.m[0][0] / divisor;
+    m.m[0][1] = matrix.m[0][1] / divisor;
+    m.m[0][2] = matrix.m[0][2] / divisor;
+    m.m[0][3] = matrix.m[0][3] / divisor;
+    m.m[1][0] = matrix.m[1][0] / divisor;
+    m.m[1][1] = matrix.m[1][1] / divisor;
+    m.m[1][2] = matrix.m[1][2] / divisor;
+    m.m[1][3] = matrix.m[1][3] / divisor;
+    m.m[2][0] = matrix.m[2][0] / divisor;
+    m.m[2][1] = matrix.m[2][1] / divisor;
+    m.m[2][2] = matrix.m[2][2] / divisor;
+    m.m[2][3] = matrix.m[2][3] / divisor;
+    m.m[3][0] = matrix.m[3][0] / divisor;
+    m.m[3][1] = matrix.m[3][1] / divisor;
+    m.m[3][2] = matrix.m[3][2] / divisor;
+    m.m[3][3] = matrix.m[3][3] / divisor;
     return m;
 }
 
@@ -703,9 +700,9 @@ QMatrix4x4 operator/(const QMatrix4x4& matrix, qreal divisor)
 */
 QMatrix4x4& QMatrix4x4::scale(const QVector3D& vector)
 {
-    qrealinner vx = vector.xp;
-    qrealinner vy = vector.yp;
-    qrealinner vz = vector.zp;
+    float vx = vector.xp;
+    float vy = vector.yp;
+    float vz = vector.zp;
     if (flagBits == Identity) {
         m[0][0] = vx;
         m[1][1] = vy;
@@ -749,9 +746,9 @@ QMatrix4x4& QMatrix4x4::scale(const QVector3D& vector)
 */
 QMatrix4x4& QMatrix4x4::scale(qreal x, qreal y, qreal z)
 {
-    qrealinner vx(x);
-    qrealinner vy(y);
-    qrealinner vz(z);
+    float vx(x);
+    float vy(y);
+    float vz(z);
     if (flagBits == Identity) {
         m[0][0] = vx;
         m[1][1] = vy;
@@ -794,34 +791,33 @@ QMatrix4x4& QMatrix4x4::scale(qreal x, qreal y, qreal z)
 */
 QMatrix4x4& QMatrix4x4::scale(qreal factor)
 {
-    qrealinner f(factor);
     if (flagBits == Identity) {
-        m[0][0] = f;
-        m[1][1] = f;
-        m[2][2] = f;
+        m[0][0] = factor;
+        m[1][1] = factor;
+        m[2][2] = factor;
         flagBits = Scale;
     } else if (flagBits == Scale || flagBits == (Scale | Translation)) {
-        m[0][0] *= f;
-        m[1][1] *= f;
-        m[2][2] *= f;
+        m[0][0] *= factor;
+        m[1][1] *= factor;
+        m[2][2] *= factor;
     } else if (flagBits == Translation) {
-        m[0][0] = f;
-        m[1][1] = f;
-        m[2][2] = f;
+        m[0][0] = factor;
+        m[1][1] = factor;
+        m[2][2] = factor;
         flagBits |= Scale;
     } else {
-        m[0][0] *= f;
-        m[0][1] *= f;
-        m[0][2] *= f;
-        m[0][3] *= f;
-        m[1][0] *= f;
-        m[1][1] *= f;
-        m[1][2] *= f;
-        m[1][3] *= f;
-        m[2][0] *= f;
-        m[2][1] *= f;
-        m[2][2] *= f;
-        m[2][3] *= f;
+        m[0][0] *= factor;
+        m[0][1] *= factor;
+        m[0][2] *= factor;
+        m[0][3] *= factor;
+        m[1][0] *= factor;
+        m[1][1] *= factor;
+        m[1][2] *= factor;
+        m[1][3] *= factor;
+        m[2][0] *= factor;
+        m[2][1] *= factor;
+        m[2][2] *= factor;
+        m[2][3] *= factor;
         flagBits = General;
     }
     return *this;
@@ -836,9 +832,9 @@ QMatrix4x4& QMatrix4x4::scale(qreal factor)
 */
 QMatrix4x4& QMatrix4x4::translate(const QVector3D& vector)
 {
-    qrealinner vx = vector.xp;
-    qrealinner vy = vector.yp;
-    qrealinner vz = vector.zp;
+    float vx = vector.xp;
+    float vy = vector.yp;
+    float vz = vector.zp;
     if (flagBits == Identity) {
         m[3][0] = vx;
         m[3][1] = vy;
@@ -882,9 +878,9 @@ QMatrix4x4& QMatrix4x4::translate(const QVector3D& vector)
 */
 QMatrix4x4& QMatrix4x4::translate(qreal x, qreal y, qreal z)
 {
-    qrealinner vx(x);
-    qrealinner vy(y);
-    qrealinner vz(z);
+    float vx(x);
+    float vy(y);
+    float vz(z);
     if (flagBits == Identity) {
         m[3][0] = vx;
         m[3][1] = vy;
@@ -931,6 +927,10 @@ QMatrix4x4& QMatrix4x4::rotate(qreal angle, const QVector3D& vector)
 
 #endif
 
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
 /*!
     \overload
 
@@ -942,8 +942,10 @@ QMatrix4x4& QMatrix4x4::rotate(qreal angle, const QVector3D& vector)
 QMatrix4x4& QMatrix4x4::rotate(qreal angle, qreal x, qreal y, qreal z)
 {
     QMatrix4x4 m(1); // The "1" says to not load the identity.
-    qrealinner c, s, ic;
-    qt_math3d_sincos(angle, &s, &c);
+    qreal a = angle * M_PI / 180.0f;
+    qreal c = qCos(a);
+    qreal s = qSin(a);
+    qreal ic;
     bool quick = false;
     if (x == 0.0f) {
         if (y == 0.0f) {
@@ -993,27 +995,24 @@ QMatrix4x4& QMatrix4x4::rotate(qreal angle, qreal x, qreal y, qreal z)
         quick = true;
     }
     if (!quick) {
-        qrealinner vx(x);
-        qrealinner vy(y);
-        qrealinner vz(z);
-        qrealinner len(qvtsqrt(vx * vx + vy * vy + vz * vz));
+        qreal len = qSqrt(x * x + y * y + z * z);
         if (len != 0) {
-            vx /= len;
-            vy /= len;
-            vz /= len;
+            x /= len;
+            y /= len;
+            z /= len;
         }
         ic = 1.0f - c;
-        m.m[0][0] = vx * vx * ic + c;
-        m.m[1][0] = vx * vy * ic - vz * s;
-        m.m[2][0] = vx * vz * ic + vy * s;
+        m.m[0][0] = x * x * ic + c;
+        m.m[1][0] = x * y * ic - z * s;
+        m.m[2][0] = x * z * ic + y * s;
         m.m[3][0] = 0.0f;
-        m.m[0][1] = vy * vx * ic + vz * s;
-        m.m[1][1] = vy * vy * ic + c;
-        m.m[2][1] = vy * vz * ic - vx * s;
+        m.m[0][1] = y * x * ic + z * s;
+        m.m[1][1] = y * y * ic + c;
+        m.m[2][1] = y * z * ic - x * s;
         m.m[3][1] = 0.0f;
-        m.m[0][2] = vx * vz * ic - vy * s;
-        m.m[1][2] = vy * vz * ic + vx * s;
-        m.m[2][2] = vz * vz * ic + c;
+        m.m[0][2] = x * z * ic - y * s;
+        m.m[1][2] = y * z * ic + x * s;
+        m.m[2][2] = z * z * ic + c;
         m.m[3][2] = 0.0f;
         m.m[0][3] = 0.0f;
         m.m[1][3] = 0.0f;
@@ -1043,15 +1042,15 @@ QMatrix4x4& QMatrix4x4::rotate(const QQuaternion& quaternion)
     // Algorithm from:
     // http://www.j3d.org/matrix_faq/matrfaq_latest.html#Q54
     QMatrix4x4 m(1);
-    qrealinner xx = quaternion.xp * quaternion.xp;
-    qrealinner xy = quaternion.xp * quaternion.yp;
-    qrealinner xz = quaternion.xp * quaternion.zp;
-    qrealinner xw = quaternion.xp * quaternion.wp;
-    qrealinner yy = quaternion.yp * quaternion.yp;
-    qrealinner yz = quaternion.yp * quaternion.zp;
-    qrealinner yw = quaternion.yp * quaternion.wp;
-    qrealinner zz = quaternion.zp * quaternion.zp;
-    qrealinner zw = quaternion.zp * quaternion.wp;
+    float xx = quaternion.xp * quaternion.xp;
+    float xy = quaternion.xp * quaternion.yp;
+    float xz = quaternion.xp * quaternion.zp;
+    float xw = quaternion.xp * quaternion.wp;
+    float yy = quaternion.yp * quaternion.yp;
+    float yz = quaternion.yp * quaternion.zp;
+    float yw = quaternion.yp * quaternion.wp;
+    float zz = quaternion.zp * quaternion.zp;
+    float zw = quaternion.zp * quaternion.wp;
     m.m[0][0] = 1.0f - 2 * (yy + zz);
     m.m[1][0] =        2 * (xy - zw);
     m.m[2][0] =        2 * (xz + yw);
@@ -1137,33 +1136,33 @@ QMatrix4x4& QMatrix4x4::ortho(qreal left, qreal right, qreal bottom, qreal top,
         // which will be more efficient to modify with further
         // transformations than producing a "General" matrix.
         translate(QVector3D
-            (qf2vt_round(-(left + right) / width),
-             qf2vt_round(-(top + bottom) / invheight),
+            (-(left + right) / width,
+             -(top + bottom) / invheight,
              0.0f, 1));
         scale(QVector3D
-            (qf2vt_round(2.0f / width),
-             qf2vt_round(2.0f / invheight),
+            (2.0f / width,
+             2.0f / invheight,
              -1.0f, 1));
         return *this;
     }
 #endif
     QMatrix4x4 m(1);
-    m.m[0][0] = qf2vt_round(2.0f / width);
-    m.m[1][0] = qf2vt_round(0.0f);
-    m.m[2][0] = qf2vt_round(0.0f);
-    m.m[3][0] = qf2vt_round(-(left + right) / width);
-    m.m[0][1] = qf2vt_round(0.0f);
-    m.m[1][1] = qf2vt_round(2.0f / invheight);
-    m.m[2][1] = qf2vt_round(0.0f);
-    m.m[3][1] = qf2vt_round(-(top + bottom) / invheight);
-    m.m[0][2] = qf2vt_round(0.0f);
-    m.m[1][2] = qf2vt_round(0.0f);
-    m.m[2][2] = qf2vt_round(-2.0f / clip);
-    m.m[3][2] = qf2vt_round(-(nearPlane + farPlane) / clip);
-    m.m[0][3] = qf2vt_round(0.0f);
-    m.m[1][3] = qf2vt_round(0.0f);
-    m.m[2][3] = qf2vt_round(0.0f);
-    m.m[3][3] = qf2vt_round(1.0f);
+    m.m[0][0] = 2.0f / width;
+    m.m[1][0] = 0.0f;
+    m.m[2][0] = 0.0f;
+    m.m[3][0] = -(left + right) / width;
+    m.m[0][1] = 0.0f;
+    m.m[1][1] = 2.0f / invheight;
+    m.m[2][1] = 0.0f;
+    m.m[3][1] = -(top + bottom) / invheight;
+    m.m[0][2] = 0.0f;
+    m.m[1][2] = 0.0f;
+    m.m[2][2] = -2.0f / clip;
+    m.m[3][2] = -(nearPlane + farPlane) / clip;
+    m.m[0][3] = 0.0f;
+    m.m[1][3] = 0.0f;
+    m.m[2][3] = 0.0f;
+    m.m[3][3] = 1.0f;
 
     // Apply the projection.
     *this *= m;
@@ -1189,22 +1188,22 @@ QMatrix4x4& QMatrix4x4::frustum(qreal left, qreal right, qreal bottom, qreal top
     qreal width = right - left;
     qreal invheight = top - bottom;
     qreal clip = farPlane - nearPlane;
-    m.m[0][0] = qf2vt_round(2.0f * nearPlane / width);
-    m.m[1][0] = qf2vt_round(0.0f);
-    m.m[2][0] = qf2vt_round((left + right) / width);
-    m.m[3][0] = qf2vt_round(0.0f);
-    m.m[0][1] = qf2vt_round(0.0f);
-    m.m[1][1] = qf2vt_round(2.0f * nearPlane / invheight);
-    m.m[2][1] = qf2vt_round((top + bottom) / invheight);
-    m.m[3][1] = qf2vt_round(0.0f);
-    m.m[0][2] = qf2vt_round(0.0f);
-    m.m[1][2] = qf2vt_round(0.0f);
-    m.m[2][2] = qf2vt_round(-(nearPlane + farPlane) / clip);
-    m.m[3][2] = qf2vt_round(-(2.0f * nearPlane * farPlane) / clip);
-    m.m[0][3] = qf2vt_round(0.0f);
-    m.m[1][3] = qf2vt_round(0.0f);
-    m.m[2][3] = qf2vt_round(-1.0f);
-    m.m[3][3] = qf2vt_round(0.0f);
+    m.m[0][0] = 2.0f * nearPlane / width;
+    m.m[1][0] = 0.0f;
+    m.m[2][0] = (left + right) / width;
+    m.m[3][0] = 0.0f;
+    m.m[0][1] = 0.0f;
+    m.m[1][1] = 2.0f * nearPlane / invheight;
+    m.m[2][1] = (top + bottom) / invheight;
+    m.m[3][1] = 0.0f;
+    m.m[0][2] = 0.0f;
+    m.m[1][2] = 0.0f;
+    m.m[2][2] = -(nearPlane + farPlane) / clip;
+    m.m[3][2] = -2.0f * nearPlane * farPlane / clip;
+    m.m[0][3] = 0.0f;
+    m.m[1][3] = 0.0f;
+    m.m[2][3] = -1.0f;
+    m.m[3][3] = 0.0f;
 
     // Apply the projection.
     *this *= m;
@@ -1234,22 +1233,22 @@ QMatrix4x4& QMatrix4x4::perspective(qreal angle, qreal aspect, qreal nearPlane,
         return *this;
     qreal cotan = qCos(radians) / sine;
     qreal clip = farPlane - nearPlane;
-    m.m[0][0] = qf2vt_round(cotan / aspect);
-    m.m[1][0] = qf2vt_round(0.0f);
-    m.m[2][0] = qf2vt_round(0.0f);
-    m.m[3][0] = qf2vt_round(0.0f);
-    m.m[0][1] = qf2vt_round(0.0f);
-    m.m[1][1] = qf2vt_round(cotan);
-    m.m[2][1] = qf2vt_round(0.0f);
-    m.m[3][1] = qf2vt_round(0.0f);
-    m.m[0][2] = qf2vt_round(0.0f);
-    m.m[1][2] = qf2vt_round(0.0f);
-    m.m[2][2] = qf2vt_round(-(nearPlane + farPlane) / clip);
-    m.m[3][2] = qf2vt_round(-(2.0f * nearPlane * farPlane) / clip);
-    m.m[0][3] = qf2vt_round(0.0f);
-    m.m[1][3] = qf2vt_round(0.0f);
-    m.m[2][3] = qf2vt_round(-1.0f);
-    m.m[3][3] = qf2vt_round(0.0f);
+    m.m[0][0] = cotan / aspect;
+    m.m[1][0] = 0.0f;
+    m.m[2][0] = 0.0f;
+    m.m[3][0] = 0.0f;
+    m.m[0][1] = 0.0f;
+    m.m[1][1] = cotan;
+    m.m[2][1] = 0.0f;
+    m.m[3][1] = 0.0f;
+    m.m[0][2] = 0.0f;
+    m.m[1][2] = 0.0f;
+    m.m[2][2] = -(nearPlane + farPlane) / clip;
+    m.m[3][2] = -(2.0f * nearPlane * farPlane) / clip;
+    m.m[0][3] = 0.0f;
+    m.m[1][3] = 0.0f;
+    m.m[2][3] = -1.0f;
+    m.m[3][3] = 0.0f;
 
     // Apply the projection.
     *this *= m;
@@ -1339,7 +1338,7 @@ void QMatrix4x4::toValueArray(qreal *values) const
 {
     for (int row = 0; row < 4; ++row)
         for (int col = 0; col < 4; ++col)
-            values[row * 4 + col] = qt_math3d_convert<qreal, qrealinner>(m[col][row]);
+            values[row * 4 + col] = qreal(m[col][row]);
 }
 
 /*!
@@ -1351,12 +1350,9 @@ void QMatrix4x4::toValueArray(qreal *values) const
 */
 QMatrix QMatrix4x4::toAffine() const
 {
-    return QMatrix(qt_math3d_convert<qreal, qrealinner>(m[0][0]),
-                   qt_math3d_convert<qreal, qrealinner>(m[0][1]),
-                   qt_math3d_convert<qreal, qrealinner>(m[1][0]),
-                   qt_math3d_convert<qreal, qrealinner>(m[1][1]),
-                   qt_math3d_convert<qreal, qrealinner>(m[3][0]),
-                   qt_math3d_convert<qreal, qrealinner>(m[3][1]));
+    return QMatrix(qreal(m[0][0]), qreal(m[0][1]),
+                   qreal(m[1][0]), qreal(m[1][1]),
+                   qreal(m[3][0]), qreal(m[3][1]));
 }
 
 /*!
@@ -1368,15 +1364,9 @@ QMatrix QMatrix4x4::toAffine() const
 */
 QTransform QMatrix4x4::toTransform() const
 {
-    return QTransform(qt_math3d_convert<qreal, qrealinner>(m[0][0]),
-                      qt_math3d_convert<qreal, qrealinner>(m[0][1]),
-                      qt_math3d_convert<qreal, qrealinner>(m[0][3]),
-                      qt_math3d_convert<qreal, qrealinner>(m[1][0]),
-                      qt_math3d_convert<qreal, qrealinner>(m[1][1]),
-                      qt_math3d_convert<qreal, qrealinner>(m[1][3]),
-                      qt_math3d_convert<qreal, qrealinner>(m[3][0]),
-                      qt_math3d_convert<qreal, qrealinner>(m[3][1]),
-                      qt_math3d_convert<qreal, qrealinner>(m[3][3]));
+    return QTransform(qreal(m[0][0]), qreal(m[0][1]), qreal(m[0][3]),
+                      qreal(m[1][0]), qreal(m[1][1]), qreal(m[1][3]),
+                      qreal(m[3][0]), qreal(m[3][1]), qreal(m[3][3]));
 }
 
 /*!
@@ -1442,7 +1432,7 @@ QTransform QMatrix4x4::toTransform() const
 */
 
 /*!
-    \fn qrealinner *QMatrix4x4::data()
+    \fn float *QMatrix4x4::data()
 
     Returns a pointer to the raw data of this matrix.  This is indended
     for use with raw GL functions.
@@ -1451,7 +1441,7 @@ QTransform QMatrix4x4::toTransform() const
 */
 
 /*!
-    \fn const qrealinner *QMatrix4x4::data() const
+    \fn const float *QMatrix4x4::data() const
 
     Returns a constant pointer to the raw data of this matrix.
     This is indended for use with raw GL functions.
@@ -1460,7 +1450,7 @@ QTransform QMatrix4x4::toTransform() const
 */
 
 /*!
-    \fn const qrealinner *QMatrix4x4::constData() const
+    \fn const float *QMatrix4x4::constData() const
 
     Returns a constant pointer to the raw data of this matrix.
     This is indended for use with raw GL functions.
@@ -1519,8 +1509,8 @@ void QMatrix4x4::extractAxisRotation(qreal &angle, QVector3D &axis) const
 {
     // Orientation is dependent on the upper 3x3 matrix; subtract the
     // homogeneous scaling element from the trace of the 4x4 matrix
-    qrealinner tr = m[0][0] + m[1][1] + m[2][2];
-    qreal cosa = qt_math3d_convert<qreal, qrealinner>(0.5f * (tr - 1.0f));
+    float tr = m[0][0] + m[1][1] + m[2][2];
+    qreal cosa = qreal(0.5f * (tr - 1.0f));
     angle = acos(cosa) * 180.0f / M_PI;
 
     // Any axis will work if r is zero (means no rotation)
@@ -1540,11 +1530,11 @@ void QMatrix4x4::extractAxisRotation(qreal &angle, QVector3D &axis) const
     }
 
     // rads == PI
-    qrealinner tmp;
+    float tmp;
 
     // r00 is maximum
     if ((m[0][0] >= m[2][2]) && (m[0][0] >= m[1][1])) {
-        axis.xp = 0.5f * qvtsqrt(m[0][0] - m[1][1] - m[2][2] + 1.0f);
+        axis.xp = 0.5f * qSqrt(m[0][0] - m[1][1] - m[2][2] + 1.0f);
         tmp = 0.5f / axis.x();
         axis.yp = m[1][0] * tmp;
         axis.zp = m[2][0] * tmp;
@@ -1552,7 +1542,7 @@ void QMatrix4x4::extractAxisRotation(qreal &angle, QVector3D &axis) const
 
     // r11 is maximum
     if ((m[1][1] >= m[2][2]) && (m[1][1] >= m[0][0])) {
-        axis.yp = 0.5f * qvtsqrt(m[1][1] - m[0][0] - m[2][2] + 1.0f);
+        axis.yp = 0.5f * qSqrt(m[1][1] - m[0][0] - m[2][2] + 1.0f);
         tmp = 0.5f / axis.y();
         axis.xp = tmp * m[1][0];
         axis.zp = tmp * m[2][1];
@@ -1560,7 +1550,7 @@ void QMatrix4x4::extractAxisRotation(qreal &angle, QVector3D &axis) const
 
     // r22 is maximum
     if ((m[2][2] >= m[1][1]) && (m[2][2] >= m[0][0])) {
-        axis.zp = 0.5f * qvtsqrt(m[2][2] - m[0][0] - m[1][1] + 1.0f);
+        axis.zp = 0.5f * qSqrt(m[2][2] - m[0][0] - m[1][1] + 1.0f);
         tmp = 0.5f / axis.z();
         axis.xp = m[2][0]*tmp;
         axis.yp = m[2][1]*tmp;
diff --git a/src/gui/math3d/qmatrix4x4.h b/src/gui/math3d/qmatrix4x4.h
index 6428b20..2b485c1 100644
--- a/src/gui/math3d/qmatrix4x4.h
+++ b/src/gui/math3d/qmatrix4x4.h
@@ -70,14 +70,14 @@ public:
                       qreal m41, qreal m42, qreal m43, qreal m44);
 #if !defined(QT_NO_MEMBER_TEMPLATES) || defined(Q_QDOC)
     template <int N, int M>
-    explicit QMatrix4x4(const QGenericMatrix<N, M, qreal, qrealinner>& matrix);
+    explicit QMatrix4x4(const QGenericMatrix<N, M, qreal, float>& matrix);
 #endif
-    QMatrix4x4(const qrealinner *values, int cols, int rows);
+    QMatrix4x4(const float *values, int cols, int rows);
     QMatrix4x4(const QTransform& transform);
     QMatrix4x4(const QMatrix& matrix);
 
     inline qreal operator()(int row, int column) const;
-    inline qrealinner& operator()(int row, int column);
+    inline float& operator()(int row, int column);
 
     inline QVector4D column(int index) const;
     inline void setColumn(int index, const QVector4D& value);
@@ -171,12 +171,12 @@ public:
 
 #if !defined(QT_NO_MEMBER_TEMPLATES) || defined(Q_QDOC)
     template <int N, int M>
-    QGenericMatrix<N, M, qreal, qrealinner> toGenericMatrix() const;
+    QGenericMatrix<N, M, qreal, float> toGenericMatrix() const;
 #endif
 
-    inline qrealinner *data();
-    inline const qrealinner *data() const { return m[0]; }
-    inline const qrealinner *constData() const { return m[0]; }
+    inline float *data();
+    inline const float *data() const { return m[0]; }
+    inline const float *constData() const { return m[0]; }
 
     void inferSpecialType();
 
@@ -185,7 +185,7 @@ public:
 #endif
 
 private:
-    qrealinner m[4][4];    // Column-major order to match OpenGL.
+    float m[4][4];          // Column-major order to match OpenGL.
     int flagBits;           // Flag bits from the enum below.
 
     enum {
@@ -219,9 +219,9 @@ inline QMatrix4x4::QMatrix4x4
 
 template <int N, int M>
 Q_INLINE_TEMPLATE QMatrix4x4::QMatrix4x4
-    (const QGenericMatrix<N, M, qreal, qrealinner>& matrix)
+    (const QGenericMatrix<N, M, qreal, float>& matrix)
 {
-    const qrealinner *values = matrix.constData();
+    const float *values = matrix.constData();
     for (int col = 0; col < 4; ++col) {
         for (int row = 0; row < 4; ++row) {
             if (col < N && row < M)
@@ -236,10 +236,10 @@ Q_INLINE_TEMPLATE QMatrix4x4::QMatrix4x4
 }
 
 template <int N, int M>
-QGenericMatrix<N, M, qreal, qrealinner> QMatrix4x4::toGenericMatrix() const
+QGenericMatrix<N, M, qreal, float> QMatrix4x4::toGenericMatrix() const
 {
-    QGenericMatrix<N, M, qreal, qrealinner> result;
-    qrealinner *values = result.data();
+    QGenericMatrix<N, M, qreal, float> result;
+    float *values = result.data();
     for (int col = 0; col < N; ++col) {
         for (int row = 0; row < M; ++row) {
             if (col < 4 && row < 4)
@@ -258,10 +258,10 @@ QGenericMatrix<N, M, qreal, qrealinner> QMatrix4x4::toGenericMatrix() const
 inline qreal QMatrix4x4::operator()(int row, int column) const
 {
     Q_ASSERT(row >= 0 && row < 4 && column >= 0 && column < 4);
-    return qt_math3d_convert<qreal, qrealinner>(m[column][row]);
+    return qreal(m[column][row]);
 }
 
-inline qrealinner& QMatrix4x4::operator()(int row, int column)
+inline float& QMatrix4x4::operator()(int row, int column)
 {
     Q_ASSERT(row >= 0 && row < 4 && column >= 0 && column < 4);
     flagBits = General;
@@ -420,23 +420,22 @@ inline QMatrix4x4& QMatrix4x4::operator*=(const QMatrix4x4& other)
 
 inline QMatrix4x4& QMatrix4x4::operator*=(qreal factor)
 {
-    qrealinner f(factor);
-    m[0][0] *= f;
-    m[0][1] *= f;
-    m[0][2] *= f;
-    m[0][3] *= f;
-    m[1][0] *= f;
-    m[1][1] *= f;
-    m[1][2] *= f;
-    m[1][3] *= f;
-    m[2][0] *= f;
-    m[2][1] *= f;
-    m[2][2] *= f;
-    m[2][3] *= f;
-    m[3][0] *= f;
-    m[3][1] *= f;
-    m[3][2] *= f;
-    m[3][3] *= f;
+    m[0][0] *= factor;
+    m[0][1] *= factor;
+    m[0][2] *= factor;
+    m[0][3] *= factor;
+    m[1][0] *= factor;
+    m[1][1] *= factor;
+    m[1][2] *= factor;
+    m[1][3] *= factor;
+    m[2][0] *= factor;
+    m[2][1] *= factor;
+    m[2][2] *= factor;
+    m[2][3] *= factor;
+    m[3][0] *= factor;
+    m[3][1] *= factor;
+    m[3][2] *= factor;
+    m[3][3] *= factor;
     flagBits = General;
     return *this;
 }
@@ -604,7 +603,7 @@ inline QMatrix4x4 operator*(const QMatrix4x4& m1, const QMatrix4x4& m2)
 
 inline QVector3D operator*(const QVector3D& vector, const QMatrix4x4& matrix)
 {
-    qrealinner x, y, z, w;
+    float x, y, z, w;
     x = vector.xp * matrix.m[0][0] +
         vector.yp * matrix.m[0][1] +
         vector.zp * matrix.m[0][2] +
@@ -629,7 +628,7 @@ inline QVector3D operator*(const QVector3D& vector, const QMatrix4x4& matrix)
 
 inline QVector3D operator*(const QMatrix4x4& matrix, const QVector3D& vector)
 {
-    qrealinner x, y, z, w;
+    float x, y, z, w;
     x = vector.xp * matrix.m[0][0] +
         vector.yp * matrix.m[1][0] +
         vector.zp * matrix.m[2][0] +
@@ -658,7 +657,7 @@ inline QVector3D operator*(const QMatrix4x4& matrix, const QVector3D& vector)
 
 inline QVector4D operator*(const QVector4D& vector, const QMatrix4x4& matrix)
 {
-    qrealinner x, y, z, w;
+    float x, y, z, w;
     x = vector.xp * matrix.m[0][0] +
         vector.yp * matrix.m[0][1] +
         vector.zp * matrix.m[0][2] +
@@ -680,7 +679,7 @@ inline QVector4D operator*(const QVector4D& vector, const QMatrix4x4& matrix)
 
 inline QVector4D operator*(const QMatrix4x4& matrix, const QVector4D& vector)
 {
-    qrealinner x, y, z, w;
+    float x, y, z, w;
     x = vector.xp * matrix.m[0][0] +
         vector.yp * matrix.m[1][0] +
         vector.zp * matrix.m[2][0] +
@@ -704,8 +703,8 @@ inline QVector4D operator*(const QMatrix4x4& matrix, const QVector4D& vector)
 
 inline QPoint operator*(const QPoint& point, const QMatrix4x4& matrix)
 {
-    qrealinner xin, yin;
-    qrealinner x, y, w;
+    float xin, yin;
+    float x, y, w;
     xin = point.x();
     yin = point.y();
     x = xin * matrix.m[0][0] +
@@ -725,8 +724,8 @@ inline QPoint operator*(const QPoint& point, const QMatrix4x4& matrix)
 
 inline QPointF operator*(const QPointF& point, const QMatrix4x4& matrix)
 {
-    qrealinner xin, yin;
-    qrealinner x, y, w;
+    float xin, yin;
+    float x, y, w;
     xin = point.x();
     yin = point.y();
     x = xin * matrix.m[0][0] +
@@ -739,18 +738,16 @@ inline QPointF operator*(const QPointF& point, const QMatrix4x4& matrix)
         yin * matrix.m[3][1] +
         matrix.m[3][3];
     if (w == 1.0f) {
-        return QPointF(qt_math3d_convert<qreal, qrealinner>(x),
-                       qt_math3d_convert<qreal, qrealinner>(y));
+        return QPointF(qreal(x), qreal(y));
     } else {
-        return QPointF(qt_math3d_convert<qreal, qrealinner>(x / w),
-                       qt_math3d_convert<qreal, qrealinner>(y / w));
+        return QPointF(qreal(x / w), qreal(y / w));
     }
 }
 
 inline QPoint operator*(const QMatrix4x4& matrix, const QPoint& point)
 {
-    qrealinner xin, yin;
-    qrealinner x, y, w;
+    float xin, yin;
+    float x, y, w;
     xin = point.x();
     yin = point.y();
     x = xin * matrix.m[0][0] +
@@ -770,8 +767,8 @@ inline QPoint operator*(const QMatrix4x4& matrix, const QPoint& point)
 
 inline QPointF operator*(const QMatrix4x4& matrix, const QPointF& point)
 {
-    qrealinner xin, yin;
-    qrealinner x, y, w;
+    float xin, yin;
+    float x, y, w;
     xin = point.x();
     yin = point.y();
     x = xin * matrix.m[0][0] +
@@ -784,11 +781,9 @@ inline QPointF operator*(const QMatrix4x4& matrix, const QPointF& point)
         yin * matrix.m[1][3] +
         matrix.m[3][3];
     if (w == 1.0f) {
-        return QPointF(qt_math3d_convert<qreal, qrealinner>(x),
-                       qt_math3d_convert<qreal, qrealinner>(y));
+        return QPointF(qreal(x), qreal(y));
     } else {
-        return QPointF(qt_math3d_convert<qreal, qrealinner>(x / w),
-                       qt_math3d_convert<qreal, qrealinner>(y / w));
+        return QPointF(qreal(x / w), qreal(y / w));
     }
 }
 
@@ -817,46 +812,44 @@ inline QMatrix4x4 operator-(const QMatrix4x4& matrix)
 inline QMatrix4x4 operator*(qreal factor, const QMatrix4x4& matrix)
 {
     QMatrix4x4 m(1);
-    qrealinner f(factor);
-    m.m[0][0] = matrix.m[0][0] * f;
-    m.m[0][1] = matrix.m[0][1] * f;
-    m.m[0][2] = matrix.m[0][2] * f;
-    m.m[0][3] = matrix.m[0][3] * f;
-    m.m[1][0] = matrix.m[1][0] * f;
-    m.m[1][1] = matrix.m[1][1] * f;
-    m.m[1][2] = matrix.m[1][2] * f;
-    m.m[1][3] = matrix.m[1][3] * f;
-    m.m[2][0] = matrix.m[2][0] * f;
-    m.m[2][1] = matrix.m[2][1] * f;
-    m.m[2][2] = matrix.m[2][2] * f;
-    m.m[2][3] = matrix.m[2][3] * f;
-    m.m[3][0] = matrix.m[3][0] * f;
-    m.m[3][1] = matrix.m[3][1] * f;
-    m.m[3][2] = matrix.m[3][2] * f;
-    m.m[3][3] = matrix.m[3][3] * f;
+    m.m[0][0] = matrix.m[0][0] * factor;
+    m.m[0][1] = matrix.m[0][1] * factor;
+    m.m[0][2] = matrix.m[0][2] * factor;
+    m.m[0][3] = matrix.m[0][3] * factor;
+    m.m[1][0] = matrix.m[1][0] * factor;
+    m.m[1][1] = matrix.m[1][1] * factor;
+    m.m[1][2] = matrix.m[1][2] * factor;
+    m.m[1][3] = matrix.m[1][3] * factor;
+    m.m[2][0] = matrix.m[2][0] * factor;
+    m.m[2][1] = matrix.m[2][1] * factor;
+    m.m[2][2] = matrix.m[2][2] * factor;
+    m.m[2][3] = matrix.m[2][3] * factor;
+    m.m[3][0] = matrix.m[3][0] * factor;
+    m.m[3][1] = matrix.m[3][1] * factor;
+    m.m[3][2] = matrix.m[3][2] * factor;
+    m.m[3][3] = matrix.m[3][3] * factor;
     return m;
 }
 
 inline QMatrix4x4 operator*(const QMatrix4x4& matrix, qreal factor)
 {
     QMatrix4x4 m(1);
-    qrealinner f(factor);
-    m.m[0][0] = matrix.m[0][0] * f;
-    m.m[0][1] = matrix.m[0][1] * f;
-    m.m[0][2] = matrix.m[0][2] * f;
-    m.m[0][3] = matrix.m[0][3] * f;
-    m.m[1][0] = matrix.m[1][0] * f;
-    m.m[1][1] = matrix.m[1][1] * f;
-    m.m[1][2] = matrix.m[1][2] * f;
-    m.m[1][3] = matrix.m[1][3] * f;
-    m.m[2][0] = matrix.m[2][0] * f;
-    m.m[2][1] = matrix.m[2][1] * f;
-    m.m[2][2] = matrix.m[2][2] * f;
-    m.m[2][3] = matrix.m[2][3] * f;
-    m.m[3][0] = matrix.m[3][0] * f;
-    m.m[3][1] = matrix.m[3][1] * f;
-    m.m[3][2] = matrix.m[3][2] * f;
-    m.m[3][3] = matrix.m[3][3] * f;
+    m.m[0][0] = matrix.m[0][0] * factor;
+    m.m[0][1] = matrix.m[0][1] * factor;
+    m.m[0][2] = matrix.m[0][2] * factor;
+    m.m[0][3] = matrix.m[0][3] * factor;
+    m.m[1][0] = matrix.m[1][0] * factor;
+    m.m[1][1] = matrix.m[1][1] * factor;
+    m.m[1][2] = matrix.m[1][2] * factor;
+    m.m[1][3] = matrix.m[1][3] * factor;
+    m.m[2][0] = matrix.m[2][0] * factor;
+    m.m[2][1] = matrix.m[2][1] * factor;
+    m.m[2][2] = matrix.m[2][2] * factor;
+    m.m[2][3] = matrix.m[2][3] * factor;
+    m.m[3][0] = matrix.m[3][0] * factor;
+    m.m[3][1] = matrix.m[3][1] * factor;
+    m.m[3][2] = matrix.m[3][2] * factor;
+    m.m[3][3] = matrix.m[3][3] * factor;
     return m;
 }
 
@@ -934,7 +927,7 @@ inline QRectF QMatrix4x4::mapRect(const QRectF& rect) const
     return QRectF(QPointF(xmin, ymin), QPointF(xmax, ymax));
 }
 
-inline qrealinner *QMatrix4x4::data()
+inline float *QMatrix4x4::data()
 {
     // We have to assume that the caller will modify the matrix elements,
     // so we flip it over to "General" mode.
@@ -947,17 +940,17 @@ Q_GUI_EXPORT QDebug operator<<(QDebug dbg, const QMatrix4x4 &m);
 #endif
 
 template <int N, int M>
-QMatrix4x4 qGenericMatrixToMatrix4x4(const QGenericMatrix<N, M, qreal, qrealinner>& matrix)
+QMatrix4x4 qGenericMatrixToMatrix4x4(const QGenericMatrix<N, M, qreal, float>& matrix)
 {
     return QMatrix4x4(matrix.constData(), N, M);
 }
 
 template <int N, int M>
-QGenericMatrix<N, M, qreal, qrealinner> qGenericMatrixFromMatrix4x4(const QMatrix4x4& matrix)
+QGenericMatrix<N, M, qreal, float> qGenericMatrixFromMatrix4x4(const QMatrix4x4& matrix)
 {
-    QGenericMatrix<N, M, qreal, qrealinner> result;
-    const qrealinner *m = matrix.constData();
-    qrealinner *values = result.data();
+    QGenericMatrix<N, M, qreal, float> result;
+    const float *m = matrix.constData();
+    float *values = result.data();
     for (int col = 0; col < N; ++col) {
         for (int row = 0; row < M; ++row) {
             if (col < 4 && row < 4)
diff --git a/src/gui/math3d/qquaternion.cpp b/src/gui/math3d/qquaternion.cpp
index 121ff51..efde362 100644
--- a/src/gui/math3d/qquaternion.cpp
+++ b/src/gui/math3d/qquaternion.cpp
@@ -40,8 +40,8 @@
 ****************************************************************************/
 
 #include "qquaternion.h"
-#include "qmath3dutil_p.h"
 #include <QtCore/qmath.h>
+#include <QtCore/qdebug.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -223,8 +223,7 @@ QT_BEGIN_NAMESPACE
 */
 qreal QQuaternion::length() const
 {
-    return qvtsqrt64(qvtmul64(xp, xp) + qvtmul64(yp, yp) +
-                     qvtmul64(zp, zp) + qvtmul64(wp, wp));
+    return qSqrt(xp * xp + yp * yp + zp * zp + wp * wp);
 }
 
 /*!
@@ -234,8 +233,7 @@ qreal QQuaternion::length() const
 */
 qreal QQuaternion::lengthSquared() const
 {
-    return qvtdot64(qvtmul64(xp, xp) + qvtmul64(yp, yp) +
-                    qvtmul64(zp, zp) + qvtmul64(wp, wp));
+    return xp * xp + yp * yp + zp * zp + wp * wp;
 }
 
 /*!
@@ -342,6 +340,10 @@ QVector3D QQuaternion::rotateVector(const QVector3D& vector) const
     \sa operator*=()
 */
 
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
 #ifndef QT_NO_VECTOR3D
 
 /*!
@@ -354,9 +356,10 @@ QQuaternion QQuaternion::fromAxisAndAngle(const QVector3D& axis, qreal angle)
     // http://www.j3d.org/matrix_faq/matrfaq_latest.html#Q56
     // We normalize the result just in case the values are close
     // to zero, as suggested in the above FAQ.
-    qrealinner s, c;
+    qreal a = (angle / 2.0f) * M_PI / 180.0f;
+    qreal s = qSin(a);
+    qreal c = qCos(a);
     QVector3D ax = axis.normalized();
-    qt_math3d_sincos(angle / 2.0f, &s, &c);
     return QQuaternion(c, ax.xp * s, ax.yp * s, ax.zp * s, 1).normalized();
 }
 
@@ -369,17 +372,18 @@ QQuaternion QQuaternion::fromAxisAndAngle(const QVector3D& axis, qreal angle)
 QQuaternion QQuaternion::fromAxisAndAngle
         (qreal x, qreal y, qreal z, qreal angle)
 {
-    qrealinner xp = x;
-    qrealinner yp = y;
-    qrealinner zp = z;
-    qrealinner s, c;
-    qreal length = qvtsqrt(xp * xp + yp * yp + zp * zp);
+    float xp = x;
+    float yp = y;
+    float zp = z;
+    qreal length = qSqrt(xp * xp + yp * yp + zp * zp);
     if (!qIsNull(length)) {
         xp /= length;
         yp /= length;
         zp /= length;
     }
-    qt_math3d_sincos(angle / 2.0f, &s, &c);
+    qreal a = (angle / 2.0f) * M_PI / 180.0f;
+    qreal s = qSin(a);
+    qreal c = qCos(a);
     return QQuaternion(c, xp * s, yp * s, zp * s, 1).normalized();
 }
 
@@ -500,8 +504,7 @@ QQuaternion QQuaternion::interpolate
     // Determine the angle between the two quaternions.
     QQuaternion q2b;
     qreal dot;
-    dot = qvtdot64(qvtmul64(q1.xp, q2.xp) + qvtmul64(q1.yp, q2.yp) +
-                   qvtmul64(q1.zp, q2.zp) + qvtmul64(q1.wp, q2.wp));
+    dot = q1.xp * q2.xp + q1.yp * q2.yp + q1.zp * q2.zp + q1.wp * q2.wp;
     if (dot >= 0.0f) {
         q2b = q2;
     } else {
diff --git a/src/gui/math3d/qquaternion.h b/src/gui/math3d/qquaternion.h
index 6ba63ec..f0cb308 100644
--- a/src/gui/math3d/qquaternion.h
+++ b/src/gui/math3d/qquaternion.h
@@ -129,11 +129,11 @@ public:
         (const QQuaternion& q1, const QQuaternion& q2, qreal t);
 
 private:
-    qrealinner wp, xp, yp, zp;
+    float wp, xp, yp, zp;
 
     friend class QMatrix4x4;
 
-    QQuaternion(qrealinner scalar, qrealinner xpos, qrealinner ypos, qrealinner zpos, int dummy);
+    QQuaternion(float scalar, float xpos, float ypos, float zpos, int dummy);
 };
 
 inline QQuaternion::QQuaternion() : wp(1.0f), xp(0.0f), yp(0.0f), zp(0.0f) {}
@@ -141,7 +141,7 @@ inline QQuaternion::QQuaternion() : wp(1.0f), xp(0.0f), yp(0.0f), zp(0.0f) {}
 inline QQuaternion::QQuaternion(qreal scalar, qreal xpos, qreal ypos, qreal zpos) : wp(scalar), xp(xpos), yp(ypos), zp(zpos) {}
 
 
-inline QQuaternion::QQuaternion(qrealinner scalar, qrealinner xpos, qrealinner ypos, qrealinner zpos, int) : wp(scalar), xp(xpos), yp(ypos), zp(zpos) {}
+inline QQuaternion::QQuaternion(float scalar, float xpos, float ypos, float zpos, int) : wp(scalar), xp(xpos), yp(ypos), zp(zpos) {}
 
 inline QQuaternion::QQuaternion(int scalar, int xpos, int ypos, int zpos) : wp(scalar), xp(xpos), yp(ypos), zp(zpos) {}
 
@@ -155,10 +155,10 @@ inline bool QQuaternion::isIdentity() const
     return qIsNull(xp) && qIsNull(yp) && qIsNull(zp) && wp == 1.0f;
 }
 
-inline qreal QQuaternion::x() const { return qt_math3d_convert<qreal, qrealinner>(xp); }
-inline qreal QQuaternion::y() const { return qt_math3d_convert<qreal, qrealinner>(yp); }
-inline qreal QQuaternion::z() const { return qt_math3d_convert<qreal, qrealinner>(zp); }
-inline qreal QQuaternion::scalar() const { return qt_math3d_convert<qreal, qrealinner>(wp); }
+inline qreal QQuaternion::x() const { return qreal(xp); }
+inline qreal QQuaternion::y() const { return qreal(yp); }
+inline qreal QQuaternion::z() const { return qreal(zp); }
+inline qreal QQuaternion::scalar() const { return qreal(wp); }
 
 inline void QQuaternion::setX(qreal x) { xp = x; }
 inline void QQuaternion::setY(qreal y) { yp = y; }
@@ -190,11 +190,10 @@ inline QQuaternion &QQuaternion::operator-=(const QQuaternion &quaternion)
 
 inline QQuaternion &QQuaternion::operator*=(qreal factor)
 {
-    qrealinner f(factor);
-    xp *= f;
-    yp *= f;
-    zp *= f;
-    wp *= f;
+    xp *= factor;
+    yp *= factor;
+    zp *= factor;
+    wp *= factor;
     return *this;
 }
 
@@ -202,19 +201,19 @@ inline const QQuaternion operator*(const QQuaternion &q1, const QQuaternion& q2)
 {
     // Algorithm from:
     // http://www.j3d.org/matrix_faq/matrfaq_latest.html#Q53
-    qrealinner x = q1.wp * q2.xp +
+    float x = q1.wp * q2.xp +
                     q1.xp * q2.wp +
                     q1.yp * q2.zp -
                     q1.zp * q2.yp;
-    qrealinner y = q1.wp * q2.yp +
+    float y = q1.wp * q2.yp +
                     q1.yp * q2.wp +
                     q1.zp * q2.xp -
                     q1.xp * q2.zp;
-    qrealinner z = q1.wp * q2.zp +
+    float z = q1.wp * q2.zp +
                     q1.zp * q2.wp +
                     q1.xp * q2.yp -
                     q1.yp * q2.xp;
-    qrealinner w = q1.wp * q2.wp -
+    float w = q1.wp * q2.wp -
                     q1.xp * q2.xp -
                     q1.yp * q2.yp -
                     q1.zp * q2.zp;
@@ -229,11 +228,10 @@ inline QQuaternion &QQuaternion::operator*=(const QQuaternion &quaternion)
 
 inline QQuaternion &QQuaternion::operator/=(qreal divisor)
 {
-    qrealinner d(divisor);
-    xp /= d;
-    yp /= d;
-    zp /= d;
-    wp /= d;
+    xp /= divisor;
+    yp /= divisor;
+    zp /= divisor;
+    wp /= divisor;
     return *this;
 }
 
@@ -259,14 +257,12 @@ inline const QQuaternion operator-(const QQuaternion &q1, const QQuaternion &q2)
 
 inline const QQuaternion operator*(qreal factor, const QQuaternion &quaternion)
 {
-    qrealinner f(factor);
-    return QQuaternion(quaternion.wp * f, quaternion.xp * f, quaternion.yp * f, quaternion.zp * f, 1);
+    return QQuaternion(quaternion.wp * factor, quaternion.xp * factor, quaternion.yp * factor, quaternion.zp * factor, 1);
 }
 
 inline const QQuaternion operator*(const QQuaternion &quaternion, qreal factor)
 {
-    qrealinner f(factor);
-    return QQuaternion(quaternion.wp * f, quaternion.xp * f, quaternion.yp * f, quaternion.zp * f, 1);
+    return QQuaternion(quaternion.wp * factor, quaternion.xp * factor, quaternion.yp * factor, quaternion.zp * factor, 1);
 }
 
 inline const QQuaternion operator-(const QQuaternion &quaternion)
@@ -276,8 +272,7 @@ inline const QQuaternion operator-(const QQuaternion &quaternion)
 
 inline const QQuaternion operator/(const QQuaternion &quaternion, qreal divisor)
 {
-    qrealinner d(divisor);
-    return QQuaternion(quaternion.wp / d, quaternion.xp / d, quaternion.yp / d, quaternion.zp / d, 1);
+    return QQuaternion(quaternion.wp / divisor, quaternion.xp / divisor, quaternion.yp / divisor, quaternion.zp / divisor, 1);
 }
 
 inline bool qFuzzyCompare(const QQuaternion& q1, const QQuaternion& q2)
diff --git a/src/gui/math3d/qvector2d.cpp b/src/gui/math3d/qvector2d.cpp
index 0426fc5..31e5be6 100644
--- a/src/gui/math3d/qvector2d.cpp
+++ b/src/gui/math3d/qvector2d.cpp
@@ -42,7 +42,8 @@
 #include "qvector2d.h"
 #include "qvector3d.h"
 #include "qvector4d.h"
-#include "qmath3dutil_p.h"
+#include <QtCore/qdebug.h>
+#include <QtCore/qmath.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -169,7 +170,7 @@ QVector2D::QVector2D(const QVector4D& vector)
 */
 qreal QVector2D::length() const
 {
-    return qvtsqrt64(qvtmul64(xp, xp) + qvtmul64(yp, yp));
+    return qSqrt(xp * xp + yp * yp);
 }
 
 /*!
@@ -180,7 +181,7 @@ qreal QVector2D::length() const
 */
 qreal QVector2D::lengthSquared() const
 {
-    return qvtdot64(qvtmul64(xp, xp) + qvtmul64(yp, yp));
+    return xp * xp + yp * yp;
 }
 
 /*!
@@ -263,7 +264,7 @@ void QVector2D::normalize()
 */
 qreal QVector2D::dotProduct(const QVector2D& v1, const QVector2D& v2)
 {
-    return qvtdot64(qvtmul64(v1.xp, v2.xp) + qvtmul64(v1.yp, v2.yp));
+    return v1.xp * v2.xp + v1.yp * v2.yp;
 }
 
 /*!
diff --git a/src/gui/math3d/qvector2d.h b/src/gui/math3d/qvector2d.h
index a72ecc5..5e15de6 100644
--- a/src/gui/math3d/qvector2d.h
+++ b/src/gui/math3d/qvector2d.h
@@ -42,7 +42,6 @@
 #ifndef QVECTOR2D_H
 #define QVECTOR2D_H
 
-#include <QtGui/qmath3dglobal.h>
 #include <QtCore/qpoint.h>
 #include <QtCore/qmetatype.h>
 
@@ -117,18 +116,17 @@ public:
     QPointF toPointF() const;
 
 private:
-    qrealinner xp, yp;
+    float xp, yp;
 
-    QVector2D(qrealinner xpos, qrealinner ypos, int dummy);
+    QVector2D(float xpos, float ypos, int dummy);
 
     friend class QVector3D;
     friend class QVector4D;
-    friend class QVertexArray;
 };
 
 inline QVector2D::QVector2D() : xp(0.0f), yp(0.0f) {}
 
-inline QVector2D::QVector2D(qrealinner xpos, qrealinner ypos, int) : xp(xpos), yp(ypos) {}
+inline QVector2D::QVector2D(float xpos, float ypos, int) : xp(xpos), yp(ypos) {}
 
 inline QVector2D::QVector2D(qreal xpos, qreal ypos) : xp(xpos), yp(ypos) {}
 
@@ -143,8 +141,8 @@ inline bool QVector2D::isNull() const
     return qIsNull(xp) && qIsNull(yp);
 }
 
-inline qreal QVector2D::x() const { return qt_math3d_convert<qreal, qrealinner>(xp); }
-inline qreal QVector2D::y() const { return qt_math3d_convert<qreal, qrealinner>(yp); }
+inline qreal QVector2D::x() const { return qreal(xp); }
+inline qreal QVector2D::y() const { return qreal(yp); }
 
 inline void QVector2D::setX(qreal x) { xp = x; }
 inline void QVector2D::setY(qreal y) { yp = y; }
@@ -165,9 +163,8 @@ inline QVector2D &QVector2D::operator-=(const QVector2D &vector)
 
 inline QVector2D &QVector2D::operator*=(qreal factor)
 {
-    qrealinner f(factor);
-    xp *= f;
-    yp *= f;
+    xp *= factor;
+    yp *= factor;
     return *this;
 }
 
@@ -180,9 +177,8 @@ inline QVector2D &QVector2D::operator*=(const QVector2D &vector)
 
 inline QVector2D &QVector2D::operator/=(qreal divisor)
 {
-    qrealinner d(divisor);
-    xp /= d;
-    yp /= d;
+    xp /= divisor;
+    yp /= divisor;
     return *this;
 }
 
@@ -208,14 +204,12 @@ inline const QVector2D operator-(const QVector2D &v1, const QVector2D &v2)
 
 inline const QVector2D operator*(qreal factor, const QVector2D &vector)
 {
-    qrealinner f(factor);
-    return QVector2D(vector.xp * f, vector.yp * f, 1);
+    return QVector2D(vector.xp * factor, vector.yp * factor, 1);
 }
 
 inline const QVector2D operator*(const QVector2D &vector, qreal factor)
 {
-    qrealinner f(factor);
-    return QVector2D(vector.xp * f, vector.yp * f, 1);
+    return QVector2D(vector.xp * factor, vector.yp * factor, 1);
 }
 
 inline const QVector2D operator*(const QVector2D &v1, const QVector2D &v2)
@@ -230,8 +224,7 @@ inline const QVector2D operator-(const QVector2D &vector)
 
 inline const QVector2D operator/(const QVector2D &vector, qreal divisor)
 {
-    qrealinner d(divisor);
-    return QVector2D(vector.xp / d, vector.yp / d, 1);
+    return QVector2D(vector.xp / divisor, vector.yp / divisor, 1);
 }
 
 inline bool qFuzzyCompare(const QVector2D& v1, const QVector2D& v2)
@@ -246,8 +239,7 @@ inline QPoint QVector2D::toPoint() const
 
 inline QPointF QVector2D::toPointF() const
 {
-    return QPointF(qt_math3d_convert<qreal, qrealinner>(xp),
-                   qt_math3d_convert<qreal, qrealinner>(yp));
+    return QPointF(qreal(xp), qreal(yp));
 }
 
 #ifndef QT_NO_DEBUG_STREAM
diff --git a/src/gui/math3d/qvector3d.cpp b/src/gui/math3d/qvector3d.cpp
index 32068ee..814753d 100644
--- a/src/gui/math3d/qvector3d.cpp
+++ b/src/gui/math3d/qvector3d.cpp
@@ -42,8 +42,8 @@
 #include "qvector3d.h"
 #include "qvector2d.h"
 #include "qvector4d.h"
-#include "qmath3dutil_p.h"
 #include <QtCore/qmath.h>
+#include <QtCore/qdebug.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -287,7 +287,7 @@ void QVector3D::normalize()
 */
 qreal QVector3D::dotProduct(const QVector3D& v1, const QVector3D& v2)
 {
-    return qvtdot64(qvtmul64(v1.xp, v2.xp) + qvtmul64(v1.yp, v2.yp) + qvtmul64(v1.zp, v2.zp));
+    return v1.xp * v2.xp + v1.yp * v2.yp + v1.zp * v2.zp;
 }
 
 /*!
@@ -535,7 +535,7 @@ QVector4D QVector3D::toVector4D() const
 */
 qreal QVector3D::length() const
 {
-    return qvtsqrt64(qvtmul64(xp, xp) + qvtmul64(yp, yp) + qvtmul64(zp, zp));
+    return qSqrt(xp * xp + yp * yp + zp * zp);
 }
 
 /*!
@@ -546,7 +546,7 @@ qreal QVector3D::length() const
 */
 qreal QVector3D::lengthSquared() const
 {
-    return qvtdot64(qvtmul64(xp, xp) + qvtmul64(yp, yp) + qvtmul64(zp, zp));
+    return xp * xp + yp * yp + zp * zp;
 }
 
 #ifndef QT_NO_DEBUG_STREAM
diff --git a/src/gui/math3d/qvector3d.h b/src/gui/math3d/qvector3d.h
index 8f8f3b4..4771d5a 100644
--- a/src/gui/math3d/qvector3d.h
+++ b/src/gui/math3d/qvector3d.h
@@ -42,7 +42,6 @@
 #ifndef QVECTOR3D_H
 #define QVECTOR3D_H
 
-#include <QtGui/qmath3dglobal.h>
 #include <QtCore/qpoint.h>
 #include <QtCore/qmetatype.h>
 
@@ -130,16 +129,14 @@ public:
     QPointF toPointF() const;
 
 private:
-    qrealinner xp, yp, zp;
+    float xp, yp, zp;
 
-    QVector3D(qrealinner xpos, qrealinner ypos, qrealinner zpos, int dummy);
+    QVector3D(float xpos, float ypos, float zpos, int dummy);
 
     friend class QVector2D;
     friend class QVector4D;
     friend class QQuaternion;
     friend class QMatrix4x4;
-    friend class QVertexArray;
-    friend class QGLPainter;
 #ifndef QT_NO_MATRIX4X4
     friend QVector3D operator*(const QVector3D& vector, const QMatrix4x4& matrix);
     friend QVector3D operator*(const QMatrix4x4& matrix, const QVector3D& vector);
@@ -150,7 +147,7 @@ inline QVector3D::QVector3D() : xp(0.0f), yp(0.0f), zp(0.0f) {}
 
 inline QVector3D::QVector3D(qreal xpos, qreal ypos, qreal zpos) : xp(xpos), yp(ypos), zp(zpos) {}
 
-inline QVector3D::QVector3D(qrealinner xpos, qrealinner ypos, qrealinner zpos, int) : xp(xpos), yp(ypos), zp(zpos) {}
+inline QVector3D::QVector3D(float xpos, float ypos, float zpos, int) : xp(xpos), yp(ypos), zp(zpos) {}
 
 inline QVector3D::QVector3D(int xpos, int ypos, int zpos) : xp(xpos), yp(ypos), zp(zpos) {}
 
@@ -163,9 +160,9 @@ inline bool QVector3D::isNull() const
     return qIsNull(xp) && qIsNull(yp) && qIsNull(zp);
 }
 
-inline qreal QVector3D::x() const { return qt_math3d_convert<qreal, qrealinner>(xp); }
-inline qreal QVector3D::y() const { return qt_math3d_convert<qreal, qrealinner>(yp); }
-inline qreal QVector3D::z() const { return qt_math3d_convert<qreal, qrealinner>(zp); }
+inline qreal QVector3D::x() const { return qreal(xp); }
+inline qreal QVector3D::y() const { return qreal(yp); }
+inline qreal QVector3D::z() const { return qreal(zp); }
 
 inline void QVector3D::setX(qreal x) { xp = x; }
 inline void QVector3D::setY(qreal y) { yp = y; }
@@ -189,10 +186,9 @@ inline QVector3D &QVector3D::operator-=(const QVector3D &vector)
 
 inline QVector3D &QVector3D::operator*=(qreal factor)
 {
-    qrealinner f(factor);
-    xp *= f;
-    yp *= f;
-    zp *= f;
+    xp *= factor;
+    yp *= factor;
+    zp *= factor;
     return *this;
 }
 
@@ -206,10 +202,9 @@ inline QVector3D &QVector3D::operator*=(const QVector3D& vector)
 
 inline QVector3D &QVector3D::operator/=(qreal divisor)
 {
-    qrealinner d(divisor);
-    xp /= d;
-    yp /= d;
-    zp /= d;
+    xp /= divisor;
+    yp /= divisor;
+    zp /= divisor;
     return *this;
 }
 
@@ -235,14 +230,12 @@ inline const QVector3D operator-(const QVector3D &v1, const QVector3D &v2)
 
 inline const QVector3D operator*(qreal factor, const QVector3D &vector)
 {
-    qrealinner f(factor);
-    return QVector3D(vector.xp * f, vector.yp * f, vector.zp * f, 1);
+    return QVector3D(vector.xp * factor, vector.yp * factor, vector.zp * factor, 1);
 }
 
 inline const QVector3D operator*(const QVector3D &vector, qreal factor)
 {
-    qrealinner f(factor);
-    return QVector3D(vector.xp * f, vector.yp * f, vector.zp * f, 1);
+    return QVector3D(vector.xp * factor, vector.yp * factor, vector.zp * factor, 1);
 }
 
 inline const QVector3D operator*(const QVector3D &v1, const QVector3D& v2)
@@ -257,8 +250,7 @@ inline const QVector3D operator-(const QVector3D &vector)
 
 inline const QVector3D operator/(const QVector3D &vector, qreal divisor)
 {
-    qrealinner d(divisor);
-    return QVector3D(vector.xp / d, vector.yp / d, vector.zp / d, 1);
+    return QVector3D(vector.xp / divisor, vector.yp / divisor, vector.zp / divisor, 1);
 }
 
 inline bool qFuzzyCompare(const QVector3D& v1, const QVector3D& v2)
@@ -275,8 +267,7 @@ inline QPoint QVector3D::toPoint() const
 
 inline QPointF QVector3D::toPointF() const
 {
-    return QPointF(qt_math3d_convert<qreal, qrealinner>(xp),
-                   qt_math3d_convert<qreal, qrealinner>(yp));
+    return QPointF(qreal(xp), qreal(yp));
 }
 
 #ifndef QT_NO_DEBUG_STREAM
diff --git a/src/gui/math3d/qvector4d.cpp b/src/gui/math3d/qvector4d.cpp
index 4287806..d19665a 100644
--- a/src/gui/math3d/qvector4d.cpp
+++ b/src/gui/math3d/qvector4d.cpp
@@ -42,7 +42,8 @@
 #include "qvector4d.h"
 #include "qvector3d.h"
 #include "qvector2d.h"
-#include "qmath3dutil_p.h"
+#include <QtCore/qdebug.h>
+#include <QtCore/qmath.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -237,8 +238,7 @@ QVector4D::QVector4D(const QVector3D& vector, qreal wpos)
 */
 qreal QVector4D::length() const
 {
-    return qvtsqrt64(qvtmul64(xp, xp) + qvtmul64(yp, yp) +
-                     qvtmul64(zp, zp) + qvtmul64(wp, wp));
+    return qSqrt(xp * xp + yp * yp + zp * zp + wp * wp);
 }
 
 /*!
@@ -249,8 +249,7 @@ qreal QVector4D::length() const
 */
 qreal QVector4D::lengthSquared() const
 {
-    return qvtdot64(qvtmul64(xp, xp) + qvtmul64(yp, yp) +
-                    qvtmul64(zp, zp) + qvtmul64(wp, wp));
+    return xp * xp + yp * yp + zp * zp + wp * wp;
 }
 
 /*!
@@ -336,8 +335,7 @@ void QVector4D::normalize()
 */
 qreal QVector4D::dotProduct(const QVector4D& v1, const QVector4D& v2)
 {
-    return qvtdot64(qvtmul64(v1.xp, v2.xp) + qvtmul64(v1.yp, v2.yp) +
-                    qvtmul64(v1.zp, v2.zp) + qvtmul64(v1.wp, v2.wp));
+    return v1.xp * v2.xp + v1.yp * v2.yp + v1.zp * v2.zp + v1.wp * v2.wp;
 }
 
 /*!
diff --git a/src/gui/math3d/qvector4d.h b/src/gui/math3d/qvector4d.h
index 4ac6ae8..12efc95 100644
--- a/src/gui/math3d/qvector4d.h
+++ b/src/gui/math3d/qvector4d.h
@@ -42,7 +42,6 @@
 #ifndef QVECTOR4D_H
 #define QVECTOR4D_H
 
-#include <QtGui/qmath3dglobal.h>
 #include <QtCore/qpoint.h>
 #include <QtCore/qmetatype.h>
 
@@ -127,15 +126,14 @@ public:
     QPointF toPointF() const;
 
 private:
-    qrealinner xp, yp, zp, wp;
+    float xp, yp, zp, wp;
 
-    QVector4D(qrealinner xpos, qrealinner ypos, qrealinner zpos, qrealinner wpos, int dummy);
+    QVector4D(float xpos, float ypos, float zpos, float wpos, int dummy);
 
     friend class QVector2D;
     friend class QVector3D;
     friend class QQuaternion;
     friend class QMatrix4x4;
-    friend class QVertexArray;
 #ifndef QT_NO_MATRIX4X4
     friend QVector4D operator*(const QVector4D& vector, const QMatrix4x4& matrix);
     friend QVector4D operator*(const QMatrix4x4& matrix, const QVector4D& vector);
@@ -146,7 +144,7 @@ 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(qrealinner xpos, qrealinner ypos, qrealinner zpos, qrealinner wpos, int) : 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(int xpos, int ypos, int zpos, int wpos) : xp(xpos), yp(ypos), zp(zpos), wp(wpos) {}
 
@@ -159,10 +157,10 @@ inline bool QVector4D::isNull() const
     return qIsNull(xp) && qIsNull(yp) && qIsNull(zp) && qIsNull(wp);
 }
 
-inline qreal QVector4D::x() const { return qt_math3d_convert<qreal, qrealinner>(xp); }
-inline qreal QVector4D::y() const { return qt_math3d_convert<qreal, qrealinner>(yp); }
-inline qreal QVector4D::z() const { return qt_math3d_convert<qreal, qrealinner>(zp); }
-inline qreal QVector4D::w() const { return qt_math3d_convert<qreal, qrealinner>(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 void QVector4D::setX(qreal x) { xp = x; }
 inline void QVector4D::setY(qreal y) { yp = y; }
@@ -189,11 +187,10 @@ inline QVector4D &QVector4D::operator-=(const QVector4D &vector)
 
 inline QVector4D &QVector4D::operator*=(qreal factor)
 {
-    qrealinner f(factor);
-    xp *= f;
-    yp *= f;
-    zp *= f;
-    wp *= f;
+    xp *= factor;
+    yp *= factor;
+    zp *= factor;
+    wp *= factor;
     return *this;
 }
 
@@ -208,11 +205,10 @@ inline QVector4D &QVector4D::operator*=(const QVector4D &vector)
 
 inline QVector4D &QVector4D::operator/=(qreal divisor)
 {
-    qrealinner d(divisor);
-    xp /= d;
-    yp /= d;
-    zp /= d;
-    wp /= d;
+    xp /= divisor;
+    yp /= divisor;
+    zp /= divisor;
+    wp /= divisor;
     return *this;
 }
 
@@ -238,14 +234,12 @@ inline const QVector4D operator-(const QVector4D &v1, const QVector4D &v2)
 
 inline const QVector4D operator*(qreal factor, const QVector4D &vector)
 {
-    qrealinner f(factor);
-    return QVector4D(vector.xp * f, vector.yp * f, vector.zp * f, vector.wp * f, 1);
+    return QVector4D(vector.xp * factor, vector.yp * factor, vector.zp * factor, vector.wp * factor, 1);
 }
 
 inline const QVector4D operator*(const QVector4D &vector, qreal factor)
 {
-    qrealinner f(factor);
-    return QVector4D(vector.xp * f, vector.yp * f, vector.zp * f, vector.wp * f, 1);
+    return QVector4D(vector.xp * factor, vector.yp * factor, vector.zp * factor, vector.wp * factor, 1);
 }
 
 inline const QVector4D operator*(const QVector4D &v1, const QVector4D& v2)
@@ -260,8 +254,7 @@ inline const QVector4D operator-(const QVector4D &vector)
 
 inline const QVector4D operator/(const QVector4D &vector, qreal divisor)
 {
-    qrealinner d(divisor);
-    return QVector4D(vector.xp / d, vector.yp / d, vector.zp / d, vector.wp / d, 1);
+    return QVector4D(vector.xp / divisor, vector.yp / divisor, vector.zp / divisor, vector.wp / divisor, 1);
 }
 
 inline bool qFuzzyCompare(const QVector4D& v1, const QVector4D& v2)
@@ -279,8 +272,7 @@ inline QPoint QVector4D::toPoint() const
 
 inline QPointF QVector4D::toPointF() const
 {
-    return QPointF(qt_math3d_convert<qreal, qrealinner>(xp),
-                   qt_math3d_convert<qreal, qrealinner>(yp));
+    return QPointF(qreal(xp), qreal(yp));
 }
 
 #ifndef QT_NO_DEBUG_STREAM
diff --git a/tests/auto/math3d/math3d.pro b/tests/auto/math3d/math3d.pro
index 3977e92..d6189ef 100644
--- a/tests/auto/math3d/math3d.pro
+++ b/tests/auto/math3d/math3d.pro
@@ -1,3 +1,2 @@
 TEMPLATE = subdirs
-SUBDIRS = qfixedpt qmatrixnxn qquaternion qvectornd
-SUBDIRS += qmatrixnxn_fixed qquaternion_fixed qvectornd_fixed
+SUBDIRS = qmatrixnxn qquaternion qvectornd
diff --git a/tests/auto/math3d/qfixedpt/qfixedpt.pro b/tests/auto/math3d/qfixedpt/qfixedpt.pro
deleted file mode 100644
index 94598b5..0000000
--- a/tests/auto/math3d/qfixedpt/qfixedpt.pro
+++ /dev/null
@@ -1,2 +0,0 @@
-load(qttest_p4)
-SOURCES += tst_qfixedpt.cpp
diff --git a/tests/auto/math3d/qfixedpt/tst_qfixedpt.cpp b/tests/auto/math3d/qfixedpt/tst_qfixedpt.cpp
deleted file mode 100644
index ef333a6..0000000
--- a/tests/auto/math3d/qfixedpt/tst_qfixedpt.cpp
+++ /dev/null
@@ -1,643 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
-**
-** This file is part of the $MODULE$ of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the either Technology Preview License Agreement or the
-** Beta Release License Agreement.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include <QtTest/QtTest>
-#include <QtCore/qmath.h>
-#include <QtGui/qfixedpt.h>
-
-class tst_QFixedPt : public QObject
-{
-    Q_OBJECT
-public:
-    tst_QFixedPt() {}
-    ~tst_QFixedPt() {}
-
-private slots:
-    void create_data();
-    void create();
-    void add_data();
-    void add();
-    void sub_data();
-    void sub();
-    void mul_data();
-    void mul();
-    void div_data();
-    void div();
-    void neg_data();
-    void neg();
-    void shift_data();
-    void shift();
-    void sqrt_data();
-    void sqrt();
-    void round_data();
-    void round();
-    void compare_data();
-    void compare();
-};
-
-// qFuzzyCompare isn't quite "fuzzy" enough to handle conversion
-// to fixed-point and back again.  So create a "fuzzier" compare.
-static bool fuzzyCompare(double x, double y)
-{
-    double diff = x - y;
-    if (diff < 0.0f)
-        diff = -diff;
-    return (diff < 0.0001);
-}
-
-// Test the creation of QFixedPt values in various ways.
-void tst_QFixedPt::create_data()
-{
-    QTest::addColumn<int>("value");
-    QTest::addColumn<int>("intValue");
-    QTest::addColumn<float>("realValue");
-
-    QTest::newRow("zero") << 0x00000000 << 0 << 0.0f;
-    QTest::newRow("one") << 0x00010000 << 1 << 1.0f;
-    QTest::newRow("1.5") << 0x00018000 << 2 << 1.5f;         // int rounds up
-    QTest::newRow("-1.5") << (int)0xFFFE8000 << -1 << -1.5f; // int rounds up
-    QTest::newRow("-7") << (int)0xFFF90000 << -7 << -7.0f;
-}
-void tst_QFixedPt::create()
-{
-    QFETCH(int, value);
-    QFETCH(int, intValue);
-    QFETCH(float, realValue);
-
-    if (qFloor(realValue) == realValue) {
-        QFixedPt<16> ivalue(intValue);
-        QCOMPARE(ivalue.bits(), value);
-        QCOMPARE(ivalue.toInt(), intValue);
-        QCOMPARE(ivalue.toReal(), (qreal)realValue);
-    }
-
-    QFixedPt<16> fvalue(realValue);
-    QCOMPARE(fvalue.bits(), value);
-    QCOMPARE(fvalue.toInt(), intValue);
-    QCOMPARE(fvalue.toReal(), (qreal)realValue);
-
-    QFixedPt<16> fpvalue;
-    fpvalue.setBits(value);
-    QCOMPARE(fpvalue.bits(), value);
-    QCOMPARE(fpvalue.toInt(), intValue);
-    QCOMPARE(fpvalue.toReal(), (qreal)realValue);
-
-    QFixedPt<16> fpvalue2(fpvalue);
-    QCOMPARE(fpvalue2.bits(), value);
-    QCOMPARE(fpvalue2.toInt(), intValue);
-    QCOMPARE(fpvalue2.toReal(), (qreal)realValue);
-
-    if (qFloor(realValue) == realValue) {
-        QFixedPt<16> ivalue2(63);   // Initialize the something else.
-        ivalue2 = intValue;         // Then change the value.
-        QCOMPARE(ivalue2.bits(), value);
-        QCOMPARE(ivalue2.toInt(), intValue);
-        QCOMPARE(ivalue2.toReal(), (qreal)realValue);
-    }
-
-    QFixedPt<16> fvalue2(36);
-    fvalue2 = realValue;
-    QCOMPARE(fvalue2.bits(), value);
-    QCOMPARE(fvalue2.toInt(), intValue);
-    QCOMPARE(fvalue2.toReal(), (qreal)realValue);
-
-    QFixedPt<16> fpvalue3;
-    fpvalue3 = fpvalue;
-    QCOMPARE(fpvalue3.bits(), value);
-    QCOMPARE(fpvalue3.toInt(), intValue);
-    QCOMPARE(fpvalue3.toReal(), (qreal)realValue);
-
-    // Now do some of the tests again with a different precision value.
-
-    if (qFloor(realValue) == realValue) {
-        QFixedPt<4> ivalue3(intValue);
-        QCOMPARE(ivalue3.bits(), value >> 12);
-        QCOMPARE(ivalue3.toInt(), intValue);
-        QCOMPARE(ivalue3.toReal(), (qreal)realValue);
-    }
-
-    QFixedPt<4> fvalue3(realValue);
-    QCOMPARE(fvalue3.bits(), value >> 12);
-    QCOMPARE(fvalue3.toInt(), intValue);
-    QCOMPARE(fvalue3.toReal(), (qreal)realValue);
-
-    QFixedPt<4> fpvalue4;
-    fpvalue4.setBits(value >> 12);
-    QCOMPARE(fpvalue4.bits(), value >> 12);
-    QCOMPARE(fpvalue4.toInt(), intValue);
-    QCOMPARE(fpvalue4.toReal(), (qreal)realValue);
-
-    // Test conversion between the precision values.
-
-#if !defined(QT_NO_MEMBER_TEMPLATES)
-    if (qFloor(realValue) == realValue) {
-        QFixedPt<16> ivalue(intValue);
-        QFixedPt<4> ivalue3(intValue);
-        QVERIFY(ivalue.toPrecision<4>() == ivalue3);
-        QVERIFY(ivalue3.toPrecision<16>() == ivalue);
-    }
-    QVERIFY(fvalue.toPrecision<4>() == fvalue3);
-    QVERIFY(fvalue3.toPrecision<16>() == fvalue);
-#endif
-
-    if (qFloor(realValue) == realValue) {
-        QFixedPt<16> ivalue(intValue);
-        QFixedPt<4> ivalue3(intValue);
-        QVERIFY(qFixedPtToPrecision<4>(ivalue) == ivalue3);
-        QVERIFY(qFixedPtToPrecision<16>(ivalue3) == ivalue);
-    }
-    QVERIFY(qFixedPtToPrecision<4>(fvalue) == fvalue3);
-    QVERIFY(qFixedPtToPrecision<16>(fvalue3) == fvalue);
-}
-
-// Test fixed point addition.
-void tst_QFixedPt::add_data()
-{
-    QTest::addColumn<float>("a");
-    QTest::addColumn<float>("b");
-
-    QTest::newRow("zero") << 0.0f << 0.0f;
-    QTest::newRow("test1") << 1.0f << 0.0f;
-    QTest::newRow("test2") << 0.0f << 1.0f;
-    QTest::newRow("test3") << 10.0f << -3.0f;
-    QTest::newRow("test4") << 10.5f << 3.25f;
-}
-void tst_QFixedPt::add()
-{
-    QFETCH(float, a);
-    QFETCH(float, b);
-
-    QFixedPt<16> avalue(a);
-    QFixedPt<16> bvalue(b);
-
-    QFixedPt<16> cvalue = avalue + bvalue;
-    QFixedPt<16> dvalue = a + bvalue;
-    QFixedPt<16> evalue = avalue + b;
-
-    QCOMPARE(cvalue.toReal(), (qreal)(a + b));
-    QCOMPARE(dvalue.toReal(), (qreal)(a + b));
-    QCOMPARE(evalue.toReal(), (qreal)(a + b));
-
-    QFixedPt<16> fvalue(avalue);
-    fvalue += bvalue;
-    QCOMPARE(fvalue.toReal(), (qreal)(a + b));
-
-    QFixedPt<16> gvalue(avalue);
-    gvalue += b;
-    QCOMPARE(gvalue.toReal(), (qreal)(a + b));
-
-    if (qFloor(a) == a && qFloor(b) == b) {
-        QFixedPt<16> hvalue = int(a) + bvalue;
-        QFixedPt<16> ivalue = avalue + int(b);
-
-        QCOMPARE(hvalue.toInt(), int(a) + int(b));
-        QCOMPARE(ivalue.toInt(), int(a) + int(b));
-        QCOMPARE(hvalue.toReal(), (qreal)(a + b));
-        QCOMPARE(ivalue.toReal(), (qreal)(a + b));
-
-        QFixedPt<16> jvalue(avalue);
-        jvalue += int(b);
-        QCOMPARE(jvalue.toReal(), (qreal)(a + b));
-    }
-}
-
-// Test fixed point subtraction.
-void tst_QFixedPt::sub_data()
-{
-    // Use the same test data as the add() test.
-    add_data();
-}
-void tst_QFixedPt::sub()
-{
-    QFETCH(float, a);
-    QFETCH(float, b);
-
-    QFixedPt<16> avalue(a);
-    QFixedPt<16> bvalue(b);
-
-    QFixedPt<16> cvalue = avalue - bvalue;
-    QFixedPt<16> dvalue = a - bvalue;
-    QFixedPt<16> evalue = avalue - b;
-
-    QCOMPARE(cvalue.toReal(), (qreal)(a - b));
-    QCOMPARE(dvalue.toReal(), (qreal)(a - b));
-    QCOMPARE(evalue.toReal(), (qreal)(a - b));
-
-    QFixedPt<16> fvalue(avalue);
-    fvalue -= bvalue;
-    QCOMPARE(fvalue.toReal(), (qreal)(a - b));
-
-    QFixedPt<16> gvalue(avalue);
-    gvalue -= b;
-    QCOMPARE(gvalue.toReal(), (qreal)(a - b));
-
-    if (qFloor(a) == a && qFloor(b) == b) {
-        QFixedPt<16> hvalue = int(a) - bvalue;
-        QFixedPt<16> ivalue = avalue - int(b);
-
-        QCOMPARE(hvalue.toInt(), int(a) - int(b));
-        QCOMPARE(ivalue.toInt(), int(a) - int(b));
-        QCOMPARE(hvalue.toReal(), (qreal)(a - b));
-        QCOMPARE(ivalue.toReal(), (qreal)(a - b));
-
-        QFixedPt<16> jvalue(avalue);
-        jvalue -= int(b);
-        QCOMPARE(jvalue.toReal(), (qreal)(a - b));
-    }
-}
-
-// Test fixed point multiplication.
-void tst_QFixedPt::mul_data()
-{
-    // Use the same test data as the add() test.
-    add_data();
-}
-void tst_QFixedPt::mul()
-{
-    QFETCH(float, a);
-    QFETCH(float, b);
-
-    QFixedPt<16> avalue(a);
-    QFixedPt<16> bvalue(b);
-
-    QFixedPt<16> cvalue = avalue * bvalue;
-    QFixedPt<16> dvalue = a * bvalue;
-    QFixedPt<16> evalue = avalue * b;
-
-    QCOMPARE(cvalue.toReal(), (qreal)(a * b));
-    QCOMPARE(dvalue.toReal(), (qreal)(a * b));
-    QCOMPARE(evalue.toReal(), (qreal)(a * b));
-
-    QFixedPt<16> fvalue(avalue);
-    fvalue *= bvalue;
-    QCOMPARE(fvalue.toReal(), (qreal)(a * b));
-
-    QFixedPt<16> gvalue(avalue);
-    gvalue *= b;
-    QCOMPARE(gvalue.toReal(), (qreal)(a * b));
-
-    if (qFloor(a) == a && qFloor(b) == b) {
-        QFixedPt<16> hvalue = int(a) * bvalue;
-        QFixedPt<16> ivalue = avalue * int(b);
-
-        QCOMPARE(hvalue.toInt(), int(a) * int(b));
-        QCOMPARE(ivalue.toInt(), int(a) * int(b));
-        QCOMPARE(hvalue.toReal(), (qreal)(a * b));
-        QCOMPARE(ivalue.toReal(), (qreal)(a * b));
-
-        QFixedPt<16> jvalue(avalue);
-        jvalue *= int(b);
-        QCOMPARE(jvalue.toReal(), (qreal)(a * b));
-    }
-}
-
-// Test fixed point division.
-void tst_QFixedPt::div_data()
-{
-    // Use the same test data as the add() test.
-    add_data();
-}
-void tst_QFixedPt::div()
-{
-    QFETCH(float, a);
-    QFETCH(float, b);
-
-    QFixedPt<16> avalue(a);
-    QFixedPt<16> bvalue(b);
-
-    qreal result;
-    if (b == 0.0f)
-        result = 0.0f;       // Divide by zero results in zero.
-    else
-        result = a / b;
-
-    QFixedPt<16> cvalue = avalue / bvalue;
-    QFixedPt<16> dvalue = a / bvalue;
-    QFixedPt<16> evalue = avalue / b;
-
-    QVERIFY(fuzzyCompare(cvalue.toReal(), result));
-    QVERIFY(fuzzyCompare(dvalue.toReal(), result));
-    QVERIFY(fuzzyCompare(evalue.toReal(), result));
-
-    QFixedPt<16> fvalue(avalue);
-    fvalue /= bvalue;
-    QVERIFY(fuzzyCompare(fvalue.toReal(), result));
-
-    QFixedPt<16> gvalue(avalue);
-    gvalue /= b;
-    QVERIFY(fuzzyCompare(gvalue.toReal(), result));
-
-    if (qFloor(a) == a && qFloor(b) == b) {
-        QFixedPt<16> hvalue = int(a) / bvalue;
-        QFixedPt<16> ivalue = avalue / int(b);
-
-        QCOMPARE(hvalue.toInt(), int(result));
-        QCOMPARE(ivalue.toInt(), int(result));
-        QVERIFY(fuzzyCompare(hvalue.toReal(), result));
-        QVERIFY(fuzzyCompare(ivalue.toReal(), result));
-
-        QFixedPt<16> jvalue(avalue);
-        jvalue /= int(b);
-        QVERIFY(fuzzyCompare(jvalue.toReal(), result));
-    }
-}
-
-// Test fixed point negation.
-void tst_QFixedPt::neg_data()
-{
-    // Use the same test data as the add() test.
-    add_data();
-}
-void tst_QFixedPt::neg()
-{
-    QFETCH(float, a);
-    QFETCH(float, b);
-
-    QFixedPt<16> avalue(a);
-    QFixedPt<16> bvalue(b);
-
-    QFixedPt<16> cvalue = -avalue;
-    QCOMPARE(cvalue.bits(), -avalue.bits());
-    QCOMPARE(cvalue.toInt(), int(-a));
-    QCOMPARE(cvalue.toReal(), (qreal)-a);
-
-    QFixedPt<16> dvalue = -bvalue;
-    QCOMPARE(dvalue.bits(), -bvalue.bits());
-    QCOMPARE(dvalue.toInt(), int(-b));
-    QCOMPARE(dvalue.toReal(), (qreal)-b);
-}
-
-// Test left and right shift operators on fixed point values.
-void tst_QFixedPt::shift_data()
-{
-    QTest::addColumn<float>("a");
-    QTest::addColumn<int>("amount");
-
-    QTest::newRow("zero") << 0.0f << 5;
-    QTest::newRow("one") << 1.0f << 4;
-    QTest::newRow("-1.75") << -1.75f << 4;
-}
-void tst_QFixedPt::shift()
-{
-    QFETCH(float, a);
-    QFETCH(int, amount);
-
-    int lresult = int((a * 65536.0) * (1 << amount));
-    int rresult = int((a * 65536.0) / (1 << amount));
-
-    QFixedPt<16> avalue(a);
-    avalue <<= amount;
-    QCOMPARE(avalue.bits(), lresult);
-
-    QFixedPt<16> bvalue(a);
-    bvalue >>= amount;
-    QCOMPARE(bvalue.bits(), rresult);
-
-    QFixedPt<16> cvalue(a);
-
-    QFixedPt<16> dvalue;
-    dvalue = cvalue << amount;
-    QCOMPARE(dvalue.bits(), lresult);
-
-    QFixedPt<16> evalue;
-    evalue = cvalue >> amount;
-    QCOMPARE(evalue.bits(), rresult);
-}
-
-// Test fixed point square root.
-void tst_QFixedPt::sqrt_data()
-{
-    QTest::addColumn<float>("a");
-
-    QTest::newRow("zero") << 0.0f;
-    QTest::newRow("one") << 1.0f;
-    QTest::newRow("two") << 2.0f;
-    QTest::newRow("sixteen") << 16.0f;
-    QTest::newRow("1.5") << 1.5f;
-}
-void tst_QFixedPt::sqrt()
-{
-    QFETCH(float, a);
-
-    QFixedPt<16> avalue(a);
-    QVERIFY(fuzzyCompare(avalue.sqrt().toReal(), qSqrt(a)));
-    QVERIFY(fuzzyCompare(avalue.sqrtF(), qSqrt(a)));
-}
-
-// Test fixed point rounding.
-void tst_QFixedPt::round_data()
-{
-    QTest::addColumn<float>("a");
-    QTest::addColumn<int>("rounded");
-    QTest::addColumn<int>("ceiling");
-    QTest::addColumn<int>("flooring");
-    QTest::addColumn<int>("truncated");
-
-    QTest::newRow("zero") << 0.0f << 0 << 0 << 0 << 0;
-    QTest::newRow("test1") << 1.0f << 1 << 1 << 1 << 1;
-    QTest::newRow("test2") << 2.5f << 3 << 3 << 2 << 2;
-    QTest::newRow("test3") << 2.3f << 2 << 3 << 2 << 2;
-    QTest::newRow("test4") << -2.5f << -2 << -2 << -3 << -3;
-    QTest::newRow("test5") << -2.3f << -2 << -2 << -3 << -3;
-    QTest::newRow("test6") << -2.7f << -3 << -2 << -3 << -3;
-}
-void tst_QFixedPt::round()
-{
-    QFETCH(float, a);
-    QFETCH(int, rounded);
-    QFETCH(int, ceiling);
-    QFETCH(int, flooring);
-    QFETCH(int, truncated);
-
-    QFixedPt<16> avalue(a);
-    QVERIFY(avalue.round() == rounded);
-    QVERIFY(avalue.ceil() == ceiling);
-    QVERIFY(avalue.floor() == flooring);
-    QVERIFY(avalue.truncate() == truncated);
-
-    QCOMPARE(qRound(avalue), rounded);
-    QCOMPARE(qCeil(avalue), ceiling);
-    QCOMPARE(qFloor(avalue), flooring);
-}
-
-// Test comparison operators.
-void tst_QFixedPt::compare_data()
-{
-    QTest::addColumn<float>("a");
-    QTest::addColumn<float>("b");
-
-    QTest::newRow("test1") << 0.0f << 0.0f;
-    QTest::newRow("test2") << 1.0f << 0.0f;
-    QTest::newRow("test3") << 2.5f << 2.5f;
-    QTest::newRow("test4") << 2.5f << -2.5f;
-    QTest::newRow("test5") << -2.5f << 2.5f;
-}
-void tst_QFixedPt::compare()
-{
-    QFETCH(float, a);
-    QFETCH(float, b);
-
-    QFixedPt<16> avalue(a);
-    QFixedPt<16> bvalue(b);
-
-    if (a == b) {
-        QVERIFY(avalue == bvalue);
-        QVERIFY(avalue == b);
-        QVERIFY(a == bvalue);
-        QVERIFY(!(avalue != bvalue));
-        QVERIFY(!(avalue != b));
-        QVERIFY(!(a != bvalue));
-        QVERIFY(!(avalue < bvalue));
-        QVERIFY(!(avalue < b));
-        QVERIFY(!(a < bvalue));
-        QVERIFY(!(avalue > bvalue));
-        QVERIFY(!(avalue > b));
-        QVERIFY(!(a > bvalue));
-        QVERIFY(avalue <= bvalue);
-        QVERIFY(avalue <= b);
-        QVERIFY(a <= bvalue);
-        QVERIFY(avalue >= bvalue);
-        QVERIFY(avalue >= b);
-        QVERIFY(a >= bvalue);
-        if (qFloor(a) == a) {
-            QVERIFY(int(a) == bvalue);
-            QVERIFY(!(int(a) != bvalue));
-            QVERIFY(!(int(a) < bvalue));
-            QVERIFY(!(int(a) > bvalue));
-            QVERIFY(int(a) <= bvalue);
-            QVERIFY(int(a) >= bvalue);
-        }
-        if (qFloor(b) == b) {
-            QVERIFY(avalue == int(b));
-            QVERIFY(!(avalue != int(b)));
-            QVERIFY(!(avalue < int(b)));
-            QVERIFY(!(avalue > int(b)));
-            QVERIFY(avalue <= int(b));
-            QVERIFY(avalue >= int(b));
-        }
-    }
-
-    if (a != b) {
-        QVERIFY(avalue != bvalue);
-        QVERIFY(avalue != b);
-        QVERIFY(a != bvalue);
-        QVERIFY(!(avalue == bvalue));
-        QVERIFY(!(avalue == b));
-        QVERIFY(!(a == bvalue));
-        if (qFloor(a) == a) {
-            QVERIFY(int(a) != bvalue);
-            QVERIFY(!(int(a) == bvalue));
-        }
-        if (qFloor(b) == b) {
-            QVERIFY(avalue != int(b));
-            QVERIFY(!(avalue == int(b)));
-        }
-    }
-
-    if (a < b) {
-        QVERIFY(avalue < bvalue);
-        QVERIFY(avalue < b);
-        QVERIFY(a < bvalue);
-        QVERIFY(!(avalue >= bvalue));
-        QVERIFY(!(avalue >= b));
-        QVERIFY(!(a >= bvalue));
-        QVERIFY(!(avalue > bvalue));
-        QVERIFY(!(avalue > b));
-        QVERIFY(!(a > bvalue));
-        QVERIFY(avalue <= bvalue);
-        QVERIFY(avalue <= b);
-        QVERIFY(a <= bvalue);
-        QVERIFY(!(avalue >= bvalue));
-        QVERIFY(!(avalue >= b));
-        QVERIFY(!(a >= bvalue));
-        if (qFloor(a) == a) {
-            QVERIFY(int(a) < bvalue);
-            QVERIFY(!(int(a) >= bvalue));
-            QVERIFY(!(int(a) > bvalue));
-            QVERIFY(int(a) <= bvalue);
-        }
-        if (qFloor(b) == b) {
-            QVERIFY(avalue < int(b));
-            QVERIFY(!(avalue >= int(b)));
-            QVERIFY(!(avalue > int(b)));
-            QVERIFY(avalue <= int(b));
-        }
-    }
-
-    if (a > b) {
-        QVERIFY(avalue > bvalue);
-        QVERIFY(avalue > b);
-        QVERIFY(a > bvalue);
-        QVERIFY(!(avalue <= bvalue));
-        QVERIFY(!(avalue <= b));
-        QVERIFY(!(a <= bvalue));
-        QVERIFY(!(avalue < bvalue));
-        QVERIFY(!(avalue < b));
-        QVERIFY(!(a < bvalue));
-        QVERIFY(avalue >= bvalue);
-        QVERIFY(avalue >= b);
-        QVERIFY(a >= bvalue);
-        QVERIFY(!(avalue <= bvalue));
-        QVERIFY(!(avalue <= b));
-        QVERIFY(!(a <= bvalue));
-        if (qFloor(a) == a) {
-            QVERIFY(int(a) > bvalue);
-            QVERIFY(!(int(a) <= bvalue));
-            QVERIFY(!(int(a) < bvalue));
-            QVERIFY(int(a) >= bvalue);
-        }
-        if (qFloor(b) == b) {
-            QVERIFY(avalue > int(b));
-            QVERIFY(!(avalue <= int(b)));
-            QVERIFY(!(avalue < int(b)));
-            QVERIFY(avalue >= int(b));
-        }
-    }
-
-    if (qFuzzyCompare(a, b))
-        QVERIFY(qFuzzyCompare(avalue, bvalue));
-    else
-        QVERIFY(!qFuzzyCompare(avalue, bvalue));
-}
-
-QTEST_APPLESS_MAIN(tst_QFixedPt)
-
-#include "tst_qfixedpt.moc"
diff --git a/tests/auto/math3d/qmatrixnxn/tst_qmatrixnxn.cpp b/tests/auto/math3d/qmatrixnxn/tst_qmatrixnxn.cpp
index 8a7dd49..bb510fc 100644
--- a/tests/auto/math3d/qmatrixnxn/tst_qmatrixnxn.cpp
+++ b/tests/auto/math3d/qmatrixnxn/tst_qmatrixnxn.cpp
@@ -321,7 +321,7 @@ void tst_QMatrix::setMatrix(QMatrix4x3& m, const qreal *values)
 // to be in row-major order.  This sets the values using fixed-point.
 void tst_QMatrix::setMatrixFixed(QMatrix2x2& m, const qreal *values)
 {
-    qrealinner *data = m.data();
+    float *data = m.data();
     for (int row = 0; row < 2; ++row) {
         for (int col = 0; col < 2; ++col) {
             data[row + col * 2] = values[row * 2 + col];
@@ -330,7 +330,7 @@ void tst_QMatrix::setMatrixFixed(QMatrix2x2& m, const qreal *values)
 }
 void tst_QMatrix::setMatrixFixed(QMatrix3x3& m, const qreal *values)
 {
-    qrealinner *data = m.data();
+    float *data = m.data();
     for (int row = 0; row < 3; ++row) {
         for (int col = 0; col < 3; ++col) {
             data[row + col * 3] = values[row * 3 + col];
@@ -339,7 +339,7 @@ void tst_QMatrix::setMatrixFixed(QMatrix3x3& m, const qreal *values)
 }
 void tst_QMatrix::setMatrixFixed(QMatrix4x4& m, const qreal *values)
 {
-    qrealinner *data = m.data();
+    float *data = m.data();
     for (int row = 0; row < 4; ++row) {
         for (int col = 0; col < 4; ++col) {
             data[row + col * 4] = values[row * 4 + col];
@@ -348,7 +348,7 @@ void tst_QMatrix::setMatrixFixed(QMatrix4x4& m, const qreal *values)
 }
 void tst_QMatrix::setMatrixFixed(QMatrix4x3& m, const qreal *values)
 {
-    qrealinner *data = m.data();
+    float *data = m.data();
     for (int row = 0; row < 3; ++row) {
         for (int col = 0; col < 4; ++col) {
             data[row + col * 3] = values[row * 4 + col];
@@ -365,15 +365,6 @@ static bool fuzzyCompare(float x, float y, qreal epsilon = 0.001)
         diff = -diff;
     return (diff < epsilon);
 }
-#ifdef QT_GL_FIXED_PREFERRED
-static bool fuzzyCompareFixed(qrealinner x, int y)
-{
-    int diff = x.bits() - y;
-    if (diff < 0)
-        diff = -diff;
-    return (diff < 50);
-}
-#endif
 
 static bool fuzzyCompare(const QVector3D &v1, const QVector3D &v2, qreal epsilon = 0.001)
 {
@@ -402,7 +393,7 @@ static bool matrixFuzzyCompare(const QMatrix4x4 &m1, const QMatrix4x4 &m2)
 // The values are assumed to be specified in row-major order.
 bool tst_QMatrix::isSame(const QMatrix2x2& m, const qreal *values)
 {
-    const qrealinner *mv = m.constData();
+    const float *mv = m.constData();
     for (int row = 0; row < 2; ++row) {
         for (int col = 0; col < 2; ++col) {
             // Check the values using the operator() function.
@@ -413,24 +404,17 @@ bool tst_QMatrix::isSame(const QMatrix2x2& m, const qreal *values)
 
             // Check the values using direct access, which verifies that the values
             // are stored internally in column-major order.
-#ifdef QT_GL_FIXED_PREFERRED
-            if (!fuzzyCompareFixed(mv[col * 2 + row], (int)(values[row * 2 + col] * 65536.0))) {
-                qDebug() << "column fixed-point failure at" << row << col << "actual =" << mv[col * 2 + row] << "expected =" << (int)(values[row * 2 + col] * 65536.0);
-                return false;
-            }
-#else
             if (!fuzzyCompare((float)(mv[col * 2 + row]), (float)(values[row * 2 + col]))) {
                 qDebug() << "column floating-point failure at" << row << col << "actual =" << mv[col * 2 + row] << "expected =" << values[row * 2 + col];
                 return false;
             }
-#endif
         }
     }
     return true;
 }
 bool tst_QMatrix::isSame(const QMatrix3x3& m, const qreal *values)
 {
-    const qrealinner *mv = m.constData();
+    const float *mv = m.constData();
     for (int row = 0; row < 3; ++row) {
         for (int col = 0; col < 3; ++col) {
             // Check the values using the operator() access function.
@@ -441,24 +425,17 @@ bool tst_QMatrix::isSame(const QMatrix3x3& m, const qreal *values)
 
             // Check the values using direct access, which verifies that the values
             // are stored internally in column-major order.
-#ifdef QT_GL_FIXED_PREFERRED
-            if (!fuzzyCompareFixed(mv[col * 3 + row], (int)(values[row * 3 + col] * 65536.0))) {
-                qDebug() << "column fixed-point failure at" << row << col << "actual =" << mv[col * 3 + row] << "expected =" << (int)(values[row * 3 + col] * 65536.0);
-                return false;
-            }
-#else
             if (!fuzzyCompare((float)(mv[col * 3 + row]), (float)(values[row * 3 + col]))) {
                 qDebug() << "column floating-point failure at" << row << col << "actual =" << mv[col * 3 + row] << "expected =" << values[row * 3 + col];
                 return false;
             }
-#endif
         }
     }
     return true;
 }
 bool tst_QMatrix::isSame(const QMatrix4x4& m, const qreal *values)
 {
-    const qrealinner *mv = m.constData();
+    const float *mv = m.constData();
     for (int row = 0; row < 4; ++row) {
         for (int col = 0; col < 4; ++col) {
             // Check the values using the operator() access function.
@@ -469,24 +446,17 @@ bool tst_QMatrix::isSame(const QMatrix4x4& m, const qreal *values)
 
             // Check the values using direct access, which verifies that the values
             // are stored internally in column-major order.
-#ifdef QT_GL_FIXED_PREFERRED
-            if (!fuzzyCompareFixed(mv[col * 4 + row], (int)(values[row * 4 + col] * 65536.0))) {
-                qDebug() << "column fixed-point failure at" << row << col << "actual =" << mv[col * 4 + row] << "expected =" << (int)(values[row * 4 + col] * 65536.0);
-                return false;
-            }
-#else
             if (!fuzzyCompare((float)(mv[col * 4 + row]), (float)(values[row * 4 + col]))) {
                 qDebug() << "column floating-point failure at" << row << col << "actual =" << mv[col * 4 + row] << "expected =" << values[row * 4 + col];
                 return false;
             }
-#endif
         }
     }
     return true;
 }
 bool tst_QMatrix::isSame(const QMatrix4x3& m, const qreal *values)
 {
-    const qrealinner *mv = m.constData();
+    const float *mv = m.constData();
     for (int row = 0; row < 3; ++row) {
         for (int col = 0; col < 4; ++col) {
             // Check the values using the operator() access function.
@@ -497,17 +467,10 @@ bool tst_QMatrix::isSame(const QMatrix4x3& m, const qreal *values)
 
             // Check the values using direct access, which verifies that the values
             // are stored internally in column-major order.
-#ifdef QT_GL_FIXED_PREFERRED
-            if (!fuzzyCompareFixed(mv[col * 3 + row], (int)(values[row * 4 + col] * 65536.0))) {
-                qDebug() << "column fixed-point failure at" << row << col << "actual =" << mv[col * 3 + row] << "expected =" << (int)(values[row * 4 + col] * 65536.0);
-                return false;
-            }
-#else
             if (!fuzzyCompare((float)(mv[col * 3 + row]), (float)(values[row * 4 + col]))) {
                 qDebug() << "column floating-point failure at" << row << col << "actual =" << mv[col * 3 + row] << "expected =" << values[row * 4 + col];
                 return false;
             }
-#endif
         }
     }
     return true;
@@ -1333,7 +1296,7 @@ void tst_QMatrix::multiply4x3()
     QMatrix4x3 m1((const qreal *)m1Values);
     QMatrix3x4 m2((const qreal *)m2Values);
 
-    QGenericMatrix<3, 3, qreal, qrealinner> m4;
+    QGenericMatrix<3, 3, qreal, float> m4;
     m4 = m1 * m2;
     qreal values[9];
     m4.toValueArray(values);
@@ -2901,11 +2864,7 @@ void tst_QMatrix::extractAxisRotation()
 
     m.extractAxisRotation(extractedAngle, extractedAxis);
  
-#ifdef QT_GL_FIXED_PREFERRED
-    qreal epsilon = 0.003;
-#else
     qreal epsilon = 0.001;
-#endif
  
     if (angle > 180) {
         QVERIFY(fuzzyCompare(360.0f - angle, extractedAngle, epsilon));
@@ -2953,11 +2912,7 @@ void tst_QMatrix::extractTranslation()
 
     QVector3D vec = rotation.extractTranslation();
 
-#ifdef QT_GL_FIXED_PREFERRED
-    qreal epsilon = 0.01;
-#else
     qreal epsilon = 0.001;
-#endif
    
     QVERIFY(fuzzyCompare(vec.x(), x, epsilon));
     QVERIFY(fuzzyCompare(vec.y(), y, epsilon));
@@ -2992,7 +2947,7 @@ enum {
 // Structure that allows direct access to "flagBits" for testing.
 struct Matrix4x4
 {
-    qrealinner m[4][4];
+    float m[4][4];
     int flagBits;
 };
 
@@ -3225,24 +3180,6 @@ void tst_QMatrix::fill()
     QVERIFY(isSame(m2, fillValues4x3));
 }
 
-// Force the fixed-point version of the test case to put a
-// different test name on the front of failure reports.
-class tst_QMatrixFixed : public tst_QMatrix
-{
-    Q_OBJECT
-public:
-    tst_QMatrixFixed() {}
-    ~tst_QMatrixFixed() {}
-};
-
-#ifdef QT_GL_FIXED_PREFERRED
-
-QTEST_APPLESS_MAIN(tst_QMatrixFixed)
-
-#else
-
 QTEST_APPLESS_MAIN(tst_QMatrix)
 
-#endif
-
 #include "tst_qmatrixnxn.moc"
diff --git a/tests/auto/math3d/qmatrixnxn_fixed/qmatrixnxn_fixed.pro b/tests/auto/math3d/qmatrixnxn_fixed/qmatrixnxn_fixed.pro
deleted file mode 100644
index cd1c8fa..0000000
--- a/tests/auto/math3d/qmatrixnxn_fixed/qmatrixnxn_fixed.pro
+++ /dev/null
@@ -1,8 +0,0 @@
-load(qttest_p4)
-VPATH += ../shared
-VPATH += ../qmatrixnxn
-INCLUDEPATH += ../shared
-INCLUDEPATH += ../../../../src/gui/math3d
-DEFINES += FIXED_POINT_TESTS
-HEADERS += math3dincludes.h
-SOURCES += tst_qmatrixnxn.cpp math3dincludes.cpp
diff --git a/tests/auto/math3d/qquaternion/tst_qquaternion.cpp b/tests/auto/math3d/qquaternion/tst_qquaternion.cpp
index 325cb40..fd7c7f8 100644
--- a/tests/auto/math3d/qquaternion/tst_qquaternion.cpp
+++ b/tests/auto/math3d/qquaternion/tst_qquaternion.cpp
@@ -768,24 +768,6 @@ void tst_QQuaternion::interpolate()
     QVERIFY(fuzzyCompare(result.scalar(), q3.scalar()));
 }
 
-// Force the fixed-point version of the test case to put a
-// different test name on the front of failure reports.
-class tst_QQuaternionFixed : public tst_QQuaternion
-{
-    Q_OBJECT
-public:
-    tst_QQuaternionFixed() {}
-    ~tst_QQuaternionFixed() {}
-};
-
-#ifdef QT_GL_FIXED_PREFERRED
-
-QTEST_APPLESS_MAIN(tst_QQuaternionFixed)
-
-#else
-
 QTEST_APPLESS_MAIN(tst_QQuaternion)
 
-#endif
-
 #include "tst_qquaternion.moc"
diff --git a/tests/auto/math3d/qquaternion_fixed/qquaternion_fixed.pro b/tests/auto/math3d/qquaternion_fixed/qquaternion_fixed.pro
deleted file mode 100644
index a0d5401..0000000
--- a/tests/auto/math3d/qquaternion_fixed/qquaternion_fixed.pro
+++ /dev/null
@@ -1,8 +0,0 @@
-load(qttest_p4)
-VPATH += ../shared
-VPATH += ../qquaternion
-INCLUDEPATH += ../shared
-INCLUDEPATH += ../../../../src/gui/math3d
-DEFINES += FIXED_POINT_TESTS
-HEADERS += math3dincludes.h
-SOURCES += tst_qquaternion.cpp math3dincludes.cpp
diff --git a/tests/auto/math3d/qvectornd/tst_qvectornd.cpp b/tests/auto/math3d/qvectornd/tst_qvectornd.cpp
index 83bacdf..a092fb0 100644
--- a/tests/auto/math3d/qvectornd/tst_qvectornd.cpp
+++ b/tests/auto/math3d/qvectornd/tst_qvectornd.cpp
@@ -2040,24 +2040,6 @@ void tst_QVector::dotProduct4()
     QCOMPARE(QVector4D::dotProduct(v1, v2), d);
 }
 
-// Force the fixed-point version of the test case to put a
-// different test name on the front of failure reports.
-class tst_QVectorFixed : public tst_QVector
-{
-    Q_OBJECT
-public:
-    tst_QVectorFixed() {}
-    ~tst_QVectorFixed() {}
-};
-
-#ifdef QT_GL_FIXED_PREFERRED
-
-QTEST_APPLESS_MAIN(tst_QVectorFixed)
-
-#else
-
 QTEST_APPLESS_MAIN(tst_QVector)
 
-#endif
-
 #include "tst_qvectornd.moc"
diff --git a/tests/auto/math3d/qvectornd_fixed/qvectornd_fixed.pro b/tests/auto/math3d/qvectornd_fixed/qvectornd_fixed.pro
deleted file mode 100644
index a667fcc..0000000
--- a/tests/auto/math3d/qvectornd_fixed/qvectornd_fixed.pro
+++ /dev/null
@@ -1,8 +0,0 @@
-load(qttest_p4)
-VPATH += ../shared
-VPATH += ../qvectornd
-INCLUDEPATH += ../shared
-INCLUDEPATH += ../../../../src/gui/math3d
-DEFINES += FIXED_POINT_TESTS
-HEADERS += math3dincludes.h
-SOURCES += tst_qvectornd.cpp math3dincludes.cpp
diff --git a/tests/auto/math3d/shared/math3dincludes.cpp b/tests/auto/math3d/shared/math3dincludes.cpp
deleted file mode 100644
index 725079d..0000000
--- a/tests/auto/math3d/shared/math3dincludes.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
-**
-** This file is part of the $MODULE$ of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the either Technology Preview License Agreement or the
-** Beta Release License Agreement.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "math3dincludes.h"
-
-#if defined(FIXED_POINT_TESTS)
-
-#include "qmatrix4x4.cpp"
-#include "qgenericmatrix.cpp"
-#include "qvector2d.cpp"
-#include "qvector3d.cpp"
-#include "qvector4d.cpp"
-#include "qquaternion.cpp"
-#include "qmath3dutil.cpp"
-
-#endif
diff --git a/tests/auto/math3d/shared/math3dincludes.h b/tests/auto/math3d/shared/math3dincludes.h
index 23b0f16..1ac0c08 100644
--- a/tests/auto/math3d/shared/math3dincludes.h
+++ b/tests/auto/math3d/shared/math3dincludes.h
@@ -42,41 +42,6 @@
 #ifndef MATH3DINCLUDES_H
 #define MATH3DINCLUDES_H
 
-#if defined(FIXED_POINT_TESTS)
-
-// Rename the classes we want to test in fixed-point mode so that
-// they don't conflict with the ones that are built into Qt.
-#define QT_NO_GL_FLOAT 1
-#define QVector2D           tst_QVector2D
-#define QVector3D           tst_QVector3D
-#define QVector4D           tst_QVector4D
-#define QQuaternion         tst_QQuaternionX
-#define QMatrix2x2          tst_QMatrix2x2
-#define QMatrix3x3          tst_QMatrix3x3
-#define QMatrix4x4          tst_QMatrix4x4
-#define QMatrix2x3          tst_QMatrix2x3
-#define QMatrix2x4          tst_QMatrix2x4
-#define QMatrix3x2          tst_QMatrix3x2
-#define QMatrix3x4          tst_QMatrix3x4
-#define QMatrix4x2          tst_QMatrix4x2
-#define QMatrix4x3          tst_QMatrix4x3
-#define QGenericMatrix      tst_QGenericMatrix
-#define qt_math3d_sincos    tst_qt_math3d_sincos
-#define qt_math3d_convert   tst_qt_math3d_convert
-#define qrealinner          tst_qrealinner
-
-// We need to re-include the headers with the changed class names.
-#undef QGENERICMATRIX_H
-#undef QMATH3DGLOBAL_H
-#undef QMATH3DUTIL_P_H
-#undef QMATRIX4X4_H
-#undef QQUATERNION_H
-#undef QVECTOR2D_H
-#undef QVECTOR3D_H
-#undef QVECTOR4D_H
-
-#endif
-
 #include <QtGui/qmatrix4x4.h>
 #include <QtGui/qgenericmatrix.h>
 #include <QtGui/qvector2d.h>