Présentation
RenderScript est un environnement d'exécution hautes performances qui fournit des opérations de calcul au niveau natif. Le code RenderScript est compilé sur les appareils au moment de l'exécution pour permettre également l'indépendance par rapport à la plate-forme.
Cette documentation de référence décrit les API d'exécution RenderScript, que vous pouvez utiliser pour écrire du code RenderScript en C99. Les fichiers d'en-tête de calcul RenderScript sont automatiquement inclus.
Pour utiliser RenderScript, vous devez vous servir des API d'exécution RenderScript décrites ici, ainsi que des API du framework Android pour RenderScript. Pour en savoir plus sur les API du framework Android, consultez la documentation de référence du package android.renderscript.
Pour en savoir plus sur le développement avec RenderScript et sur la manière dont les API d'exécution et du framework Android interagissent, consultez le guide du développeur RenderScript et les exemples RenderScript.
Types numériques
Scalaires:
RenderScript accepte les types numériques scalaires suivants:
| 8 bits | 16 bits | 32 bits | 64 bits | |
| Entier: | car, int8_t | court, int16_t | int32_t | long, long, int64_t |
| Entier non signé: | uchar, uint8_t | ushort, uint16_t | uint, uint32_t | ulong, uint64_t |
| Virgule flottante: | mi-temps | float | double |
Vecteurs:
RenderScript accepte les vecteurs de taille fixe de longueur 2, 3 et 4. Les vecteurs sont déclarés à l'aide du nom de type commun suivi du 2, du 3 ou du 4. Exemple : float4, int3, double2, ulong4.
Pour créer des littéraux vectoriels, utilisez le type de vecteur suivi des valeurs entre accolades (par exemple, (float3){1.0f, 2.0f, 3.0f}).
Il est possible d'accéder aux entrées d'un vecteur en utilisant différents styles de dénomination.
Pour accéder aux entrées uniques, ajoutez un point à la suite du nom de la variable et ajoutez les lignes suivantes:
- Les lettres x, y, z et w,
- Les lettres r, g, b et a
- La lettre s ou S, suivie d'un index basé sur zéro.
Par exemple, avec int4 myVar;, les éléments suivants sont équivalents:
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
Il est possible d'accéder simultanément à plusieurs entrées d'un vecteur à l'aide d'un identifiant qui est la concaténation de plusieurs lettres ou index. La taille du vecteur résultant est égale au nombre d'entrées nommées.
Dans l'exemple ci-dessus, les deux entrées du milieu sont accessibles à l'aide de myVar.yz, myVar.gb, myVar.s12 et myVar.S12.
Les entrées ne doivent pas nécessairement être contiguës ni par ordre croissant. Les entrées peuvent même être répétées, tant que nous n'essayons pas de leur attribuer. Vous ne pouvez pas non plus mélanger les styles d'attribution de noms.
Voici quelques exemples de ce que vous pouvez faire ou non:
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
Matrices et quaternions:
RenderScript accepte les matrices carrées de taille fixe de flottants de taille 2x2, 3x3 et 4x4. Les types sont nommés rs_matrix2x2, rs_matrix3x3 et rs_matrix4x4. Consultez la section Fonctions matricielles pour obtenir la liste des opérations.
Les quaternions sont également compatibles avec rs_quaternion. Consultez la page Fonctions de quantification pour obtenir la liste des opérations.
| Types | |
|---|---|
| car2 | Deux entiers signés de 8 bits |
| car3 | Trois entiers signés de 8 bits |
| carac4 | Quatre entiers signés de 8 bits |
| double2 | Deux floats 64 bits |
| double3 | Trois flottants 64 bits |
| double4 | Quatre floats 64 bits |
| float2 | Deux floats 32 bits |
| Flottant 3 | Trois flottants 32 bits |
| Nombre décimal4 | Quatre floats 32 bits |
| moitié | Valeur à virgule flottante 16 bits |
| moitié2 | Deux floats 16 bits |
| demi-3 | Trois flottants 16 bits |
| moitié4 | Quatre floats 16 bits |
| int16_t | Entier signé de 16 bits |
| Int2 | Deux entiers signés de 32 bits |
| Int3 | Trois entiers signés de 32 bits |
| int32_t | Entier signé de 32 bits |
| Int4 | Quatre entiers signés de 32 bits |
| int64_t | Entier signé de 64 bits |
| int8_t | Entier signé de 8 bits |
| longue2 | Deux entiers signés de 64 bits |
| long3 | Trois entiers signés de 64 bits |
| long4 | Quatre entiers signés de 64 bits |
| rs_matrix2x2 | Matrice 2 x 2 de floats 32 bits |
| rs_matrix3x3 | Matrice 3 x 3 de floats 32 bits |
| rs_matrix4x4 | Matrice 4 x 4 de floats 32 bits |
| quaternion_rs | Quaternion |
| courte2 | Deux entiers signés de 16 bits |
| courte3 | Trois entiers signés de 16 bits |
| courte4 | Quatre entiers signés de 16 bits |
| taille_t | Type de coupe non signé |
| taille_t | Type de taille signée |
| uchar | Entier non signé de 8 bits |
| uchar2 | Deux entiers non signés de 8 bits |
| uchar3 | Trois entiers non signés de 8 bits |
| uchar4 | Quatre entiers non signés de 8 bits |
| uint | Entier non signé de 32 bits |
| uint16_t. | Entier non signé de 16 bits |
| uint2 | Deux entiers non signés de 32 bits |
| uint3 | Trois entiers non signés de 32 bits |
| uint32_t | Entier non signé de 32 bits |
| uint4 | Quatre entiers non signés de 32 bits |
| uint64_t | Entier non signé de 64 bits |
| uint8_t | Entier non signé de 8 bits |
| ulong | Entier non signé de 64 bits |
| ulong2 | Deux entiers non signés de 64 bits |
| ulong3 | Trois entiers non signés de 64 bits |
| ulong4 | Quatre entiers non signés de 64 bits |
| ushort | Entier non signé de 16 bits |
| ushort2 | Deux entiers non signés de 16 bits |
| ushort3 | Trois entiers non signés de 16 bits |
| ushort4 | Quatre entiers non signés de 16 bits |
Types d'objets
Les types ci-dessous sont utilisés pour manipuler des objets RenderScript tels que les allocations, les échantillonneurs, les éléments et les scripts. La plupart de ces objets sont créés à l'aide des API Java RenderScript.
| Types | |
|---|---|
| rs_allocation | Gérer une allocation |
| rs_allocation_cubemap_face | Énumération pour la sélection de faces en forme de cube |
| rs_allocation_usage_type | Champ de bits permettant de spécifier le mode d'utilisation d'une allocation |
| rs_data_kind | Type de données de l'élément |
| rs_data_type | Type de données de base de l'élément |
| rs_element | Gérer un élément |
| rs_sampler | Traiter un échantillonneur |
| rs_sampler_value | Valeur T de l'encapsulation de l'échantillonneur |
| script rs | Traiter un script |
| rs_type | Appliquer une poignée à un type |
| rs_yuv_format. | Format YUV |
Fonctions de conversion
Les fonctions ci-dessous convertissent un type de vecteur numérique à un autre, ou une représentation couleur à une autre.
| Fonctions | |
|---|---|
| convertir | Convertir des vecteurs numériques |
| rsPackColorTo8888 | Créer un RVBA uchar4 à partir de floats |
| rsUnpackColor8888 | Créer un RVBA float4 à partir de uchar4 |
| rsYuvToRVBA | Convertir une valeur YUV en RVBA |
Constantes et fonctions mathématiques
Les fonctions mathématiques ci-dessous peuvent être appliquées aux scalaires et aux vecteurs. Lorsqu'elle est appliquée à des vecteurs, la valeur renvoyée est un vecteur de la fonction appliquée à chaque entrée de l'entrée.
Exemple:
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);
Consultez la section Fonctions de mathématiques vectorielles pour obtenir des fonctions telles que distance() et length() qui interprètent plutôt l'entrée comme un vecteur unique dans un espace à N dimensions.
La précision des opérations mathématiques sur les floats 32 bits est affectée par les pragmas rs_fp_relaxed et rs_fp_full. Sous rs_fp_relaxed, les valeurs subnormales peuvent être vidées à zéro et les valeurs arrondies peuvent être arrondies vers zéro. En comparaison, rs_fp_full nécessite de traiter correctement les valeurs subnormales, c'est-à-dire inférieures à 1,17549435e-38f. rs_fp_rull nécessite également d'arrondir au plus proche avec des relations égales à pair.
Différents compromis de précision/vitesse peuvent être obtenus en utilisant des variantes des fonctions mathématiques courantes. Fonctions dont le nom commence par
- native_: peut disposer d'implémentations matérielles personnalisées avec une précision plus faible. En outre, les valeurs subnormales peuvent être vidées à zéro, les valeurs arrondies vers zéro peuvent être utilisées, et les valeurs NaN et infinies peuvent ne pas être gérées correctement.
- Half_: peut effectuer des calculs internes à l'aide de floats 16 bits. En outre, les valeurs inférieures à zéro peuvent être arrondies à zéro.
| Constantes | |
|---|---|
| M_1_PI | 1 / pi, en tant que valeur flottante de 32 bits |
| M_2_PI | 2 / pi, en tant que float 32 bits |
| M_2_RACINE.PI | 2 / carrée(pi), en tant que float 32 bits |
| M_E | e, sous la forme d'une valeur flottante de 32 bits |
| M_LN10 | log_e(10), sous forme de float 32 bits |
| M_LN2 | log_e(2), sous forme de float 32 bits |
| M_LOG10E | log_10(e), sous forme de float 32 bits |
| LOG2E_M | log_2(e), sous forme de float 32 bits |
| M_PI | pi, sous la forme d'une valeur flottante de 32 bits |
| M_PI_2 | pi / 2, en tant que valeur flottante de 32 bits |
| M_PI_4 | pi / 4, en tant que float 32 bits |
| M_RACINE1_2 | 1 / carrée(2), en tant que float 32 bits |
| M_RACINE2 | sqrt(2), en tant que valeur flottante de 32 bits |
| Fonctions | |
|---|---|
| abdos | Valeur absolue d'un entier |
| Acos | Cosinus inverse |
| Acosh | Cosinus hyperbolique inverse |
| Acospi | Cosinus inverse divisé par pi |
| asin | Sinus inverse |
| Asinh | Sinus hyperbolique inverse |
| Asinpi | Sinus inverse divisé par pi |
| TAtan | Tangente inversée |
| Atan2 | Tangente inverse d'un ratio |
| atan2pi | Tangente inverse d'un ratio, divisée par Pi |
| Atanh | Tangente hyperbolique inverse |
| Atanpi | Tangente inverse divisée par Pi |
| cbrt | Racine cubique |
| ceil | Le plus petit nombre entier supérieur ou égal à une valeur |
| pincer | Limiter une valeur à une plage |
| clz | Nombre de 0 bits au début |
| copier | Copie le signe d'un nombre dans un autre |
| Cs | Cosinus |
| cosh | Cosinus hypobolique |
| Cospi | Cosinus d'un nombre multiplié par pi |
| degrés | Convertit des radians en degrés |
| erf | Fonction d'erreur mathématique |
| ERFC | Fonction d'erreur mathématique complémentaire |
| expérience | e élevé à un nombre |
| "exp10" | 10 élevé à un nombre |
| Exp2 | 2 élevé à un nombre |
| expm1 | e élevé à un chiffre moins un |
| fabricants de café | Valeur absolue d'un float |
| FID | Différence positive entre deux valeurs |
| étage | Le plus petit nombre entier inférieur à une valeur |
| FMA | Multiplier et ajouter |
| FMax | Deux valeurs flottantes au maximum |
| Fmin | Minimum de deux nombres à virgule flottante |
| Fmod | Module |
| fracter | Partie fractionnaire positive |
| frexp | Mantisse binaire et exposant |
| demi-récip | Calcul réciproque avec une précision de 16 bits |
| half_rsqrt | Réciproque d'une racine carrée calculée avec une précision de 16 bits |
| half_sqrt | Racine carrée calculée avec une précision de 16 bits |
| hypot | Hypoténuse |
| Ilogb | Exposant de base deux |
| ldexp | Crée une valeur à virgule flottante à partir d'une mantisse et de l'exposant |
| Lgamma | Logarithme naturel de la fonction gamma |
| journal | Logarithme naturel |
| Journal10 | Logarithme de base 10 |
| log1p | Logarithme naturel d'une valeur plus 1 |
| Journal2 | Logarithme de base 2 |
| Logb | Exposant de base deux |
| fou | Multiplier et ajouter |
| max. | Maximum |
| min | Minimum |
| mix | Mélange deux valeurs |
| modf | Composants intégraux et fractionnaires |
| Nan | N'est pas un nombre |
| nan_half | N'est pas un nombre |
| native_acos | Cosinus inverse approximatif |
| native_acosh | Cosinus hyperbolique inverse approximatif |
| native_acospi | Cosinus inverse approximatif divisé par pi |
| native_asin [asin_native] | Sinus inverse approximatif |
| native_asinh | Sinus hyperbolique inverse approximatif |
| native_asinpi | Sinus inverse approximatif divisé par pi |
| native_atan | Tangente inverse approximative |
| native_atan2 | Tangente inverse approximative d'un ratio |
| native_atan2pi | Tangente inverse approximative d'un ratio, divisée par Pi |
| native_atanh | Tangente hyperbolique inverse approximative |
| native_atanpi | Tangente inverse approximative divisée par Pi |
| native_cbrt | Racine cubique approximative |
| native_cos | Cosinus approximatif |
| native_cosh | Cosinus hypébolique approximatif |
| native_cospi | Cosinus approximatif d'un nombre multiplié par pi |
| native_divide | Division approximative |
| native_exp. | e approximatif élevé à un nombre |
| native_exp10. | Environ 10 remontées à un nombre donné |
| native_exp2 | Environ 2 élevé à un nombre |
| native_expm1. | E approximatif élevé à un chiffre moins un |
| native_hypot (hypothèse_native) | Hypoténuse approximatif |
| native_log | Logarithme naturel approximatif |
| log10_native | Logarithme en base 10 approximatif |
| native_log1p | Logarithme naturel approximatif d'une valeur plus 1 |
| log_native_2 | Logarithme approximatif en base 2 |
| native_powr | Base positive approximative élevée à un exposant |
| native_recip | Réciproque approximatif |
| native_rootn | Racine n-ième approximative |
| native_rsqrt. | Réciproque approximatif d'une racine carrée |
| native_sin (sin_natif) | Sinus approximatif |
| native_sincos | Sinus et cosinus approximatifs |
| native_sinh | Sinus hyperbolique approximatif |
| native_sinpi | Sinus approximatif d'un nombre multiplié par pi |
| native_sqrt. | Racine carrée approximative |
| native_tan | Tangente approximative |
| native_tanh | Tangente hyperbolique approximative |
| native_tanpi | Tangente approximative d'un nombre multiplié par pi |
| Suivant | Nombre à virgule flottante suivant |
| mouve | Base élevée à un exposant |
| Base élevée à un exposant entier | |
| powr | Base positive élevée à un exposant |
| radians | Convertit des degrés en radians |
| reste | Reste d'une division |
| Remquo | Reste et quotient d'une division |
| rincer | Arrondir au nombre pair |
| rootn | Racine n-ième |
| arrondi | Arrondi à zéro |
| rsRand | Nombre pseudo-aléatoire |
| Réciproque d'une racine carrée | |
| signe | Signe d'une valeur |
| sin | Sinus |
| sincos | Sinus et cosinus |
| sinh | Sinus hyperbolique |
| Sinpi | Sinus d'un nombre multiplié par Pi |
| raccourci | Racine carrée |
| pas | 0 si inférieur à une valeur, 0 dans le cas contraire |
| brun clair | Tangente |
| Tanh | Tangente hyperbolique |
| tanpi | Tangente d'un nombre multiplié par Pi |
| tgamma | Fonction gamma |
| tronc | Tronque une valeur à virgule flottante |
Fonctions de mathématiques vectorielles
Ces fonctions interprètent les arguments d'entrée comme une représentation de vecteurs dans un espace à N dimensions.
La précision des opérations mathématiques sur les floats 32 bits est affectée par les pragmas rs_fp_relaxed et rs_fp_full. Pour en savoir plus, consultez la page Constantes et fonctions mathématiques.
Différents compromis de précision/vitesse peuvent être obtenus en utilisant des variantes des fonctions mathématiques courantes. Fonctions dont le nom commence par
- native_: peut disposer d'implémentations matérielles personnalisées avec une précision plus faible. En outre, les valeurs subnormales peuvent être vidées à zéro, les valeurs arrondies vers zéro peuvent être utilisées, et les valeurs NaN et infinies peuvent ne pas être gérées correctement.
- fast_: peut effectuer des calculs internes à l'aide de floats 16 bits. En outre, les valeurs inférieures à zéro peuvent être arrondies à zéro.
| Fonctions | |
|---|---|
| croix | Produit croisé de deux vecteurs |
| distance | Distance entre deux points |
| point | Produit scalaire de deux vecteurs |
| fast_distance | Distance approximative entre deux points |
| longueur_rapide | Longueur approximative d'un vecteur |
| fast_normalize | Vecteur normalisé approximatif |
| longueur | Longueur d'un vecteur |
| native_distance | Distance approximative entre deux points |
| native_length | Longueur approximative d'un vecteur |
| native_normalize | Normaliser approximativement un vecteur |
| normaliser | Normaliser un vecteur |
Fonctions matricielles
Ces fonctions vous permettent de manipuler des matrices carrées de rang 2x2, 3x3 et 4x4. Ils sont particulièrement utiles pour les transformations graphiques et sont compatibles avec OpenGL.
Nous utilisons un index de base zéro pour les lignes et les colonnes. Par exemple, le dernier élément d'un élément rs_matrix4x4 se trouve aux coordonnées (3, 3).
RenderScript utilise des matrices à majeure colonne et des vecteurs basés sur des colonnes. La transformation d'un vecteur s'effectue en post-multipliant (par exemple, (matrix * vector)) par la méthode rsMatrixMultiply().
Pour créer une matrice de transformation qui effectue deux transformations à la fois, multipliez les deux matrices sources, en utilisant la première transformation comme argument de droite. Par exemple, pour créer une matrice de transformation qui applique la transformation s1 suivie de s2, appelez rsMatrixLoadMultiply(&combined, &s2, &s1).
Elle est dérivée de s2 * (s1 * v), qui correspond à (s2 * s1) * v.
Nous disposons de deux styles de fonctions pour créer des matrices de transformation : rsMatrixLoadTransformation et rsMatrixTransformation. Le premier style stocke simplement la matrice de transformation dans le premier argument. Ce dernier modifie une matrice de transformation préexistante afin que la nouvelle transformation soit effectuée en premier. Par exemple, si vous appelez rsMatrixTranslate() sur une matrice qui effectue déjà une mise à l'échelle, la matrice résultante lorsqu'elle est appliquée à un vecteur effectue d'abord la translation, puis la mise à l'échelle.
| Fonctions | |
|---|---|
| rsExtractFrustumPlanes | Calculer les plans de tronc |
| rsIsSphereInFrustum | Vérifie si une sphère se trouve dans les plans troncaux |
| rsMatrixGet | Obtenir un élément |
| rsMatrixInverse | Inverser une matrice en place |
| rsMatrixInverseTranspose | Inverser et transposer une matrice sur place |
| rsMatrixLoad | Charger ou copier une matrice |
| rsMatrixLoadFrustum | Charger une matrice de projection de tronc |
| rsMatrixLoadIdentity | Charger la matrice d'identité |
| rsMatrixLoadMultiply | Multiplier deux matrices |
| rsMatrixLoadOrtho | Charger une matrice de projection orthographique |
| rsMatrixLoadPerspective | Charger une matrice de projection en perspective |
| rsMatrixLoadRotation | Charger une matrice de rotation |
| rsMatrixLoadScale | Charger une matrice de scaling |
| rsMatrixLoadTranslate | Charger une matrice de traduction |
| rsMatrixMultiply | Multiplier une matrice par un vecteur ou une autre matrice |
| rsMatrixRotate | Appliquer une rotation à une matrice de transformation |
| rsMatrixScale | Appliquer un scaling à une matrice de transformation |
| rsMatrixSet | Définir un élément |
| rsMatrixTranslate | Appliquer une traduction à une matrice de transformation |
| rsMatrixTranspose | Transposer un lieu matriciel |
Fonctions quaternioniques
Les fonctions suivantes manipulent des quaternions.
| Fonctions | |
|---|---|
| rsQuaternionAdd | Ajouter deux quaternions |
| Conjugate rsQuaternion | Conjuguer un quaternion |
| rsQuaternionDot | Produit scalaire de deux quaternions |
| rsQuaternionGetMatrixUnit | Obtenir une matrice de rotation à partir d'un quaternion |
| rsQuaternionLoadScroll | Créer un quaternion de rotation |
| rsQuaternionLoadScrollUnit | Quaternion représentant une rotation par rapport à un vecteur unitaire arbitraire |
| rsQuaternionMultiply | Multiplier un quaternion par un scalaire ou un autre quaternion |
| rsQuaternionNormalize | Normaliser un quaternion |
| Ensemble rsQuaternion | Créer un quaternion |
| rsQuaternionSlerp | Interpolation linéaire sphérique entre deux quaternions |
Fonctions de mise à jour atomique
Pour mettre à jour les valeurs partagées entre plusieurs threads, utilisez les fonctions ci-dessous. Ils garantissent que les valeurs sont mises à jour de manière atomique, c'est-à-dire que les lectures, les mises à jour et les écritures de la mémoire sont effectuées dans le bon ordre.
Ces fonctions sont plus lentes que leurs équivalents non atomiques. Vous ne devez donc les utiliser que lorsqu'une synchronisation est nécessaire.
Notez que dans RenderScript, votre code est susceptible de s'exécuter dans des threads distincts, même si vous ne les avez pas créés explicitement. L'environnement d'exécution RenderScript divise très souvent l'exécution d'un noyau sur plusieurs threads. La mise à jour des éléments généraux doit être effectuée à l'aide de fonctions atomiques. Si possible, modifiez votre algorithme pour les éviter complètement.
| Fonctions | |
|---|---|
| rsAtomicAdd | Ajout sécurisé |
| rsAtomicAnd | Thread sécurisé et au niveau du bit |
| rsAtomicCas | Fonctionnalité de comparaison et de définition sécurisée |
| rsAtomicDec | Décréement de type thread sécurisé |
| rsAtomicInc | Incrément de sécurité thread |
| rsAtomicMax | Sécurité maximale |
| rsAtomicMin | Valeur minimale de sécurité du thread |
| rsAtomicOr | Thread sécurisé au niveau du bit ou |
| rsAtomicSub | Soustraction sécurisée |
| rsAtomicXor | Thread sécurisé exclusif ou au niveau du bit |
Fonctions et types de temps
Les fonctions ci-dessous peuvent être utilisées pour indiquer l'heure actuelle et l'heure de disponibilité actuelle du système. Il est déconseillé d'appeler ces fonctions à l'intérieur d'un noyau.
| Types | |
|---|---|
| rs_time_t | Secondes depuis le 1er janvier 1970 |
| rs_tm | Structure de la date et de l'heure |
| Fonctions | |
|---|---|
| rsGetDt | Temps écoulé depuis le dernier appel |
| rsLocaltime | Convertir en heure locale |
| rsTime | Secondes depuis le 1er janvier 1970 |
| rsUptimeMillis | Temps d'activité du système en millisecondes |
| rsUptimeNanos | Temps d'activité du système en nanosecondes |
Fonctions de création d'allocation
Les fonctions ci-dessous peuvent être utilisées pour créer des allocations à partir d'un script.
Ces fonctions peuvent être appelées directement ou indirectement à partir d'une fonction pouvant être appelée. Si un chemin de flux de contrôle peut entraîner un appel à ces fonctions à partir d'une fonction de noyau RenderScript, une erreur de compilateur sera générée.
| Fonctions | |
|---|---|
| rsCreateAllocation | Crée un objet "rs_allocation" du type donné. |
| rsCreateElement | Crée un objet rs_element avec le type de données spécifié |
| rsCreatePixelElement | Crée un objet rs_element avec le type de données et le genre de données spécifiés |
| Type rsCreate | Crée un objet rs_type avec les attributs d'élément et de forme spécifiés. |
| rsCreateVectorElement. | Crée un objet rs_element avec le type de données et la largeur vectorielle spécifiés |
Fonctions d'accès aux données d'allocation
Les fonctions ci-dessous peuvent être utilisées pour obtenir et définir les cellules qui composent une allocation.
- Les cellules individuelles sont accessibles à l'aide des fonctions rsGetElementAt* et rsSetElementAt.
- Vous pouvez copier plusieurs cellules à l'aide des fonctions rsAllocationCopy* et rsAllocationV*.
- Pour obtenir des valeurs via un échantillonneur, utilisez rsSample.
| Fonctions | |
|---|---|
| rsAllocationCopy1DRange | Copier des cellules consécutives entre des allocations |
| rsAllocationCopy2DRange | Copier une zone rectangulaire de cellules entre des allocations |
| rsAllocationVLoadX. | Obtenir un vecteur à partir d'une allocation de scalaires |
| rsAllocationVStoreX | Stocker un vecteur dans une allocation de scalaires |
| rsGetElementAt | Renvoyer une cellule à partir d'une allocation |
| rsGetElementAtYuv_uchar_U | Obtenir la composante U d'une allocation de YUV |
| rsGetElementAtYuv_uchar_V | Obtenir la composante V d'une allocation de YUV |
| rsGetElementAtYuv_uchar_Y | Obtenir la composante Y d'une allocation de YUV |
| rsSample | Échantillonner une valeur à partir d'une allocation de texture |
| rsSetElementAt | Définir une cellule d'allocation |
Fonctions des caractéristiques de l'objet
Les fonctions ci-dessous peuvent être utilisées pour interroger les caractéristiques d'un objet Attribution, Element ou Sampler. Ces objets sont créés à partir de Java. Vous ne pouvez pas les créer à partir d'un script.
Allocations:
Les allocations constituent la principale méthode utilisée pour transmettre des données vers et depuis les noyaux RenderScript.
Il s'agit d'une collection structurée de cellules pouvant être utilisées pour stocker des bitmaps, des textures, des points de données arbitraires, etc.
Cet ensemble de cellules peut comporter de nombreuses dimensions (X, Y, Z, Array0, Array1, Array2 et Array3), de faces (pour les cubes) et de niveaux de détails (pour mipmapping).
Pour en savoir plus sur la création d'allocations, consultez android.renderscript.Allocation.
Éléments:
Le terme "élément" est utilisé de manière un peu ambiguë dans RenderScript, à la fois comme informations de type pour les cellules d'une allocation et pour instanciation de ce type. Par exemple :
- rs_element est un handle vers une spécification de type.
- Dans des fonctions telles que rsGetElementAt(), "element" désigne l'instanciation du type, c'est-à-dire une cellule d'une allocation.
Les fonctions ci-dessous vous permettent d'interroger les caractéristiques de la spécification de type.
Un élément peut spécifier des types de données simples (par exemple, un entier, un nombre à virgule flottante ou un booléen). Il peut également spécifier un handle vers un objet RenderScript. Consultez la section rs_data_type pour obtenir la liste des types de base.
Les éléments peuvent spécifier des versions de vecteur de taille fixe (de taille 2, 3 ou 4) des types de base. Les éléments peuvent être regroupés en éléments complexes, créant ainsi l'équivalent des définitions de la structure C.
Les éléments peuvent également avoir un genre, qui correspond à une information sémantique utilisée pour interpréter les données de pixels. Consultez rs_data_kind.
Lorsque vous créez des allocations d'éléments communs, vous pouvez simplement utiliser l'un des nombreux éléments prédéfinis tels que F32_2.
Pour créer des éléments complexes, utilisez la classe Java Element.Builder.
Échantillonneurs:
Les objets Samplers définissent comment les allocations peuvent être lues comme une structure au sein d'un noyau. Voir android.renderscript.S.
| Fonctions | |
|---|---|
| rsAllocationGetDimFaces | Présence de plusieurs visages |
| rsAllocationGetDimLOD | Présence de niveaux de détail |
| rsAllocationGetDimX | Taille de la dimension X |
| rsAllocationGetDimY | Taille de la dimension Y |
| rsAllocationGetDimZ | Taille de la dimension Z |
| rsAllocationGetElement | Obtenir l'objet qui décrit la cellule d'une allocation |
| rsClearObject | Libérer un objet |
| rsElementGetBytesSize | Taille d'un élément |
| rsElementGetDataKind | Type d'élément |
| rsElementGetDataType | Type de données d'un élément |
| rsElementGetSubElement | Sous-élément d'un élément complexe |
| rsElementGetSubElementArraySize | Taille du tableau d'un sous-élément d'un élément complexe |
| rsElementGetSubElementCount | Nombre de sous-éléments |
| rsElementGetSubElementName | Nom d'un sous-élément |
| rsElementGetSubElementNameLength | Longueur du nom d'un sous-élément |
| rsElementGetSubElementOffsetBytes | Décalage du sous-élément instancié |
| rsElementGetVectorSize. | Taille vectorielle de l'élément |
| rsIsObject | Rechercher un identifiant vide |
| rsSamplerGetAnisotropy | Anisotropie de l'échantillonneur |
| rsSamplerGetMagnification | Valeur d'agrandissement de l'échantillonneur |
| rsSamplerGetMinification | Valeur de minimisation de l'échantillonneur |
| rsSamplerGetWrapS | Valeur S de l'encapsulation de l'échantillonneur |
| rsSamplerGetWrapT | Valeur T de l'encapsulation de l'échantillonneur |
Fonctions et types d'appels du noyau
La fonction rsForEvery() peut être utilisée pour appeler le noyau racine d'un script.
Les autres fonctions permettent d'obtenir les caractéristiques de l'appel d'un noyau en cours d'exécution, telles que les dimensions et les index actuels. Ces fonctions utilisent rs_kernel_context comme argument.
| Types | |
|---|---|
| rs_for_each_strategy_t | Ordre suggéré pour le traitement des cellules |
| rs_kernel | Gérer une fonction de noyau |
| rs_kernel_context | Gérer un contexte d'appel du noyau |
| rs_script_call_t | Informations sur l'itération des cellules |
| Fonctions | |
|---|---|
| rsForChaque | Lance un noyau |
| rsForEveryInternal | (API interne) Lancer un noyau dans le script actuel (avec le numéro d'emplacement) |
| rsForEveryWithOptions | Lance un noyau avec des options |
| rsGetArray0 | Index dans la dimension Array0 pour le contexte de noyau spécifié |
| rsGetArray1 | Index dans la dimension Array1 pour le contexte de noyau spécifié |
| rsGetArray2 | Index dans la dimension Array2 pour le contexte de noyau spécifié |
| rsGetArray3 | Index dans la dimension Array3 pour le contexte de noyau spécifié |
| rsGetDimArray0 | Taille de la dimension Array0 pour le contexte de noyau spécifié |
| rsGetDimArray1 | Taille de la dimension Array1 pour le contexte de noyau spécifié |
| rsGetDimArray2 | Taille de la dimension Array2 pour le contexte de noyau spécifié |
| rsGetDimArray3 | Taille de la dimension Array3 pour le contexte de noyau spécifié |
| rsGetDimHasFaces | Présence de plusieurs visages pour le contexte de noyau spécifié |
| rsGetDimLod | Nombre de niveaux de détail pour le contexte de noyau spécifié |
| rsGetDimX | Taille de la dimension X pour le contexte de noyau spécifié |
| RSGetDimY | Taille de la dimension Y pour le contexte de noyau spécifié |
| rsGetDimZ | Taille de la dimension Z pour le contexte de noyau spécifié |
| rsGetFace | Coordonnées du visage pour le contexte du noyau spécifié |
| rsGetLod | Index dans la dimension Niveaux de détail pour le contexte de noyau spécifié |
Fonctions d'entrée/sortie
Ces fonctions sont utilisées pour:
- envoyer des informations au client Java ;
- Envoyer l'allocation traitée ou recevoir l'allocation suivante à traiter.
| Fonctions | |
|---|---|
| rsAllocationIoReceive | Recevoir le nouveau contenu de la file d'attente |
| rsAllocationIoSend | Envoyer les nouveaux contenus dans la file d'attente |
| rsSendToClient | Envoyer un message au client, non bloquant |
| rsSendToClientBlocking | Envoyer un message au client, en bloquant |
Fonctions de débogage
Les fonctions ci-dessous sont destinées à être utilisées lors du développement d'applications. Ils ne doivent pas être utilisés dans les applications de livraison.
| Fonctions | |
|---|---|
| rsDebug | Enregistrer un message et ses valeurs |
Fonctions et types de graphiques
Le sous-système graphique de RenderScript a été supprimé au niveau d'API 23.