Funciones de matriz de RenderScript

Descripción general

Estas funciones te permiten manipular matrices cuadradas de rango 2x2, 3x3 y 4x4. Son particularmente útiles para las transformaciones gráficas y son compatibles con OpenGL.

Usamos un índice basado en cero para las filas y columnas. P.ej., el último elemento de una rs_matrix4x4 se encuentra en (3, 3).

RenderScript usa matrices de columna mayor y vectores basados en columnas. Se puede transformar un vector mediante la posmultiplicación, p.ej., (matrix * vector), según lo proporciona rsMatrixMultiply().

Para crear una matriz de transformación que realice dos transformaciones a la vez, multiplica las dos matrices de origen, con la primera transformación como el argumento correcto. P.ej., para crear una matriz de transformación que aplique la transformación s1 seguida de s2, llama a rsMatrixLoadMultiply(&combined, &s2, &s1). Esto deriva de s2 * (s1 * v), que es (s2 * s1) * v.

Tenemos dos estilos de funciones para crear matrices de transformación: rsMatrixLoadTransformation y rsMatrixTransformation. El primer estilo simplemente almacena la matriz de transformación en el primer argumento. La última modificación modifica una matriz de transformación preexistente para que la transformación nueva ocurra primero. P.ej., si llamas a rsMatrixTranslate() en una matriz que ya realiza un ajuste de tamaño, la matriz resultante cuando se aplica a un vector realizará primero la traducción y, luego, el ajuste.

Resumen

Funciones
rsExtractFrustumPlanes Calcula los planos de tronco
rsIsSphereInFrustum. Comprueba si una esfera está dentro de los planos del tronco.
rsMatrixGet Obtén un elemento
rsMatrixInverso Invierte una matriz en su lugar
rsMatrixInverseTranspose Invierte y transpone una matriz en el lugar
rsMatrixLoad Carga o copia una matriz
rsMatrixLoadFrustum. Carga una matriz de proyección de tronco
rsMatrixLoadIdentity Cargar matriz de identidad
rsMatrixLoadMultiply. Multiplica dos matrices
rsMatrixLoadOrtho Carga una matriz de proyección ortográfica
rsMatrixLoadPerspective Cómo cargar una matriz de proyección de perspectiva
rsMatrixLoadRotate Carga una matriz de rotación
rsMatrixLoadScale Carga una matriz de escalamiento
rsMatrixLoadTranslate Carga una matriz de traducción
rsMatrixMultiply Multiplicar una matriz por un vector o por otra matriz
rsMatrixRotate Aplicar una rotación a una matriz de transformación
rsMatrixScale Aplicar un escalamiento a una matriz de transformación
ConjuntorsMatrix Cómo establecer un elemento
rsMatrixTranslate Aplicar una traslación a una matriz de transformación
rsMatrixTranspose Transpone un lugar de matriz

Funciones

rsExtractFrustumPlanes : calcula planos de frustum

void rsExtractFrustumPlanes(const rs_matrix4x4* viewProj, float4* left, float4* righ, float4* top, float4* inferior, float4* cerca de float4* far); Se agregó en el nivel de API 24.
void rsExtractFrustumPlanes(const rs_matrix4x4* viewProj, float4* left, float4* right, float4* top, float4* low, float4* nearby, float4* far); Se quitó del nivel de API 24 y versiones posteriores.
Parámetros
ViewProjMatriz de la que se extraerán los planos.
izquierdaPlano izquierdo.
derechaPlano derecho.
altaPlano superior.
bajaPlano inferior.
cercaCerca de un avión.
lejosAvión lejos.
derecho

Calcula 6 planos de tronco a partir de la matriz de proyección de vista

rsIsSphereInFrustum : Comprueba si una esfera se encuentra dentro de los planos del tronco.

bool rsIsSphereInFrustum(float4* sphere, float4* left, float4* right, float4* top, float4* inferior, float4* cerca de float4* lejos);)
Parámetros
esferafloat4, que representa la esfera.
izquierdaPlano izquierdo.
derechaPlano derecho.
altaPlano superior.
bajaPlano inferior.
cercaCerca de un avión.
lejosAvión lejos.

