Targeting dei formati di compressione delle texture in Android App Bundle

Le trame sono immagini che possono essere applicate alla superficie di un modello 3D. Le texture vengono utilizzate anche dai renderer 2D per disegnare elementi come sprite o sfondi. Questa pagina descrive i formati di compressione delle texture più diffusi utilizzati nei giochi e come sceglierli come target negli Android App Bundle. Leggi gli articoli Informazioni sugli Android App Bundle e Play Asset Delivery prima di iniziare questa guida.

Premessa

In genere le GPU supportano un set di formati di compressione delle texture. Il formato di compressione delle texture (o TCF) è un formato file ottimizzato per le GPU. La GPU carica ed esegue il rendering di una texture più velocemente e con meno memoria rispetto a quando utilizza un array di valori RGBA in memoria. Questo supporto avviene a livello di hardware: il produttore della GPU incorpora nel chip delle schede grafiche componenti che leggono, decomprimono e mostrano i formati supportati.

Di seguito sono riportati i formati di compressione delle texture più comuni sull'hardware mobile moderno:

  • ASTC: formato recente progettato per sostituire i formati precedenti. Più flessibile rispetto ai precedenti formati grazie al supporto di varie dimensioni dei blocchi. Usare questo formato è un buon modo per ottimizzare le dimensioni del gioco.
  • ETC2: supportato da tutti i dispositivi che supportano OpenGL ES 3.0 e versioni successive. inclusi quasi tutti i dispositivi mobili Android attivi.

Questi formati sono supportati dalle seguenti percentuali approssimative di dispositivi Android:

Formato di compressione delle texture Percentuale di dispositivi Google Play con assistenza
ASTC >80%
ETC2 >95%

Le GPU per computer desktop con Google Play Giochi per PC supportano anche questo formato:

  • DDS o S3TC: a volte chiamati BCn, DXTC o DXTn.

I formati di compressione delle texture meno recenti e non più consigliati includono:

  • ETC1: supportato sulla maggior parte dei dispositivi. Questo formato non supporta la trasparenza, ma i giochi possono usare un secondo file di texture per il componente alpha.
  • PVRTC: popolare con i giochi iOS e supportato anche su alcuni dispositivi Android.

Il supporto ETC1 è un requisito solo per i giochi che supportano dispositivi legacy molto vecchi o per alcuni dispositivi Android TV che non supportano OpenGL ES 3.0 e versioni successive.

Un formato predefinito

Con così tanti formati disponibili (con diversi livelli di supporto per i dispositivi), potresti non sapere quali formati utilizzare per la creazione delle texture del tuo gioco. Come salvaguardia, il formato dell'app bundle consente di selezionare un formato di compressione delle texture predefinito per ogni pacchetto di asset. Se un dispositivo non supporta gli altri formati specificati, vengono installati gli asset che utilizzano questo formato predefinito.

A meno che tu non abbia come target l'hardware dei dispositivi molto vecchio, ETC2 è un'ottima scelta per il formato predefinito. Dovresti utilizzare i formati ETC2 che sono garantiti supportati in OpenGL ES 3.0. Questi formati sono disponibili anche nell'API grafica Vulkan.

Il formato ASTC definisce una varietà di dimensioni dei blocchi di compressione, che ti consentono di comprare in modo selettivo una qualità ridotta delle immagini con una maggiore compressione. A seconda della natura del materiale artistico di origine, per una data texture puoi scegliere un blocco di dimensioni inferiori o superiori per mantenere una qualità visiva accettabile.

Se il tuo gioco supporta Google Play Giochi per PC e utilizza Vulkan, dovresti includere le texture S3TC. I formati S3TC sono supportati da tutte le GPU desktop.

Creare un app bundle

Google Play utilizza Android App Bundle per generare e pubblicare APK ottimizzati per la configurazione del dispositivo di ogni utente, in modo che gli utenti scarichino solo il codice e le risorse di cui hanno bisogno per eseguire il gioco. Questi APK ottimizzati includono un singolo insieme di asset texture, formattati con il formato di compressione ottimale per il dispositivo.

Se il tuo gioco non è disponibile su Unity, utilizza Gradle per creare un app bundle. Gli utenti esperti possono decidere di utilizzare bundletool.

Se il tuo gioco è su Unity, il supporto per gli app bundle con Play Asset Delivery è disponibile in Unity 2021.3 e versioni successive. Per ulteriori informazioni, consulta la documentazione di Unity. Puoi utilizzare un plug-in Unity per creare un app bundle con versioni precedenti di Unity.

