QMatrix4x4 Class

Documentation des fonctions membres

QMatrix4x4::QMatrix4x4()

Crée une matrice identité.

[explicit] template <int N, int M> QMatrix4x4::QMatrix4x4(const QGenericMatrix<N, M, float> &matrix)

Construit une matrice 4x4 à partir des 4 colonnes les plus à gauche et des 4 lignes les plus en haut de matrix. Si matrix comporte moins de 4 colonnes ou lignes, les éléments manquants sont complétés par des éléments de la matrice identité.

Voir également toGenericMatrix().

QMatrix4x4::QMatrix4x4(const QTransform &transform)

Construit une matrice 4x4 à partir de la matrice de transformation 2D classique de Qt XML transform.

Si transform est d’un type particulier (identité, translation, mise à l’échelle, etc.), le programmeur doit faire suivre ce constructeur d’un appel à optimize() s’il souhaite que QMatrix4x4 optimise les appels ultérieurs à translate(), scale(), etc.

Voir également toTransform() et optimize().

[explicit] QMatrix4x4::QMatrix4x4(const float *values)

Construit une matrice à partir des 16 values s en virgule flottante fournies. Le contenu du tableau values est supposé être classé selon l'ordre des lignes.

Si la matrice est d’un type particulier (matrice identité, translation, mise à l’échelle, etc.), le programmeur doit faire suivre ce constructeur d’un appel à optimize() s’il souhaite que QMatrix4x4 optimise les appels ultérieurs à translate(), scale(), etc.

Voir également copyDataTo() et optimize().

QMatrix4x4::QMatrix4x4(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)

Construit une matrice à partir des 16 éléments suivants : m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43 et m44. Les éléments sont spécifiés dans l'ordre des lignes.

Si la matrice est d’un type particulier (identité, translation, mise à l’échelle, etc.), le programmeur doit faire suivre ce constructeur d’un appel à ` optimize()` s’il souhaite que `QMatrix4x4` optimise les appels ultérieurs à ` translate()`, ` scale()`, etc.

Voir également optimize().

QVector4D QMatrix4x4::column(int index) const

Renvoie les éléments de la colonne « index » sous la forme d'un vecteur 4D.

Voir aussi ` setColumn()` et ` row()`.

const float *QMatrix4x4::constData() const

Renvoie un pointeur constant vers les données brutes de cette matrice. Ces données brutes sont stockées au format « column-major ».

Voir également data().

void QMatrix4x4::copyDataTo(float *values) const

Récupère les 16 éléments de cette matrice et les copie dans ` values ` en ordre de rangées.

float *QMatrix4x4::data()

Renvoie un pointeur vers les données brutes de cette matrice.

Voir également constData() et optimize().

const float *QMatrix4x4::data() const

Renvoie un pointeur constant vers les données brutes de cette matrice. Ces données brutes sont stockées au format « column-major ».

Voir également constData().

double QMatrix4x4::determinant() const

Renvoie le déterminant de cette matrice.

void QMatrix4x4::fill(float value)

Remplit tous les éléments de cette matrice avec value.

void QMatrix4x4::frustum(float left, float right, float bottom, float top, float nearPlane, float farPlane)

Multiplie cette matrice par une autre qui applique une projection en cône de perspective pour une fenêtre dont le coin inférieur gauche est situé à (left, bottom), le coin supérieur droit à (right, top), et dont les plans de découpe spécifiés sont nearPlane et farPlane.

Voir également ortho() et perspective().

QMatrix4x4 QMatrix4x4::inverted(bool *invertible = nullptr) const

Renvoie l'inverse de cette matrice. Renvoie la matrice identité si cette matrice ne peut pas être inversée ; c'est-à-dire si determinant() est égal à zéro. Si invertible n'est pas nul, la valeur « true » sera écrite à cet emplacement si la matrice peut être inversée ; « false » dans le cas contraire.

Si la matrice est reconnue comme étant l'identité ou une matrice orthonormée, cette fonction inversera rapidement la matrice à l'aide de routines optimisées.

Voir également determinant() et normalMatrix().

bool QMatrix4x4::isAffine() const

Renvoie « true » si cette matrice est une matrice affine ; « false » dans le cas contraire.