Muestra true si la esfera está dentro de los 6 planos de tronco.

rsMatrixGet : Obtén un elemento

float rsMatrixGet(const rs_matrix2x2* m, uint32_t col, uint32_t fila);
float rsMatrixGet(const rs_matrix3x3* m, uint32_t col, uint32_t fila);
float rsMatrixGet(const rs_matrix4x4* m, uint32_t col, uint32_t fila);
Parámetros
mMatriz de la que se extraerá el elemento.
columnaColumna basada en cero del elemento que se desea extraer.
filaFila basada en cero del elemento que se extraerá.

Muestra un elemento de una matriz.

Advertencia: El orden de los parámetros de columna y fila puede ser inesperado.

rsMatrixInverse : Invierte una matriz en su lugar

bool rsMatrixInverse(rs_matrix4x4* m);
Parámetros
mMatriz para invertir

Muestra true si la matriz se invirtió correctamente.

rsMatrixInverseTranspose : Invierte y transpone una matriz en el lugar

bool rsMatrixInverseTranspose(rs_matrix4x4* m);
Parámetros
mMatriz que se modificará.

Primero, se invierte la matriz y, luego, se transpone. El resultado es verdadero si se invirtió correctamente la matriz.

rsMatrixLoad : Carga o copia una matriz

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);
Parámetros
destinoMatriz para establecer
matrizArreglo de valores para establecer la matriz. Estos arrays deben tener 4, 9 o 16 números de punto flotante, según el tamaño de la matriz.
fuenteMatriz de origen.

Establece los elementos de una matriz a partir de un array de números de punto flotante o de otra matriz.

Si se cargan desde un array, los números de punto flotante deben estar en orden de fila principal, es decir, el elemento row 0, column 0 debe estar primero, seguido del elemento en row 0, column 1, etcétera.

Si se realiza la carga desde una matriz y el origen es más pequeño que el destino, el resto del destino se llena con elementos de la matriz de identidad. P.ej., cargar una rs_matrix2x2 en una rs_matrix4x4 arrojará lo siguiente:

M0 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 : Carga una matriz de proyección de tronco

void rsMatrixLoadFrustum(rs_matrix4x4* m, flotante a la izquierda, flotante a la derecha, float inferior, float arriba, float cerca, flotar lejos);
Parámetros
mMatriz para establecer
izquierda
derecha
baja
alta
cerca
lejos

Construye una matriz de proyección de tronco y transforma el cuadro identificado por los seis planos de recorte left, right, bottom, top, near, far.

Para aplicar esta proyección a un vector, multiplica el vector por la matriz creada mediante rsMatrixMultiply().

rsMatrixLoadIdentity : Cargar matriz de identidad

void rsMatrixLoadIdentity(rs_matrix2x2* m);
void rsMatrixLoadIdentity(rs_matrix3x3* m);
void rsMatrixLoadIdentity(rs_matrix4x4* m);
Parámetros
mMatriz para establecer

Establece los elementos de una matriz en la matriz identidad.

rsMatrixLoadMultiply : Multiplica dos 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);
Parámetros
mMatriz para establecer
lMatriz izquierda del producto
rhsMatriz derecha del producto

Configura m en el producto de matriz de lhs * rhs.

Para combinar dos matrices de transformación de 4 x 4, multiplica la segunda matriz de transformación por la primera matriz de transformación. P.ej., para crear una matriz de transformación que aplique la transformación s1 seguida de s2, llama a rsMatrixLoadMultiply(&combined, &s2, &s1).

Advertencia: Antes de la versión 21, no se admite el almacenamiento del resultado en la matriz derecha, lo que generará un comportamiento indefinido. En su lugar, usa rsMatrixMulitply. P.ej., en lugar de hacer rsMatrixLoadMultiply (&m2r, &m2r, &m2l), usa rsMatrixMultiply (&m2r y &m2l). rsMatrixLoadMultiply (&m2l, &m2r, &m2l) funciona según lo esperado.

rsMatrixLoadOrtho : Carga una matriz de proyección ortográfica

void rsMatrixLoadOrtho(rs_matrix4x4* m, flotante a la izquierda, flotante a la derecha, float inferior, float superior, float cerca de, a float le)
Parámetros
mMatriz para establecer
izquierda
derecha
baja
alta
cerca
lejos

