Panoramica
Queste funzioni consentono di manipolare le matrici quadrate di rango 2x2, 3x3 e 4x4. Sono particolarmente utili per le trasformazioni grafiche e sono compatibili con OpenGL.
Utilizziamo un indice in base zero per le righe e le colonne. Ad esempio, l'ultimo elemento di rs_matrix4x4 si trova in (3, 3).
RenderScript utilizza le matrici principali e i vettori basati su colonne. La trasformazione di un vettore viene eseguita postmoltiplicandolo, ad esempio (matrix * vector)
, come fornito da rsMatrixMultiply().
Per creare una matrice di trasformazione che esegue due trasformazioni contemporaneamente, moltiplica le due matrici di origine, con la prima trasformazione come argomento giusto. Ad esempio, per creare una matrice di trasformazione che applichi la trasformazione s1 seguita da s2, chiama rsMatrixLoadMultiply(&combined, &s2, &s1)
.
Questo deriva da s2 * (s1 * v)
, che corrisponde a (s2 * s1) * v
.
Abbiamo due tipi di funzioni per creare le matrici di trasformazione: rsMatrixLoadTransformation e rsMatrixTransformation. Lo stile precedente archivia semplicemente la matrice di trasformazione nel primo argomento. Quest'ultimo modifica una matrice di trasformazione preesistente in modo che la nuova trasformazione avvenga per prima. Ad esempio, se chiami rsMatrixTranslate() su una matrice che già esegue una scala, la matrice risultante, quando applicata a un vettore, eseguirà prima la traslazione e poi la scala.
Riepilogo
Funzioni | |
---|---|
rsExtractFrustumPlanes | Piani a tronco di calcolo |
rsIsSphereInFrustum | Verifica se una sfera si trova all'interno dei piani troncocologici |
rsMatrixGet | Ottieni un elemento |
rsMatrixInverse | Inverte una matrice presente |
rsMatrixInverseTranspose | Inverte e trasponi una matrice in posizione |
rsMatrixLoad | Carica o copia una matrice |
rsMatrixLoadFrustum | Carica una matrice di proiezione del tronco |
rsMatrixLoadIdentity | Carica matrice identità |
rsMatrixLoadMultiply | Moltiplicare due matrici |
rsMatrixLoadOrtho | Carica una matrice di proiezione ortografica |
rsMatrixLoadPerspective | Carica una matrice di proiezione prospettica |
rsMatrixLoadRuota | Carica una matrice di rotazione |
rsMatrixLoadScale | Carica una matrice di scalabilità |
rsMatrixLoadTranslate | Carica una matrice di traduzione |
rsMatrixMultiply | Moltiplicare una matrice per un vettore o un'altra matrice |
rsMatrixRuota | Applicare una rotazione a una matrice di trasformazione |
rsMatrixScale | Applicare una scala a una matrice di trasformazione |
InsMatrixSet | Imposta un elemento |
Traduttore di rsMatrix | Applicare una traduzione a una matrice di trasformazione |
rsMatrixTranspose | Trasponi una posizione della matrice |
Funzioni
rsExtractFrustumPlanes : piani a tronco di calcolo
void rsExtractFrustumPlanes(const rs_matrix4x4* viewProj, float4* sinistro, float4* righ, float4* in alto, float4* in basso, float4* vicino, float4* lontano); | Aggiunto al livello API 24 |
void rsExtractFrustumPlanes(const rs_matrix4x4* viewProj, float4* left, float4* destra, float4* in alto, float4* in basso, float4* vicino, float4* lontano); | Rimossa dal livello API 24 e successivi |
Parametri
viewProj | Matrice da cui estrarre i piani. |
---|---|
a sinistra | Aereo a sinistra. |
a destra | L'aereo destro. |
superiore | Piano superiore. |
inferiore | Piano inferiore. |
vicino a | Quasi l'aereo. |
lontano | Aereo lontano. |
giusto |
Calcola 6 piani a tronco dalla matrice di proiezione della vista
rsIsSphereInFrustum : controlla se una sfera si trova all'interno dei piani troncocologici
bool rsIsSphereInFrustum(float4* sfera, float4* sinistra, float4* destra, float4* in alto, float4* in basso, float4* vicino, float4* lontano); |
Parametri
sfera | float4 che rappresenta la sfera. |
---|---|
a sinistra | Aereo a sinistra. |
a destra | L'aereo destro. |
superiore | Piano superiore. |
inferiore | Piano inferiore. |
vicino a | Quasi l'aereo. |
lontano | Aereo lontano. |
Restituisce true se la sfera si trova all'interno dei sei piani a tronco.
rsMatrixGet : ottieni un elemento
float rsMatrixGet(const rs_matrix2x2* m, uint32_t col, uint32_t riga); | |
float rsMatrixGet(const rs_matrix3x3* m, uint32_t col, uint32_t riga); | |
float rsMatrixGet(const rs_matrix4x4* m, uint32_t col, uint32_t riga); |
Parametri
m | Matrice da cui estrarre l'elemento. |
---|---|
col | Colonna in base zero dell'elemento da estrarre. |
riga | Riga in base zero dell'elemento da estratto. |
Restituisce un elemento di una matrice.
Avviso:l'ordine dei parametri di colonna e riga potrebbe essere imprevisto.
rsMatrixInverse : inverte una matrice presente
bool rsMatrixInverse(rs_matrix4x4* m); |
Parametri
m | Matrice da invertire. |
---|
Restituisce true se la matrice è stata invertita correttamente.
rsMatrixInverseTranspose : inverte e trasponi una matrice presente
bool rsMatrixInverseTranspose(rs_matrix4x4* m); |
Parametri
m | Matrice da modificare. |
---|
La matrice viene prima invertita e poi trasposta. Restituisce true se la matrice è stata invertita correttamente.
rsMatrixLoad : carica o copia una 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); |
Parametri
destinazione | Matrice da impostare. |
---|---|
array | Array di valori su cui impostare la matrice. Questi array dovrebbero essere lunghi 4, 9 o 16 float, a seconda delle dimensioni della matrice. |
fonte | Matrice di origine. |
Imposta gli elementi di una matrice da un array di numeri in virgola mobile o da un'altra matrice.
Se il caricamento avviene da un array, i valori in virgola mobile devono essere in ordine di riga principale, ovvero l'elemento row 0, column 0
deve essere il primo, seguito dall'elemento in row 0, column 1
e così via.
Se il caricamento da una matrice e l'origine è minore della destinazione, il resto della destinazione viene riempito con gli elementi della matrice identità. Ad esempio, il caricamento di un file rs_matrix2x2 in rs_matrix4x4 restituirà:
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 : carica una matrice di proiezione del tronco
void rsMatrixLoadFrustum(rs_matrix4x4* m, virgola mobile a sinistra, galleggiante a destra, galleggiante in basso, galleggiante in alto, galleggiante vicino, galleggiante lontano); |
Parametri
m | Matrice da impostare. |
---|---|
a sinistra | |
a destra | |
inferiore | |
superiore | |
vicino a | |
lontano |
Crea una matrice di proiezione del tronco, trasformando il riquadro identificato dai sei piani di ritaglio left, right, bottom, top, near, far
.
Per applicare questa proiezione a un vettore, moltiplica il vettore per la matrice creata utilizzando rsMatrixMultiply().
rsMatrixLoadIdentity : carica la matrice dell'identità
void rsMatrixLoadIdentity(rs_matrix2x2* m); | |
void rsMatrixLoadIdentity(rs_matrix3x3* m); | |
void rsMatrixLoadIdentity(rs_matrix4x4* m); |
Parametri
m | Matrice da impostare. |
---|
Imposta gli elementi di una matrice sulla matrice identità.
rsMatrixLoadMultiply : moltiplica due matrici
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); |
Parametri
m | Matrice da impostare. |
---|---|
Ls | Matrice di sinistra del prodotto. |
dx | Matrice destra del prodotto. |
Imposta m sul prodotto della matrice di lhs * rhs
.
Per combinare due matrici di trasformazione 4 x 4, moltiplica la seconda matrice di trasformazione per la prima. Ad esempio, per creare una matrice di trasformazione che applica
la trasformazione s1 seguita da s2, chiama rsMatrixLoadMultiply(&combined, &s2, &s1)
.
Avviso: prima della versione 21, l'archiviazione dei risultati nella matrice destra non è supportata e comporterà un comportamento indefinito. Utilizza rsMatrixMulitply. Ad esempio, invece di eseguire rsMatrixLoadMultiply (&m2r, &m2r, &m2l), utilizza rsMatrixMultiply (&m2r, &m2l). rsMatrixLoadMultiply (&m2l, &m2r, &m2l) funziona come previsto.
rsMatrixLoadOrtho : carica una matrice di proiezione ortografica
void rsMatrixLoadOrtho(rs_matrix4x4* m, galleggia a sinistra, galleggia a destra, galleggia in basso, galleggia in alto, galleggia vicino, galleggia lontano); |
Parametri
m | Matrice da impostare. |
---|---|
a sinistra | |
a destra | |
inferiore | |
superiore | |
vicino a | |
lontano |
Crea una matrice di proiezione ortografica, trasformando il riquadro identificato dai sei piani di ritaglio left, right, bottom, top, near, far
in un cubo unitario con un angolo in (-1, -1, -1)
e il contrario in (1, 1, 1)
.
Per applicare questa proiezione a un vettore, moltiplica il vettore per la matrice creata utilizzando rsMatrixMultiply().
Consulta la pagina https://en.wikipedia.org/wiki/Orthographic_projection .
rsMatrixLoadPerspective : carica una matrice di proiezione prospettica
void rsMatrixLoadPerspective(rs_matrix4x4* m, float fovy, aspetto float, float near, float lontano); |
Parametri
m | Matrice da impostare. |
---|---|
Fovy | Campo visivo, in gradi lungo l'asse Y. |
aspetto | Rapporto x / y. |
vicino a | Vicino al piano di aggancio. |
lontano | Piano di ritaglio lontano. |
Crea una matrice di proiezione prospettica, assumendo un campo visivo simmetrico.
Per applicare questa proiezione a un vettore, moltiplica il vettore per la matrice creata utilizzando rsMatrixMultiply().
rsMatrixLoadRuota : carica una matrice di rotazione
void rsMatrixLoadRuota(rs_matrix4x4* m, float rot, float x, float y, float z); |
Parametri
m | Matrice da impostare. |
---|---|
marcire | Quanta rotazione fare, in gradi. |
x | Componente X del vettore che è l'asse di rotazione. |
y | Componente Y del vettore che è l'asse di rotazione. |
z | Componente Z del vettore che è l'asse di rotazione. |
Questa funzione crea una matrice di rotazione. L'asse di rotazione è il vettore (x, y, z)
.
Per ruotare un vettore, moltiplicalo per la matrice creata utilizzando rsMatrixMultiply().
Consulta https://en.wikipedia.org/wiki/Rotazione_matrix .
rsMatrixLoadScale : carica una matrice di scalabilità
void rsMatrixLoadScale(rs_matrix4x4* m, numero in virgola mobile x, numero in virgola mobile y, numero in virgola mobile z); |
Parametri
m | Matrice da impostare. |
---|---|
x | Multiplo per cui scalare i componenti x. |
y | Multiplo per scalare i componenti y. |
z | Multiplo per scalare i componenti z. |
Questa funzione crea una matrice di scala, in cui ogni componente di un vettore viene moltiplicato per un numero. Questo numero può essere negativo.
Per scalare un vettore, moltiplicalo per la matrice creata utilizzando rsMatrixMultiply().
rsMatrixLoadTranslate : carica una matrice di traduzione
void rsMatrixLoadTranslate(rs_matrix4x4* m, float x, float y, float z); |
Parametri
m | Matrice da impostare. |
---|---|
x | Numero da aggiungere a ciascun componente x. |
y | Numero da aggiungere a ciascun componente y. |
z | Numero da aggiungere a ciascun componente z. |
Questa funzione crea una matrice di traslazione, in cui viene aggiunto un numero a ogni elemento di un vettore.
Per tradurre un vettore, moltiplica il vettore per la matrice creata utilizzando rsMatrixMultiply().
rsMatrixMultiply : moltiplica una matrice per un vettore o un'altra matrice
float2 rsMatrixMultiply(const rs_matrix2x2* m, float2 in); | Aggiunto al livello API 14 |
float2 rsMatrixMultiply(rs_matrix2x2* m, float2 in); | Rimossa dal livello API 14 e successivi |
float3 rsMatrixMultiply(const rs_matrix3x3* m, float2 in); | Aggiunto al livello API 14 |
float3 rsMatrixMultiply(const rs_matrix3x3* m, float3 in); | Aggiunto al livello API 14 |
float3 rsMatrixMultiply(rs_matrix3x3* m, float2 in); | Rimossa dal livello API 14 e successivi |
float3 rsMatrixMultiply(rs_matrix3x3* m, float3 in); | Rimossa dal livello API 14 e successivi |
float4 rsMatrixMultiply(const rs_matrix4x4* m, float2 in); | Aggiunto al livello API 14 |
float4 rsMatrixMultiply(const rs_matrix4x4* m, float3 in); | Aggiunto al livello API 14 |
float4 rsMatrixMultiply(const rs_matrix4x4* m, float4 in); | Aggiunto al livello API 14 |
float4 rsMatrixMultiply(rs_matrix4x4* m, float2 in); | Rimossa dal livello API 14 e successivi |
float4 rsMatrixMultiply(rs_matrix4x4* m, float3 in); | Rimossa dal livello API 14 e successivi |
float4 rsMatrixMultiply(rs_matrix4x4* m, float4 in); | Rimossa dal livello API 14 e successivi |
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); |
Parametri
m | Matrice di sinistra del prodotto e matrice da impostare. |
---|---|
dx | Matrice destra del prodotto. |
in |
Per la matrice per variante della matrice, imposta m sul prodotto della matrice m * rhs
.
Quando combini due matrici di trasformazione 4x4 utilizzando questa funzione, la matrice risultante corrisponderà all'esecuzione della trasformazione rhs prima seguita dalla trasformazione m originale.
Per la matrice per variante vettoriale, restituisce la post-moltiplicazione del vettore per la matrice, ovvero m * in
.
Moltiplicando un float3 per un rs_matrix4x4, il vettore viene espanso con (1).
Moltiplicando un float2 per un rs_matrix4x4, il vettore viene espanso con (0, 1).
Moltiplicando un float2 per un rs_matrix3x3, il vettore viene espanso con (0).
A partire dall'API 14, questa funzione prende una matrice const come primo argomento.
rsMatrixRuota : applica una rotazione a una matrice di trasformazione
void rsMatrixRuota(rs_matrix4x4* m, float rot, float x, float y, float z); |
Parametri
m | Matrice da modificare. |
---|---|
marcire | Quanta rotazione fare, in gradi. |
x | Componente X del vettore che è l'asse di rotazione. |
y | Componente Y del vettore che è l'asse di rotazione. |
z | Componente Z del vettore che è l'asse di rotazione. |
Moltiplica la matrice m con una matrice di rotazione.
Questa funzione modifica una matrice di trasformazione per eseguire prima una rotazione. L'asse di rotazione è il vettore (x, y, z)
.
Per applicare questa trasformazione combinata a un vettore, moltiplica il vettore per la matrice creata utilizzando rsMatrixMultiply().
rsMatrixScale : applica una scalabilità a una matrice di trasformazione
void rsMatrixScale(rs_matrix4x4* m, numero in virgola mobile x, numero in virgola mobile y, numero in virgola mobile z); |
Parametri
m | Matrice da modificare. |
---|---|
x | Multiplo per cui scalare i componenti x. |
y | Multiplo per scalare i componenti y. |
z | Multiplo per scalare i componenti z. |
Moltiplica la matrice m per una matrice di scala.
Questa funzione modifica una matrice di trasformazione per eseguire prima una scala. Durante il ridimensionamento, ogni componente di un vettore viene moltiplicato per un numero. Questo numero può essere negativo.
Per applicare questa trasformazione combinata a un vettore, moltiplica il vettore per la matrice creata utilizzando rsMatrixMultiply().
rsMatrixSet : imposta un elemento
void rsMatrixSet(rs_matrix2x2* m, uint32_t col, uint32_t riga, float v); | |
void rsMatrixSet(rs_matrix3x3* m, uint32_t col, uint32_t riga, float v); | |
void rsMatrixSet(rs_matrix4x4* m, uint32_t col, uint32_t riga, float v); |
Parametri
m | Matrice che verrà modificata. |
---|---|
col | Colonna in base zero dell'elemento da impostare. |
riga | Riga in base zero dell'elemento da impostare. |
v | Valore da impostare. |
Imposta un elemento di una matrice.
Avviso:l'ordine dei parametri di colonna e riga potrebbe essere imprevisto.
rsMatrixTranslate : applica una traduzione a una matrice di trasformazione
void rsMatrixTranslate(rs_matrix4x4* m, float x, float y, float z); |
Parametri
m | Matrice da modificare. |
---|---|
x | Numero da aggiungere a ciascun componente x. |
y | Numero da aggiungere a ciascun componente y. |
z | Numero da aggiungere a ciascun componente z. |
Moltiplica la matrice m con una matrice di traslazione.
Questa funzione modifica una matrice di trasformazione per eseguire prima una traduzione. Durante la traduzione, viene aggiunto un numero a ogni componente di un vettore.
Per applicare questa trasformazione combinata a un vettore, moltiplica il vettore per la matrice creata utilizzando rsMatrixMultiply().
rsMatrixTranspose : trasponi una posizione della matrice
void rsMatrixTranspose(rs_matrix2x2* m); | |
void rsMatrixTranspose(rs_matrix3x3* m); | |
void rsMatrixTranspose(rs_matrix4x4* m); |
Parametri
m | Matrice da trasporre. |
---|
Trasponi la matrice m in posizione.