Funzioni della matrice RenderScript

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
viewProjMatrice da cui estrarre i piani.
a sinistraAereo a sinistra.
a destraL'aereo destro.
superiorePiano superiore.
inferiorePiano inferiore.
vicino aQuasi l'aereo.
lontanoAereo 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
sferafloat4 che rappresenta la sfera.
a sinistraAereo a sinistra.
a destraL'aereo destro.
superiorePiano superiore.
inferiorePiano inferiore.
vicino aQuasi l'aereo.
lontanoAereo 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
mMatrice da cui estrarre l'elemento.
colColonna in base zero dell'elemento da estrarre.
rigaRiga 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
mMatrice da invertire.

Restituisce true se la matrice è stata invertita correttamente.

rsMatrixInverseTranspose : inverte e trasponi una matrice presente

bool rsMatrixInverseTranspose(rs_matrix4x4* m);
Parametri
mMatrice 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
destinazioneMatrice da impostare.
arrayArray di valori su cui impostare la matrice. Questi array dovrebbero essere lunghi 4, 9 o 16 float, a seconda delle dimensioni della matrice.
fonteMatrice 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
mMatrice 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
mMatrice 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
mMatrice da impostare.
LsMatrice di sinistra del prodotto.
dxMatrice 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
mMatrice 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
mMatrice da impostare.
FovyCampo visivo, in gradi lungo l'asse Y.
aspettoRapporto x / y.
vicino aVicino al piano di aggancio.
lontanoPiano 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
mMatrice da impostare.
marcireQuanta rotazione fare, in gradi.
xComponente X del vettore che è l'asse di rotazione.
yComponente Y del vettore che è l'asse di rotazione.
zComponente 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
mMatrice da impostare.
xMultiplo per cui scalare i componenti x.
yMultiplo per scalare i componenti y.
zMultiplo 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
mMatrice da impostare.
xNumero da aggiungere a ciascun componente x.
yNumero da aggiungere a ciascun componente y.
zNumero 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
mMatrice di sinistra del prodotto e matrice da impostare.
dxMatrice 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
mMatrice da modificare.
marcireQuanta rotazione fare, in gradi.
xComponente X del vettore che è l'asse di rotazione.
yComponente Y del vettore che è l'asse di rotazione.
zComponente 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
mMatrice da modificare.
xMultiplo per cui scalare i componenti x.
yMultiplo per scalare i componenti y.
zMultiplo 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
mMatrice che verrà modificata.
colColonna in base zero dell'elemento da impostare.
rigaRiga in base zero dell'elemento da impostare.
vValore 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
mMatrice da modificare.
xNumero da aggiungere a ciascun componente x.
yNumero da aggiungere a ciascun componente y.
zNumero 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
mMatrice da trasporre.

Trasponi la matrice m in posizione.