Cette page a été traduite par l'API Cloud Translation.

Cibler les formats de compression de texture dans les Android App Bundles

Les textures sont des images qui peuvent être appliquées à la surface d'une modélisation 3D. Les moteurs de rendu 2D utilisent également les textures pour dessiner des éléments tels que des sprites ou des arrière-plans. Cette page décrit les formats de compression de texture populaires utilisés dans les jeux et explique comment les cibler dans des Android App Bundles. Consultez À propos des Android App Bundles et Play Asset Delivery avant de commencer.

Arrière-plan

Les GPU sont généralement compatibles avec un ensemble de formats de compression de texture. Un format de compression de texture est un format de fichier optimisé pour les GPU. Le GPU charge et affiche une texture plus rapidement et avec moins de mémoire que s'il utilisait un tableau de valeurs RGBA en mémoire. Cette compatibilité est assurée au niveau matériel : le fabricant de GPU intègre des composants dans la puce des cartes graphiques qui lisent, décompressent et affichent les formats compatibles.

Voici quelques formats de compression de texture courants sur les appareils mobiles modernes :

ASTC : format récent conçu pour remplacer les formats précédents. Plus flexible que les formats précédents en raison de la compatibilité avec différentes tailles de bloc. Ce format est un bon moyen d'optimiser la taille de votre jeu.
ETC2 : compatible avec tous les appareils prenant en charge OpenGL ES 3.0 ou version ultérieure. Cela inclut presque tous les appareils mobiles Android actifs.

Ces formats sont compatibles avec les pourcentages approximatifs d'appareils Android suivants :

Format de compression de texture	Pourcentage d'appareils Google Play compatibles
ASTC	>80 %
ETC2	>95 %

Les GPU pour ordinateurs de bureau exécutant Google Play Jeux pour PC sont également compatibles avec le format suivant :

DDS ou S3TC : parfois appelé BCn, DXTC ou DXTn.

Les formats de compression de texture plus anciens (qui ne sont plus recommandés) incluent ce qui suit :

ETC1 : compatible avec la plupart des appareils. Ce format n'est pas compatible avec la transparence, mais les jeux peuvent utiliser un deuxième fichier de texture pour le composant alpha.
PVRTC : populaire pour les jeux iOS et sur certains appareils Android.

La compatibilité ETC1 n'est requise que pour les jeux compatibles avec d'anciens appareils très anciens ou certains appareils Android TV qui ne sont pas compatibles avec OpenGL ES 3.0 ou version ultérieure.

Un format par défaut

Avec autant de formats disponibles (avec des niveaux de compatibilité différents de ceux proposés), vous risquez de ne pas savoir quels formats utiliser pour créer vos textures de jeu. Par mesure de précaution, le format d'app bundle vous permet de sélectionner un format de compression de texture par défaut pour chaque pack d'éléments. Si un appareil n'est pas compatible avec les autres formats spécifiés, les éléments utilisant ce format par défaut sont installés.

À moins de cibler du matériel d'appareil très ancien, ETC2 est un bon choix pour un format par défaut. Vous devez utiliser les formats ETC2 qui sont compatibles avec OpenGL ES 3.0. Ces formats sont également disponibles dans l'API de graphiques Vulkan.

Formats recommandés

Le format ASTC définit diverses tailles de blocs de compression, ce qui vous permet d'échanger de manière sélective une qualité d'image réduite au profit d'une compression plus importante. Selon la nature du matériau d'art source, pour une texture donnée, vous pouvez choisir une taille de bloc plus petite ou plus grande afin de maintenir une qualité visuelle acceptable.

Si votre jeu est compatible avec Google Play Jeux pour PC et utilise Vulkan, vous devez inclure des textures S3TC. Les formats S3TC sont compatibles avec tous les GPU d'ordinateur.

Compiler un app bundle

Google Play utilise des Android App Bundles pour créer et diffuser des APK optimisés pour la configuration de l'appareil de chaque utilisateur. Les utilisateurs téléchargent ainsi uniquement le code et les ressources nécessaires à l'exécution de votre jeu. Ces APK optimisés incluent un ensemble unique d'éléments de texture, au format de compression optimal pour l'appareil.

Si votre jeu n'est pas dans Unity, utilisez Gradle pour créer un app bundle. Les utilisateurs avancés peuvent utiliser bundletool.

Si votre jeu est dans Unity, la prise en charge des app bundles avec Play Asset Delivery est disponible dans Unity 2021.3 et versions ultérieures. Pour en savoir plus, consultez les documents concernant Unity. Vous pouvez utiliser un plug-in Unity pour créer un app bundle avec des versions antérieures d'Unity.

