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:
- In Visual Studio, apri e crea l'esempio HelloJNI.
- Aggiungi una piattaforma Android ARM64-v8a. Per saperne di più, consulta la sezione Aggiungere una piattaforma Android.
- Aggiungi un elemento APK Android alla nuova piattaforma.
- Compila il progetto.
- Aggiungi le seguenti piattaforme Android e aggiungi un elemento APK Android a ognuna: Android-armeabi-v7a, Android-x86 e Android-x86_64.
- 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:
- Installa GLEW:
- Scarica e decomprimi GLEW.
- Copia i file binari da
$your-glew-directory\bin\Release\x64
a%SystemRoot%\system32
.
- Installa freeglut:
- Scarica e decomprimi freeglut.
- Copia
$your-freeglut-directory\bin\x86\freeglut.dll
in%SystemRoot%\system32
.
- Aggiungi le dipendenze del progetto freeglut:
- Apri
Teapot.sln
in Visual Studio. - Nel menu, fai clic su Debug > x64 > Debugger locale Windows.
- In Esplora soluzioni, fai clic con il pulsante destro del mouse su GameApplication e scegli Proprietà > C/C++ > Generale > Includi directory aggiuntive.
- Aggiungi
$your-freeglut-dir\include
al percorso.
- Fai clic su OK.
- Scegli Linker > Generale > Altre Elenchi Biblioteche.
- Aggiungi
$your-freeglut-dir\lib\x64
al percorso. - Fai clic su OK.
- Scegli Linker > Generale > Altre Elenchi Biblioteche.
- Aggiungi
freeglut.lib
al percorso. - Fai clic su OK.
- Apri
- Aggiungi le dipendenze del progetto GLEW:
- Nel riquadro Esplora soluzioni, fai clic con il pulsante destro del mouse su GameApplication e scegli Proprietà > C/C++ > Generale > Includi directory aggiuntive.
- Aggiungi
$your-glew-dir\include
al percorso. - Fai clic su OK.
- Scegli Linker > Generale > Altre Elenchi Biblioteche.
- Aggiungi
$your-glew-dir\lib\Release\x86
al percorso. - Fai clic su OK.
- Scegli Linker > Generale > Altre Elenchi Biblioteche.
- Aggiungi
glew32.lib
al percorso. - Fai clic su OK.
- Esegui l'esempio su Windows:
- Nella barra degli strumenti di Visual Studio, fai clic sul pulsante di esecuzione Local Windows Debugger.
- L'esempio dovrebbe avere il seguente aspetto:
AssemblyCode-Link-Objects
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 funzionefrom_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:
- In Visual Studio, verifica che gli strumenti di creazione personalizzati siano configurati per i file di assemblaggio:
- 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.
- Seleziona la configurazione e la piattaforma, ad esempio Tutte le configurazioni per Android-arm64-v8a.
- Assicurati che Generale > Escludi da build sia impostato su No.
- Assicurati che Generale > Tipo di elemento sia impostato su Strumento di creazione personalizzato.
- Fai clic su Applica se ci sono modifiche da applicare.
- 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)
. - 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. - 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:
- Crea il progetto. Questa operazione crea il
file
libAssmeblyCodeLinkObjects.so
:- Apri il file
AssemblyCode-Link-Objects.sln
. - Nel menu, fai clic su Build > Build Solution (Crea soluzione > Crea soluzione).
- Apri il file
- Per verificare che le funzioni siano esportate correttamente nella libreria Android, utilizza lo strumento NDK nm.exe:
- Nella riga di comando, vai alla directory di esempio.
- 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. - 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