Campioni

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

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 di modello che contiene codice sorgente dell'assemblaggio.

Prima di iniziare

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

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

HelloJNI

L'esempio HelloJNI è un semplice progetto che visualizza un messaggio "Hello from JNI" nella finestra di un'app. Il progetto utilizza un set di codice sorgente diverso per Windows Android.

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

Quando crei il progetto, Visual Studio trasmette quanto segue impostazioni al file build.gradle a livello di app. Puoi modificare queste impostazioni modificare 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 ulteriori informazioni le informazioni, vedi Aggiunta di una piattaforma Android.
  3. Aggiungere un elemento APK Android alla nuova piattaforma.
  4. Compila il progetto.
  5. Aggiungi le seguenti piattaforme Android e poi aggiungi un elemento APK Android a ognuno di essi: 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 mentre cerca di raggiungere la fine di un tunnel. È stato trasferito da una finestra OpenGL campione nel Repository NDK di Android su GitHub. L'esempio non fornisce una versione del gioco per Windows.

Nell'esempio sono già configurate le impostazioni e le piattaforme Android, quindi puoi creare ed eseguire il progetto in Visual Studio senza apportare modifiche. Quando apri la soluzione, Esplora soluzioni mostra questi moduli:

  • endless-tunnel: il modulo dell'applicazione che mostra la logica di gioco.
  • glm: un'istantanea del repository Math OpenGL creata come una libreria statica.
  • native_app_glue: un wrapper NDK che comunica con Attività native .

Teiera

L'esempio Teiera mostra una classica teiera il cui rendering viene eseguito con OpenGL ES e portati nell'estensione Android Game Development per dimostrare le seguenti funzionalità:

  • Sviluppo di progetti su più piattaforme: puoi creare un esempio di Teapot per Windows e Android.
  • Utilizzo di pacchetti Android personalizzati: gli script di build Gradle sono stati spostati nella directory root di un esempio, dove si trova il file Teapot.sln.
  • Integrazione di build Ninja sperimentale che consente l'apertura del progetto in Android Studio.
  • Configurazioni personalizzate di Android che mostrano come utilizzare sanitizer degli indirizzi (ASan) e Sanitizzatore di indirizzi hardware (HWAsan).

L'implementazione dell'esempio di Teiera è suddivisa in più parti, ovvero tipico per le grandi applicazioni e i giochi multipiattaforma:

  • Modulo GameApplication: definisce le azioni dell'utente e gli stati dell'applicazione, ad esempio un utente che ruota la teglia o 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. A configura l'esempio ed eseguilo su Windows:

  1. Installa GLEW:
    1. Scarica e decomprimi GLEW.
    2. Copia i file binari da 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 di Windows.
    3. In Esplorazione soluzioni, fai clic con il tasto destro del mouse GameApplication e scegli Proprietà > C/C++ > Generali > Directory di inclusione 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 > Generali > Directory aggiuntive della biblioteca.
    7. Aggiungi $your-freeglut-dir\lib\x64 al percorso. Screenshot della finestra di dialogo Directory aggiuntive della raccolta.
    8. Fai clic su OK.
    9. Scegli Linker > Generali > Directory aggiuntive della biblioteca.
    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 tasto destro del mouse GameApplication e scegli Proprietà > C/C++ > Generali > Directory di inclusione aggiuntive.
    2. Aggiungi $your-glew-dir\include al percorso.
    3. Fai clic su OK.
    4. Scegli Linker > Generali > Directory aggiuntive della biblioteca.
    5. Aggiungi $your-glew-dir\lib\Release\x86 al percorso.
    6. Fai clic su OK.
    7. Scegli Linker > Generali > Directory aggiuntive della biblioteca.
    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 Esegui Local Windows Debugger.
    2. L'esempio dovrebbe avere il seguente aspetto:
      Screenshot dell'esempio di Teapot in esecuzione su Windows.

Questo è un progetto di modello che dimostra come generare un modello nativo di Android libreria da Assembly e da codice sorgente C/C++. Di seguito sono riportati i componenti principali:

  • AssemblyCode-Link-Objects: la libreria nativa principale Android creata da C++ e il codice sorgente dell'assemblaggio.
  • StaticLib: una libreria statica helper che esporta i Funzione from_static_lib_assembly_code_as.

Il progetto supporta più architetture. Ogni architettura supportata ha i suoi propri file sorgente che implementano funzioni esportate da StaticLib. Devi includere solo i file di origine dell'assemblaggio per le piattaforme che utilizzi edifici. Questo progetto include file assembly nelle build utilizzando strumenti di creazione personalizzati.

Per configurare e creare l'esempio:

  1. In Visual Studio, verifica che siano configurati strumenti di creazione personalizzati per i file assembly:
    1. In Esplora soluzioni, fai clic con il tasto destro del mouse file di assemblaggio e fai clic su Proprietà. Si apre Finestra di dialogo Pagine delle proprietà per il file.
    2. Seleziona la configurazione e la piattaforma, ad esempio Tutte le configurazioni per Android-arm64-v8a.
    3. Assicurati che Generale > Escludi dalla build impostato su No.
    4. Assicurati che Generale > Il tipo di articolo sia impostato. nello strumento di creazione personalizzato.
    5. Fai clic su Applica se sono presenti modifiche da applicare.
    6. Assicurati che Proprietà di configurazione > Strumenti per creare personalizzati > Riga di comando: è impostato su $(AsToolExe) -o "$(IntDir)%(FileName).o" %(FullPath). NDK include un assemblatore separato per ogni architettura CPU e $(AsToolExe) viene mappato all'assemblatore corretto. Questo esempio usa la toolchain NDK per creare Android x86 e x86_64 in modo programmatico a gestire i progetti. Se vuoi usare Yasm per la piattaforma Android x86_64, usa invece $(YasmToolExe).
    7. Assicurati che Proprietà di configurazione > Strumenti per creare personalizzati > Output: è impostato su $(IntDir)%(FileName).o. Questa stringa deve essere inclusa nell'impostazione Riga di comando.
    8. Assicurati che Proprietà di configurazione > Strumenti per creare personalizzati > Oggetti di collegamento: è impostato su Yes.

    Ad esempio, le impostazioni Android-arm64-v8a dovrebbero simile allo screenshot seguente:

    Screenshot della pagina Proprietà per gli strumenti per build personalizzati.
  2. Crea il progetto. Questo crea File libAssmeblyCodeLinkObjects.so:
    1. Apri il file AssemblyCode-Link-Objects.sln.
    2. Nel menu, fai clic su Crea > Crea la soluzione.
  3. Per verificare che le funzioni siano esportate correttamente in Android utilizza lo strumento nm.exe NDK:
    1. Nella riga di comando, vai alla directory di esempio.
    2. Vai alla posizione della raccolta Android generata dal tuo creare. 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 del simbolo esportato contenga le funzioni esegui 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 il seguenti: 

         T from_shared_object_assembly_code_as
   T from_static_lib_assembly_code_as