Une matrice affine est une matrice 4x4 dont la troisième ligne est égale à (0, 0, 0, 1), c'est-à-dire qui ne contient aucun coefficient projectif.

Voir également isIdentity().

bool QMatrix4x4::isIdentity() const

Renvoie « true » si cette matrice est l'identité ; « false » dans le cas contraire.

Voir aussi setToIdentity().

void QMatrix4x4::lookAt(const QVector3D &eye, const QVector3D &center, const QVector3D &up)

Multiplie cette matrice par une matrice de vue dérivée d'un point de vue. La valeur « center » indique le centre de la vue que l'eye observe. La valeur « up » indique quelle direction doit être considérée comme le haut par rapport à l'eye.

QPoint QMatrix4x4::map(const QPoint &point) const

La mise en correspondance s'effectue point en multipliant cette matrice par point. La matrice est appliquée avant le point.

Voir également mapRect().

QPointF QMatrix4x4::map(const QPointF &point) const

Associe point en multipliant cette matrice par point. La matrice est appliquée avant le point.

Voir également mapRect().

QVector3D QMatrix4x4::map(const QVector3D &point) const

La fonction « Maps » point en multipliant cette matrice par point, étendue à un vecteur à 4 dimensions en attribuant la valeur 1,0 à la coordonnée w. La matrice est appliquée avant le point.

Voir également mapRect() et mapVector().

QVector4D QMatrix4x4::map(const QVector4D &point) const

La mise en correspondance s'effectue point en multipliant cette matrice par point. La matrice est appliquée avant le point.

Voir également mapRect().

QRect QMatrix4x4::mapRect(const QRect &rect) const

La fonction ` rect ` multiplie cette matrice par les coins de ` rect `, puis forme un nouveau rectangle à partir des résultats. Le rectangle renvoyé sera un rectangle 2D classique dont les côtés sont parallèles aux axes horizontal et vertical.

Voir également map().

QRectF QMatrix4x4::mapRect(const QRectF &rect) const

La fonction ` rect ` multiplie cette matrice par les coins de ` rect `, puis forme un nouveau rectangle à partir des résultats. Le rectangle renvoyé sera un rectangle 2D classique dont les côtés sont parallèles aux axes horizontal et vertical.

Voir également map().

QVector3D QMatrix4x4::mapVector(const QVector3D &vector) const

La matrice « Maps vector » s'obtient en multipliant la partie supérieure 3×3 de cette matrice par vector. Les composantes de translation et de projection de cette matrice sont ignorées. La matrice est appliquée sous forme de pré-vecteur.

Voir également map().

QMatrix3x3 QMatrix4x4::normalMatrix() const

Renvoie la matrice normale correspondant à cette transformation 4x4. La matrice normale est la transposée de l'inverse de la partie 3x3 située en haut à gauche de cette matrice 4x4. Si la sous-matrice 3x3 n'est pas inversible, cette fonction renvoie la matrice identité.

Voir également inverted().

void QMatrix4x4::optimize()

Optimiser l'utilisation de cette matrice à partir de ses éléments actuels.

Certaines opérations telles que ` translate()`, ` scale()` et ` rotate()` peuvent être exécutées plus efficacement si l'on sait déjà que la matrice à modifier est la matrice identité, le résultat d'un précédent ` translate()`, d'un précédent ` scale()`, etc.

Normalement, la classe QMatrix4x4 garde la trace de ce type spécial en interne au fur et à mesure que les opérations sont effectuées. Cependant, si la matrice est modifiée directement à l’aide de operator()(int, int) ou data(), alors QMatrix4x4 perdra la trace de ce type spécial et reviendra par la suite aux opérations les plus sûres, mais les moins efficaces.

En appelant `optimize()` après avoir modifié directement la matrice, le programmeur peut forcer ` QMatrix4x4 ` à récupérer le type spécial si les éléments semblent correspondre à l’un des types optimisés connus.

Voir également operator()(int, int), data() et translate().

void QMatrix4x4::ortho(float left, float right, float bottom, float top, float nearPlane, float farPlane)

