Visão geral
Essas funções permitem manipular matrizes quadradas de classificação 2x2, 3x3 e 4x4. Eles são particularmente úteis para transformações gráficas e são compatíveis com o OpenGL.
Usamos um índice baseado em zero para linhas e colunas. Por exemplo, o último elemento de rs_matrix4x4 é encontrado em (3, 3).
O RenderScript usa matrizes principais de coluna e vetores baseados em colunas. A transformação de um vetor é feita por meio da pós-multiplicação do vetor, por exemplo, (matrix * vector), conforme fornecido por rsMatrixMultiply().
Para criar uma matriz de transformação que execute duas transformações ao mesmo tempo,
multiplique as duas matrizes de origem, sendo que a primeira transformação é o argumento
correto. Por exemplo, para criar uma matriz de transformação que aplique a transformação s1 seguida por s2, chame rsMatrixLoadMultiply(&combined, &s2, &s1).
Isso é derivado de s2 * (s1 * v), que é (s2 * s1) * v.
Temos dois estilos de funções para criar matrizes de transformação: rsMatrixLoadTransformation e rsMatrixTransformation. O estilo anterior simplesmente armazena a matriz de transformação no primeiro argumento. O último modifica uma matriz de transformação pré-existente para que a nova transformação aconteça primeiro. Por exemplo, se você chamar rsMatrix Translate() em uma matriz que já faz um dimensionamento, a matriz resultante, quando aplicada a um vetor, fará a conversão e depois o dimensionamento.
Resumo
| Funções | |
|---|---|
| rsExtractFrustumPlanes (em inglês) | Calcular planos de tronco |
| rsIsSphereInFrustum (em inglês) | Verifica se uma esfera está dentro dos planos de tronco |
| rsMatrixGet (em inglês) | Receber um elemento |
| rsMatrixInverse (em inglês) | Inverte uma matriz no lugar |
| rsMatrixInverseTranspose (link em inglês) | Inverte e transpõe uma matriz no lugar |
| rsMatrixLoad (em inglês) | Carregar ou copiar uma matriz |
| rsMatrixLoadFrustum (link em inglês) | Carregar uma matriz de projeção de tronco |
| rsMatrixLoadIdentity (em inglês) | Carregar matriz de identidade |
| rsMatrixLoadMultiply (link em inglês) | Multiplicar duas matrizes |
| rsMatrixLoadOrtho (link em inglês) | Carregar uma matriz de projeção ortográfica |
| rsMatrixLoadPerspective (em inglês) | Carregar uma matriz de projeção de perspectiva |
| rsMatrixLoadrotate (em inglês) | Carregar uma matriz de rotação |
| rsMatrixLoadScale (em inglês) | Carregar uma matriz de escalonamento |
| rsMatrixLoadTradutor | Carregar uma matriz de translação |
| rsMatrixMultiply (link em inglês) | Multiplicar uma matriz por um vetor ou outra matriz |
| rsMatrixrotate (em inglês) | Aplicar uma rotação a uma matriz de transformação |
| rsMatrixScale (em inglês) | Aplicar um escalonamento a uma matriz de transformação |
| rsMatrixSet (em inglês) | Definir um elemento |
| rsMatrixTradutor | Aplicar uma translação a uma matriz de transformação |
| rsMatrixTranspose (link em inglês) | Transpor um lugar de matriz |
Funções
rsExtractFrustumPlanes : computação de planos de tronco
| void rsExtractFrustumPlanes(const rs_matrix4x4* viewProj, float4* esquerda, float4* righ, float4* superior, float4* inferior, float4* próximo, float4* longe); | Adicionado no nível 24 da API. |
| void rsExtractFrustumPlanes(const rs_matrix4x4* viewProj, float4* esquerda, float4* direita, float4* superior, float4* inferior, float4* próximo, float4* longe); | Removido da API de nível 24 e mais recentes. |
Parâmetros
| PROJ | Matriz da qual extrair planos. |
|---|---|
| esquerda | Avião à esquerda. |
| direita | Plano da direita. |
| superior | Plano superior. |
| inferior | Plano de baixo. |
| perto | Perto do avião. |
| longe | Avião distante. |
| certo |
Calcula seis planos de tronco da matriz de projeção de visualização
rsIsSphereInFrustum : verifica se uma esfera está dentro dos planos de tronco
| bool rsIsSphereInFrustum(float4* esfera, float4* esquerda, float4* direita, float4* superior, float4* inferior, float4* próximo, float4* longe); |
Parâmetros
| esfera | float4 representando a esfera. |
|---|---|
| esquerda | Avião à esquerda. |
| direita | Plano da direita. |
| superior | Plano superior. |
| inferior | Plano de baixo. |
| perto | Perto do avião. |
| longe | Avião distante. |
Retorna verdadeiro se a esfera estiver dentro dos seis planos de tronco.
rsMatrixGet : acessar um elemento
| float rsMatrixGet(const rs_matrix2x2* m, uint32_t col, uint32_t linha); | |
| float rsMatrixGet(const rs_matrix3x3* m, uint32_t col, uint32_t linha); | |
| float rsMatrixGet(const rs_matrix4x4* m, uint32_t col, linha uint32_t); |
Parâmetros
| m | Matriz da qual extrair o elemento. |
|---|---|
| col | Coluna baseada em zero do elemento a ser extraído. |
| linha | Linha baseada em zero do elemento a ser extraído. |
Retorna um elemento de uma matriz.
Aviso:a ordem dos parâmetros de coluna e linha pode ser inesperada.
rsMatrixInverse : inverte uma matriz no local
| bool rsMatrixInverse(rs_matrix4x4* m); |
Parâmetros
| m | Matriz a ser invertida. |
|---|
Retorna verdadeiro se a matriz tiver sido invertida com sucesso.
rsMatrixInverseTranspose : inverte e transpõe uma matriz no local
| bool rsMatrixInverseTranspose(rs_matrix4x4* m); |
Parâmetros
| m | Matriz a ser modificada. |
|---|
Primeiro, a matriz é invertida e depois transposta. Retorna verdadeiro se a matriz foi invertida com sucesso.
rsMatrixLoad : carregar ou copiar uma matriz
| void rsMatrixLoad(rs_matrix2x2* destino, const float* matriz); | |
| void rsMatrixLoad(rs_matrix2x2* destino, const rs_matrix2x2* origem); | |
| void rsMatrixLoad(rs_matrix3x3* destino, const float* matriz); | |
| void rsMatrixLoad(rs_matrix3x3* destino, const rs_matrix3x3* origem); | |
| void rsMatrixLoad(rs_matrix4x4* destino, const float* matriz); | |
| void rsMatrixLoad(rs_matrix4x4* destino, const rs_matrix2x2* origem); | |
| void rsMatrixLoad(rs_matrix4x4* destino, const rs_matrix3x3* origem); | |
| void rsMatrixLoad(rs_matrix4x4* destino, const rs_matrix4x4* origem); |
Parâmetros
| destino | Matriz a ser definida. |
|---|---|
| matriz | Matriz de valores para definir a matriz. Essas matrizes devem ter 4, 9 ou 16 flutuações, dependendo do tamanho da matriz. |
| fonte | Matriz de origem. |
Define os elementos de uma matriz a partir de uma matriz de pontos flutuantes ou de outra matriz.
Ao carregar de uma matriz, os pontos flutuantes precisam estar na ordem principal da linha, ou seja, o elemento
row 0, column 0 precisa ser o primeiro, seguido pelo elemento em
row 0, column 1 etc.
Se o carregamento for de uma matriz e a origem for menor que o destino, o restante do destino vai ser preenchido com elementos da matriz de identidade. Por exemplo, carregar uma rs_matrix2x2 em uma rs_matrix4x4 resultará em:
| 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 : carregar uma matriz de projeção de tronco
| void rsMatrixLoadFrustum(rs_matrix4x4* m, flutuar para a esquerda, flutuar para a direita, flutuar para baixo, flutuar para cima, flutuar perto, flutuar longe); |
Parâmetros
| m | Matriz a ser definida. |
|---|---|
| esquerda | |
| direita | |
| inferior | |
| superior | |
| perto | |
| longe |
Constrói uma matriz de projeção de tronco, transformando a caixa identificada pelos seis planos de recorte left, right, bottom, top, near, far.
Para aplicar essa projeção a um vetor, multiplique-o pela matriz criada usando rsMatrixMultiply().
rsMatrixLoadIdentity : matriz de identidade de carregamento
| void rsMatrixLoadIdentity(rs_matrix2x2* m); | |
| void rsMatrixLoadIdentity(rs_matrix3x3* m); | |
| void rsMatrixLoadIdentity(rs_matrix4x4* m); |
Parâmetros
| m | Matriz a ser definida. |
|---|
Defina os elementos de uma matriz como a matriz de identidade.
rsMatrixLoadMultiply : multiplicar duas matrizes
| 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 a ser definida. |
|---|---|
| H | Matriz esquerda do produto. |
| rhs | É a matriz direita do produto. |
Define m como o produto matricial de lhs * rhs.
Para combinar duas matrizes de transformação 4x4, multiplique a segunda matriz de transformação
pela primeira. Por exemplo, para criar uma matriz de transformação que aplique a transformação s1 seguida por s2, chame rsMatrixLoadMultiply(&combined, &s2, &s1).
Aviso:em versões anteriores à 21, não é possível armazenar o resultado na matriz correta e resultar em comportamento indefinido. Use rsMatrixMulitply Por exemplo, em vez de rsMatrixLoadMultiply (&m2r, &m2r e &m2l), use rsMatrixMultiply (&m2r, &m2l). rsMatrixLoadMultiply (&m2l, &m2r, &m2l) funciona conforme o esperado.
rsMatrixLoadOrtho : carregar uma matriz de projeção ortográfica
| void rsMatrixLoadOrtho(rs_matrix4x4* m, flutuar para a esquerda, flutuar para a direita, flutuar para baixo, flutuar para cima, flutuar perto, flutuar longe); |
Parâmetros
| m | Matriz a ser definida. |
|---|---|
| esquerda | |
| direita | |
| inferior | |
| superior | |
| perto | |
| longe |
Constrói uma matriz de projeção ortográfica, transformando a caixa identificada pelos
seis planos de recorte left, right, bottom, top, near, far em um cubo unitário
com um canto em (-1, -1, -1) e o oposto em (1, 1, 1).
Para aplicar essa projeção a um vetor, multiplique-o pela matriz criada usando rsMatrixMultiply().
Consulte https://pt.wikipedia.org/wiki/Orthographic_projection .
rsMatrixLoadPerspective : carregar uma matriz de projeção de perspectiva
| void rsMatrixLoadPerspective(rs_matrix4x4* m, flutuação fovy, flutuação próxima, flutuar longe); |
Parâmetros
| m | Matriz a ser definida. |
|---|---|
| fovy | Campo de visão, em graus ao longo do eixo Y. |
| aspecto | Proporção de x / y. |
| perto | Próximo ao plano de corte. |
| longe | Avião de recorte distante. |
Constrói uma matriz de projeção de perspectiva, presumindo um campo de visão simétrico.
Para aplicar essa projeção a um vetor, multiplique-o pela matriz criada usando rsMatrixMultiply().
rsMatrixLoadLoad : carregar uma matriz de rotação
| void rsMatrixLoadrotate(rs_matrix4x4* m, float rot, float x, float y, float z); |
Parâmetros
| m | Matriz a ser definida. |
|---|---|
| apodrecer | Quantos graus de rotação será feito. |
| x | Componente X do vetor que é o eixo de rotação. |
| y | Componente Y do vetor que é o eixo de rotação. |
| z | Componente Z do vetor que é o eixo de rotação. |
Essa função cria uma matriz de rotação. O eixo de rotação é o vetor (x, y, z).
Para girar um vetor, multiplique o vetor pela matriz criada usando rsMatrixMultiply().
Consulte https://en.wikipedia.org/wiki/Rotation_matrix (em inglês).
rsMatrixLoadScale : carregar uma matriz de escalonamento
| void rsMatrixLoadScale(rs_matrix4x4* m, flutuante x, flutuante y, ponto flutuante z); |
Parâmetros
| m | Matriz a ser definida. |
|---|---|
| x | Vários para dimensionar os componentes x. |
| y | Múltiplo para dimensionar os componentes y. |
| z | Vários para dimensionar os componentes z. |
Essa função cria uma matriz de escalonamento em que cada componente de um vetor é multiplicado por um número. Esse número pode ser negativo.
Para dimensionar um vetor, multiplique o vetor pela matriz criada usando rsMatrixMultiply().
rsMatrixLoadTradutor : carregar uma matriz de translação
| void rsMatrixLoadTranslate(rs_matrix4x4* m, flutuação x, flutuação y, ponto flutuante z); |
Parâmetros
| m | Matriz a ser definida. |
|---|---|
| x | Número a ser adicionado a cada componente x. |
| y | Número a ser adicionado a cada componente y. |
| z | Número a ser adicionado a cada componente z. |
Essa função cria uma matriz de translação, em que um número é adicionado a cada elemento de um vetor.
Para converter um vetor, multiplique-o pela matriz criada usando rsMatrixMultiply().
rsMatrixMultiply : multiplica uma matriz por um vetor ou outra
| float2 rsMatrixMultiply(const rs_matrix2x2* m, float2 in); | Adicionado no nível 14 da API. |
| float2 rsMatrixMultiply(rs_matrix2x2* m, float2 in); | Removido da API de nível 14 e mais recentes. |
| float3 rsMatrixMultiply(const rs_matrix3x3* m, float2 in); | Adicionado no nível 14 da API. |
| float3 rsMatrixMultiply(const rs_matrix3x3* m, float3 in); | Adicionado no nível 14 da API. |
| float3 rsMatrixMultiply(rs_matrix3x3* m, float2 in); | Removido da API de nível 14 e mais recentes. |
| float3 rsMatrixMultiply(rs_matrix3x3* m, float3 in); | Removido da API de nível 14 e mais recentes. |
| float4 rsMatrixMultiply(const rs_matrix4x4* m, float2 in); | Adicionado no nível 14 da API. |
| float4 rsMatrixMultiply(const rs_matrix4x4* m, float3 in); | Adicionado no nível 14 da API. |
| float4 rsMatrixMultiply(const rs_matrix4x4* m, float4 in); | Adicionado no nível 14 da API. |
| float4 rsMatrixMultiply(rs_matrix4x4* m, float2 in); | Removido da API de nível 14 e mais recentes. |
| float4 rsMatrixMultiply(rs_matrix4x4* m, float3 in); | Removido da API de nível 14 e mais recentes. |
| float4 rsMatrixMultiply(rs_matrix4x4* m, float4 in); | Removido da API de nível 14 e mais recentes. |
| 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 esquerda do produto e a matriz a ser definida. |
|---|---|
| rhs | É a matriz direita do produto. |
| pol. |
Para a variante matricial, define m como o produto de matriz m * rhs.
Ao combinar duas matrizes de transformação 4x4 usando essa função, a matriz resultante corresponderá à execução da transformação rhs seguida pela transformação m original.
Para a matriz por variante de vetor, retorna a pós-multiplicação do vetor pela matriz, ou seja, m * in.
Ao multiplicar um float3 por rs_matrix4x4, o vetor é expandido com (1).
Ao multiplicar um float2 por rs_matrix4x4, o vetor é expandido com (0, 1).
Ao multiplicar um float2 por rs_matrix3x3, o vetor é expandido com (0).
A partir da API 14, essa função usa uma matriz de constantes como o primeiro argumento.
rsMatrixrotate : aplicar uma rotação a uma matriz de transformação
| void rsMatrixrotate(rs_matrix4x4* m, float rot, float x, float y, float z); |
Parâmetros
| m | Matriz a ser modificada. |
|---|---|
| apodrecer | Quantos graus de rotação será feito. |
| x | Componente X do vetor que é o eixo de rotação. |
| y | Componente Y do vetor que é o eixo de rotação. |
| z | Componente Z do vetor que é o eixo de rotação. |
Multiplique a matriz m por uma matriz de rotação.
Essa função modifica uma matriz de transformação para fazer uma rotação primeiro. O eixo de
rotação é o vetor (x, y, z).
Para aplicar essa transformação combinada a um vetor, multiplique-o pela matriz criada usando rsMatrixMultiply().
rsMatrixScale : aplicar um escalonamento a uma matriz de transformação
| void rsMatrixScale(rs_matrix4x4* m, flutuação x, flutuação y, ponto flutuante z); |
Parâmetros
| m | Matriz a ser modificada. |
|---|---|
| x | Vários para dimensionar os componentes x. |
| y | Múltiplo para dimensionar os componentes y. |
| z | Vários para dimensionar os componentes z. |
Multiplique a matriz m por uma matriz de escalonamento.
Essa função modifica uma matriz de transformação para fazer um escalonamento. Ao dimensionar, cada componente de um vetor é multiplicado por um número. Esse número pode ser negativo.
Para aplicar essa transformação combinada a um vetor, multiplique-o pela matriz criada usando rsMatrixMultiply().
rsMatrixSet : define um elemento
| void rsMatrixSet(rs_matrix2x2* m, uint32_t col, linha uint32_t, float v); | |
| void rsMatrixSet(rs_matrix3x3* m, uint32_t col, linha uint32_t, float v); | |
| void rsMatrixSet(rs_matrix4x4* m, uint32_t col, linha uint32_t, float v); |
Parâmetros
| m | Matriz que será modificada. |
|---|---|
| col | Coluna baseada em zero do elemento a ser definido. |
| linha | Linha baseada em zero do elemento a ser definido. |
| v | Valor a ser definido. |
Define um elemento de uma matriz.
Aviso:a ordem dos parâmetros de coluna e linha pode ser inesperada.
rsMatrix Translate : aplicar uma translação a uma matriz de transformação
| void rsMatrixTranslate(rs_matrix4x4* m, flutuação x, flutuação y, ponto flutuante z); |
Parâmetros
| m | Matriz a ser modificada. |
|---|---|
| x | Número a ser adicionado a cada componente x. |
| y | Número a ser adicionado a cada componente y. |
| z | Número a ser adicionado a cada componente z. |
Multiplique a matriz m por uma matriz de translação.
Essa função modifica uma matriz de transformação para fazer uma translação primeiro. Ao traduzir, um número é adicionado a cada componente de um vetor.
Para aplicar essa transformação combinada a um vetor, multiplique-o pela matriz criada usando rsMatrixMultiply().
rsMatrixTranspose : transpor um lugar de matriz
| void rsMatrixTranspose(rs_matrix2x2* m); | |
| void rsMatrixTranspose(rs_matrix3x3* m); | |
| void rsMatrixTranspose(rs_matrix4x4* m); |
Parâmetros
| m | Matriz a ser transposta. |
|---|
Transpor a matriz m no lugar