Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Targeting dei formati di compressione delle texture in Android App Bundle

Le texture 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. In questa pagina vengono descritti i formati di compressione delle texture più diffusi utilizzati nei giochi e come utilizzarli come target negli Android App Bundle. Leggi Informazioni su Android App Bundle e Play Asset Delivery prima di iniziare questa guida.

Sfondo

In genere, le GPU supportano un insieme di formati di compressione delle texture. Un 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 viene fornito a livello hardware: il produttore della GPU incorpora nel chip della scheda grafica componenti che leggono, decomprimono ed eseguono il rendering dei 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 dei formati precedenti grazie al supporto di varie dimensioni dei blocchi. L'utilizzo di 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. Sono 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%

Anche le GPU dei computer desktop che eseguono Google Play Games su PC supportano questo formato:

DDS o S3TC: a volte chiamato 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 utilizzare un secondo file di texture per il componente alfa.
PVRTC: molto diffuso nei giochi per iOS e supportato anche su alcuni dispositivi Android.

Il supporto di ETC1 è un requisito solo per i giochi che supportano dispositivi legacy molto vecchi o determinati 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 dei dispositivi), potresti non sapere quali formati utilizzare durante la creazione delle texture del gioco. Come misura di sicurezza, il formato app bundle ti 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 scelga come target hardware di dispositivi molto vecchi, ETC2 è una buona scelta come formato predefinito. Utilizza i formati ETC2 supportati in OpenGL ES 3.0. Questi formati sono disponibili anche nell'API Vulkan Graphics.

Formati consigliati

Il formato ASTC definisce una serie di dimensioni dei blocchi di compressione, che ti consentono di scegliere se ridurre la qualità dell'immagine per ottenere una compressione maggiore. A seconda della natura del materiale grafico di origine, per una determinata texture puoi scegliere una dimensione del blocco più piccola o più grande per mantenere una qualità visiva accettabile.

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

Crea un app bundle

Google Play utilizza gli 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 necessari per eseguire il gioco. Questi APK ottimizzati includono un singolo set di asset di texture, formattati con il formato di compressione ottimale per il dispositivo.

Se il tuo gioco non è in Unity, utilizza Gradle per creare un app bundle. Gli utenti avanzati potrebbero voler utilizzare bundletool.

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

Utilizza Gradle

Aggiorna la versione del plug-in Android per Gradle nel file build.gradle del progetto alla versione 4.1 o successiva (ad esempio, com.android.tools.build:gradle:4.1.0).
Determina l'insieme di tipi di dispositivi che vuoi scegliere come target per il tuo gioco e i formati di compressione delle texture che supportano (per ulteriori informazioni sui formati, consulta la sezione Informazioni generali).
Crea versioni degli asset per ogni formato di compressione delle texture del passaggio precedente. Ciò potrebbe comportare la generazione di Sprite Sheet 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).
Crea pacchetti di asset (consulta Crea per C++ o Java), che contengono gli asset di gioco e vengono utilizzati da Play Asset Delivery. Ad esempio, puoi creare un pacchetto di asset per livello o pacchetti di asset per diverse parti del gioco.

Nota: non è necessario utilizzare le API Play Asset Delivery all'interno del gioco se selezioni il tipo di distribuzione install-time per i pacchetti di asset. Questi pacchetti di asset vengono installati contemporaneamente all'APK dell'applicazione principale.

All'interno dei pacchetti di asset, aggiungi directory per ogni formato di compressione delle texture che vuoi supportare. Aggiungi i 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 texture. 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 seguente), il Google Play Store installa questa directory.

Directory prima	Directory dopo
`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` pacchetto di asset: level1/build.gradle level1/src/main/assets/textures/…	`level1` pacchetto di asset: level1/build.gradle level1/src/main/assets/textures/… level1/src/main/assets/textures#tcf_astc/… level1/src/main/assets/textures#tcf_pvrtc/…
`level2` pacchetto di asset: level2/build.gradle level2/src/main/assets/textures/…	`level2` pacchetto di asset: level2/build.gradle level2/src/main/assets/textures/… level2/src/main/assets/textures#tcf_astc/… level2/src/main/assets/textures#tcf_pvrtc/…

Aggiorna il file build.gradle della tua app per attivare la suddivisione dei pacchetti di asset in base alle texture.

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

In Android Studio, seleziona Build > Generate Signed Bundle / APK (Crea > Genera bundle/APK firmato) o avvia l'attività Gradle dalla riga di comando per generare il bundle.

Nota: quando gli APK (da installare su un dispositivo) vengono generati dall'app bundle, i suffissi (ad esempio #tcf_xxx) vengono rimossi dai nomi delle directory. Il gioco deve solo leggere i file da un nome di directory noto (ad esempio, level1/assets/textures). Alcuni motori grafici possono rilevare il formato di un file, quindi il gioco può essere indifferente al formato degli asset di gioco installati.

Utilizza il plug-in Google Play Unity

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

Prepara gli asset

Per preparare gli asset di texture per la creazione di un app bundle, segui questi passaggi:

Pacchettizza la scena e gli asset in più AssetBundle Unity.

Nota: sebbene AssetBundle Manager sia deprecato per le versioni di Unity 2018.2 e successive, gli AssetBundle sono ancora supportati.
Determina l'insieme di tipi di dispositivi che vuoi scegliere come target per il tuo gioco e i formati di compressione delle texture che supportano (per ulteriori informazioni sui formati, consulta la sezione Informazioni generali).

