Funções de matriz do RenderScript

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
PROJMatriz da qual extrair planos.
esquerdaAvião à esquerda.
direitaPlano da direita.
superiorPlano superior.
inferiorPlano de baixo.
pertoPerto do avião.
longeAviã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
esferafloat4 representando a esfera.
esquerdaAvião à esquerda.
direitaPlano da direita.
superiorPlano superior.
inferiorPlano de baixo.
pertoPerto do avião.
longeAviã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
mMatriz da qual extrair o elemento.
colColuna baseada em zero do elemento a ser extraído.
linhaLinha 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
mMatriz 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
mMatriz 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
destinoMatriz a ser definida.
matrizMatriz de valores para definir a matriz. Essas matrizes devem ter 4, 9 ou 16 flutuações, dependendo do tamanho da matriz.
fonteMatriz 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
mMatriz 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
mMatriz 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
mMatriz a ser definida.
HMatriz 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
mMatriz 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
mMatriz a ser definida.
fovyCampo de visão, em graus ao longo do eixo Y.
aspectoProporção de x / y.
pertoPróximo ao plano de corte.
longeAviã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
mMatriz a ser definida.
apodrecerQuantos graus de rotação será feito.
xComponente X do vetor que é o eixo de rotação.
yComponente Y do vetor que é o eixo de rotação.
zComponente 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
mMatriz a ser definida.
xVários para dimensionar os componentes x.
yMúltiplo para dimensionar os componentes y.
zVá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
mMatriz a ser definida.
xNúmero a ser adicionado a cada componente x.
yNúmero a ser adicionado a cada componente y.
zNú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
mMatriz 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
mMatriz a ser modificada.
apodrecerQuantos graus de rotação será feito.
xComponente X do vetor que é o eixo de rotação.
yComponente Y do vetor que é o eixo de rotação.
zComponente 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
mMatriz a ser modificada.
xVários para dimensionar os componentes x.
yMúltiplo para dimensionar os componentes y.
zVá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
mMatriz que será modificada.
colColuna baseada em zero do elemento a ser definido.
linhaLinha baseada em zero do elemento a ser definido.
vValor 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
mMatriz a ser modificada.
xNúmero a ser adicionado a cada componente x.
yNúmero a ser adicionado a cada componente y.
zNú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
mMatriz a ser transposta.

Transpor a matriz m no lugar