Questa pagina è stata tradotta dall'API Cloud Translation.

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

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.