Utilizzo di Gradle

  1. Aggiorna la versione del plug-in Android per Gradle nel file build.gradle del tuo progetto alla versione 4.1 o successiva (ad esempio, com.android.tools.build:gradle:4.1.0).

  2. Stabilisci l'insieme di tipi di dispositivi che vuoi scegliere come target per il tuo gioco e i formati di compressione delle texture supportati (per ulteriori informazioni sui formati, consulta la sezione Informazioni preliminari).

  3. Crea versioni degli asset per ogni formato di compressione delle texture dal passaggio precedente. Ciò potrebbe comportare la generazione di fogli sprite utilizzando software come TexturePacker o l'esecuzione di uno script che converte gli asset non elaborati in asset con un formato specifico (ad esempio, astc-encoder).

  4. Crea pacchetti di asset (consulta la pagina relativa a Build per C++ o Java), che contengono le tue risorse di gioco e vengono utilizzati da Play Asset Delivery. Ad esempio, puoi creare un pacchetto di asset per livello o pacchetti per diverse parti del gioco.

  5. All'interno dei pacchetti di asset, aggiungi le directory per ogni formato di compressione delle texture che vuoi supportare. Aggiungi suffissi supportati ai nomi delle directory delle texture che corrispondono al formato di compressione delle texture utilizzato per i file contenuti.

    Crea una directory senza suffisso nel nome (ad esempio common/src/main/assets/textures/). In questa directory, inserisci il formato predefinito degli asset trama. Questo formato predefinito dovrebbe essere supportato dalla maggior parte dei dispositivi (ad esempio ETC1 o ETC2). Se un dispositivo non supporta gli altri formati specificati (ad esempio, PVRTC e ASTC nella tabella riportata di seguito), il Google Play Store installa questa directory.

    Directory prima del giorno Directory dopo il giorno
    common Pacchetto di asset:
    common/build.gradle
    common/src/main/assets/textures/...
    common Pacchetto di asset:
    common/build.gradle
    common/src/main/assets/textures/...
    common/src/main/assets/textures#tcf_astc/...
    common/src/main/assets/textures#tcf_pvrtc/...
    level1 asset pack:
    level1/build.gradle
    level1/src/main/assets/textures/...
    level1 asset pack:
    level1/build.gradle
    level1/src/main/assets/textures/...
    level1/src/main/assets/textures#tcf_astc/...
    level1/src/main/assets/textures#tcf_pvrtc/...
    level2 asset pack:
    level2/build.gradle
    level2/src/main/assets/textures/...
    level2 asset pack:
    level2/build.gradle
    level2/src/main/assets/textures/...
    level2/src/main/assets/textures#tcf_astc/...
    level2/src/main/assets/textures#tcf_pvrtc/...
  6. Aggiorna il file build.gradle dell'app per abilitare la suddivisione dei pacchetti di asset per texture.

    // In the app build.gradle file:
    android {
        ...
        bundle {
            texture {
                enableSplit true
            }
        }
    }
    
  7. In Android Studio, seleziona Crea > Genera bundle / APK firmato oppure avvia l'attività Gradle dalla riga di comando per generare il bundle.

Utilizzare il plug-in Unity di Google Play

Scarica il plug-in (o il pacchetto) Unity per Play Asset Delivery per creare un app bundle con pacchetti di asset con targeting per texture.

Prepara gli asset