Construye una matriz de proyección ortográfica y transforma el cuadro identificado por los seis planos de recorte left, right, bottom, top, near, far en un cubo unitario con una esquina en (-1, -1, -1) y lo contrario en (1, 1, 1).

Para aplicar esta proyección a un vector, multiplica el vector por la matriz creada con rsMatrixMultiply().

Consulta https://es.wikipedia.org/wiki/Orthoography_projection .

rsMatrixLoadPerspective : Carga una matriz de proyección de perspectiva

void rsMatrixLoadPerspective(rs_matrix4x4* m, fovy de flote, aspecto de float, float cerca, flotar lejos);
Parámetros
mMatriz para establecer
de modaCampo visual, en grados a lo largo del eje Y.
aspectoProporción de x / y
cercaCerca de un avión de recorte.
lejosAvión de recortes lejano.

Construye una matriz de proyección de perspectiva, suponiendo un campo visual simétrico.

Para aplicar esta proyección a un vector, multiplica el vector por la matriz creada con rsMatrixMultiply().

rsMatrixLoadRotate : Carga una matriz de rotación

void rsMatrixLoadRotate(rs_matrix4x4* m, float rot, float x, float y, float z);
Parámetros
mMatriz para establecer
podridoIndica la rotación que se debe realizar, en grados.
xComponente X del vector que es el eje de rotación.
yEs el componente Y del vector que es el eje de rotación.
zComponente Z del vector que es el eje de rotación.

Esta función crea una matriz de rotación. El eje de rotación es el vector (x, y, z).

Para rotar un vector, multiplícalo por la matriz creada con rsMatrixMultiply().

Consulta https://es.wikipedia.org/wiki/Rotation_matrix .

rsMatrixLoadScale : Carga una matriz de escalamiento

void rsMatrixLoadScale(rs_matrix4x4* m, float x, float y, float z);
Parámetros
mMatriz para establecer
xMúltiple para escalar los componentes x.
yMúltiple para escalar los componentes y.
zMúltiple para escalar los componentes z por

Esta función crea una matriz de escalamiento, en la que cada componente de un vector se multiplica por un número. Este número puede ser negativo.

Para escalar un vector, multiplícalo por la matriz creada con rsMatrixMultiply().

rsMatrixLoadTranslate : Carga una matriz de traducción

void rsMatrixLoadTranslate(rs_matrix4x4* m, float x, float y, float z);
Parámetros
mMatriz para establecer
xNúmero que se agregará a cada componente x.
yNúmero que se agregará a cada componente y.
zNúmero que se agregará a cada componente z.

Esta función crea una matriz de traducción, en la que se suma un número a cada elemento de un vector.

Para traducir un vector, multiplica el vector por la matriz creada mediante rsMatrixMultiply().

rsMatrixMultiply : Multiplicar una matriz por un vector o por otra matriz

float2 rsMatrixMultiply(const rs_matrix2x2* m, float2 in); Se agregó en el nivel de API 14.
float2 rsMatrixMultiply(rs_matrix2x2* m, float2 in); Se quitó del nivel de API 14 y versiones posteriores.
float3 rsMatrixMultiply(const rs_matrix3x3* m, float2 in); Se agregó en el nivel de API 14.
float3 rsMatrixMultiply(const rs_matrix3x3* m, float3 in); Se agregó en el nivel de API 14.
float3 rsMatrixMultiply(rs_matrix3x3* m, float2 in); Se quitó del nivel de API 14 y versiones posteriores.
float3 rsMatrixMultiply(rs_matrix3x3* m, float3 in); Se quitó del nivel de API 14 y versiones posteriores.
float4 rsMatrixMultiply(const rs_matrix4x4* m, float2 in); Se agregó en el nivel de API 14.
float4 rsMatrixMultiply(const rs_matrix4x4* m, float3 in); Se agregó en el nivel de API 14.
float4 rsMatrixMultiply(const rs_matrix4x4* m, float4 in); Se agregó en el nivel de API 14.
float4 rsMatrixMultiply(rs_matrix4x4* m, float2 in); Se quitó del nivel de API 14 y versiones posteriores.
float4 rsMatrixMultiply(rs_matrix4x4* m, float3 in); Se quitó del nivel de API 14 y versiones posteriores.
float4 rsMatrixMultiply(rs_matrix4x4* m, float4 in); Se quitó del nivel de API 14 y versiones posteriores.
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);
Parámetros
mMatriz izquierda del producto y la matriz que se va a establecer
rhsMatriz derecha del producto
in

