Questa pagina è stata tradotta dall'API Cloud Translation.

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. Texture vengono utilizzati anche dai renderer 2D per disegnare elementi come sprite o sfondi. Questa pagina descrive i formati di compressione delle texture più diffusi nei giochi e come sceglierli come target in Android App Bundle. Letto Informazioni su Android App Bundle e Play Asset Delivery prima di iniziare guida.

Premessa

Le GPU in genere supportano un insieme di formati di compressione delle texture. R Il formato di compressione delle texture (o TCF) è un formato file ottimizzato per le GPU. La GPU si carica e esegue il rendering di una texture più rapidamente e con meno memoria, rispetto a quando utilizzavano un array di valori RGBA in memoria. L'assistenza viene fornita Livello hardware: il produttore della GPU incorpora componenti nelle schede grafiche in grado di leggere, decomprimere e visualizzare 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 quelli precedenti. Più flessibile rispetto a formati precedenti grazie al supporto di blocchi di varie dimensioni. Utilizzo di questo formato è un buon metodo per ottimizzare le dimensioni del tuo 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 Android dispositivi:

Formato di compressione della trama	Percentuale di dispositivi Google Play che supportano
ASTC	>80%
ETC2	Più del 95%

Le GPU per computer desktop con Google Play Giochi per PC supportano anche 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, mentre per i giochi è possibile utilizzare un secondo file di texture per il componente alfa.
PVRTC: popolare tra i giochi per iOS e anche supportato su alcuni dispositivi Android.

Il supporto di ETC1 è un requisito solo per i giochi che supportano un'esperienza precedente o alcuni dispositivi Android TV che non supportano OpenGL ES 3.0 e in alto.

Un formato predefinito

Con così tanti formati disponibili (con vari livelli di supporto per i dispositivi), potrebbero non sapere quali formati utilizzare per creare le texture di gioco. Come , il formato app bundle ti consente di selezionare una compressione delle texture predefinita per ogni pacchetto di asset. Se un dispositivo non supporta l'altro vengono installati gli asset che usano questo formato predefinito.

A meno che tu non abbia come target un hardware molto vecchio, ETC2 è una buona scelta per un formato predefinito. Devi usare i formati ETC2 che garantiscono supportata in OpenGL ES 3.0. Questi formati sono disponibili anche nell'API grafica Vulkan.

Formati consigliati

Il formato ASTC definisce varie dimensioni di blocchi di compressione, che consentono di scambiare selettivamente la qualità delle immagini con una maggiore compressione. A seconda della natura del materiale artistico di origine, per una determinata texture puoi scegli una dimensione del blocco più piccola o più grande per mantenere una qualità visiva accettabile.

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

Creare un app bundle

Google Play utilizza Android App Bundle per generare e pubblicare APK ottimizzati per configurazione del dispositivo di ciascun utente, quindi gli utenti scaricano solo il codice e le risorse di cui hanno bisogno per eseguire il tuo gioco. Questi APK ottimizzati includono un unico set di texture gli asset, 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, supporta gli app bundle con Play Asset Delivery è disponibile in Unity 2021.3 e versioni successive. Per ulteriori informazioni, consulta Documentazione Unity. Puoi usare un plug-in Unity per creare un app bundle con di Unity.

Utilizzare Gradle

Aggiorna la versione del plug-in Android per Gradle nel pannello build.gradle alla versione 4.1 o successive (ad esempio, com.android.tools.build:gradle:4.1.0).
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 formati, consulta la sezione Sfondo).
Crea versioni degli asset per ogni formato di compressione delle texture dal passaggio precedente. Può comportare la generazione di fogli sprite tramite software Mi piace TexturePacker oppure eseguendo uno script che converte gli asset non elaborati in quelli con un formato specifico (ad esempio, encoder astc).
Crea pacchetti di asset (vedi Build per C++ o Java), che contengono le tue risorse di gioco e che vengono utilizzate da Play Asset Delivery. Per 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 seleziona il tipo di pubblicazione install-time per i pacchetti di asset. Questi asset i pacchetti 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 i nomi delle directory delle texture che corrispondono alla compressione della 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 valore predefinito degli asset di texture. Questo formato predefinito dovrebbe essere supportato la maggior parte dei dispositivi (ad esempio, ETC1 o ETC2). Se un dispositivo non supporta altri formati specificati (ad esempio, PVRTC e ASTC nella tabella seguente), Google Play Store installa invece questa directory.

Directory prima del giorno	Directory dopo il giorno
`common` pacchetto di asset: comune/build.gradle comune/src/main/assets/textures/...	`common` pacchetto di asset: comune/build.gradle comune/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 dell'app per abilitare la suddivisione del pacchetti di asset per texture.

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

In Android Studio, seleziona Crea > Generare bundle / APK firmato oppure avvia il Classifica l'attività dalla riga di comando a generare il bundle.

Nota :quando gli APK (da installare su un dispositivo) vengono generati dall'app. bundle, i suffissi (ad es. #tcf_xxx) vengono rimossi dai nomi delle directory. Il tuo gioco deve solo leggere file da un nome di directory noto (ad esempio, level1/assets/textures). Alcuni motori di gioco sono in grado di rilevare il formato quindi il tuo gioco può essere indifferente dal formato delle risorse del gioco installato.

Utilizza il plug-in Unity di Google Play