Utiliser Gradle

Mettez à jour le plug-in Android Gradle dans le fichier build.gradle de votre projet vers la version 4.1 ou ultérieure (par exemple, com.android.tools.build:gradle:4.1.0).
Déterminez les types d'appareils que vous souhaitez cibler pour votre jeu et les formats de compression de texture compatibles (pour en savoir plus sur les formats, consultez Contexte).
Créez des versions de vos éléments pour chaque format de compression de texture à l'étape précédente. Cela peut impliquer la génération de feuilles de sprites à l'aide d'un logiciel tel que TexturePacker ou en exécutant un script qui convertit les éléments bruts en un format spécifique (par exemple,astc-encoder).
Créez des packs d'éléments (consultez Créer pour C++ ou Java) qui contiennent vos éléments de jeu et sont utilisés par Play Asset Delivery. Par exemple, vous pouvez créer un pack d'éléments par niveau ou des packs d'éléments pour différentes parties de votre jeu.

Remarque : Vous n'avez pas besoin d'utiliser les API de Play Asset Delivery dans votre jeu si vous sélectionnez le type de diffusion install-time pour vos packs d'éléments. Ces packs d'éléments sont installés en même temps que l'APK de l'application principale.

Dans vos packs d'éléments, ajoutez des répertoires pour chaque format de compression de texture que vous souhaitez prendre en charge. Ajoutez des suffixes compatibles aux noms des répertoires de texture qui correspondent au format de compression de texture utilisé pour les fichiers contenus.

Créez un répertoire avec un nom sans suffixe (par exemple, common/src/main/assets/textures/). Dans ce répertoire, placez le format par défaut de vos éléments de texture. Ce format par défaut doit être compatible avec la plupart des appareils (par exemple, ETC1 ou ETC2). Si un appareil n'est pas compatible avec les autres formats spécifiés (par exemple, PVRTC et ASTC dans le tableau ci-dessous), le Google Play Store installe ce répertoire à la place.

Répertoire avant	Répertoire après
`common` pack d'éléments : common/build.gradle common/src/main/assets/textures/…	`common` pack d'éléments : common/build.gradle common/src/main/assets/textures/… common/src/main/assets/textures#tcf_astc/… common/src/main/assets/textures#tcf_pvrtc/…
`level1` pack d'éléments : level1/build.gradle level1/src/main/assets/textures/…	`level1` pack d'éléments : level1/build.gradle level1/src/main/assets/textures/… level1/src/main/assets/textures#tcf_astc/… level1/src/main/assets/textures#tcf_pvrtc/…
`level2` pack d'éléments : level2/build.gradle level2/src/main/assets/textures/…	`level2` pack d'éléments : level2/build.gradle level2/src/main/assets/textures/… level2/src/main/assets/textures#tcf_astc/… level2/src/main/assets/textures#tcf_pvrtc/…

Mettez à jour le fichier build.gradle de votre application pour activer la division de vos packs d'éléments par texture.

// In the app build.gradle file:
android {
    ...
    bundle {
        texture {
            enableSplit true
        }
    }
}

Dans Android Studio, sélectionnez Générer > Générer un bundle signé / APK ou lancez la tâche Gradle à partir de la ligne de commande pour générer votre bundle.

Remarque : Lorsque des APK (à installer sur un appareil) sont générés à partir de l'app bundle, les suffixes (par exemple, #tcf_xxx) sont supprimés des noms de répertoires. Votre jeu doit simplement lire les fichiers à partir d'un nom de répertoire connu (par exemple, level1/assets/textures). Certains moteurs de jeu peuvent détecter le format d'un fichier, ce qui permet à votre jeu d'être indépendant du format des éléments de texture avec lesquels il a été installé.

Utiliser le plug-in Unity de Google Play

Téléchargez le plug-in (ou package) Unity pour Play Asset Delivery afin de créer un app bundle avec des packs d'éléments ciblés par des textures.

Préparer les éléments

Pour préparer vos éléments de texture en vue de créer un app bundle, procédez comme suit :

Organisez votre scène et vos éléments en packages dans plusieurs AssetBundles Unity.

Remarque : Bien que le Gestionnaire AssetBundle soit obsolète pour les versions 2018.2 et ultérieures d'Unity, les AssetBundles sont toujours acceptés.
Déterminez les types d'appareils que vous souhaitez cibler pour votre jeu et les formats de compression de texture compatibles (pour en savoir plus sur les formats, consultez Contexte).

Modifiez le script de compilation de votre jeu pour générer plusieurs fois les AssetBundles, une fois par format de texture que vous souhaitez accepter. Consultez l'exemple de script suivant :

