Visão geral
RenderScript é um ambiente de execução de alto desempenho que fornece operações de computação no nível nativo. O código do RenderScript é compilado nos dispositivos durante a execução para permitir a independência da plataforma também.
Esta documentação de referência descreve as APIs de tempo de execução do RenderScript, que podem ser usadas para escrever código do RenderScript na versão C99. Os arquivos de cabeçalho de computação do RenderScript são incluídos automaticamente para você.
Para usar o RenderScript, você precisa utilizar as APIs de tempo de execução do RenderScript documentadas aqui, bem como as APIs de framework do Android para o RenderScript. Para ver a documentação sobre as APIs do framework do Android, consulte a referência do pacote android.renderscript.
Para mais informações sobre como desenvolver com o RenderScript e como as APIs de ambiente de execução e de framework do Android interagem, consulte o Guia para desenvolvedores do RenderScript e os exemplos do RenderScript (link em inglês).
Tipos numéricos
Escalares:
O RenderScript é compatível com os seguintes tipos numéricos escalares:
| 8 bits | 16 bits | 32 bits | 64 bits | |
| Número inteiro: | caractere, int8_t | curto, int16_t | int32_t (link em inglês) | long, long, int64_t |
| Número inteiro sem assinatura: | uchar, uint8_t | ushort, uint16_t | uint, uint32_t | ulong, uint64_t |
| Ponto flutuante: | tempo | float | double |
Vetores:
O RenderScript é compatível com vetores de tamanho fixo de 2, 3 e 4. Os vetores são declarados usando o nome de tipo comum seguido por 2, 3 ou 4. Por exemplo, float4, int3, double2, ulong4.
Para criar literais vetoriais, use o tipo de vetor seguido pelos valores entre chaves, por exemplo, (float3){1.0f, 2.0f, 3.0f}.
As entradas de um vetor podem ser acessadas usando estilos de nomenclatura diferentes.
Entradas únicas podem ser acessadas seguindo o nome da variável com um ponto e:
- As letras x, y, z e w
- As letras r, g, b e a
- A letra s ou S, seguida por um índice baseado em zero.
Por exemplo, com int4 myVar;, os seguintes são equivalentes:
myVar.x == myVar.r == myVar.s0 == myVar.S0
myVar.y == myVar.g == myVar.s1 == myVar.S1
myVar.z == myVar.b == myVar.s2 == myVar.S2
myVar.w == myVar.a == myVar.s3 == myVar.S3
Várias entradas de um vetor podem ser acessadas de uma só vez usando um identificador que é a concatenação de várias letras ou índices. O vetor resultante tem um tamanho igual ao número de entradas nomeadas.
No exemplo acima, as duas entradas do meio podem ser acessadas usando
myVar.yz, myVar.gb, myVar.s12 e myVar.S12.
As entradas não precisam ser contíguas ou em ordem crescente. As entradas podem até ser repetidas, desde que não estejamos tentando atribuir a elas. Também não é possível misturar estilos de nomenclatura.
Confira alguns exemplos do que pode ou não ser feito:
float4 v4;
float3 v3;
float2 v2;
v2 = v4.xx; // Valid
v3 = v4.zxw; // Valid
v3 = v4.bba; // Valid
v3 = v4.s032; // Valid
v3.s120 = v4.S233; // Valid
v4.yz = v3.rg; // Valid
v4.yzx = v3.rg; // Invalid: mismatched sizes
v4.yzz = v3; // Invalid: z appears twice in an assignment
v3 = v3.xas0; // Invalid: can't mix xyzw with rgba nor s0...
v3 = v4.s034; // Invalid: the digit can only be 0, 1, 2, or 3
Matrizes e quatérnios:
O RenderScript é compatível com matrizes quadradas de tamanho fixo de pontos flutuantes de 2x2, 3x3 e 4x4. Os tipos são chamados de rs_matrix2x2, rs_matrix3x3 e rs_matrix4x4. Consulte Funções de matriz para ver a lista de operações.
Os quaternions também são compatíveis com rs_quaternion. Consulte Funções do Quaterion para a lista de operações.
| Tipos | |
|---|---|
| char2 | Dois números inteiros com sinal de 8 bits |
| char3. | Três números inteiros com sinal de 8 bits |
| char4 (link em inglês) | Quatro números inteiros com sinal de 8 bits |
| double2. | Dois flutuantes de 64 bits |
| double3. | Três flutuações de 64 bits |
| double4. | Quatro flutuações de 64 bits |
| float2 (link em inglês) | Dois flutuantes de 32 bits |
| float3 (link em inglês) | Três flutuantes de 32 bits |
| float4 (link em inglês) | Quatro flutuações de 32 bits |
| metade | Valor de ponto flutuante de 16 bits |
| metade2 | Dois flutuantes de 16 bits |
| half3 | Três flutuações de 16 bits |
| half4 | Quatro flutuações de 16 bits |
| int16_t (link em inglês) | Número inteiro assinado de 16 bits |
| int2 (link em inglês) | Dois números inteiros com sinal de 32 bits |
| int3 (link em inglês) | Três números inteiros com sinal de 32 bits |
| int32_t (link em inglês) | Número inteiro assinado de 32 bits |
| int4 (link em inglês) | Quatro números inteiros assinados de 32 bits |
| int64_t (link em inglês) | Número inteiro assinado de 64 bits |
| int8_t (link em inglês) | Número inteiro assinado de 8 bits |
| long2 (link em inglês) | Dois números inteiros com sinal de 64 bits |
| long3 (link em inglês) | Três números inteiros com assinatura de 64 bits |
| long4 (link em inglês) | Quatro números inteiros assinados de 64 bits |
| rs_matrix2x2 (link em inglês) | Matriz 2x2 de flutuações de 32 bits |
| rs_matrix3x3 (link em inglês) | Matriz 3x3 de flutuações de 32 bits |
| rs_matrix4x4 (link em inglês) | Matriz 4x4 de flutuações de 32 bits |
| rs_quaternion (em inglês) | Quaternion |
| curta2 | Dois números inteiros com sinal de 16 bits |
| curta3 | Três números inteiros assinados de 16 bits |
| short4 (em inglês) | Quatro números inteiros com sinal de 16 bits |
| size_t (em inglês) | Tipo de tamanho sem assinatura |
| tamanho_t | Tipo de tamanho assinado |
| uchar (em inglês) | Número inteiro não assinado de 8 bits |
| uchar2 (em inglês) | Dois números inteiros de 8 bits sem assinatura |
| uchar3 (link em inglês) | Três números inteiros de 8 bits sem assinatura |
| uchar4 (link em inglês) | Quatro números inteiros sem assinatura de 8 bits |
| uint (em inglês) | Número inteiro não assinado de 32 bits |
| uint16_t (link em inglês) | Número inteiro não assinado de 16 bits |
| uint2 (em inglês) | Dois números inteiros de 32 bits sem assinatura |
| uint3 (em inglês) | Três números inteiros de 32 bits sem assinatura |
| uint32_t (link em inglês) | Número inteiro não assinado de 32 bits |
| uint4 (link em inglês) | Quatro números inteiros de 32 bits sem assinatura |
| uint64_t (link em inglês) | Número inteiro não assinado de 64 bits |
| uint8_t (link em inglês) | Número inteiro não assinado de 8 bits |
| ulong (link em inglês) | Número inteiro não assinado de 64 bits |
| ulong2 (link em inglês) | Dois números inteiros de 64 bits sem assinatura |
| ulong3 (link em inglês) | Três números inteiros de 64 bits sem assinatura |
| ulong4 (link em inglês) | Quatro números inteiros sem assinatura de 64 bits |
| ushort | Número inteiro não assinado de 16 bits |
| ushort2 (em inglês) | Dois números inteiros de 16 bits sem assinatura |
| ushort3 (em inglês) | Três números inteiros de 16 bits sem assinatura |
| ushort4 (link em inglês) | Quatro números inteiros sem assinatura de 16 bits |
Tipos de objeto
Os tipos abaixo são usados para manipular objetos do RenderScript, como alocações, amostras, elementos e scripts. A maioria desses objetos é criada usando as APIs Java RenderScript.
| Tipos | |
|---|---|
| rs_allocation (link em inglês) | Gerenciar uma alocação |
| rs_allocation_cubemap_face (link em inglês) | Enumeração para selecionar faces do mapa em cubo |
| rs_allocation_usage_type (em inglês) | Bitfield para especificar como uma alocação é usada |
| rs_data_Kind (em inglês) | Tipo de dados do elemento |
| rs_data_type (em inglês) | Tipo de dados básicos do elemento |
| rs_element (link em inglês) | Processar um elemento |
| rs_sampler (em inglês) | Processar um Sampler |
| rs_sampler_value (em inglês) | Valor T de agrupamento do Sampler |
| rs_script (em inglês) | Processar um script |
| rs_type (em inglês) | Processar um tipo |
| rs_yuv_format (em inglês) | Formato YUV |
Funções de conversão
As funções abaixo convertem de um tipo de vetor numérico em outro ou de uma representação de cor para outra.
| Funções | |
|---|---|
| converter | Converter vetores numéricos |
| rsPackColorTo8888 (link em inglês) | Criar um RGBA uchar4 a partir de pontos flutuantes |
| rsUnpackColor8888 (link em inglês) | Criar um RGBA float4 a partir de uchar4 |
| rsYuvToRGBA (link em inglês) | Converter um valor YUV para RGBA |
Constantes e funções matemáticas
As funções matemáticas abaixo podem ser aplicadas a escalares e vetores. Quando aplicado a vetores, o valor retornado é um vetor da função aplicada a cada entrada da entrada.
Por exemplo:
float3 a, b;
// The following call sets
// a.x to sin(b.x),
// a.y to sin(b.y), and
// a.z to sin(b.z).
a = sin(b);
Consulte Funções matemáticas de vetores para funções como distance() e length() que interpretam a entrada como um único vetor em um espaço n-dimensional.
A precisão das operações matemáticas em flutuações de 32 bits é afetada pelos pragmas rs_fp_relaxed e rs_fp_full. Em rs_fp_relaxed, os valores subnormais podem ser reduzidos a zero e o arredondamento pode ser feito em direção a zero. Em comparação, rs_fp_full requer o processamento correto de valores subnormais, ou seja, menores que 1,17549435e-38f. O rs_fp_rull também requer arredondamento para o mais próximo com vínculos a par.
Diferentes compensações de precisão/velocidade podem ser feitas usando variantes das funções matemáticas comuns. Funções com um nome que começa com
- native_: pode ter implementações de hardware personalizadas com precisão mais fraca. Além disso, valores subnormais podem ser desviados para zero, arredondamentos para zero podem ser usados e a entrada de NaN e infinito pode não ser tratada corretamente.
- half_: pode realizar cálculos internos usando flutuações de 16 bits. Além disso, valores subnormais podem ser desviados para zero e arredondamentos até zero podem ser usados.
| Constantes | |
|---|---|
| M_1_PI (link em inglês) | 1 / pi, como um ponto flutuante de 32 bits |
| M_2_PI (link em inglês) | 2 / pi, como um flutuante de 32 bits |
| M_2_RAIZPI | 2 / sqrt(pi), como um flutuante de 32 bits |
| M_E | e, como um ponto flutuante de 32 bits |
| M_LN10 (link em inglês) | log_e(10), como um ponto flutuante de 32 bits |
| M_LN2 (link em inglês) | log_e(2), como um ponto flutuante de 32 bits |
| M_LOG10E (link em inglês) | log_10(e), como um ponto flutuante de 32 bits |
| M_LOG2E (link em inglês) | log_2(e), como um ponto flutuante de 32 bits |
| M_PI (link em inglês) | pi, como um ponto flutuante de 32 bits |
| M_PI_2 (link em inglês) | pi / 2, como um ponto flutuante de 32 bits |
| M_PI_4 (link em inglês) | pi / 4, como um ponto flutuante de 32 bits |
| M_RAIZ1_2 | 1 / sqrt(2), como um flutuante de 32 bits |
| M_RAIZ2 | sqrt(2), como um flutuante de 32 bits |
| Funções | |
|---|---|
| abs | Valor absoluto de um número inteiro |
| acos (link em inglês) | Cosseno inverso |
| acosh (link em inglês) | Cosseno hiperbólico inverso |
| Acospi (link em inglês) | Cosseno inverso dividido por Pi |
| asin | Seno inverso |
| asinh (link em inglês) | Seno hiperbólico inverso |
| asinpi (em inglês) | Seno inverso dividido por Pi |
| atan (em inglês) | Tangente inversa |
| atan2 (link em inglês) | Tangente inversa de uma razão |
| atan2pi (em inglês) | Tangente inversa de uma razão dividida por Pi |
| atanh | Tangente hiperbólica inversa |
| atanpi (em inglês) | Tangente inversa dividida por Pi |
| cbrt (em inglês) | Raiz cúbica |
| ceil (link em inglês) | O menor número inteiro não é menor que um valor |
| braçadeira | Restringir um valor a um intervalo |
| clz (link em inglês) | Número de 0 bits iniciais |
| copysign | Copia o sinal de um número para outro |
| cos (link em inglês) | Cosseno |
| cosh (link em inglês) | Cosseno hipobólico |
| cospi (link em inglês) | Cosseno de um número multiplicado por pi |
| graus | Converte radianos em graus |
| erf (link em inglês) | Função de erro matemático |
| erfc | Função de erro matemático complementar |
| exp | "e" elevado a um número |
| exp10 | 10 elevado a um número |
| exp2 | 2 elevados a um número |
| expm1 (em inglês) | e elevado a um número menos um |
| fabs (link em inglês) | Valor absoluto de um ponto flutuante |
| Fdim (link em inglês) | Diferença positiva entre dois valores |
| andar | O menor número inteiro não é maior que um valor |
| fma (link em inglês) | Multiplicar e adicionar |
| fmax (em inglês) | Máximo de dois flutuantes |
| fmin (link em inglês) | Mínimo de dois flutuantes |
| fmod (link em inglês) | Módulo |
| fract (em inglês) | Parte fracionária positiva |
| frexp (em inglês) | Mantissa binária e expoente |
| half_recip (em inglês) | Recíproco calculado com precisão de 16 bits |
| half_rsqrt (em inglês) | Recíproco de uma raiz quadrada calculada com precisão de 16 bits |
| half_sqrt (em inglês) | Raiz quadrada calculada com precisão de 16 bits |
| hipoteto | Hipotenusa |
| ilogb (link em inglês) | Expoente da base dois |
| ldexp (em inglês) | Cria um ponto flutuante com base na mantissa e no expoente |
| lgamma (link em inglês) | Logaritmo natural da função gama |
| registro | Logaritmo natural |
| log10 (em inglês) | Logaritmo de base 10 |
| log1p (em inglês) | Logaritmo natural de um valor mais 1 |
| log2 | Logaritmo de base 2 |
| logb (em inglês) | Expoente da base dois |
| mad | Multiplicar e adicionar |
| máx. | Máxima |
| min | Mínima |
| mix | Mistura dois valores |
| modf (link em inglês) | Componentes integrais e fracionários |
| nan (link em inglês) | Não é um número |
| nan_half (em inglês) | Não é um número |
| native_acos (em inglês) | Cosseno inverso aproximado |
| native_acosh (em inglês) | Cosseno hiperbólico inverso aproximado |
| native_acospi (link em inglês) | Cosseno inverso aproximado dividido por Pi |
| native_asin (em inglês) | Seno inverso aproximado |
| native_asinh (em inglês) | Seno hiperbólico aproximado |
| native_asinpi (em inglês) | Seno inverso aproximado dividido por Pi |
| native_atan (em inglês) | Tangente inversa aproximada |
| native_atan2 (em inglês) | Tangente inversa aproximada de uma razão |
| native_atan2pi (em inglês) | Tangente inversa aproximada de uma razão dividida por Pi |
| native_atanh (em inglês) | Tangente hiperbólica inversa aproximada |
| native_atanpi (em inglês) | Tangente inversa aproximada dividida por Pi |
| native_cbrt (em inglês) | Raiz cúbica aproximada |
| native_cos (em inglês) | Cosseno aproximado |
| native_cosh (link em inglês) | Cosseno hipobólico aproximado |
| native_cospi (link em inglês) | Cosseno aproximado de um número multiplicado por Pi |
| native_divide (em inglês) | Divisão aproximada |
| native_exp (em inglês) | "E" aproximado elevado a um número |
| native_exp10 (em inglês) | Aproximadamente 10 elevados a um número |
| native_exp2 (em inglês) | Aproximação de 2 elevadas a um número |
| native_expm1 (em inglês) | E aproximado elevado para um número menos um |
| native_hypot (em inglês) | Hipotenusa aproximada |
| native_log (em inglês) | Logaritmo natural aproximado |
| native_log10 (em inglês) | Logaritmo de base 10 aproximada |
| native_log1p (em inglês) | Logaritmo natural aproximado de um valor mais 1 |
| native_log2 (em inglês) | Logaritmo de base 2 aproximado |
| native_powr (em inglês) | Base positiva aproximada elevada a um expoente |
| native_recip (em inglês) | Recíproco aproximado |
| native_rootn (link em inglês) | Raiz enésima aproximada |
| native_rsqrt (em inglês) | Recíproco aproximado de uma raiz quadrada |
| native_sin (em inglês) | Seno aproximado |
| native_sincos (em inglês) | Seno e cosseno aproximados |
| native_sinh (em inglês) | Seno hiperbólico aproximado |
| native_sinpi (em inglês) | Seno aproximado de um número multiplicado por Pi |
| native_sqrt (em inglês) | Raiz quadrada aproximada |
| native_tan (link em inglês) | Tangente aproximada |
| native_tanh (em inglês) | Tangente hiperbólica aproximada |
| native_tanpi (em inglês) | Tangente aproximada de um número multiplicado por Pi |
| nextafter | Próximo número de ponto flutuante |
| pow | Base elevada a um expoente |
| pown | Base elevada em um expoente inteiro. |
| powr | Base positiva elevada a um expoente |
| radianos | Converte graus em radianos |
| restante | Restante de uma divisão |
| remquo | Restante e quociente de uma divisão |
| rint (em inglês) | Arredondar para par |
| rootn (em inglês) | Raiz enésima |
| rodada | Arredondar a partir de zero |
| rsRand (link em inglês) | Número pseudoaleatório |
| rsqrt (link em inglês) | Recíproco de uma raiz quadrada |
| sinal | Sinal de um valor |
| sin | Seno |
| sincos (link em inglês) | Seno e cosseno |
| sinh (link em inglês) | Seno hiperbólico |
| sinpi (em inglês) | Seno de um número multiplicado por pi |
| sqrt (link em inglês) | Raiz quadrada |
| etapa | 0 se for menor que um valor. Caso contrário, 0 |
| marrom | Tangente |
| tanh (link em inglês) | Tangente hiperbólica |
| tanpi (em inglês) | Tangente de um número multiplicado por pi |
| Gama | Função gama |
| trunc (link em inglês) | Trunca um ponto flutuante |
Funções matemáticas de vetores
Essas funções interpretam os argumentos de entrada como representação de vetores em um espaço de dimensão n.
A precisão das operações matemáticas em flutuações de 32 bits é afetada pelos pragmas rs_fp_relaxed e rs_fp_full. Consulte Constantes e funções matemáticas para mais detalhes.
Diferentes compensações de precisão/velocidade podem ser feitas usando variantes das funções matemáticas comuns. Funções com um nome que começa com
- native_: pode ter implementações de hardware personalizadas com precisão mais fraca. Além disso, valores subnormais podem ser desviados para zero, arredondamentos para zero podem ser usados e a entrada de NaN e infinito pode não ser tratada corretamente.
- fast_: pode realizar cálculos internos usando flutuações de 16 bits. Além disso, valores subnormais podem ser desviados para zero e arredondamentos até zero podem ser usados.
| Funções | |
|---|---|
| cruz | Produto cruzado de dois vetores |
| distância | Distância entre dois pontos |
| ponto | Produto escalar de dois vetores |
| fast_distance | Distância aproximada entre dois pontos |
| fast_length (link em inglês) | Comprimento aproximado de um vetor |
| fast_normalize (link em inglês) | Vetor normalizado aproximado |
| tamanho | Comprimento de um vetor |
| native_distance | Distância aproximada entre dois pontos |
| native_length | Comprimento aproximado de um vetor |
| native_normalize (link em inglês) | Normalizar aproximadamente um vetor |
| normalizar | Normalizar um vetor |
Funções de matriz
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.
| 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 de quaternion
As funções a seguir manipulam quatérnios.
| Funções | |
|---|---|
| rsQuaternionAdd (em inglês) | Somar dois quatérnios |
| rsQuaternionConjugate (em inglês) | Conjugar um quatérnio |
| rsQuaternionDot (em inglês) | Produto escalar de dois quatérnios |
| rsQuaternionGetMatrixUnit | Calcular uma matriz de rotação de um quatérnio |
| rsQuaternionLoadReturn (em inglês) | Criar um quatérnio de rotação |
| rsQuaternionLoadRotationUnit (em inglês) | Quaternion que representa uma rotação sobre um vetor unitário arbitrário |
| rsQuaternionMultiply (em inglês) | Multiplicar um quatérnio por um escalar ou outro quatérnio |
| rsQuaternionNormalize. | Normalizar um quatérnio |
| rsQuaternionSet (em inglês) | Criar um quatérnio |
| rsQuaternionSlerp (em inglês) | Interpolação linear esférica entre dois quatérnios |
Funções de atualização atômicas
Para atualizar valores compartilhados entre várias linhas de execução, use as funções abaixo. Eles garantem que os valores sejam atualizados atomicamente, ou seja, que as leituras, atualizações e gravações da memória sejam feitas na ordem correta.
Essas funções são mais lentas que as equivalentes não atômicas. Portanto, use-as apenas quando a sincronização for necessária.
No RenderScript, o código provavelmente será executado em linhas de execução separadas, mesmo que você não as tenha criado explicitamente. O ambiente de execução do RenderScript costuma dividir a execução de um kernel em várias linhas de execução. A atualização de globais precisa ser feita com funções atômicas. Se possível, modifique seu algoritmo para evitá-los completamente.
| Funções | |
|---|---|
| rsAtomicAdd (link em inglês) | Adição segura de linha de execução |
| rsAtomicAnd (em inglês) | Segurança de encadeamento bit a bit e |
| rsAtomicCas (em inglês) | Comparação e definição segura para linhas de execução |
| rsAtomicDec (link em inglês) | Redução segura de linha de execução |
| rsAtomicInc (link em inglês) | Incremento seguro para thread |
| rsAtomicMax (em inglês) | Máximo seguro de linha de execução |
| rsAtomicMin (link em inglês) | Mínimo seguro para linha de execução |
| rsAtomicOr (link em inglês) | Segurança de thread bit a bit ou |
| rsAtomicSub (em inglês) | Subtração segura de linhas de execução |
| rsAtomicXor (em inglês) | Exclusividade de bit a bit seguro para thread |
Funções e tipos de tempo
As funções abaixo podem ser usadas para informar a hora atual do relógio e o horário de atividade atual do sistema. Não é recomendado chamar essas funções dentro de um kernel.
| Tipos | |
|---|---|
| rs_time_t (em inglês) | Segundos desde 1o de janeiro de 1970 |
| rs_tm (link em inglês) | Estrutura de data e hora |
| Funções | |
|---|---|
| rsGetDt (link em inglês) | Tempo decorrido desde a última ligação |
| rsLocaltime (em inglês) | Converter para o horário local |
| rsTime (link em inglês) | Segundos desde 1o de janeiro de 1970 |
| rsUptimeMillis (em inglês) | Tempo de atividade do sistema em milissegundos |
| rsUptimeNanos (em inglês) | Tempo de atividade do sistema em nanossegundos |
Funções de criação de alocação
As funções abaixo podem ser usadas para criar alocações de um script.
Essas funções podem ser chamadas direta ou indiretamente de uma função invocável. Se algum caminho do fluxo de controle puder resultar em uma chamada para essas funções a partir de uma função do kernel do RenderScript, será gerado um erro do compilador.
| Funções | |
|---|---|
| rsCreateAllocation (link em inglês) | Cria um objeto rs_allocation de determinado tipo. |
| rsCreateElement (link em inglês) | Cria um objeto rs_element do tipo de dados especificado |
| rsCreatePixelElement (em inglês) | Cria um objeto rs_element do tipo de dados e do tipo de dados especificados |
| rsCreateType (em inglês) | Cria um objeto rs_type com os atributos de elemento e forma especificados |
| rsCreateVectorElement (link em inglês) | Cria um objeto rs_element do tipo de dados e largura de vetor especificados |
Funções de acesso a dados de alocação
As funções abaixo podem ser usadas para receber e definir as células que compõem uma alocação.
- As células individuais são acessadas usando as funções rsGetElementAt* e rsSetElementAt.
- Várias células podem ser copiadas usando as funções rsAllocationCopy* e rsAllocationV*.
- Para receber valores por meio de um sampler, use rsSample.
| Funções | |
|---|---|
| rsAllocationCopy1DRange. | Copiar células consecutivas entre alocações |
| rsAllocationCopy2DRange. | Copiar uma região retangular de células entre alocações |
| rsAllocationVLoadX (link em inglês) | Encontrar um vetor de uma alocação de escalares |
| rsAllocationVStoreX (link em inglês) | Armazenar um vetor em uma alocação de escalares |
| rsGetElementAt (link em inglês) | Retornar uma célula de uma alocação |
| rsGetElementAtYuv_uchar_U (em inglês) | Acessar o componente U de uma alocação de YUVs |
| rsGetElementAtYuv_uchar_V (link em inglês) | Acessar o componente V de uma alocação de YUVs |
| rsGetElementAtYuv_uchar_Y (em inglês) | Encontrar o componente Y de uma alocação de YUVs |
| rsSample (link em inglês) | Testar um valor de uma alocação de textura |
| rsSetElementAt (link em inglês) | Definir uma célula de uma alocação |
Funções de características de objetos
As funções abaixo podem ser usadas para consultar as características de um objeto de alocação, elemento ou Sampler. Esses objetos são criados em Java. Não é possível criá-los a partir de um script.
Alocações:
As alocações são o método principal usado para transmitir dados de e para os kernels do RenderScript.
Elas são uma coleção estruturada de células que podem ser usadas para armazenar bitmaps, texturas, pontos de dados arbitrários etc.
Esse conjunto de células pode ter muitas dimensões (X, Y, Z, Array0, Array1, Array2, Array3), rostos (para mapas cubos) e níveis de detalhes (para mipmapping).
Consulte android.renderscript.Allocation para ver detalhes sobre a criação de alocações.
Elementos:
O termo "elemento" é usado de forma ambígua no RenderScript, já que tanto informações de tipo para as células de uma alocação quanto a instanciação desse tipo. Por exemplo:
- rs_element é um handle para uma especificação de tipo.
- Em funções como rsGetElementAt(), "element" significa a instanciação do tipo, ou seja, uma célula de uma alocação.
As funções abaixo permitem consultar as características da especificação de tipo.
Um elemento pode especificar tipos de dados simples, como encontrados em C, por exemplo, um número inteiro, um ponto flutuante ou um booleano. Ele também pode especificar um identificador para um objeto do RenderScript. Consulte rs_data_type para uma lista de tipos básicos.
Os elementos podem especificar versões de vetor de tamanho fixo (de 2, 3 ou 4) dos tipos básicos. Os elementos podem ser agrupados em elementos complexos, criando o equivalente às definições de estrutura C.
Os elementos também podem ter um tipo, que é uma informação semântica usada para interpretar dados de pixel. Consulte rs_data_Kind.
Ao criar alocações de elementos comuns, basta usar um dos muitos elementos predefinidos, como F32_2.
Para criar elementos complexos, use a classe Java Element.Builder.
Amostras:
Os objetos de amostra definem como as alocações podem ser lidas como estrutura dentro de um kernel. Consulte android.renderscript.S.
| Funções | |
|---|---|
| rsAllocationGetDimFaces | Presença de mais de um rosto |
| rsAllocationGetDimLOD. | Presença de níveis de detalhes |
| rsAllocationGetDimX (em inglês) | Tamanho da dimensão X |
| rsAllocationGetDimY. | Tamanho da dimensão Y |
| rsAllocationGetDimZ (link em inglês) | Tamanho da dimensão Z |
| rsAllocationGetElement (link em inglês) | Acessa o objeto que descreve a célula de uma alocação |
| rsClearObject (link em inglês) | Liberar um objeto |
| rsElementGetBytesSize (em inglês) | Tamanho de um elemento |
| rsElementGetDataKind (em inglês) | Tipo de elemento |
| rsElementGetDataType (em inglês) | Tipo de dados de um elemento |
| rsElementGetSubElement (link em inglês) | Subelemento de um elemento complexo |
| rsElementGetSubElementArraySize (em inglês) | Tamanho da matriz de um subelemento de um elemento complexo |
| rsElementGetSubElementCount (em inglês) | Número de subelementos |
| rsElementGetSubElementName (link em inglês) | Nome de um subelemento |
| rsElementGetSubElementNameLength (em inglês) | Comprimento do nome de um subelemento |
| rsElementGetSubElementOffsetBytes (em inglês) | Deslocamento do subelemento instanciado |
| rsElementGetVectorSize (em inglês) | Tamanho do vetor do elemento |
| rsIsObject (link em inglês) | Verificar se há um identificador vazio |
| rsSamplerGetAnisotropy. | Anisotropia do Sampler |
| rsSamplerGetMagnification (em inglês) | Valor de ampliação do Sampler |
| rsSamplerGetMinification (link em inglês) | Valor de minificação do Sampler |
| rsSamplerGetWrapS (em inglês) | Valor S de wrapper do Sampler |
| rsSamplerGetWrapT (link em inglês) | Valor T de agrupamento do Sampler |
Funções e tipos de invocação de kernel
A função rsForEvery() pode ser usada para invocar o kernel raiz de um script.
As outras funções são usadas para conseguir as características da invocação de um kernel em execução, como dimensões e índices atuais. Essas funções usam um rs_kernel_context como argumento.
| Tipos | |
|---|---|
| rs_for_each_strategy_t (link em inglês) | Ordem sugerida de processamento de células |
| rs_kernel | Processar uma função do kernel |
| rs_kernel_context (em inglês) | Processar um contexto de invocação do kernel |
| rs_script_call_t (em inglês) | Informações de iteração da célula |
| Funções | |
|---|---|
| rsForEvery (em inglês) | Inicia um kernel |
| rsForEachInternal (em inglês) | (API interna) Inicie um kernel no script atual (com o número do slot) |
| rsForEachWithOptions (em inglês) | Inicia um kernel com opções |
| rsGetArray0. | Índice na dimensão Array0 para o contexto do kernel especificado |
| rsGetArray1. | Índice na dimensão Array1 para o contexto do kernel especificado |
| rsGetArray2. | Índice na dimensão Array2 para o contexto do kernel especificado |
| rsGetArray3. | Índice na dimensão Array3 para o contexto do kernel especificado |
| rsGetDimArray0. | Tamanho da dimensão Array0 para o contexto do kernel especificado |
| rsGetDimArray1. | Tamanho da dimensão Array1 para o contexto do kernel especificado |
| rsGetDimArray2. | Tamanho da dimensão Array2 para o contexto do kernel especificado |
| rsGetDimArray3. | Tamanho da dimensão Array3 para o contexto do kernel especificado |
| rsGetDimHasFaces | Presença de mais de uma face para o contexto do kernel especificado |
| rsGetDimLod (em inglês) | Número de níveis de detalhes para o contexto especificado do kernel |
| rsGetDimX (em inglês) | Tamanho da dimensão X para o contexto do kernel especificado |
| rsGetDimY (em inglês) | Tamanho da dimensão Y para o contexto do kernel especificado |
| rsGetDimZ (link em inglês) | Tamanho da dimensão Z para o contexto do kernel especificado |
| rsGetFace (link em inglês) | Coordenada da face para o contexto especificado do kernel |
| rsGetLod (em inglês) | Índice na dimensão "Níveis de detalhes" para o contexto do kernel especificado |
Funções de entrada/saída
Essas funções são usadas para:
- enviar informações para o cliente Java;
- Enviar a alocação processada ou receber a próxima para processamento.
| Funções | |
|---|---|
| rsAllocationIoReceive (em inglês) | Receber novos conteúdos da fila |
| rsAllocationIoSend (link em inglês) | Enviar novos conteúdos para a fila |
| rsSendToClient (link em inglês) | Enviar uma mensagem ao cliente sem bloqueio |
| rsSendToClientBlock (link em inglês) | Enviar uma mensagem ao cliente, bloqueando |
Funções de deputação
As funções abaixo são usadas durante o desenvolvimento do aplicativo. Eles não devem ser usados em aplicativos de remessa.
| Funções | |
|---|---|
| rsDebug (em inglês) | Registrar uma mensagem e valores |
Funções e tipos de gráfico
O subsistema gráfico do RenderScript foi removido no nível 23 da API