Scarica il plug-in (o 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:

Pacchettizza la tua scena e le tue risorse in più unità Unity AssetBundle.

Nota: anche se AssetBundle Manager è deprecato per le versioni Unity 2018.2 e successivi, gli AssetBundle sono ancora supportati.
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 formati, consulta la sezione Sfondo).

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

Verifica che l'output di ogni asset di texture in una directory con il codice suffisso nel nome (ad esempio, #tcf_astc).

Verifica che venga restituito l'output di una directory senza suffisso nel nome (ad esempio, Assets/AssetBundles/). Questa directory contiene il formato predefinito 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 es. ASTC nel codice del passaggio precedente), la versione di Google Play Store installa invece 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 > Consegna degli asset.
Fai clic su Aggiungi cartella per aggiungere la cartella contenente l'asset predefinito. bundle. Questi bundle sono installati su dispositivi che non supportano l'altro formati da te definiti.

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

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

Crea

Seleziona Google > Crea Android App Bundle per lanciare la build Unity del tuo per giocare. Inoltre, raggruppa gli AssetBundle in più pacchetti di asset, dove ogni Il nome AssetBundle viene convertito in un singolo pacchetto di asset.

(Utenti con competenze avanzate) Utilizzare bundletool

Per ulteriori informazioni su bundletool, vedi Creare un app bundle utilizzando bundletool.

Per creare l'app bundle, svolgi i seguenti passaggi:

Scarica bundletool dal suo repository GitHub.
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 formati, consulta la sezione Sfondo).
Crea versioni degli asset per ogni formato di compressione delle texture dal passaggio precedente. Può comportare la generazione di fogli sprite tramite software Mi piace TexturePacker oppure eseguendo uno script che converte gli asset non elaborati in quelli con un formato specifico (ad esempio, encoder astc).
Crea pacchetti di asset (vedi Build per C++ o Java), che contengono le tue risorse di gioco e che vengono utilizzate da Play Asset Delivery. Per 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 seleziona il tipo di pubblicazione install-time per i pacchetti di asset. Questi asset i pacchetti 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 alla compressione della texture utilizzato per i file contenuti.

Directory prima del giorno	Directory dopo il giorno
`common` pacchetto di asset: comune/build.gradle comune/src/main/assets/textures/...	`common` pacchetto di asset: comune/build.gradle comune/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 a file di metadati dell'app bundle (BundleConfig.json). Usa TEXTURE_COMPRESSION_FORMAT per value campo:
```
{
  ...
  "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. Questo consente al gioco di leggere file da un nome di directory noto (come level1/assets/textures). Alcuni motori di gioco sono in grado di rilevare il formato quindi il tuo gioco può essere indifferente al formato degli asset di texture che 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 (API livello 21) e inferiore. Nella tabella di esempio precedente, la versione predefinita gli asset texture sono installati su questi dispositivi; questo è il tipo di comportamento degli utenti 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

Verificare i contenuti dell'app bundle

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

Verifica i contenuti dell'app bundle di output creando APK da esso, quindi durante il loro esame:

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 è applicato correttamente. Se estrai i contenuti di un APK di livello (ad esempio, asset-slices/level1-astc.apk), può 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. tra cui ABI, densità dello schermo, lingua e le formato di compressione delle texture applicabile. Questa operazione simula ciò che viene fatto al Google Play Store per il gioco pubblicato.

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

Usa il comando bundletool extract-apks per visualizzare gli apk installati il tuo dispositivo in una directory e quindi controlla questa directory.
1. Estrai la specifica 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 presenti i pacchetti di asset corretti. sono installate. I nomi dei pacchetti di asset hanno come suffisso il nome del formato della texture (ad ad esempio level1-astc.apk).
Aggiungi al tuo gioco istruzioni di log che restituiscano il formato della texture durante il caricamento una texture.
Generare un set di test di texture (ad esempio, sostituire una texture con singolo colore luminoso per un determinato formato). Esegui il gioco e verifica che sia presenti.

Se l'app contiene pacchetti di asset on-demand o fast-follow, utilizza la soluzione di test locale per la pubblicazione degli asset.

Suffissi supportati per i nomi delle directory delle texture

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

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

Regole di pubblicazione di Google Play

Google Play controlla le stringhe dell'estensione OpenGL utilizzate dal dispositivo e Versione OpenGL supportata dal dispositivo. Google Play utilizza queste informazioni per determinare il formato corretto della texture da pubblicare sul dispositivo da Android App Bundle.

Google Play carica il primo formato, nell'ordine indicato di seguito supportata dal dispositivo.

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 hardware specifico del dispositivo, ETC1 o ETC2 sono buoni scelte per un formato predefinito). Per informazioni su come pacchettizzare gli asset nel predefinito, fai riferimento a Utilizzare 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 non disponibili per il dispositivo. In questo caso, gli utenti non possono scaricare l'app.

Formato (indicato in `tcf_xxxx`)	Funzionalità supportata sui dispositivi con OpenGL stringa di estensione
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`
3D	`GL_AMD_compressed_3DC_texture`
e così via	Non applicabile. Il dispositivo deve supportare OpenGL ES versione 3.0 o in un secondo momento.
e così via	`GL_OES_compressed_ETC1_RGB8_texture`
con tavolozza	`GL_OES_compressed_paletted_texture`