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
ViewProj | Matriz de la que se extraerán los planos. |
---|---|
izquierda | Plano izquierdo. |
derecha | Plano derecho. |
alta | Plano superior. |
baja | Plano inferior. |
cerca | Cerca de un avión. |
lejos | Avió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
esfera | float4, que representa la esfera. |
---|---|
izquierda | Plano izquierdo. |
derecha | Plano derecho. |
alta | Plano superior. |
baja | Plano inferior. |
cerca | Cerca de un avión. |
lejos | Avió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
m | Matriz de la que se extraerá el elemento. |
---|---|
columna | Columna basada en cero del elemento que se desea extraer. |
fila | Fila 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
m | Matriz 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
m | Matriz 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
destino | Matriz para establecer |
---|---|
matriz | Arreglo 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. |
fuente | Matriz 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
m | Matriz 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
m | Matriz 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
m | Matriz para establecer |
---|---|
l | Matriz izquierda del producto |
rhs | Matriz 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
m | Matriz 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
m | Matriz para establecer |
---|---|
de moda | Campo visual, en grados a lo largo del eje Y. |
aspecto | Proporción de x / y |
cerca | Cerca de un avión de recorte. |
lejos | Avió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
m | Matriz para establecer |
---|---|
podrido | Indica la rotación que se debe realizar, en grados. |
x | Componente X del vector que es el eje de rotación. |
y | Es el componente Y del vector que es el eje de rotación. |
z | Componente 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
m | Matriz para establecer |
---|---|
x | Múltiple para escalar los componentes x. |
y | Múltiple para escalar los componentes y. |
z | Mú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
m | Matriz para establecer |
---|---|
x | Número que se agregará a cada componente x. |
y | Número que se agregará a cada componente y. |
z | Nú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
m | Matriz izquierda del producto y la matriz que se va a establecer |
---|---|
rhs | Matriz 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
m | Matriz que se modificará. |
---|---|
podrido | Indica la rotación que se debe realizar, en grados. |
x | Componente X del vector que es el eje de rotación. |
y | Es el componente Y del vector que es el eje de rotación. |
z | Componente 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
m | Matriz que se modificará. |
---|---|
x | Múltiple para escalar los componentes x. |
y | Múltiple para escalar los componentes y. |
z | Mú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
m | Matriz que se modificará. |
---|---|
columna | Columna basada en cero del elemento que se configurará. |
fila | Fila basada en cero del elemento que se establecerá. |
v | Valor 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
m | Matriz que se modificará. |
---|---|
x | Número que se agregará a cada componente x. |
y | Número que se agregará a cada componente y. |
z | Nú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
m | Matriz para transponer |
---|
Transpone la matriz m en su lugar.