Présentation
Ces fonctions vous permettent de manipuler des matrices carrées de rang 2x2, 3x3 et 4x4. Ils sont particulièrement utiles pour les transformations graphiques et sont compatibles avec OpenGL.
Nous utilisons un index de base zéro pour les lignes et les colonnes. Par exemple, le dernier élément d'un élément rs_matrix4x4 se trouve aux coordonnées (3, 3).
RenderScript utilise des matrices à majeure colonne et des vecteurs basés sur des colonnes. La transformation d'un vecteur s'effectue en post-multipliant (par exemple, (matrix * vector)) par la méthode rsMatrixMultiply().
Pour créer une matrice de transformation qui effectue deux transformations à la fois, multipliez les deux matrices sources, en utilisant la première transformation comme argument de droite. Par exemple, pour créer une matrice de transformation qui applique la transformation s1 suivie de s2, appelez rsMatrixLoadMultiply(&combined, &s2, &s1).
Elle est dérivée de s2 * (s1 * v), qui correspond à (s2 * s1) * v.
Nous disposons de deux styles de fonctions pour créer des matrices de transformation : rsMatrixLoadTransformation et rsMatrixTransformation. Le premier style stocke simplement la matrice de transformation dans le premier argument. Ce dernier modifie une matrice de transformation préexistante afin que la nouvelle transformation soit effectuée en premier. Par exemple, si vous appelez rsMatrixTranslate() sur une matrice qui effectue déjà une mise à l'échelle, la matrice résultante lorsqu'elle est appliquée à un vecteur effectue d'abord la translation, puis la mise à l'échelle.
Résumé
| Fonctions | |
|---|---|
| rsExtractFrustumPlanes | Calculer les plans de tronc |
| rsIsSphereInFrustum | Vérifie si une sphère se trouve dans les plans troncaux |
| rsMatrixGet | Obtenir un élément |
| rsMatrixInverse | Inverser une matrice en place |
| rsMatrixInverseTranspose | Inverser et transposer une matrice sur place |
| rsMatrixLoad | Charger ou copier une matrice |
| rsMatrixLoadFrustum | Charger une matrice de projection de tronc |
| rsMatrixLoadIdentity | Charger la matrice d'identité |
| rsMatrixLoadMultiply | Multiplier deux matrices |
| rsMatrixLoadOrtho | Charger une matrice de projection orthographique |
| rsMatrixLoadPerspective | Charger une matrice de projection en perspective |
| rsMatrixLoadRotation | Charger une matrice de rotation |
| rsMatrixLoadScale | Charger une matrice de scaling |
| rsMatrixLoadTranslate | Charger une matrice de traduction |
| rsMatrixMultiply | Multiplier une matrice par un vecteur ou une autre matrice |
| rsMatrixRotate | Appliquer une rotation à une matrice de transformation |
| rsMatrixScale | Appliquer un scaling à une matrice de transformation |
| rsMatrixSet | Définir un élément |
| rsMatrixTranslate | Appliquer une traduction à une matrice de transformation |
| rsMatrixTranspose | Transposer un lieu matriciel |
Fonctions
rsExtractFrustumPlanes : calculer les plans de frustum
| void rsExtractFrustumPlanes(const rs_matrix4x4* viewProj, float4* left, float4* righ, float4* haut, float4* bottom, float4* near, float4* ; | Ajouté au niveau d'API 24 |
| void rsExtractFrustumPlanes(const rs_matrix4x4* viewProj, float4* left, float4* droite, float4* haut, float4* bottom, float4* near, float4* ; | Supprimé du niveau d'API 24 ou supérieur |
Paramètres
| viewProj | Matrice à partir de laquelle extraire les plans. |
|---|---|
| la gauche | Plan de gauche. |
| droite | Plan de droite. |
| haut | Plan supérieur. |
| bas | Plan inférieur. |
| à proximité de | Près d'un avion. |
| éloigné(e) | Avion loin. |
| poing |
Calcule six plans de tronc à partir de la matrice de projection de vue
rsIsSphereInFrustum : vérifie si une sphère se trouve dans les plans de tronc
| bool rsIsSphereInFrustum(float4* sphère, float4* gauche, float4* droite, float4* haut, float4* bas, float4* près, float4* loin); |
Paramètres
| sphère | float4 représentant la sphère. |
|---|---|
| la gauche | Plan de gauche. |
| droite | Plan de droite. |
| haut | Plan supérieur. |
| bas | Plan inférieur. |
| à proximité de | Près d'un avion. |
| éloigné(e) | Avion loin. |
Renvoie la valeur "true" si la sphère se trouve dans les six plans de tronc.
rsMatrixGet : récupérer un élément
| float rsMatrixGet(const rs_matrix2x2* m, uint32_t col, uint32_t ligne); | |
| float rsMatrixGet(const rs_matrix3x3* m, col uint32_t, uint32_t ligne); | |
| float rsMatrixGet(const rs_matrix4x4* m, col uint32_t, uint32_t ); |
Paramètres
| m | Matrice d'extraction de l'élément. |
|---|---|
| col | Colonne basée sur zéro de l'élément à extraire. |
| ligne | Ligne basée sur zéro de l'élément à extraire. |
Renvoie un élément d'une matrice.
Avertissement:L'ordre des paramètres de colonne et de ligne peut être inattendu.
rsMatrixInverse : inverse une matrice en place
| bool rsMatrixInverse(rs_matrix4x4* m); |
Paramètres
| m | Matrice à inverser. |
|---|
Renvoie la valeur "true" si la matrice a bien été inversée.
rsMatrixInverseTranspose : inverse et transpose une matrice sur place
| bool rsMatrixInverseTranspose(rs_matrix4x4* m); |
Paramètres
| m | Matrice à modifier. |
|---|
La matrice est d'abord inversée, puis transposée. Renvoie la valeur "true" si la matrice a bien été inversée.
rsMatrixLoad : charger ou copier une matrice
| void rsMatrixLoad(rs_matrix2x2* destination, const float* array); | |
| void rsMatrixLoad(rs_matrix2x2* destination, const rs_matrix2x2* source); | |
| void rsMatrixLoad(rs_matrix3x3* destination, const float* array); | |
| void rsMatrixLoad(rs_matrix3x3* destination, const rs_matrix3x3* source); | |
| void rsMatrixLoad(rs_matrix4x4* destination, const float* array); | |
| void rsMatrixLoad(rs_matrix4x4* destination, const rs_matrix2x2* source); | |
| void rsMatrixLoad(rs_matrix4x4* destination, const rs_matrix3x3* source); | |
| void rsMatrixLoad(rs_matrix4x4* destination, const rs_matrix4x4* source); |
Paramètres
| destination | Matrice à définir. |
|---|---|
| tableau | Tableau de valeurs sur lesquelles définir la matrice. Ces tableaux doivent avoir une longueur de 4, 9 ou 16 floats, en fonction de la taille de la matrice. |
| source | Matrice source. |
Définissez les éléments d'une matrice à partir d'un tableau de flottants ou d'une autre matrice.
En cas de chargement à partir d'un tableau, les valeurs flottantes doivent être classées par ligne principale. Autrement dit, l'élément row 0, column 0 doit apparaître en premier, suivi de l'élément situé dans row 0, column 1, etc.
Si le chargement à partir d'une matrice et que la source est plus petite que la destination, le reste de la destination est rempli d'éléments de la matrice identité. Par exemple, le chargement de rs_matrix2x2 dans rs_matrix4x4 donne:
| m00 | M01 | 0,0 | 0,0 |
| M10 | M11 | 0,0 | 0,0 |
| 0,0 | 0,0 | 1.0 | 0,0 |
| 0,0 | 0,0 | 0,0 | 1.0 |
rsMatrixLoadFrustum : charger une matrice de projection de tronc
| void rsMatrixLoadFrustum(rs_matrix4x4* m, float left, float droite, float bottom, float top, float near, float far); |
Paramètres
| m | Matrice à définir. |
|---|---|
| la gauche | |
| droite | |
| bas | |
| haut | |
| à proximité de | |
| éloigné(e) |
Construit une matrice de projection tronculaire en transformant le cadre identifié par les six plans d'écrêtage left, right, bottom, top, near, far.
Pour appliquer cette projection à un vecteur, multipliez-le par la matrice créée à l'aide de rsMatrixMultiply().
rsMatrixLoadIdentity : matrice d'identité de chargement
| void rsMatrixLoadIdentity(rs_matrix2x2* m); | |
| void rsMatrixLoadIdentity(rs_matrix3x3* m); | |
| void rsMatrixLoadIdentity(rs_matrix4x4* m); |
Paramètres
| m | Matrice à définir. |
|---|
Définissez les éléments d'une matrice sur la matrice identité.
rsMatrixLoadMultiply : multiplier deux matrices
| void rsMatrixLoadMultiply(rs_matrix2x2* m, const rs_matrix2x2* lhs, const rs_matrix2x2* rhs); | |
| void rsMatrixLoadMultiply(rs_matrix3x3* m, const rs_matrix3x3* lhs, const rs_matrix3x3* rhs); | |
| void rsMatrixLoadMultiply(rs_matrix4x4* m, const rs_matrix4x4* lhs, const rs_matrix4x4* rhs); |
Paramètres
| m | Matrice à définir. |
|---|---|
| lhs | Matrice gauche du produit. |
| RH | Matrice droite du produit. |
Définit m sur le produit matriciel de lhs * rhs.
Pour combiner deux matrices de transformation 4x4, multipliez la deuxième matrice de transformation par la première. Par exemple, pour créer une matrice de transformation qui applique la transformation s1 suivie de s2, appelez rsMatrixLoadMultiply(&combined, &s2, &s1).
Avertissement:Avant la version 21, il n'était pas possible de replacer le résultat dans la matrice droite, ce qui entraînait un comportement indéfini. Utilisez plutôt rsMatrixMulitply. Par exemple, au lieu d'utiliser rsMatrixLoadMultiply (&m2r, &m2r et &m2l), utilisez rsMatrixMultiply (&m2r, &m2l). rsMatrixLoadMultiply (&m2l, &m2r, &m2l) fonctionne comme prévu.
rsMatrixLoadOrtho : charger une matrice de projection orthographique
| void rsMatrixLoadOrtho(rs_matrix4x4* m, flotter à gauche, flotter à droite, flotter en bas, flotter en haut, flotter près, flotter loin); |
Paramètres
| m | Matrice à définir. |
|---|---|
| la gauche | |
| droite | |
| bas | |
| haut | |
| à proximité de | |
| éloigné(e) |
Construit une matrice de projection orthographique, transformant le cadre identifié par les six plans d'écrêtage left, right, bottom, top, near, far en un cube unitaire avec un angle à (-1, -1, -1) et l'inverse à (1, 1, 1).
Pour appliquer cette projection à un vecteur, multipliez-le par la matrice créée à l'aide de rsMatrixMultiply().
Voir https://fr.wikipedia.org/wiki/Projection_orthgraphique
rsMatrixLoadPerspective : charger une matrice de projection en perspective
| void rsMatrixLoadPerspective(rs_matrix4x4* m, flotteur, aspect flottant, flotter à proximité, flotter loin); |
Paramètres
| m | Matrice à définir. |
|---|---|
| Brume | Champ de vision, en degrés, le long de l'axe Y. |
| format | Ratio x / y. |
| à proximité de | Plan de bornement proche. |
| éloigné(e) | Plan de bornement éloigné. |
Construit une matrice de projection en perspective, en supposant un champ de vision symétrique.
Pour appliquer cette projection à un vecteur, multipliez-le par la matrice créée à l'aide de rsMatrixMultiply().
rsMatrixLoadScroll : charger une matrice de rotation
| void rsMatrixLoadScroll(rs_matrix4x4* m, float rot, float x, float y, float z); |
Paramètres
| m | Matrice à définir. |
|---|---|
| pourriture | Rotation à effectuer, en degrés. |
| x | Composante X du vecteur qui est l'axe de rotation. |
| y | Composante Y du vecteur qui est l'axe de rotation. |
| m | Composante Z du vecteur qui est l'axe de rotation. |
Cette fonction crée une matrice de rotation. L'axe de rotation est le vecteur (x, y, z).
Pour faire pivoter un vecteur, multipliez-le par la matrice créée à l'aide de rsMatrixMultiply().
Voir https://fr.wikipedia.org/wiki/Matrice_de_rotation
rsMatrixLoadScale : charger une matrice de scaling
| void rsMatrixLoadScale(rs_matrix4x4* m, float x, float y, float z); |
Paramètres
| m | Matrice à définir. |
|---|---|
| x | Multiple à partir duquel les composants x sont mis à l'échelle. |
| y | Multiple à partir duquel les composants Y sont mis à l'échelle. |
| m | Multiples permettant de redimensionner les composants z. |
Cette fonction crée une matrice de mise à l'échelle dans laquelle chaque composant d'un vecteur est multiplié par un nombre. Ce nombre peut être négatif.
Pour mettre à l'échelle un vecteur, multipliez-le par la matrice créée à l'aide de rsMatrixMultiply().
rsMatrixLoadTranslate : charger une matrice de traduction
| void rsMatrixLoadTranslate(rs_matrix4x4* m, float x, float y, float z); |
Paramètres
| m | Matrice à définir. |
|---|---|
| x | Nombre à ajouter à chaque composant x. |
| y | Nombre à ajouter à chaque composant y. |
| m | Nombre à ajouter à chaque composant z. |
Cette fonction crée une matrice de translation, dans laquelle un nombre est ajouté à chaque élément d'un vecteur.
Pour traduire un vecteur, multipliez-le par la matrice créée à l'aide de rsMatrixMultiply().
rsMatrixMultiply : Multiplier une matrice par un vecteur ou une autre matrice
| float2 rsMatrixMultiply(const rs_matrix2x2* m, float2 in); | Ajouté au niveau d'API 14 |
| float2 rsMatrixMultiply(rs_matrix2x2* m, float2 in); | Supprimé du niveau d'API 14 ou supérieur |
| float3 rsMatrixMultiply(const rs_matrix3x3* m, float2 in); | Ajouté au niveau d'API 14 |
| float3 rsMatrixMultiply(const rs_matrix3x3* m, float3 in); | Ajouté au niveau d'API 14 |
| float3 rsMatrixMultiply(rs_matrix3x3* m, float2 in); | Supprimé du niveau d'API 14 ou supérieur |
| float3 rsMatrixMultiply(rs_matrix3x3* m, float3 in); | Supprimé du niveau d'API 14 ou supérieur |
| float4 rsMatrixMultiply(const rs_matrix4x4* m, float2 in); | Ajouté au niveau d'API 14 |
| float4 rsMatrixMultiply(const rs_matrix4x4* m, float3 in); | Ajouté au niveau d'API 14 |
| float4 rsMatrixMultiply(const rs_matrix4x4* m, float4 in); | Ajouté au niveau d'API 14 |
| float4 rsMatrixMultiply(rs_matrix4x4* m, float2 in); | Supprimé du niveau d'API 14 ou supérieur |
| float4 rsMatrixMultiply(rs_matrix4x4* m, float3 in); | Supprimé du niveau d'API 14 ou supérieur |
| float4 rsMatrixMultiply(rs_matrix4x4* m, float4 in); | Supprimé du niveau d'API 14 ou supérieur |
| void rsMatrixMultiply(rs_matrix2x2* m, const rs_matrix2x2* rhs); | |
| void rsMatrixMultiply(rs_matrix3x3* m, const rs_matrix3x3* rhs); | |
| void rsMatrixMultiply(rs_matrix4x4* m, const rs_matrix4x4* rhs); |
Paramètres
| m | Matrice gauche du produit et matrice à définir. |
|---|---|
| RH | Matrice droite du produit. |
| po |
Pour la variante de la matrice par variante, définit m sur le produit matriciel m * rhs.
Lorsque vous combinez deux matrices de transformation 4x4 à l'aide de cette fonction, la matrice résultante correspond à l'exécution de la transformation rhs en premier, suivie de la transformation m d'origine.
Pour la variante de la matrice par vecteur, renvoie la post-multiplication du vecteur par la matrice, c'est-à-dire m * in.
Lorsque vous multipliez une valeur float3 en rs_matrix4x4, le vecteur est développé par (1).
Lorsque vous multipliez une valeur float2 en rs_matrix4x4, le vecteur est développé par (0, 1).
Lorsque vous multipliez une valeur float2 en rs_matrix3x3, le vecteur est développé par (0).
À partir de l'API 14, cette fonction utilise une matrice "const" comme premier argument.
rsMatrixturn : appliquer une rotation à une matrice de transformation
| void rsMatrixScroll(rs_matrix4x4* m, float rot, float x, float y, float z); |
Paramètres
| m | Matrice à modifier. |
|---|---|
| pourriture | Rotation à effectuer, en degrés. |
| x | Composante X du vecteur qui est l'axe de rotation. |
| y | Composante Y du vecteur qui est l'axe de rotation. |
| m | Composante Z du vecteur qui est l'axe de rotation. |
Multipliez la matrice m par une matrice de rotation.
Cette fonction modifie une matrice de transformation pour effectuer d'abord une rotation. L'axe de rotation est le vecteur (x, y, z).
Pour appliquer cette transformation combinée à un vecteur, multipliez le vecteur par la matrice créée à l'aide de rsMatrixMultiply().
rsMatrixScale : appliquer un scaling à une matrice de transformation
| void rsMatrixScale(rs_matrix4x4* m, float x, float y, float z); |
Paramètres
| m | Matrice à modifier. |
|---|---|
| x | Multiple à partir duquel les composants x sont mis à l'échelle. |
| y | Multiple à partir duquel les composants Y sont mis à l'échelle. |
| m | Multiples permettant de redimensionner les composants z. |
Multipliez la matrice m par une matrice de mise à l'échelle.
Cette fonction modifie une matrice de transformation pour effectuer d'abord un scaling. Lors de la mise à l'échelle, chaque composante d'un vecteur est multipliée par un nombre. Ce nombre peut être négatif.
Pour appliquer cette transformation combinée à un vecteur, multipliez le vecteur par la matrice créée à l'aide de rsMatrixMultiply().
rsMatrixSet : définir un élément
| void rsMatrixSet(rs_matrix2x2* m, uint32_t col, uint32_t line, float v); | |
| void rsMatrixSet(rs_matrix3x3* m, uint32_t col, uint32_t line, float v); | |
| void rsMatrixSet(rs_matrix4x4* m, uint32_t col, uint32_t line, float v); |
Paramètres
| m | Matrice qui sera modifiée. |
|---|---|
| col | Colonne basée sur zéro de l'élément à définir. |
| ligne | Ligne basée sur zéro de l'élément à définir. |
| v | Valeur à définir. |
Définissez un élément d'une matrice.
Avertissement:L'ordre des paramètres de colonne et de ligne peut être inattendu.
rsMatrixTranslate : appliquer une translation en matrice de transformation
| void rsMatrixTranslate(rs_matrix4x4* m, float x, float y, float z); |
Paramètres
| m | Matrice à modifier. |
|---|---|
| x | Nombre à ajouter à chaque composant x. |
| y | Nombre à ajouter à chaque composant y. |
| m | Nombre à ajouter à chaque composant z. |
Multipliez la matrice m par une matrice de translation.
Cette fonction modifie une matrice de transformation pour effectuer d'abord une traduction. Lors de la traduction, un nombre est ajouté à chaque composant d'un vecteur.
Pour appliquer cette transformation combinée à un vecteur, multipliez le vecteur par la matrice créée à l'aide de rsMatrixMultiply().
rsMatrixTranspose : transposer un lieu matriciel
| void rsMatrixTranspose(rs_matrix2x2* m); | |
| void rsMatrixTranspose(rs_matrix3x3* m); | |
| void rsMatrixTranspose(rs_matrix4x4* m); |
Paramètres
| m | Matrice à transposer. |
|---|
Transposer la matrice m en place.