using Google.Android.AppBundle.Editor;
using UnityEditor;

public class MyBundleBuilder
{
   [MenuItem("Assets/Build AssetBundles TCF variants")]
   public static void BuildAssetBundles()
   {
       // Describe the AssetBundles to be built:
       var assetBundlesToBuild = new []
       {
           new AssetBundleBuild
           {
               assetBundleName = "level1-textures",
               assetNames = new[] {"level1/character-textures", "level1/background-textures"}
           },
           new AssetBundleBuild
           {
               assetBundleName = "level2-textures",
               assetNames = new[] {"level2/character-textures", "level2/background-textures"}
           }
       };

       // Describe where to output the asset bundles and in which formats:
       var outputPath = "Assets/AssetBundles";
       var defaultTextureFormat = MobileTextureSubtarget.ETC2;
       var additionalTextureFormats = new[] { MobileTextureSubtarget.ASTC, MobileTextureSubtarget.PVRTC }
       var allowClearDirectory = true;

       // Generate asset bundles:
       AssetBundleBuilder.BuildAssetBundles(
           outputPath,
           assetBundlesToBuild,
           BuildAssetBundleOptions.UncompressedAssetBundle,
           defaultTextureFormat,
           additionalTextureFormats,
           allowClearDirectory);

       // While in this example we're using the UI to configure the
       // AssetBundles, you can use the value returned by BuildAssetBundles
       // to configure the asset packs, if you want to build the bundle
       // entirely using the scripting API.
   }
}

