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