Per preparare gli asset di texture per la creazione di un app bundle:

  1. Raggruppa la scena e gli asset in più AssetBundle Unity.

  2. Stabilisci l'insieme di tipi di dispositivi che vuoi scegliere come target per il tuo gioco e i formati di compressione delle texture supportati (per ulteriori informazioni sui formati, consulta la sezione Informazioni preliminari).

  3. Modifica lo script di build del tuo gioco per generare gli AssetBundle più volte, una volta per ogni formato di texture da supportare. Vedi il seguente script di esempio:

    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.
       }
    }
    
  4. Verifica che ogni asset di texture venga generato in una directory contenente il suffisso corretto nel nome (ad esempio #tcf_astc).

    Verifica che venga eseguito l'output di una directory senza suffisso nel nome (ad esempio Assets/AssetBundles/). Questa directory contiene il formato predefinito degli asset di texture. Questo formato predefinito dovrebbe essere supportato dalla maggior parte dei dispositivi (ad esempio, ETC2). Se un dispositivo non supporta gli altri formati specificati (ad esempio ASTC nel codice del passaggio precedente), Google Play Store installa questa directory.

    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
    
  5. Seleziona Google > Android > Pubblicazione degli asset.

  6. Fai clic su Aggiungi cartella per aggiungere la cartella contenente i gruppi di asset predefiniti. Questi pacchetti sono installati su dispositivi che non supportano gli altri formati che definisci.

    Assicurati di impostare la Modalità di invio per AssetBundle.

    Formato predefinito di pubblicazione di Unity AssetBundle

  7. Fai clic su Aggiungi cartella per aggiungere una cartella contenente AssetBundles creati per un altro formato (ad esempio, ASTC). Ripeti secondo l'occorrenza.

    Assicurati di impostare la Modalità di invio per ogni AssetBundle.

    Formato ASTC di pubblicazione Unity AssetBundle

Crea

Seleziona Google > Build Android App Bundle per lanciare la build Unity del tuo gioco. Raggruppa inoltre gli AssetBundles in più pacchetti di asset, dove ogni nome AssetBundle viene convertito in un unico pacchetto di asset.

(Avanzato) Utilizzare bundletool

Per maggiori informazioni su bundletool, consulta Creare un app bundle utilizzando bundletool.

Per creare l'app bundle:

  1. Scarica bundletool dal suo repository GitHub.

  2. Stabilisci l'insieme di tipi di dispositivi che vuoi scegliere come target per il tuo gioco e i formati di compressione delle texture supportati (per ulteriori informazioni sui formati, consulta la sezione Informazioni preliminari).

  3. Crea versioni degli asset per ogni formato di compressione delle texture dal passaggio precedente. Ciò potrebbe comportare la generazione di fogli sprite utilizzando software come TexturePacker o l'esecuzione di uno script che converte gli asset non elaborati in asset con un formato specifico (ad esempio, astc-encoder).

  4. Crea pacchetti di asset (consulta la pagina relativa a Build per C++ o Java), che contengono le tue risorse di gioco e vengono utilizzati da Play Asset Delivery. Ad esempio, puoi creare un pacchetto di asset per livello o pacchetti per diverse parti del gioco.

  5. Nei diversi pacchetti di asset, aggiungi suffissi supportati ai nomi delle directory delle texture che corrispondono al formato di compressione delle texture utilizzato per i file contenuti.

    Crea una directory senza suffisso nel nome (ad esempio common/src/main/assets/textures/). In questa directory, inserisci il formato predefinito degli asset trama. Questo formato predefinito dovrebbe essere supportato dalla maggior parte dei dispositivi (ad esempio ETC1 o ETC2). Se un dispositivo non supporta gli altri formati specificati (ad esempio, PVRTC e ASTC nella tabella riportata di seguito), il Google Play Store installa questa directory.

    Directory prima del giorno Directory dopo il giorno
    common Pacchetto di asset:
    common/build.gradle
    common/src/main/assets/textures/...
    common Pacchetto di asset:
    common/build.gradle
    common/src/main/assets/textures/...
    common/src/main/assets/textures#tcf_astc/...
    common/src/main/assets/textures#tcf_pvrtc/...
    level1 asset pack:
    level1/build.gradle
    level1/src/main/assets/textures/...
    level1 asset pack:
    level1/build.gradle
    level1/src/main/assets/textures/...
    level1/src/main/assets/textures#tcf_astc/...
    level1/src/main/assets/textures#tcf_pvrtc/...
    level2 asset pack:
    level2/build.gradle
    level2/src/main/assets/textures/...
    level2 asset pack:
    level2/build.gradle
    level2/src/main/assets/textures/...
    level2/src/main/assets/textures#tcf_astc/...
    level2/src/main/assets/textures#tcf_pvrtc/...
  6. Aggiungi la dimensione TCF al file di metadati dell'app bundle (BundleConfig.json). Utilizza TEXTURE_COMPRESSION_FORMAT per il campo value:

    {
      ...
      "optimizations": {
        "splitsConfig": {
          "splitDimension": [
          ...
          {
             "value": "TEXTURE_COMPRESSION_FORMAT",
             "negate": false,
             "suffixStripping": {
               "enabled": true,
               "defaultSuffix": ""
              }
          }],
        }
      }
    }
    

    Imposta suffixStripping.enabled su true per rimuovere il suffisso (ad esempio #tcf_astc) dai nomi delle directory durante la generazione dei pacchetti di asset. In questo modo il gioco può leggere i file da un nome di directory molto noto (ad esempio level1/assets/textures). Alcuni motori di gioco sono in grado di rilevare il formato di un file, pertanto il gioco potrebbe non essere diverso dal formato degli asset texture con cui è stato installato.

    suffixStripping.defaultSuffix specifica il suffisso della directory predefinito quando bundletool genera un APK autonomo per i dispositivi con Android 5.0 (livello API 21) e versioni precedenti. Nella tabella di esempio precedente, la versione predefinita degli asset di texture è installata su questi dispositivi; questo è il comportamento previsto nella maggior parte dei casi.

  7. Crea l'app bundle:

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

Verificare i contenuti dell'app bundle

Se non l'hai ancora fatto, scarica bundletool dal repository GitHub.

Verifica i contenuti dell'app bundle di output creando APK a partire da quest'ultimo e ispezionandoli:

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

L'output dovrebbe essere simile al seguente:

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

Questi nomi indicano che il targeting TCF viene applicato correttamente. Se estrai i contenuti di un APK di livello (ad esempio asset-slices/level1-astc.apk), puoi verificare che sia presente una sola directory denominata textures.

Testare l'app bundle

Collega un dispositivo e installa i pacchetti di asset applicabili:

bundletool install-apks --apks=APKS.apks

Questo comando installa solo i pacchetti di asset che soddisfano le specifiche del dispositivo. Queste specifiche includono ABI, densità dello schermo, linguaggio e il formato di compressione delle texture più applicabile. Questa operazione simula le azioni eseguite dal Google Play Store per il gioco pubblicato.

Per verificare che siano stati installati i pacchetti di asset corretti, procedi in uno dei seguenti modi:

  • Utilizza il comando bundletool extract-apks per restituire gli apk installati per il dispositivo in una directory, quindi controlla questa directory.

    1. Estrai la specifica del dispositivo:

      bundletool get-device-spec --output=MY_DEVICE_SPEC.json
      
    2. Esegui bundletool extract-apks con questa specifica del dispositivo:

      bundletool extract-apks --apks=APKS.apks --device-spec=MY_DEVICE_SPEC.json \
          --output-dir out
      
    3. Elenca i file nella directory out e verifica che siano installati i pacchetti di asset corretti. I nomi dei pacchetti di asset sono preceduti dal nome del formato di texture (ad esempio, level1-astc.apk).

  • Aggiungi nel gioco istruzioni di log che restituiscano il formato delle texture durante il caricamento di una texture.

  • Genera un set di test di texture (ad esempio, sostituisci una texture con un singolo colore brillante per un determinato formato). Esegui il gioco e verifica che sia presente.

Se la tua app contiene pacchetti di asset on-demand o fast-follow, usa la soluzione di test locale per il caricamento degli asset.

Suffissi supportati per i nomi delle directory delle texture

Google Play riconosce i seguenti suffissi utilizzati nei nomi delle directory delle texture:

  • #tcf_astc per Adaptive Scalable Texture Compression (ASTC)
  • #tcf_atc per la compressione delle texture ATI (ATC)
  • #tcf_dxt1 per la compressione delle texture S3 DXT1 (DXT1)
  • #tcf_latc per la compressione delle texture Luminance-Alpha (LATC)
  • #tcf_paletted per la compressione generica di texture con tavolozza
  • #tcf_pvrtc per la compressione delle texture PowerVR (PVRTC)
  • #tcf_etc1 per la compressione delle texture Ericsson (ETC1)
  • #tcf_etc2 per la compressione delle texture Ericsson 2 (ETC2)
  • #tcf_s3tc per la compressione delle texture S3 (S3TC)
  • #tcf_3dc per la compressione delle texture ATI 3Dc (3Dc)

Regole di pubblicazione di Google Play

Google Play controlla le stringhe dell'estensione OpenGL utilizzate dal dispositivo e la versione OpenGL supportata dal dispositivo. Google Play utilizza queste informazioni per determinare il formato di texture corretto da inviare al dispositivo dall'Android App Bundle.

Google Play pubblica il primo formato supportato dal dispositivo nell'ordine indicato nella tabella seguente.

Se nessuno dei formati di texture nell'App Bundle è supportato dal dispositivo, Google Play offre i formati di texture pacchettizzati nel formato predefinito. A meno che tu non abbia scelto come target un hardware specifico, ETC1 o ETC2 sono ottime opzioni per il formato predefinito. Per informazioni su come pacchettizzare gli asset nel formato predefinito, consulta Utilizzare bundletool o Utilizzare il plug-in Unity di Google Play.

Se gli asset non sono stati pacchettizzati in un formato predefinito, Google Play contrassegna l'app come non disponibile per il dispositivo. In questo caso, gli utenti non possono scaricare l'app.

Formato (indicato in tcf_xxxx) Supportata sui dispositivi con stringa di estensione OpenGL
astc GL_KHR_texture_compression_astc_ldr
PVR GL_IMG_texture_compression_pvrtc
S3TC GL_EXT_texture_compression_s3tc
DXT1 GL_EXT_texture_compression_dxt1
latc GL_EXT_texture_compression_latc
ACT GL_AMD_compressed_ATC_texture
3dc GL_AMD_compressed_3DC_texture
ecc2 Non applicabile. Il dispositivo deve supportare OpenGL ES versione 3.0 o successive.
ecc1 GL_OES_compressed_ETC1_RGB8_texture
con tavolozza GL_OES_compressed_paletted_texture