Vérifiez que chaque élément de texture apparaît dans un répertoire dont le nom contient le suffixe approprié (par exemple, #tcf_astc).

Vérifiez qu'un répertoire dont le nom ne contient aucun suffixe apparaît (par exemple, Assets/AssetBundles/). Ce répertoire contient le format par défaut de vos éléments de texture. Ce format par défaut doit être compatible avec la plupart des appareils (par exemple, ETC2). Si un appareil n'est pas compatible avec les autres formats spécifiés (par exemple, ASTC dans le code de l'étape précédente), le Google Play Store installe ce répertoire à la place.

Assets/AssetBundles.meta
Assets/AssetBundles/AssetBundles
Assets/AssetBundles/AssetBundles.manifest
Assets/AssetBundles/AssetBundles.manifest.meta
Assets/AssetBundles/AssetBundles.meta
Assets/AssetBundles/samplescene
Assets/AssetBundles/samplescene.manifest
Assets/AssetBundles/samplescene.manifest.meta
Assets/AssetBundles/samplescene.meta
Assets/AssetBundles/texturesbundle
Assets/AssetBundles/texturesbundle.manifest
Assets/AssetBundles/texturesbundle.manifest.meta
Assets/AssetBundles/texturesbundle.meta
Assets/AssetBundles#tcf_astc.meta
Assets/AssetBundles#tcf_astc/AssetBundles
Assets/AssetBundles#tcf_astc/AssetBundles.manifest
Assets/AssetBundles#tcf_astc/AssetBundles.manifest.meta
Assets/AssetBundles#tcf_astc/AssetBundles.meta
Assets/AssetBundles#tcf_astc/samplescene
Assets/AssetBundles#tcf_astc/samplescene.manifest
Assets/AssetBundles#tcf_astc/samplescene.manifest.meta
Assets/AssetBundles#tcf_astc/samplescene.meta
Assets/AssetBundles#tcf_astc/texturesbundle
Assets/AssetBundles#tcf_astc/texturesbundle.manifest
Assets/AssetBundles#tcf_astc/texturesbundle.manifest.meta
Assets/AssetBundles#tcf_astc/texturesbundle.meta

Sélectionnez Google > Android > Assets Delivery.
Cliquez sur Ajouter un dossier pour ajouter le dossier contenant vos asset bundles par défaut. Ces bundles sont installés sur les appareils qui ne sont pas compatibles avec les autres formats que vous définissez.

Assurez-vous de définir le mode d'envoi pour l'AssetBundle.
Cliquez sur Ajouter un dossier pour ajouter un dossier contenant des AssetBundles créés pour un autre format (par exemple, ASTC). Recommencez si nécessaire.

Assurez-vous de définir le mode d'envoi pour chaque AssetBundle.

Créer

Sélectionnez Google > Créer un Android App Bundle pour lancer le build Unity de votre jeu. Il organise également les AssetBundles en plusieurs packs d'éléments, où chaque nom d'AssetBundle est converti en un seul pack d'éléments.

(Avancé) Utiliser bundletool

Pour en savoir plus sur bundletool, consultez la section Créer un app bundle à l'aide de bundletool.

Pour créer l'app bundle, procédez comme suit :

Télécharger bundletool de son dépôt GitHub.
Déterminez les types d'appareils que vous souhaitez cibler pour votre jeu et les formats de compression de texture compatibles (pour en savoir plus sur les formats, consultez Contexte).
Créez des versions de vos éléments pour chaque format de compression de texture à l'étape précédente. Cela peut impliquer la génération de feuilles de sprites à l'aide d'un logiciel tel que TexturePacker ou en exécutant un script qui convertit les éléments bruts en un format spécifique (par exemple,astc-encoder).
Créez des packs d'éléments (consultez Créer pour C++ ou Java) qui contiennent vos éléments de jeu et sont utilisés par Play Asset Delivery. Par exemple, vous pouvez créer un pack d'éléments par niveau ou des packs d'éléments pour différentes parties de votre jeu.

Remarque : Vous n'avez pas besoin d'utiliser les API de Play Asset Delivery dans votre jeu si vous sélectionnez le type de diffusion install-time pour vos packs d'éléments. Ces packs d'éléments sont installés en même temps que l'APK de l'application principale.

Dans vos différents packs d'éléments, ajoutez des suffixes compatibles aux noms des répertoires de texture qui correspondent au format de compression de texture utilisé pour les fichiers contenus.

Répertoire avant	Répertoire après
`common` pack d'éléments : common/build.gradle common/src/main/assets/textures/…	`common` pack d'éléments : common/build.gradle common/src/main/assets/textures/… common/src/main/assets/textures#tcf_astc/… common/src/main/assets/textures#tcf_pvrtc/…
`level1` pack d'éléments : level1/build.gradle level1/src/main/assets/textures/…	`level1` pack d'éléments : level1/build.gradle level1/src/main/assets/textures/… level1/src/main/assets/textures#tcf_astc/… level1/src/main/assets/textures#tcf_pvrtc/…
`level2` pack d'éléments : level2/build.gradle level2/src/main/assets/textures/…	`level2` pack d'éléments : level2/build.gradle level2/src/main/assets/textures/… level2/src/main/assets/textures#tcf_astc/… level2/src/main/assets/textures#tcf_pvrtc/…

Ajoutez la dimension TCF au fichier de métadonnées de l'app bundle (BundleConfig.json). Utilisez TEXTURE_COMPRESSION_FORMAT pour le champ value :
```
{
  ...
  "optimizations": {
    "splitsConfig": {
      "splitDimension": [
      ...
      {
         "value": "TEXTURE_COMPRESSION_FORMAT",
         "negate": false,
         "suffixStripping": {
           "enabled": true,
           "defaultSuffix": ""
          }
      }],
    }
  }
}
```
Définissez suffixStripping.enabled sur true pour supprimer le suffixe (par exemple, #tcf_astc) des noms de répertoire au moment de créer des packs d'éléments. Votre jeu peut alors lire des fichiers à partir d'un nom de répertoire connu (level1/assets/textures, par exemple). Certains moteurs de jeu peuvent détecter le format d'un fichier, ce qui permet à votre jeu d'être indépendant du format des éléments de texture avec lesquels il a été installé.

suffixStripping.defaultSuffix précise le suffixe de répertoire par défaut, tandis que bundletool génère un APK autonome pour les appareils équipés d'Android version 5.0 ou antérieure (niveau d'API 21). Dans l'exemple de tableau précédent, la version par défaut des éléments de texture est installée sur ces appareils, ce qui est voulu dans la plupart des cas.

Créer l'app bundle :

bundletool build-bundle --config=BUILD_CONFIG.json \
  --modules=level1.zip,level2.zip,common.zip,base.zip --output=MY_BUNDLE.aab

Vérifier le contenu de l'app bundle

Si ce n'est pas déjà fait, télécharger bundletool à partir du dépôt GitHub.

Vérifiez le contenu de l'app bundle qui en résulte en créant des APK et en les examinant :

bundletool build-apks --output=APKS.apks --bundle=MY_BUNDLE.aab
zipinfo APKS.apks

Le résultat doit se présenter comme suit :

toc.pb
splits/base-master.apk
splits/base-armeabi_v7a.apk
splits/…
asset-slices/level1-astc.apk
asset-slices/level1-other_tcf.apk
asset-slices/level1-pvrtc.apk

Ces noms indiquent que le ciblage TCF est correctement appliqué. Si vous extrayez le contenu d'un APK de niveau (par exemple, asset-slices/level1-astc.apk), vous pouvez vérifier qu'il n'y a qu'un seul répertoire nommé textures.

Tester l'app bundle

Connectez un appareil et installez les packs d'éléments adéquats :

bundletool install-apks --apks=APKS.apks

Cette commande n'installe que les packs d'éléments qui répondent aux spécifications de l'appareil. Ces caractéristiques incluent l'ABI, la densité de l'écran, la langue et le format de compression de texture le plus adéquat. Cette opération simule le fonctionnement du Google Play Store pour le jeu que vous avez publié.

Pour vérifier que les bons packs d'éléments ont été installés, effectuez l'une des opérations suivantes :

Utilisez la commande bundletool extract-apks pour générer les APK installés pour votre appareil dans un répertoire, puis examinez ce répertoire.
1. Extrayez les caractéristiques de votre appareil :
```
bundletool get-device-spec --output=MY_DEVICE_SPEC.json
```
2. Exécutez bundletool extract-apks avec la caractéristique d'appareil suivante :
```
bundletool extract-apks --apks=APKS.apks --device-spec=MY_DEVICE_SPEC.json \
    --output-dir out
```
3. Répertoriez les fichiers dans le répertoire out et vérifiez que les packs d'éléments adéquats sont installés. Les noms des packs d'éléments sont suivis du nom du format de texture (par exemple, level1-astc.apk).
Ajoutez à votre jeu des instructions de journalisation qui génèrent le format de texture au moment de charger une texture.
Générez un ensemble de textures test (par exemple, remplacez une texture par une seule couleur vive pour un format donné). Exécutez le jeu et vérifiez que l'opération a fonctionné.

Si votre application contient des packs d'éléments on-demand ou fast-follow, utilisez la solution de test locale pour Asset Delivery.

Suffixes compatibles avec les noms de répertoire de texture

Google Play comprend les suffixes suivants utilisés dans les noms de répertoire des textures :

#tcf_astc pour la compression de textures Adaptive Scalable Texture Compression (ASTC)
#tcf_atc pour la compression de texture ATI Texture Compression (ATC)
#tcf_dxt1 pour la compression de texture S3 DXT1 Texture Compression (DXT1)
#tcf_latc pour la compression de texture Luminance-Alpha Texture Compression (LATC)
#tcf_paletted pour la compression de textures génériques à palettes
#tcf_pvrtc pour la compression de texture PowerVR Texture Compression (PVRTC)
#tcf_etc1 pour la compression de texture Ericsson Texture Compression (ETC1)
#tcf_etc2 pour la compression de texture Ericsson Texture Compression 2 (ETC2)
#tcf_s3tc pour la compression de texture S3 Texture Compression (S3TC)
#tcf_3dc pour la compression de texture ATI 3Dc Texture Compression (3Dc)

Règles de diffusion Google Play

Google Play inspecte les chaînes d'extension OpenGL utilisées par l'appareil et la version d'OpenGL compatible avec celui-ci. Google Play utilise ces informations pour déterminer le format de texture adapté à l'appareil à partir de l'Android App Bundle.

Google Play fournit le premier format compatible avec l'appareil, selon l'ordre indiqué dans le tableau suivant.

Si aucun des formats de texture de l'app bundle n'est compatible avec l'appareil, Google Play diffuse les formats de texture organisés en packages dans le format par défaut. (À moins de cibler du matériel spécifique, ETC1 ou ETC2 constituent un bon choix pour un format par défaut.) Pour savoir comment organiser des éléments en packages au format par défaut, consultez les sections Utiliser bundletool ou Utiliser le plug-in Unity Google Play.

Si les éléments n'ont pas été organisés en packages dans un format par défaut, Google Play indique que l'application n'est pas disponible pour l'appareil. Dans ce cas, les utilisateurs ne peuvent pas télécharger l'application.

Format (indiqué dans `tcf_xxxx`)	Compatible avec les appareils avec une chaîne d'extension OpenGL
astc	`GL_KHR_texture_compression_astc_ldr`
pvrtc	`GL_IMG_texture_compression_pvrtc`
s3tc	`GL_EXT_texture_compression_s3tc`
dxt1	`GL_EXT_texture_compression_dxt1`
latc	`GL_EXT_texture_compression_latc`
atc	`GL_AMD_compressed_ATC_texture`
3dc	`GL_AMD_compressed_3DC_texture`
etc2	Non applicable. L'appareil doit être compatible avec OpenGL ES version 3.0 ou ultérieure.
etc1	`GL_OES_compressed_ETC1_RGB8_texture`
en palettes	`GL_OES_compressed_paletted_texture`