Multiplie cette matrice par une autre qui applique une projection orthographique à une fenêtre dont le coin inférieur gauche est situé à (left, bottom), le coin supérieur droit à (right, top), et dont les plans de découpe spécifiés sont nearPlane et farPlane.

Voir également frustum() et perspective().

void QMatrix4x4::ortho(const QRect &rect)

Multiplie cette matrice par une autre qui applique une projection orthographique à une fenêtre dont les limites sont spécifiées par rect. Les plans de découpe proche et lointain seront respectivement -1 et 1.

Voir également frustum() et perspective().

void QMatrix4x4::ortho(const QRectF &rect)

Multiplie cette matrice par une autre qui applique une projection orthographique à une fenêtre dont les limites sont spécifiées par rect. Les plans de découpe proche et lointain seront respectivement -1 et 1.

Voir également frustum() et perspective().

void QMatrix4x4::perspective(float verticalAngle, float aspectRatio, float nearPlane, float farPlane)

Multiplie cette matrice par une autre qui applique une projection en perspective. Le champ de vision vertical sera de verticalAngle degrés dans une fenêtre dont l’ aspectRatio, qui détermine le champ de vision horizontal, est spécifiée. La projection aura les plans de découpe spécifiés nearPlane et farPlane, qui correspondent aux distances entre l’observateur et les plans correspondants.

Voir également ortho() et frustum().

void QMatrix4x4::rotate(const QQuaternion &quaternion)

Multiplie cette matrice par une autre qui fait pivoter les coordonnées selon une quaternion spécifiée. On suppose que l'quaternion a été normalisée.

Voir également scale(), translate() et QQuaternion.

void QMatrix4x4::rotate(float angle, const QVector3D &vector)

Multiplie cette matrice par une autre qui fait pivoter les coordonnées de angle degrés autour de vector.

Voir également scale() et translate().

void QMatrix4x4::rotate(float angle, float x, float y, float z = 0.0f)

Multiplie cette matrice par une autre qui fait pivoter les coordonnées de angle degrés autour du vecteur (x, y, z).

Voir également scale() et translate().

QVector4D QMatrix4x4::row(int index) const

Renvoie les éléments de la ligne index sous la forme d'un vecteur 4D.

Voir aussi setRow() et column().

void QMatrix4x4::scale(const QVector3D &vector)

Multiplie cette matrice par une autre qui met les coordonnées à l'échelle en fonction des composantes de vector.

Voir également translate() et rotate().

void QMatrix4x4::scale(float factor)

Multiplie cette matrice par une autre qui met les coordonnées à l'échelle selon l'factor on donnée.

Voir également ` translate()` et ` rotate()`.

void QMatrix4x4::scale(float x, float y)

Multiplie cette matrice par une autre qui met les coordonnées à l'échelle selon les composantes x et y.

Voir également translate() et rotate().

void QMatrix4x4::scale(float x, float y, float z)

Multiplie cette matrice par une autre qui met les coordonnées à l'échelle selon les composantes x, y et z.

Voir également translate() et rotate().

void QMatrix4x4::setColumn(int index, const QVector4D &value)

Attribue aux éléments de la colonne index les composants de value.

Voir également column() et setRow().

void QMatrix4x4::setRow(int index, const QVector4D &value)

Attribue aux éléments de la ligne index les composants de value.

Voir également row() et setColumn().

void QMatrix4x4::setToIdentity()

Définit cette matrice comme étant la matrice identité.

Voir également isIdentity().

template <int N, int M> QGenericMatrix<N, M, float> QMatrix4x4::toGenericMatrix() const

Construit une matrice générique de dimensions N x M à partir des N colonnes les plus à gauche et des M lignes les plus en haut de cette matrice 4x4. Si N ou M est supérieur à 4, les éléments restants sont complétés par des éléments issus de la matrice identité.

QTransform QMatrix4x4::toTransform() const

Renvoie la matrice de transformation 2D Qt classique qui correspond à cette matrice.

La matrice de transformation QTransform ainsi renvoyée est obtenue en supprimant simplement la troisième ligne et la troisième colonne de la matrice QMatrix4x4. Cela convient à la mise en œuvre de projections orthographiques où la coordonnée z doit être supprimée plutôt que projetée.