Para la variante de matriz por variante de matriz, establece m en el producto de la matriz m * rhs.

Cuando se combinan dos matrices de transformación 4x4 con esta función, la matriz resultante corresponderá a realizar primero la transformación rhs, seguida por la transformación m original.

Para la matriz por variante de vector, muestra la posmultiplicación del vector por la matriz, es decir, m * in.

Cuando se multiplica un float3 a rs_matrix4x4, se expande el vector con (1).

Cuando se multiplica un float2 a rs_matrix4x4, se expande el vector con (0, 1).

Cuando se multiplica un float2 a rs_matrix3x3, el vector se expande con (0).

A partir del nivel de API 14, esta función toma una matriz const como primer argumento.

rsMatrixRotate : Aplica una rotación a una matriz de transformación

void rsMatrixRotate(rs_matrix4x4* m, float rot, float x, float y, float z);
Parámetros
mMatriz que se modificará.
podridoIndica la rotación que se debe realizar, en grados.
xComponente X del vector que es el eje de rotación.
yEs el componente Y del vector que es el eje de rotación.
zComponente Z del vector que es el eje de rotación.

Multiplica la m de la matriz con una matriz de rotación.

Esta función modifica una matriz de transformación para que primero realice una rotación. El eje de rotación es el vector (x, y, z).

Para aplicar esta transformación combinada a un vector, multiplica el vector por la matriz creada mediante rsMatrixMultiply().

rsMatrixScale : Aplica un escalamiento a una matriz de transformación

void rsMatrixScale(rs_matrix4x4* m, float x, float y, float z);
Parámetros
mMatriz que se modificará.
xMúltiple para escalar los componentes x.
yMúltiple para escalar los componentes y.
zMúltiple para escalar los componentes z por

Multiplica la m de la matriz con una matriz de escalamiento.

Esta función modifica una matriz de transformación para realizar primero un escalamiento. Cuando se escala, cada componente de un vector se multiplica por un número. Este número puede ser negativo.

Para aplicar esta transformación combinada a un vector, multiplica el vector por la matriz creada mediante rsMatrixMultiply().

rsMatrixSet : Configura un elemento

void rsMatrixSet(rs_matrix2x2* m, uint32_t col, uint32_t fila, float v);
void rsMatrixSet(rs_matrix3x3* m, uint32_t col, uint32_t fila, float v);
void rsMatrixSet(rs_matrix4x4* m, uint32_t col, uint32_t fila, float v);
Parámetros
mMatriz que se modificará.
columnaColumna basada en cero del elemento que se configurará.
filaFila basada en cero del elemento que se establecerá.
vValor que se establecerá.

Configura un elemento de una matriz.

Advertencia: El orden de los parámetros de columna y fila puede ser inesperado.

rsMatrixTranslate : Aplica una traducción a una matriz de transformación

void rsMatrixTranslate(rs_matrix4x4* m, float x, float y, float z);
Parámetros
mMatriz que se modificará.
xNúmero que se agregará a cada componente x.
yNúmero que se agregará a cada componente y.
zNúmero que se agregará a cada componente z.

Multiplica la m de la matriz con una matriz de traslación.

Esta función modifica una matriz de transformación para hacer primero una traducción. Cuando se traduce, se agrega un número a cada componente de un vector.

Para aplicar esta transformación combinada a un vector, multiplica el vector por la matriz creada mediante rsMatrixMultiply().

rsMatrixTranspose : transpone un lugar de matriz

void rsMatrixTranspose(rs_matrix2x2* m);
void rsMatrixTranspose(rs_matrix3x3* m);
void rsMatrixTranspose(rs_matrix4x4* m);
Parámetros
mMatriz para transponer

Transpone la matriz m en su lugar.