Übersicht
Mit diesen Funktionen können Sie quadratische Matrizen des Rangs 2x2, 3x3 und 4x4 bearbeiten. Sie sind besonders nützlich für grafische Transformationen und sind mit OpenGL kompatibel.
Wir verwenden einen nullbasierten Index für Zeilen und Spalten. Das letzte Element einer rs_matrix4x4 befindet sich z.B. bei (3, 3).
RenderScript verwendet spaltenorientierte Matrizen und spaltenbasierte Vektoren. Ein Vektor wird durch Nachmultiplikation des Vektors transformiert, z.B. mit (matrix * vector), wie von rsMatrixMultiply() bereitgestellt.
Multiplizieren Sie die beiden Quellmatrizen, um eine Transformationsmatrix zu erstellen, die zwei Transformationen gleichzeitig ausführt, wobei die erste Transformation das rechte Argument ist. Um beispielsweise eine Transformationsmatrix zu erstellen, die die Transformation s1 gefolgt von s2 anwendet, rufen Sie rsMatrixLoadMultiply(&combined, &s2, &s1) auf.
Sie leitet sich von s2 * (s1 * v) ab, was (s2 * s1) * v ist.
Zum Erstellen von Transformationsmatrizen gibt es zwei Arten von Funktionen: rsMatrixLoadTransformation und rsMatrixTransformation. Beim erstgenannten Stil wird die Transformationsmatrix einfach im ersten Argument gespeichert. Letzterer modifiziert eine bereits vorhandene Transformationsmatrix so, dass die neue Transformation zuerst stattfindet. Wenn Sie beispielsweise rsMatrixTranslate() für eine Matrix aufrufen, die bereits eine Skalierung ausführt, führt die resultierende Matrix bei Anwendung auf einen Vektor zuerst die Übersetzung und dann die Skalierung durch.
Zusammenfassung
| Funktionen | |
|---|---|
| rsExtractFrustumPlanes | Sichtbereichebenen berechnen |
| rsIsSphereInFrustum | Prüft, ob sich eine Kugel innerhalb der Sichtbereichebenen befindet |
| rsMatrixGet | Ein Element abrufen |
| rsMatrixInverse | Invertiert eine vorhandene Matrix |
| rsMatrixInverseTranspose | Eine vorhandene Matrix invertieren und transponieren |
| rsMatrixLoad | Matrix laden oder kopieren |
| rsMatrixLoadFrustum | Sichtbereichsmatrix laden |
| rsMatrixLoadIdentity | Identitätsmatrix laden |
| rsMatrixLoadMultiply | Zwei Matrizen multiplizieren |
| rsMatrixLoadOrtho | orthografische Projektionsmatrix laden |
| rsMatrixLoadPerspective | Perspektivische Projektionsmatrix laden |
| rsMatrixLoadRotieren | Rotationsmatrix laden |
| rsMatrixLoadScale | Skalierungsmatrix laden |
| rsMatrixLoadTranslate | Übersetzungsmatrix laden |
| rsMatrixMultiply | Eine Matrix mit einem Vektor oder einer anderen Matrix multiplizieren |
| rsMatrixRotieren | Rotation auf eine Transformationsmatrix anwenden |
| rsMatrixScale | Skalierung auf eine Transformationsmatrix anwenden |
| rsMatrixSet | Ein Element festlegen |
| rsMatrixTranslate | Übersetzung auf eine Transformationsmatrix anwenden |
| rsMatrixTranspose | Matrixort transponieren |
Funktionen
rsExtractFrustumPlanes : Sichtbereichebenen berechnen
| void rsExtractFrustumPlanes(const rs_matrix4x4* viewProj, float4* left, float4* rechts, float4* oben, float4* unten, float4* nahe, float4* weit); | In API-Level 24 hinzugefügt |
| void rsExtractFrustumPlanes(const rs_matrix4x4* viewProj, float4* left, float4* rechts, float4* oben, float4* unten, float4* nah, float4* weit); | Aus API-Level 24 und höher entfernt |
Parameter
| ViewProj | Matrix, aus der Ebenen extrahiert werden sollen. |
|---|---|
| hat den Chatroom verlassen | Linke Ebene. |
| rechts | Rechte Ebene. |
| oben | Obere Ebene. |
| unten | Untere Ebene |
| nahe | In der Nähe des Flugzeugs. |
| weit entfernt | Ferner Flugzeug |
| Richtig |
Berechnet 6 Sichtbereichsebenen aus der Ansichtsprojektionsmatrix
rsIsSphereInFrustum : Prüft, ob sich eine Kugel innerhalb der Sichtbereichebenen befindet.
| bool rsIsSphereInFrustum(float4* sphere, float4* links, float4* rechts, float4* oben, float4* unten, float4* nah, float4* weit); |
Parameter
| Kugel | FLOAT4 zur Darstellung der Kugel. |
|---|---|
| hat den Chatroom verlassen | Linke Ebene. |
| rechts | Rechte Ebene. |
| oben | Obere Ebene. |
| unten | Untere Ebene |
| nahe | In der Nähe des Flugzeugs. |
| weit entfernt | Ferner Flugzeug |
Gibt „true“ zurück, wenn sich die Kugel innerhalb der sechs Sichtbereichebenen befindet.
rsMatrixGet : Ein Element abrufen
| float rsMatrixGet(const rs_matrix2x2* m, uint32_t col, uint32_t row); | |
| float rsMatrixGet(const rs_matrix3x3* m, uint32_t col, uint32_t row); | |
| float rsMatrixGet(const rs_matrix4x4* m, uint32_t col, uint32_t row); |
Parameter
| m | Matrix, aus der das Element extrahiert werden soll. |
|---|---|
| Spalte | Nullbasierte Spalte des zu extrahierenden Elements. |
| Zeile | Nullbasierte Zeile des zu extrahierenden Elements. |
Gibt ein Element einer Matrix zurück.
Warnung:Die Reihenfolge der Spalten- und Zeilenparameter ist möglicherweise nicht korrekt.
rsMatrixInverse : Invertiert eine vorhandene Matrix.
| bool rsMatrixInverse(rs_matrix4x4* m); |
Parameter
| m | Invertierte Matrix. |
|---|
Gibt "true" zurück, wenn die Matrix erfolgreich invertiert wurde.
rsMatrixInverseTranspose : Invertiert und transponiert eine vorhandene Matrix.
| bool rsMatrixInverseTranspose(rs_matrix4x4* m); |
Parameter
| m | Matrix, die geändert werden soll. |
|---|
Die Matrix wird zuerst invertiert und dann transponiert. Gibt „true“ zurück, wenn die Matrix erfolgreich invertiert wurde.
rsMatrixLoad : Matrix laden oder kopieren
| void rsMatrixLoad(rs_matrix2x2* destination, const float* Array); | |
| void rsMatrixLoad(rs_matrix2x2* target, const rs_matrix2x2* source); | |
| void rsMatrixLoad(rs_matrix3x3* destination, const float* Array); | |
| void rsMatrixLoad(rs_matrix3x3* target, const rs_matrix3x3* source); | |
| void rsMatrixLoad(rs_matrix4x4* destination, const float* Array); | |
| void rsMatrixLoad(rs_matrix4x4* destination, const rs_matrix2x2* Quelle); | |
| void rsMatrixLoad(rs_matrix4x4* destination, const rs_matrix3x3* source); | |
| void rsMatrixLoad(rs_matrix4x4* destination, const rs_matrix4x4* source); |
Parameter
| ziel | Legen Sie die Matrix fest. |
|---|---|
| Array | Array von Werten, auf die die Matrix gesetzt werden soll. Diese Arrays sollten je nach Matrixgröße 4, 9 oder 16 Gleitkommazahlen lang sein. |
| Quelle | Quellmatrix. |
Legen Sie die Elemente einer Matrix aus einem Array von Gleitkommazahlen oder einer anderen Matrix fest.
Beim Laden aus einem Array sollten die Gleitkommazahlen in der Zeilen-Hauptreihenfolge stehen, d.h. das Element a row 0, column 0 sollte an erster Stelle stehen, gefolgt von dem Element bei row 0, column 1 usw.
Wenn das Laden aus einer Matrix und die Quelle kleiner als das Ziel ist, wird der Rest des Ziels mit Elementen der Identitätsmatrix gefüllt. Wenn Sie z.B. eine rs_matrix2x2 in eine rs_matrix4x4 laden, erhalten Sie:
| Min. | 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: Frustumprojektionsmatrix laden
| void rsMatrixLoadFrustum(rs_matrix4x4* m, Gleitkommazahl links, rechts schweben, unten schweben, oben schweben, nahe schweben, schweben weit); |
Parameter
| m | Legen Sie die Matrix fest. |
|---|---|
| hat den Chatroom verlassen | |
| rechts | |
| unten | |
| oben | |
| nahe | |
| weit entfernt |
Erstellt eine Sichtbereichsmatrix und transformiert den durch die sechs Beschneidungsebenen left, right, bottom, top, near, far angegebenen Rahmen.
Um diese Projektion auf einen Vektor anzuwenden, multiplizieren Sie den Vektor mithilfe von rsMatrixMultiply mit der erstellten Matrix.
rsMatrixLoadIdentity: Identitätsmatrix laden
| void rsMatrixLoadIdentity(rs_matrix2x2* m); | |
| void rsMatrixLoadIdentity(rs_matrix3x3* m); | |
| void rsMatrixLoadIdentity(rs_matrix4x4* m); |
Parameter
| m | Legen Sie die Matrix fest. |
|---|
Legen Sie die Elemente einer Matrix auf die Identitätsmatrix fest.
rsMatrixLoadMultiply : Zwei Matrizen multiplizieren
| 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); |
Parameter
| m | Legen Sie die Matrix fest. |
|---|---|
| LH | Linke Matrix des Produkts. |
| RHS | Die rechte Matrix des Produkts. |
Legt m auf das Matrixprodukt von lhs * rhs fest.
Um zwei 4x4-Transformationsmatrizen zu kombinieren, multiplizieren Sie die zweite Transformationsmatrix mit der ersten Transformationsmatrix. Um beispielsweise eine Transformationsmatrix zu erstellen, die die Transformation s1 gefolgt von s2 anwendet, rufen Sie rsMatrixLoadMultiply(&combined, &s2, &s1) auf.
Warnung:Vor Version 21 wird das Speichern des Ergebnisses wieder in der rechten Matrix nicht unterstützt, was zu einem nicht definierten Verhalten führt. Verwenden Sie stattdessen „rsMatrixMulitply“. Verwenden Sie beispielsweise statt rsMatrixLoadMultiply (&m2r, &m2r, &m2l) rsMatrixMultiply (&m2r, &m2l). rsMatrixLoadMultiply (&m2l, &m2r, &m2l) funktioniert wie erwartet.
rsMatrixLoadOrtho: Lädt eine orthografische Projektionsmatrix.
| void rsMatrixLoadOrtho(rs_matrix4x4* m, float links, schweben rechts, schwebend unten, schweben oben, schweben nahe, schweben weit); |
Parameter
| m | Legen Sie die Matrix fest. |
|---|---|
| hat den Chatroom verlassen | |
| rechts | |
| unten | |
| oben | |
| nahe | |
| weit entfernt |
Erstellt eine orthografische Projektionsmatrix und wandelt den durch die sechs Beschneidungsebenen left, right, bottom, top, near, far angegebenen Rahmen in einen Einheitswürfel mit einer Ecke bei (-1, -1, -1) und dem entgegengesetzten Punkt (1, 1, 1) um.
Um diese Projektion auf einen Vektor anzuwenden, multiplizieren Sie den Vektor mit der erstellten Matrix mithilfe von rsMatrixMultiply().
Weitere Informationen finden Sie unter https://de.wikipedia.org/wiki/Orthografische_Projektion .
rsMatrixLoadPerspective : Eine perspektivische Projektionsmatrix laden
| void rsMatrixLoadPerspective(rs_matrix4x4* m, schweben fovy, schweben, schwebend in der Nähe, schweben weit); |
Parameter
| m | Legen Sie die Matrix fest. |
|---|---|
| Fovy | Sichtfeld in Grad entlang der Y-Achse. |
| Aspekt | Verhältnis von x / y. |
| nahe | In der Nähe der Beschneidungsebene. |
| weit entfernt | Entfernungsflugzeug. |
Erstellt eine perspektivische Projektionsmatrix unter der Annahme eines symmetrischen Sichtfelds.
Um diese Projektion auf einen Vektor anzuwenden, multiplizieren Sie den Vektor mit der erstellten Matrix mithilfe von rsMatrixMultiply().
rsMatrixLoadInsert : Eine Rotationsmatrix laden
| void rsMatrixLoadRotation(rs_matrix4x4* m, float rot, float x, float y, float z); |
Parameter
| m | Legen Sie die Matrix fest. |
|---|---|
| faul | Um wie viel Drehung in Grad erfolgen soll |
| x | X-Komponente des Vektors, der die Drehachse ist. |
| y | Y-Komponente des Vektors, der die Drehachse ist. |
| z | Z-Komponente des Vektors, das die Drehachse ist. |
Diese Funktion erstellt eine Rotationsmatrix. Die Drehachse ist der Vektor (x, y, z).
Um einen Vektor zu drehen, multiplizieren Sie ihn mit der erstellten Matrix mithilfe von rsMatrixMultiply().
Weitere Informationen finden Sie unter https://de.wikipedia.org/wiki/Rotationsmatrix .
rsMatrixLoadScale: Eine Skalierungsmatrix laden
| void rsMatrixLoadScale(rs_matrix4x4* m, Gleitkommazahl x, Gleitkommazahl y, Gleitkommazahl z); |
Parameter
| m | Legen Sie die Matrix fest. |
|---|---|
| x | Mehrere, um die x-Komponenten zu skalieren. |
| y | Mehrere, um die y-Komponenten zu skalieren. |
| z | Mehrere, um die Z-Komponenten zu skalieren. |
Diese Funktion erstellt eine Skalierungsmatrix, in der jede Komponente eines Vektors mit einer Zahl multipliziert wird. Diese Zahl kann negativ sein.
Um einen Vektor zu skalieren, multiplizieren Sie ihn mit der erstellten Matrix mithilfe von rsMatrixMultiply().
rsMatrixLoadTranslate : Übersetzungsmatrix laden
| void rsMatrixLoadTranslate(rs_matrix4x4* m, Gleitkommazahl x, Gleitkommazahl y, Gleitkommazahl z); |
Parameter
| m | Legen Sie die Matrix fest. |
|---|---|
| x | Zahl, die jeder x-Komponente hinzugefügt werden soll. |
| y | Zahl, die jeder y-Komponente hinzugefügt werden soll. |
| z | Zahl, die jeder Z-Komponente hinzugefügt werden soll. |
Diese Funktion erstellt eine Übersetzungsmatrix, in der jedem Element eines Vektors eine Zahl hinzugefügt wird.
Wenn Sie einen Vektor übersetzen möchten, multiplizieren Sie ihn mithilfe von rsMatrixMultiply() mit der erstellten Matrix.
rsMatrixMultiply : Eine Matrix mit einem Vektor oder einer anderen Matrix multiplizieren
| float2 rsMatrixMultiply(const rs_matrix2x2* m, float2 in); | In API-Level 14 hinzugefügt |
| float2 rsMatrixMultiply(rs_matrix2x2* m, float2 in); | Aus API-Level 14 und höher entfernt |
| float3 rsMatrixMultiply(const rs_matrix3x3* m, float2 in); | In API-Level 14 hinzugefügt |
| float3 rsMatrixMultiply(const rs_matrix3x3* m, float3 in); | In API-Level 14 hinzugefügt |
| float3 rsMatrixMultiply(rs_matrix3x3* m, float2 in); | Aus API-Level 14 und höher entfernt |
| float3 rsMatrixMultiply(rs_matrix3x3* m, float3 in); | Aus API-Level 14 und höher entfernt |
| float4 rsMatrixMultiply(const rs_matrix4x4* m, float2 in); | In API-Level 14 hinzugefügt |
| float4 rsMatrixMultiply(const rs_matrix4x4* m, float3 in); | In API-Level 14 hinzugefügt |
| float4 rsMatrixMultiply(const rs_matrix4x4* m, float4 in); | In API-Level 14 hinzugefügt |
| float4 rsMatrixMultiply(rs_matrix4x4* m, float2 in); | Aus API-Level 14 und höher entfernt |
| float4 rsMatrixMultiply(rs_matrix4x4* m, float3 in); | Aus API-Level 14 und höher entfernt |
| float4 rsMatrixMultiply(rs_matrix4x4* m, float4 in); | Aus API-Level 14 und höher entfernt |
| 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); |
Parameter
| m | Linke Matrix des Produkts und die festzulegende Matrix. |
|---|---|
| RHS | Die rechte Matrix des Produkts. |
| in |
Für die Matrixvariante „Matrix“ wird „m“ auf das Matrixprodukt m * rhs festgelegt.
Wenn Sie zwei 4x4-Transformationsmatrizen mithilfe dieser Funktion kombinieren, entspricht die resultierende Matrix der Ausführung der rhs-Transformation gefolgt von der ursprünglichen m-Transformation.
Gibt für die Matrix nach Vektorvariante die Post-Multiplikation des Vektors durch die Matrix zurück, d. h. m * in.
Wenn Sie Gleitkommazahl3 mit rs_matrix4x4 multiplizieren, wird der Vektor mit (1) erweitert.
Wenn Sie Gleitkommazahl2 mit rs_matrix4x4 multiplizieren, wird der Vektor mit (0, 1) erweitert.
Wenn Sie Gleitkommazahl2 mit rs_matrix3x3 multiplizieren, wird der Vektor mit (0) erweitert.
Ab API 14 verwendet diese Funktion eine const-Matrix als erstes Argument.
rsMatrixRotation : Eine Rotation auf eine Transformationsmatrix anwenden
| void rsMatrix bereitgestellte(rs_matrix4x4* m, float rot, float x, float y, float z); |
Parameter
| m | Matrix, die geändert werden soll. |
|---|---|
| faul | Um wie viel Drehung in Grad erfolgen soll |
| x | X-Komponente des Vektors, der die Drehachse ist. |
| y | Y-Komponente des Vektors, der die Drehachse ist. |
| z | Z-Komponente des Vektors, das die Drehachse ist. |
Die Matrix m wird mit einer Rotationsmatrix multipliziert.
Diese Funktion ändert eine Transformationsmatrix, um zuerst eine Rotation auszuführen. Die Rotationsachse ist der Vektor (x, y, z).
Um diese kombinierte Transformation auf einen Vektor anzuwenden, multiplizieren Sie den Vektor mit der erstellten Matrix mithilfe von rsMatrixMultiply().
rsMatrixScale : Skalierung auf eine Transformationsmatrix anwenden
| void rsMatrixScale(rs_matrix4x4* m, Gleitkommazahl x, Gleitkommazahl y, Gleitkommazahl z); |
Parameter
| m | Matrix, die geändert werden soll. |
|---|---|
| x | Mehrere, um die x-Komponenten zu skalieren. |
| y | Mehrere, um die y-Komponenten zu skalieren. |
| z | Mehrere, um die Z-Komponenten zu skalieren. |
Die Matrix m wird mit einer Skalierungsmatrix multipliziert.
Diese Funktion ändert eine Transformationsmatrix, um zuerst eine Skalierung auszuführen. Bei der Skalierung wird jede Komponente eines Vektors mit einer Zahl multipliziert. Diese Zahl kann negativ sein.
Um diese kombinierte Transformation auf einen Vektor anzuwenden, multiplizieren Sie den Vektor mit der erstellten Matrix mithilfe von rsMatrixMultiply().
rsMatrixSet : Ein Element festlegen
| void rsMatrixSet(rs_matrix2x2* m, uint32_t col, uint32_t row, float v); | |
| void rsMatrixSet(rs_matrix3x3* m, uint32_t col, uint32_t row, float v); | |
| void rsMatrixSet(rs_matrix4x4* m, uint32_t col, uint32_t row, float v); |
Parameter
| m | Matrix, die geändert wird. |
|---|---|
| Spalte | Nullbasierte Spalte des festzulegenden Elements. |
| Zeile | Nullbasierte Zeile des festzulegenden Elements. |
| v | Festzulegender Wert. |
Legen Sie ein Element einer Matrix fest.
Warnung:Die Reihenfolge der Spalten- und Zeilenparameter ist möglicherweise nicht korrekt.
rsMatrixTranslate : Übersetzung auf eine Transformationsmatrix anwenden
| void rsMatrixTranslate(rs_matrix4x4* m, Gleitkommazahl x, Gleitkommazahl y, Gleitkommazahl z); |
Parameter
| m | Matrix, die geändert werden soll. |
|---|---|
| x | Zahl, die jeder x-Komponente hinzugefügt werden soll. |
| y | Zahl, die jeder y-Komponente hinzugefügt werden soll. |
| z | Zahl, die jeder Z-Komponente hinzugefügt werden soll. |
Multipliziere die Matrix m mit einer Übersetzungsmatrix.
Diese Funktion ändert eine Transformationsmatrix, um zuerst eine Übersetzung auszuführen. Beim Übersetzen wird jeder Komponente eines Vektors eine Zahl hinzugefügt.
Um diese kombinierte Transformation auf einen Vektor anzuwenden, multiplizieren Sie den Vektor mit der erstellten Matrix mithilfe von rsMatrixMultiply().
rsMatrixTranspose : Matrixort transponieren
| void rsMatrixTranspose(rs_matrix2x2* m); | |
| void rsMatrixTranspose(rs_matrix3x3* m); | |
| void rsMatrixTranspose(rs_matrix4x4* m); |
Parameter
| m | Zu transponierte Matrix. |
|---|
Matrix m transponieren.