QTransform QMatrix4x4::toTransform(float distanceToPlane) const

Renvoie la matrice de transformation 2D Qt standard qui correspond à cette matrice.

Si ` distanceToPlane ` est différent de zéro, il s'agit d'un facteur de projection à utiliser pour ajuster la coordonnée z. La valeur 1024 correspond au facteur de projection utilisé par ` QTransform::rotate()` pour les axes x et y.

Si ` distanceToPlane ` est égal à zéro, alors la matrice de transformation QTransform renvoyée est obtenue en supprimant simplement la troisième ligne et la troisième colonne de la matrice QMatrix4x4. Cela convient à la mise en œuvre de projections orthographiques où la coordonnée z doit être supprimée plutôt que projetée.

void QMatrix4x4::translate(const QVector3D &vector)

Multiplie cette matrice par une autre qui translate les coordonnées selon les composantes de vector.

Voir également scale() et rotate().

void QMatrix4x4::translate(float x, float y)

Multiplie cette matrice par une autre qui translate les coordonnées selon les composantes x et y.

Voir également scale() et rotate().

void QMatrix4x4::translate(float x, float y, float z)

Multiplie cette matrice par une autre qui translat les coordonnées selon les composantes x, y et z.

Voir également scale() et rotate().

QMatrix4x4 QMatrix4x4::transposed() const

Renvoie cette matrice transposée par rapport à sa diagonale.

void QMatrix4x4::viewport(float left, float bottom, float width, float height, float nearPlane = 0.0f, float farPlane = 1.0f)

Multiplie cette matrice par une autre qui effectue la transformation d'échelle et de décalage utilisée par OpenGL pour passer des coordonnées normalisées du périphérique (NDC) aux coordonnées de la fenêtre d'affichage. En d'autres termes, elle mappe les points du cube, dont les valeurs sont comprises entre [-1, 1] dans chaque dimension, vers la fenêtre de visualisation dont le coin inférieur gauche se trouve en (left, bottom, nearPlane) et dont les dimensions sont (width, height, farPlane - nearPlane).

Cela correspond à la transformation utilisée par la transformation de la fenêtre d'affichage OpenGL à fonction fixe, contrôlée par les fonctions glViewport() et glDepthRange().

void QMatrix4x4::viewport(const QRectF &rect)

Configure la transformation de la fenêtre d'affichage pour une fenêtre délimitée par rect, les valeurs « near » et « far » étant respectivement définies sur 0 et 1.

QMatrix4x4::operator QVariant() const

Renvoie la matrice sous la forme d'un objet de type « QVariant ».

bool QMatrix4x4::operator!=(const QMatrix4x4 &other) const

Renvoie ` true ` si cette matrice n'est pas identique à ` other` ; `false` dans le cas contraire. Cet opérateur utilise une comparaison exacte en virgule flottante.

float &QMatrix4x4::operator()(int row, int column)

Renvoie une référence à l'élément situé à la position (row, column) dans cette matrice, afin de pouvoir y affecter une valeur.

Voir également optimize(), setColumn() et setRow().

const float &QMatrix4x4::operator()(int row, int column) const

Renvoie une référence constante à l'élément situé à la position (row, column) dans cette matrice.

Voir également column() et row().

QMatrix4x4 &QMatrix4x4::operator*=(const QMatrix4x4 &other)

Multiplie le contenu de ` other ` par cette matrice.

QMatrix4x4 &QMatrix4x4::operator*=(float factor)

Multiplie tous les éléments de cette matrice par factor.

QMatrix4x4 &QMatrix4x4::operator+=(const QMatrix4x4 &other)

Ajoute le contenu de other à cette matrice.

QMatrix4x4 &QMatrix4x4::operator-=(const QMatrix4x4 &other)

Soustrait le contenu de ` other ` de cette matrice.

QMatrix4x4 &QMatrix4x4::operator/=(float divisor)

Divise tous les éléments de cette matrice par divisor.

bool QMatrix4x4::operator==(const QMatrix4x4 &other) const

Renvoie « true » si cette matrice est identique à « other » ; « false » dans le cas contraire. Cet opérateur utilise une comparaison exacte en virgule flottante.