Modifica lo script di build del gioco per generare gli AssetBundle più volte, una per ogni formato di texture che vuoi supportare. Ecco uno 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.
   }
}

Verifica che ogni asset texture venga generato in una directory con il suffisso corretto nel nome (ad esempio, #tcf_astc).

Verifica che venga generata una directory senza suffisso nel nome (ad esempio, Assets/AssetBundles/). Questa directory contiene il formato predefinito degli asset 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), il 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

Seleziona Google > Android > Assets Delivery.
Fai clic su Aggiungi cartella per aggiungere la cartella contenente i bundle di asset predefiniti. Questi bundle vengono installati sui dispositivi che non supportano gli altri formati definiti.

Assicurati di impostare la modalità di pubblicazione per l'AssetBundle.
Fai clic su Aggiungi cartella per aggiungere una cartella contenente AssetBundle creati per un altro formato (ad esempio ASTC). Ripeti secondo l'occorrenza.

Assicurati di impostare la modalità di pubblicazione per ogni AssetBundle.

Build

Seleziona Google > Build Android App Bundle per avviare la build Unity del tuo gioco. Inoltre, pacchettizza gli AssetBundle in più pacchetti di asset, in cui ogni nome di AssetBundle viene convertito in un singolo pacchetto di asset.

(Avanzato) Utilizza bundletool

Per saperne di più su bundletool, consulta Crea un app bundle utilizzando bundletool.

Per creare l'app bundle:

Scarica bundletool dal relativo repository GitHub.
Determina l'insieme di tipi di dispositivi che vuoi scegliere come target per il tuo gioco e i formati di compressione delle texture che supportano (per ulteriori informazioni sui formati, consulta la sezione Informazioni generali).
Crea versioni degli asset per ogni formato di compressione delle texture del passaggio precedente. Ciò potrebbe comportare la generazione di Sprite Sheet 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).
Crea pacchetti di asset (consulta Crea per C++ o Java), che contengono gli asset di gioco e vengono utilizzati da Play Asset Delivery. Ad esempio, puoi creare un pacchetto di asset per livello o pacchetti di asset per diverse parti del gioco.

Nota: non è necessario utilizzare le API Play Asset Delivery all'interno del gioco se selezioni il tipo di distribuzione install-time per i pacchetti di asset. Questi pacchetti di asset vengono installati contemporaneamente all'APK dell'applicazione principale.

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

Directory prima	Directory dopo
`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` pacchetto di asset: level1/build.gradle level1/src/main/assets/textures/…	`level1` pacchetto di asset: level1/build.gradle level1/src/main/assets/textures/… level1/src/main/assets/textures#tcf_astc/… level1/src/main/assets/textures#tcf_pvrtc/…
`level2` pacchetto di asset: level2/build.gradle level2/src/main/assets/textures/…	`level2` pacchetto di asset: level2/build.gradle level2/src/main/assets/textures/… level2/src/main/assets/textures#tcf_astc/… level2/src/main/assets/textures#tcf_pvrtc/…

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 noto (ad esempio level1/assets/textures). Alcuni motori grafici possono rilevare il formato di un file, quindi il gioco può essere indifferente al formato degli asset di texture con cui è stato installato.

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

Crea l'app bundle:

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

Verifica i contenuti dell'app bundle

Se non lo hai già fatto, scarica bundletool dal repository GitHub.

Verifica i contenuti dell'app bundle di output creando APK da quest'ultimo ed esaminandoli:

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 è stato 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.

Testa 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, lingua e il formato di compressione delle texture più applicabile. Questa operazione simula ciò che viene fatto dal Google Play Store per il tuo gioco pubblicato.

Per verificare che siano stati installati i pacchetti di asset corretti, esegui una delle seguenti operazioni:

Utilizza il comando bundletool extract-apks per generare gli APK installati per il tuo dispositivo in una directory, quindi ispeziona questa directory.
1. Estrai le specifiche del tuo 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 seguiti dal nome del formato della texture (ad esempio, level1-astc.apk).
Aggiungi istruzioni di log nel gioco che mostrano il formato della texture durante il caricamento di una texture.
Genera un set di texture di prova (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, utilizza la soluzione di test locale per l'asset delivery.

Suffissi supportati per i nomi delle directory delle texture

Google Play comprende 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 delle texture con tavolozza
#tcf_pvrtc per la compressione delle texture PowerVR (PVRTC)
#tcf_etc1 per Ericsson Texture Compression (ETC1)
#tcf_etc2 per Ericsson Texture Compression 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 esamina le stringhe di 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 fornisce il primo formato, nell'ordine elencato nella tabella seguente, supportato dal dispositivo.

Se nessuno dei formati di texture nell'app bundle è supportato dal dispositivo, Google Play fornisce i formati di texture pacchettizzati nel formato predefinito. (A meno che tu non scelga come target un hardware specifico per i dispositivi, ETC1 o ETC2 sono buone scelte per un formato predefinito). Per informazioni su come pacchettizzare gli asset nel formato predefinito, consulta Utilizza bundletool o Utilizza 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`)	Supportato su dispositivi con stringa di estensione 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 applicabile. Il dispositivo deve supportare la versione OpenGL ES 3.0 o successive.
etc1	`GL_OES_compressed_ETC1_RGB8_texture`
paletted	`GL_OES_compressed_paletted_texture`