Campioni

Gli esempi dell'estensione per lo sviluppo di giochi Android mostrano come utilizzare le funzionalità chiave dell'estensione. Questo argomento descrive gli esempi e le impostazioni necessarie per eseguirli.

I seguenti esempi sono disponibili nella pagina dei download:

  • HelloJNI: un progetto introduttivo.
  • Endless-Tunnel: un progetto solo per Android.
  • Teapot: un progetto multipiattaforma per Windows e Android.
  • AssemblyCode-Link-Objects: un progetto modello con codice sorgente dell'assemblaggio.

Prima di iniziare

  • Installa l'estensione Android Game Development e gli esempi. Consulta la guida rapida per i dettagli. L'argomento descrive inoltre come creare ed eseguire un esempio e utilizza la versione Android dell'esempio Teapot come esempio.

  • La guida alla configurazione del progetto descrive come configurare le impostazioni per un progetto che utilizza l'estensione, ad esempio l'aggiunta di una piattaforma Android e di un APK.

CiaoJNI

L'esempio HelloJNI è un progetto semplice che visualizza un messaggio "Hello From JNI" in una finestra dell'app. Il progetto utilizza un set di codice sorgente diverso per Windows e Android.

  • Directory degli script di build gradle e codice sorgente Android: HelloJNI\AndroidPackaging
  • Codice sorgente di Windows e directory del progetto di Visual Studio: HelloJNI

Quando crei il progetto, Visual Studio passa le seguenti impostazioni al file build.gradle a livello di app. Puoi modificare queste impostazioni modificando gli script di build Gradle.

  • MSBUILD_NDK_VERSION
  • MSBUILD_MIN_SDK_VERSION
  • MSBUILD_JNI_LIBS_SRC_DIR
  • MSBUILD_ANDROID_OUTPUT_APK_NAME
  • MSBUILD_ANDROID_GRADLE_BUILD_OUTPUT_DIR

Per configurare ed eseguire l'esempio:

  1. In Visual Studio, apri e crea l'esempio HelloJNI.
  2. Aggiungi una piattaforma Android ARM64-v8a. Per saperne di più, consulta la sezione Aggiungere una piattaforma Android.
  3. Aggiungi un elemento APK Android alla nuova piattaforma.
  4. Compila il progetto.
  5. Aggiungi le seguenti piattaforme Android e aggiungi un elemento APK Android a ognuna: Android-armeabi-v7a, Android-x86 e Android-x86_64.
  6. Crea ed esegui l'esempio.

Tunnel infinito

L'esempio di Endless-Tunnel è un gioco Android in cui il giocatore raccoglie cubi bianchi cercando di raggiungere la fine di un tunnel. È stato trasferito da un campione OpenGL nel repository NDK di Android su GitHub. L'esempio non fornisce una versione del gioco per Windows.

Le impostazioni e i formati Android dell'esempio sono già configurati, quindi puoi creare ed eseguire il progetto in Visual Studio senza alcuna modifica. Quando apri la soluzione, Esplora soluzioni mostra i seguenti moduli:

  • endless-tunnel: il modulo dell'applicazione che mostra la logica del gioco.
  • glm: un'istantanea del repository Math OpenGL creato come libreria statica.
  • native_app_glue: un wrapper NDK che comunica con l'oggetto nativeActivity.

Teiera

L'esempio di Teapot mostra una teiera classica visualizzata con OpenGL ES e trasferita all'estensione per lo sviluppo di giochi Android per dimostrare le seguenti funzionalità:

  • Sviluppo di progetti multipiattaforma: puoi creare Teapot di esempio per Windows e Android.
  • Utilizzo della pacchettizzazione di Android personalizzata: gli script di build Gradle sono stati spostati nella directory root dell'esempio, dove si trova il file Teapot.sln.
  • Integrazione della build Nina sperimentale che consente l'apertura del progetto in Android Studio.
  • Configurazioni Android personalizzate che dimostrano come utilizzare Address Sanitizer (ASan) e Hardware Address Sanitizer (HWAsan).

L'implementazione dell'esempio di Teapot è suddiviso in più parti, un comportamento tipico per applicazioni e giochi multipiattaforma di grandi dimensioni:

  • Modulo GameApplication: definisce le azioni dell'utente e gli stati dell'applicazione, ad esempio un utente che ruota la teiera o che aggiorna le statistiche dell'applicazione.
  • Modulo GameEngine: implementa il modulo di rendering principale.

