Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2026-09-22 09:03:16 

0001 // Copyright (C) 2016 The Qt Company Ltd.
0002 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
0003 
0004 #ifndef QQUATERNION_H
0005 #define QQUATERNION_H
0006 
0007 #include <QtGui/qtguiglobal.h>
0008 #include <QtGui/qgenericmatrix.h>
0009 #include <QtGui/qvector3d.h>
0010 #include <QtGui/qvector4d.h>
0011 
0012 QT_BEGIN_NAMESPACE
0013 
0014 
0015 #ifndef QT_NO_QUATERNION
0016 
0017 class QMatrix4x4;
0018 class QVariant;
0019 
0020 class QT6_ONLY(Q_GUI_EXPORT) QQuaternion
0021 {
0022 public:
0023     constexpr QQuaternion() noexcept;
0024     explicit QQuaternion(Qt::Initialization) noexcept {}
0025     constexpr QQuaternion(float scalar, float xpos, float ypos, float zpos) noexcept;
0026 #ifndef QT_NO_VECTOR3D
0027     constexpr QQuaternion(float scalar, const QVector3D &vector) noexcept;
0028 #endif
0029 #ifndef QT_NO_VECTOR4D
0030     constexpr explicit QQuaternion(const QVector4D &vector) noexcept;
0031 #endif
0032 
0033     constexpr bool isNull() const noexcept;
0034     constexpr bool isIdentity() const noexcept;
0035 
0036 #ifndef QT_NO_VECTOR3D
0037     constexpr QVector3D vector() const noexcept;
0038     constexpr void setVector(const QVector3D &vector) noexcept;
0039 #endif
0040     constexpr void setVector(float x, float y, float z) noexcept;
0041 
0042     constexpr float x() const noexcept;
0043     constexpr float y() const noexcept;
0044     constexpr float z() const noexcept;
0045     constexpr float scalar() const noexcept;
0046 
0047     constexpr void setX(float x) noexcept;
0048     constexpr void setY(float y) noexcept;
0049     constexpr void setZ(float z) noexcept;
0050     constexpr void setScalar(float scalar) noexcept;
0051 
0052     constexpr static float dotProduct(const QQuaternion &q1, const QQuaternion &q2) noexcept;
0053 
0054     // ### Qt 7: make the next four constexpr
0055     // (perhaps using std::hypot, constexpr in C++26, or constexpr qHypot)
0056     QT7_ONLY(Q_GUI_EXPORT) float length() const;
0057     QT7_ONLY(Q_GUI_EXPORT) float lengthSquared() const;
0058 
0059     [[nodiscard]] QT7_ONLY(Q_GUI_EXPORT) QQuaternion normalized() const;
0060     QT7_ONLY(Q_GUI_EXPORT)  void normalize();
0061 
0062     constexpr QQuaternion inverted() const noexcept;
0063 
0064     [[nodiscard]] constexpr QQuaternion conjugated() const noexcept;
0065 
0066     QT7_ONLY(Q_GUI_EXPORT) QVector3D rotatedVector(const QVector3D &vector) const;
0067 
0068     constexpr QQuaternion &operator+=(const QQuaternion &quaternion) noexcept;
0069     constexpr QQuaternion &operator-=(const QQuaternion &quaternion) noexcept;
0070     constexpr QQuaternion &operator*=(float factor) noexcept;
0071     constexpr QQuaternion &operator*=(const QQuaternion &quaternion) noexcept;
0072     constexpr QQuaternion &operator/=(float divisor);
0073 
0074 QT_WARNING_PUSH
0075 QT_WARNING_DISABLE_FLOAT_COMPARE
0076     friend constexpr bool operator==(const QQuaternion &q1, const QQuaternion &q2) noexcept
0077     {
0078         return q1.wp == q2.wp && q1.xp == q2.xp && q1.yp == q2.yp && q1.zp == q2.zp;
0079     }
0080     friend constexpr bool operator!=(const QQuaternion &q1, const QQuaternion &q2) noexcept
0081     {
0082         return !(q1 == q2);
0083     }
0084 QT_WARNING_POP
0085 
0086     friend constexpr QQuaternion operator+(const QQuaternion &q1, const QQuaternion &q2) noexcept;
0087     friend constexpr QQuaternion operator-(const QQuaternion &q1, const QQuaternion &q2) noexcept;
0088     friend constexpr QQuaternion operator*(float factor, const QQuaternion &quaternion) noexcept;
0089     friend constexpr QQuaternion operator*(const QQuaternion &quaternion, float factor) noexcept;
0090     friend constexpr QQuaternion operator*(const QQuaternion &q1, const QQuaternion &q2) noexcept;
0091     friend constexpr QQuaternion operator-(const QQuaternion &quaternion) noexcept;
0092     friend constexpr QQuaternion operator/(const QQuaternion &quaternion, float divisor);
0093 
0094     friend constexpr bool qFuzzyCompare(const QQuaternion &q1, const QQuaternion &q2) noexcept;
0095 
0096 #ifndef QT_NO_VECTOR4D
0097     constexpr QVector4D toVector4D() const noexcept;
0098 #endif
0099 
0100     QT7_ONLY(Q_GUI_EXPORT) operator QVariant() const;
0101 
0102     struct Axis {
0103         float x, y, z;
0104         // prevent users from defining them themselves, until we do:
0105         friend constexpr bool comparesEqual(Axis lhs, Axis rhs) noexcept
0106             Q_DECL_EQ_DELETE_X("Deliberately not implemented. Don't implement it yourself!");
0107         friend bool operator==(Axis, Axis)
0108             Q_DECL_EQ_DELETE_X("Deliberately not implemented. Don't implement it yourself!");
0109         friend bool operator!=(Axis, Axis)
0110             Q_DECL_EQ_DELETE_X("Deliberately not implemented. Don't implement it yourself!");
0111         friend size_t qHash(const Axis &, size_t) noexcept
0112             Q_DECL_EQ_DELETE_X("Deliberately not implemented. Don't implement it yourself!");
0113         friend size_t qHash(const Axis &) noexcept
0114             Q_DECL_EQ_DELETE_X("Deliberately not implemented. Don't implement it yourself!");
0115         friend bool qFuzzyIsNull(Axis axis) noexcept
0116         { return qFuzzyIsNull(axis.x) && qFuzzyIsNull(axis.y) && qFuzzyIsNull(axis.z); }
0117         friend bool qFuzzyCompare(Axis lhs, Axis rhs) noexcept
0118             Q_DECL_EQ_DELETE_X("Deliberately not implemented. Don't implement it yourself!");
0119 #ifndef QT_NO_VECTOR3D
0120         static constexpr Axis fromVector3D(QVector3D v) noexcept
0121         { return {v.x(), v.y(), v.z()}; }
0122         constexpr QVector3D toVector3D() const noexcept { return {x, y, z}; }
0123         friend constexpr bool comparesEqual(Axis lhs, QVector3D rhs) noexcept
0124             Q_DECL_EQ_DELETE_X("Deliberately not implemented. Don't implement it yourself!");
0125 #endif
0126     };
0127 
0128 #ifndef QT_NO_VECTOR3D
0129     inline void getAxisAndAngle(QVector3D *axis, float *angle) const;
0130     QT7_ONLY(Q_GUI_EXPORT) static QQuaternion fromAxisAndAngle(const QVector3D &axis, float angle);
0131 #endif
0132     QT7_ONLY(Q_GUI_EXPORT) void getAxisAndAngle(float *x, float *y, float *z, float *angle) const;
0133     QT7_ONLY(Q_GUI_EXPORT) static QQuaternion fromAxisAndAngle(float x, float y, float z,
0134                                                                float angle);
0135 
0136 #ifndef QT_NO_VECTOR3D
0137     inline QVector3D toEulerAngles() const;
0138 # if !QT_CORE_REMOVED_SINCE(6, 11)
0139     Q_WEAK_OVERLOAD
0140 # endif
0141     static QQuaternion fromEulerAngles(const QVector3D &angles)
0142     { return fromEulerAngles(angles.x(), angles.y(), angles.z()); }
0143 
0144 #endif
0145     template <typename T>
0146     struct EulerAngles
0147     {
0148         T pitch, yaw, roll;
0149     };
0150     QT7_ONLY(Q_GUI_EXPORT) EulerAngles<float> eulerAngles() const;
0151     static QQuaternion fromEulerAngles(EulerAngles<float> angles)
0152     { return fromEulerAngles(angles.pitch, angles.yaw, angles.roll); }
0153 
0154     QT_GUI_INLINE_SINCE(6, 11)
0155     void getEulerAngles(float *pitch, float *yaw, float *roll) const;
0156     static QQuaternion fromEulerAngles(float pitch, float yaw, float roll);
0157 
0158     QT7_ONLY(Q_GUI_EXPORT) QMatrix3x3 toRotationMatrix() const;
0159     QT7_ONLY(Q_GUI_EXPORT) static QQuaternion fromRotationMatrix(const QMatrix3x3 &rot3x3);
0160 
0161     struct Axes
0162     {
0163         Axis x, y, z;
0164     };
0165     QT7_ONLY(Q_GUI_EXPORT) Axes toAxes() const;
0166     QT7_ONLY(Q_GUI_EXPORT) static QQuaternion fromAxes(Axes axes); // clazy:exclude=function-args-by-ref
0167 #ifndef QT_NO_VECTOR3D
0168     QT_GUI_INLINE_SINCE(6, 11)
0169     void getAxes(QVector3D *xAxis, QVector3D *yAxis, QVector3D *zAxis) const;
0170     QT_GUI_INLINE_SINCE(6, 11)
0171     static QQuaternion fromAxes(const QVector3D &xAxis,
0172                                 const QVector3D &yAxis,
0173                                 const QVector3D &zAxis);
0174 
0175     QT7_ONLY(Q_GUI_EXPORT) static QQuaternion fromDirection(const QVector3D &direction,
0176                                                             const QVector3D &up);
0177 
0178     QT7_ONLY(Q_GUI_EXPORT) static QQuaternion rotationTo(const QVector3D &from,
0179                                                          const QVector3D &to);
0180 #endif // QT_NO_VECTOR3D
0181 
0182     QT7_ONLY(Q_GUI_EXPORT) static QQuaternion slerp(const QQuaternion &q1, const QQuaternion &q2,
0183                                                     float t);
0184     QT7_ONLY(Q_GUI_EXPORT) static QQuaternion nlerp(const QQuaternion &q1, const QQuaternion &q2,
0185                                                     float t);
0186 
0187 private:
0188     float wp, xp, yp, zp;
0189 };
0190 
0191 Q_DECLARE_TYPEINFO(QQuaternion, Q_PRIMITIVE_TYPE);
0192 
0193 constexpr QQuaternion::QQuaternion() noexcept : wp(1.0f), xp(0.0f), yp(0.0f), zp(0.0f) {}
0194 
0195 constexpr QQuaternion::QQuaternion(float aScalar, float xpos, float ypos, float zpos) noexcept
0196     : wp(aScalar), xp(xpos), yp(ypos), zp(zpos) {}
0197 
0198 QT_WARNING_PUSH
0199 QT_WARNING_DISABLE_FLOAT_COMPARE
0200 
0201 constexpr bool QQuaternion::isNull() const noexcept
0202 {
0203     return wp == 0.0f && xp == 0.0f && yp == 0.0f && zp == 0.0f;
0204 }
0205 
0206 constexpr bool QQuaternion::isIdentity() const noexcept
0207 {
0208     return wp == 1.0f && xp == 0.0f && yp == 0.0f && zp == 0.0f;
0209 }
0210 QT_WARNING_POP
0211 
0212 constexpr float QQuaternion::x() const noexcept { return xp; }
0213 constexpr float QQuaternion::y() const noexcept { return yp; }
0214 constexpr float QQuaternion::z() const noexcept { return zp; }
0215 constexpr float QQuaternion::scalar() const noexcept { return wp; }
0216 
0217 constexpr void QQuaternion::setX(float aX) noexcept { xp = aX; }
0218 constexpr void QQuaternion::setY(float aY) noexcept { yp = aY; }
0219 constexpr void QQuaternion::setZ(float aZ) noexcept { zp = aZ; }
0220 constexpr void QQuaternion::setScalar(float aScalar) noexcept { wp = aScalar; }
0221 
0222 constexpr float QQuaternion::dotProduct(const QQuaternion &q1, const QQuaternion &q2) noexcept
0223 {
0224     return q1.wp * q2.wp + q1.xp * q2.xp + q1.yp * q2.yp + q1.zp * q2.zp;
0225 }
0226 
0227 constexpr QQuaternion QQuaternion::inverted() const noexcept
0228 {
0229     // Need some extra precision if the length is very small.
0230     double len = double(wp) * double(wp) +
0231                  double(xp) * double(xp) +
0232                  double(yp) * double(yp) +
0233                  double(zp) * double(zp);
0234     if (!qFuzzyIsNull(len))
0235         return QQuaternion(float(double(wp) / len), float(double(-xp) / len),
0236                            float(double(-yp) / len), float(double(-zp) / len));
0237     return QQuaternion(0.0f, 0.0f, 0.0f, 0.0f);
0238 }
0239 
0240 constexpr QQuaternion QQuaternion::conjugated() const noexcept
0241 {
0242     return QQuaternion(wp, -xp, -yp, -zp);
0243 }
0244 
0245 constexpr QQuaternion &QQuaternion::operator+=(const QQuaternion &quaternion) noexcept
0246 {
0247     wp += quaternion.wp;
0248     xp += quaternion.xp;
0249     yp += quaternion.yp;
0250     zp += quaternion.zp;
0251     return *this;
0252 }
0253 
0254 constexpr QQuaternion &QQuaternion::operator-=(const QQuaternion &quaternion) noexcept
0255 {
0256     wp -= quaternion.wp;
0257     xp -= quaternion.xp;
0258     yp -= quaternion.yp;
0259     zp -= quaternion.zp;
0260     return *this;
0261 }
0262 
0263 constexpr QQuaternion &QQuaternion::operator*=(float factor) noexcept
0264 {
0265     wp *= factor;
0266     xp *= factor;
0267     yp *= factor;
0268     zp *= factor;
0269     return *this;
0270 }
0271 
0272 constexpr QQuaternion operator*(const QQuaternion &q1, const QQuaternion &q2) noexcept
0273 {
0274     float yy = (q1.wp - q1.yp) * (q2.wp + q2.zp);
0275     float zz = (q1.wp + q1.yp) * (q2.wp - q2.zp);
0276     float ww = (q1.zp + q1.xp) * (q2.xp + q2.yp);
0277     float xx = ww + yy + zz;
0278     float qq = 0.5f * (xx + (q1.zp - q1.xp) * (q2.xp - q2.yp));
0279 
0280     float w = qq - ww + (q1.zp - q1.yp) * (q2.yp - q2.zp);
0281     float x = qq - xx + (q1.xp + q1.wp) * (q2.xp + q2.wp);
0282     float y = qq - yy + (q1.wp - q1.xp) * (q2.yp + q2.zp);
0283     float z = qq - zz + (q1.zp + q1.yp) * (q2.wp - q2.xp);
0284 
0285     return QQuaternion(w, x, y, z);
0286 }
0287 
0288 constexpr QQuaternion &QQuaternion::operator*=(const QQuaternion &quaternion) noexcept
0289 {
0290     *this = *this * quaternion;
0291     return *this;
0292 }
0293 
0294 constexpr QQuaternion &QQuaternion::operator/=(float divisor)
0295 {
0296     wp /= divisor;
0297     xp /= divisor;
0298     yp /= divisor;
0299     zp /= divisor;
0300     return *this;
0301 }
0302 
0303 constexpr QQuaternion operator+(const QQuaternion &q1, const QQuaternion &q2) noexcept
0304 {
0305     return QQuaternion(q1.wp + q2.wp, q1.xp + q2.xp, q1.yp + q2.yp, q1.zp + q2.zp);
0306 }
0307 
0308 constexpr QQuaternion operator-(const QQuaternion &q1, const QQuaternion &q2) noexcept
0309 {
0310     return QQuaternion(q1.wp - q2.wp, q1.xp - q2.xp, q1.yp - q2.yp, q1.zp - q2.zp);
0311 }
0312 
0313 constexpr QQuaternion operator*(float factor, const QQuaternion &quaternion) noexcept
0314 {
0315     return QQuaternion(quaternion.wp * factor, quaternion.xp * factor, quaternion.yp * factor, quaternion.zp * factor);
0316 }
0317 
0318 constexpr QQuaternion operator*(const QQuaternion &quaternion, float factor) noexcept
0319 {
0320     return QQuaternion(quaternion.wp * factor, quaternion.xp * factor, quaternion.yp * factor, quaternion.zp * factor);
0321 }
0322 
0323 constexpr QQuaternion operator-(const QQuaternion &quaternion) noexcept
0324 {
0325     return QQuaternion(-quaternion.wp, -quaternion.xp, -quaternion.yp, -quaternion.zp);
0326 }
0327 
0328 constexpr QQuaternion operator/(const QQuaternion &quaternion, float divisor)
0329 {
0330     return QQuaternion(quaternion.wp / divisor, quaternion.xp / divisor, quaternion.yp / divisor, quaternion.zp / divisor);
0331 }
0332 
0333 constexpr bool qFuzzyCompare(const QQuaternion &q1, const QQuaternion &q2) noexcept
0334 {
0335     return QtPrivate::fuzzyCompare(q1.wp, q2.wp)
0336         && QtPrivate::fuzzyCompare(q1.xp, q2.xp)
0337         && QtPrivate::fuzzyCompare(q1.yp, q2.yp)
0338         && QtPrivate::fuzzyCompare(q1.zp, q2.zp);
0339 }
0340 
0341 #if QT_GUI_INLINE_IMPL_SINCE(6, 11)
0342 void QQuaternion::getEulerAngles(float *pitch, float *yaw, float *roll) const
0343 {
0344     Q_PRE(pitch);
0345     Q_PRE(yaw);
0346     Q_PRE(roll);
0347     const auto angles = eulerAngles();
0348     *pitch = angles.pitch;
0349     *yaw   = angles.yaw;
0350     *roll  = angles.roll;
0351 }
0352 #endif // QT_GUI_INLINE_IMPL_SINCE
0353 
0354 #ifndef QT_NO_VECTOR3D
0355 
0356 constexpr QQuaternion::QQuaternion(float aScalar, const QVector3D &aVector) noexcept
0357     : wp(aScalar), xp(aVector.x()), yp(aVector.y()), zp(aVector.z()) {}
0358 
0359 constexpr void QQuaternion::setVector(const QVector3D &aVector) noexcept
0360 {
0361     xp = aVector.x();
0362     yp = aVector.y();
0363     zp = aVector.z();
0364 }
0365 
0366 constexpr QVector3D QQuaternion::vector() const noexcept
0367 {
0368     return QVector3D(xp, yp, zp);
0369 }
0370 
0371 inline QVector3D operator*(const QQuaternion &quaternion, const QVector3D &vec)
0372 {
0373     return quaternion.rotatedVector(vec);
0374 }
0375 
0376 void QQuaternion::getAxisAndAngle(QVector3D *axis, float *angle) const
0377 {
0378     float aX, aY, aZ;
0379     getAxisAndAngle(&aX, &aY, &aZ, angle);
0380     *axis = QVector3D(aX, aY, aZ);
0381 }
0382 
0383 QVector3D QQuaternion::toEulerAngles() const
0384 {
0385     const auto angles = eulerAngles();
0386     return QVector3D{angles.pitch, angles.yaw, angles.roll};
0387 }
0388 
0389 #if QT_GUI_INLINE_IMPL_SINCE(6, 11)
0390 void QQuaternion::getAxes(QVector3D *xAxis, QVector3D *yAxis, QVector3D *zAxis) const
0391 {
0392     Q_PRE(xAxis);
0393     Q_PRE(yAxis);
0394     Q_PRE(zAxis);
0395     const Axes axes = toAxes();
0396     *xAxis = axes.x.toVector3D();
0397     *yAxis = axes.y.toVector3D();
0398     *zAxis = axes.z.toVector3D();
0399 }
0400 
0401 QQuaternion QQuaternion::fromAxes(const QVector3D &xAxis, const QVector3D &yAxis, const QVector3D &zAxis)
0402 {
0403     return fromAxes(Axes{Axis::fromVector3D(xAxis),
0404                          Axis::fromVector3D(yAxis),
0405                          Axis::fromVector3D(zAxis)});
0406 }
0407 #endif // QT_GUI_INLINE_IMPL_SINCE(6, 11)
0408 
0409 #endif // QT_NO_VECTOR3D
0410 
0411 constexpr void QQuaternion::setVector(float aX, float aY, float aZ) noexcept
0412 {
0413     xp = aX;
0414     yp = aY;
0415     zp = aZ;
0416 }
0417 
0418 #ifndef QT_NO_VECTOR4D
0419 
0420 constexpr QQuaternion::QQuaternion(const QVector4D &aVector) noexcept
0421     : wp(aVector.w()), xp(aVector.x()), yp(aVector.y()), zp(aVector.z()) {}
0422 
0423 constexpr QVector4D QQuaternion::toVector4D() const noexcept
0424 {
0425     return QVector4D(xp, yp, zp, wp);
0426 }
0427 
0428 #endif // QT_NO_VECTOR4D
0429 
0430 #ifndef QT_NO_DEBUG_STREAM
0431 Q_GUI_EXPORT QDebug operator<<(QDebug dbg, const QQuaternion &q);
0432 #endif
0433 
0434 #ifndef QT_NO_DATASTREAM
0435 Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QQuaternion &);
0436 Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QQuaternion &);
0437 #endif
0438 
0439 #endif // QT_NO_QUATERNION
0440 
0441 QT_END_NAMESPACE
0442 
0443 #endif // QQUATERNION_H
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!