Per configurare l'esempio ed eseguirlo su Android, consulta la guida rapida. Per configurare l'esempio ed eseguirlo su Windows:

  1. Installa GLEW:
    1. Scarica e decomprimi GLEW.
    2. Copia i file binari da $your-glew-directory\bin\Release\x64 a %SystemRoot%\system32.
  2. Installa freeglut:
    1. Scarica e decomprimi freeglut.
    2. Copia $your-freeglut-directory\bin\x86\freeglut.dll in %SystemRoot%\system32.
  3. Aggiungi le dipendenze del progetto freeglut:
    1. Apri Teapot.sln in Visual Studio.
    2. Nel menu, fai clic su Debug > x64 > Debugger locale Windows.
    3. In Esplora soluzioni, fai clic con il pulsante destro del mouse su GameApplication e scegli Proprietà > C/C++ > Generale > Includi directory aggiuntive.
    4. Aggiungi $your-freeglut-dir\include al percorso.
      Screenshot della finestra di dialogo Includi directory aggiuntive.
    5. Fai clic su OK.
    6. Scegli Linker > Generale > Altre Elenchi Biblioteche.
    7. Aggiungi $your-freeglut-dir\lib\x64 al percorso. Screenshot della finestra di dialogo Elenco raccolte aggiuntive.
    8. Fai clic su OK.
    9. Scegli Linker > Generale > Altre Elenchi Biblioteche.
    10. Aggiungi freeglut.lib al percorso.
    11. Fai clic su OK.
  4. Aggiungi le dipendenze del progetto GLEW:
    1. Nel riquadro Esplora soluzioni, fai clic con il pulsante destro del mouse su GameApplication e scegli Proprietà > C/C++ > Generale > Includi directory aggiuntive.
    2. Aggiungi $your-glew-dir\include al percorso.
    3. Fai clic su OK.
    4. Scegli Linker > Generale > Altre Elenchi Biblioteche.
    5. Aggiungi $your-glew-dir\lib\Release\x86 al percorso.
    6. Fai clic su OK.
    7. Scegli Linker > Generale > Altre Elenchi Biblioteche.
    8. Aggiungi glew32.lib al percorso.
    9. Fai clic su OK.
  5. Esegui l'esempio su Windows:
    1. Nella barra degli strumenti di Visual Studio, fai clic sul pulsante di esecuzione Local Windows Debugger.
    2. L'esempio dovrebbe avere il seguente aspetto:
      Screenshot dell'esempio di Teapot in esecuzione su Windows.

Questo è un progetto modello che dimostra come generare una libreria nativa Android da codice sorgente Assembly e C/C++. I componenti principali sono:

  • AssemblyCode-Link-Objects: la libreria nativa di Android principale creata da C++ e codice sorgente Assembly.
  • StaticLib: una libreria statica helper che esporta la funzione from_static_lib_assembly_code_as.

Il progetto supporta più architetture. Ogni architettura supportata ha i propri file di origine che implementano le funzioni esportate da StaticLib. Dovresti includere solo i file di origine assembly per le piattaforme che stai creando. Questo progetto include file di assemblaggio nelle build utilizzando strumenti di creazione personalizzati.

Per configurare e creare l'esempio:

  1. In Visual Studio, verifica che gli strumenti di creazione personalizzati siano configurati per i file di assemblaggio:
    1. In Esplora soluzioni, fai clic con il pulsante destro del mouse sul file di assemblaggio e fai clic su Proprietà. Viene visualizzata la finestra di dialogo Pagine delle proprietà relativa al file.
    2. Seleziona la configurazione e la piattaforma, ad esempio Tutte le configurazioni per Android-arm64-v8a.
    3. Assicurati che Generale > Escludi da build sia impostato su No.
    4. Assicurati che Generale > Tipo di elemento sia impostato su Strumento di creazione personalizzato.
    5. Fai clic su Applica se ci sono modifiche da applicare.
    6. Assicurati che Proprietà di configurazione > Strumenti di creazione personalizzati > Riga di comando: sia impostato su $(AsToolExe) -o "$(IntDir)%(FileName).o" %(FullPath). NDK include un assemblatore separato per ogni architettura della CPU e $(AsToolExe) viene mappato all'assemblatore corretto. Questo esempio utilizza la toolchain NDK per creare progetti Android x86 e x86_64. Se vuoi utilizzare yasm per la piattaforma Android x86_64, usa invece $(YasmToolExe).
    7. Assicurati che Proprietà di configurazione > Strumenti di creazione personalizzati > Output: sia impostato su $(IntDir)%(FileName).o. Questa stringa deve essere inclusa nell'impostazione Riga di comando.
    8. Assicurati che Proprietà di configurazione > Strumenti di creazione personalizzati > Collega oggetti: sia impostato su Yes.

    Ad esempio, le impostazioni Android-arm64-v8a dovrebbero essere simili al seguente screenshot:

    Screenshot della pagina della proprietà per gli strumenti di creazione personalizzati.
  2. Crea il progetto. Questa operazione crea il file libAssmeblyCodeLinkObjects.so:
    1. Apri il file AssemblyCode-Link-Objects.sln.
    2. Nel menu, fai clic su Build > Build Solution (Crea soluzione > Crea soluzione).
  3. Per verificare che le funzioni siano esportate correttamente nella libreria Android, utilizza lo strumento NDK nm.exe:
    1. Nella riga di comando, vai alla directory di esempio.
    2. Vai alla posizione della libreria Android generata dalla build. La località predefinita è simile a $sample_dir\$solution_configuration\$solution_platform\$platform e $sample_dir\Debug\Android-arm64-v8a\arm64-v8a per la piattaforma arm64-v8a.
    3. Verifica che la sezione dei simboli esportati contenga le funzioni eseguendo questo comando: 
        …\ndk\toolschains\llvm\prebuilt\windows-x86_64\aarch64-linux-android\bin\nm.exe --defined-only …\Debug\Android-arm64-v8a\arm64-v8a\libAssmeblyCodeLinkObjects.so

      Nell'output dovresti vedere un elenco di simboli che includono quanto segue: 

         T from_shared_object_assembly_code_as
   T from_static_lib_assembly_code_as