Compilatori di Shadr Vulkan su Android

Un'app Vulkan deve gestire gli streamr in modo diverso rispetto a un'app OpenGL ES: In OpenGL ES, fornisci uno shaker sotto forma di insieme di stringhe che formano il testo di origine di un il programma Shader GLSL. Al contrario, l'API Vulkan richiede che tu fornisca uno shaker in come punto di ingresso in un modulo SPIR-V.

NDK 12 e versioni successive include una libreria di runtime per la compilazione di GLSL in SPIR-V. La libreria di runtime è la stessa della libreria progetto open source Shaderc, che utilizza lo stesso come compilatore di riferimento Glslang GLSL e il backend. Per impostazione predefinita, la versione Shaderc il compilatore presume che tu stia eseguendo la compilazione per Vulkan. Dopo aver controllato se il codice è valido per Il compilatore Vulkan abilita automaticamente l'estensione KHR_vulkan_glsl. Shaderc del compilatore genera anche codice SPIR-V conforme a Vulkan.

Puoi scegliere di compilare i moduli SPIR-V nella tua app Vulkan durante lo sviluppo, una chiamata ahead-of-time o AOT, compilazione. In alternativa, puoi fare in modo che la tua app le compili da uno shaker spedito o generato proceduralmente quando necessario durante il runtime. Questa pratica è chiamata compilazione del runtime. Android Studio include il supporto integrato per la creazione di Shar Vulkan.

Il resto di questa pagina fornisce maggiori dettagli su ogni pratica, poi spiega come integrare la compilation di shadowr nell'app Vulkan.

Compilation AOT

Esistono due modi per ottenere la compilazione AOT Shar, descritti nelle sezioni seguenti.

Utilizzare Android Studio

Inserire gli snapshot in app/src/main/shaders/ e Android Studio riconosce questi ultimi tramite le rispettive estensioni di file ed eseguire le seguenti azioni:

• Compila tutti i file Shar in modo ricorsivo in quella directory.
• Aggiungi il suffisso .spv ai file snapshot SPIR-V.
• Crea un pacchetto di SPIRV-shader nella directory assets/shaders/ dell'APK.

L'applicazione caricherà gli streamr compilati dalla posizione assets/shaders/ corrispondente in fase di esecuzione; la struttura del file spv Shar compilato è la stessa della struttura del file GLSL Shar dell'applicazione in app/src/main/shaders/:

AAsset* file = AAssetManager_open(assetManager,
                     "shaders/tri.vert.spv", AASSET_MODE_BUFFER);
size_t fileLength = AAsset_getLength(file);
char* fileContent = new char[fileLength];
AAsset_read(file, fileContent, fileLength);

È possibile configurare i flag di compilazione Shaderc all'interno del blocco shaders DSL gradle, come mostrato nell'esempio seguente:

Alla moda

android {
  defaultConfig {
    shaders {
      glslcArgs.addAll(['-c', '-g'])
      scopedArgs.create('lights') {
        glslcArgs.addAll(['-DLIGHT1=1', '-DLIGHT2=0'])
      }
    }
  }
}

Kotlin

android {
  defaultConfig {
    shaders {
        glslcArgs += listOf("-c", "-g")
        glslcScopedArgs("lights", "-DLIGHT1=1", "-DLIGHT2=0")
    }
  }
}

glslcArgs si applicano a tutte le compilation di shaker; scopedArgs si applicano solo durante la compilazione per quell'ambito. L'esempio precedente crea un argomento di ambito lights, che verrà applicato solo a Shar GLSL nella directory app/src/main/shaders/lights/. Consulta glslc per l'elenco completo di flag di compilazione disponibili. Tieni presente che Shaderc all'interno di NDK è un'istantanea del repository GitHub Data di rilascio NDK; puoi ottenere gli esatti flag supportati per quella versione con il comando glslc --help, come descritto nella prossima sezione.

Compilazione offline della riga di comando

Gli Shader GLSL possono essere compilati su SPIR-V indipendentemente dall'applicazione principale utilizzando il compilatore a riga di comando glslc. NDK 12 e versioni successive contiene una versione predefinita di glslc e nella directory <android-ndk-dir>/shader-tools/ per supportare questo modello di utilizzo.

Il compilatore è disponibile anche in Shaderc progetto; segui le istruzioni per creare una versione binaria.

glslc offre un ricco insieme di delle opzioni della riga di comando per la compilazione dello shaker al fine di soddisfare vari requisiti per un'applicazione.

Lo strumento glslc compila un file di origine singola in un modulo SPIR-V con un singolo shaker il punto di accesso. Per impostazione predefinita, il file di output ha lo stesso nome del file di origine. ma con l'estensione .spv aggiunta.

Puoi usare le estensioni dei nomi file per indicare allo strumento glslc quale fase dello streamr grafico compilare, o se è in corso la compilazione di un computing shard. Per informazioni su come utilizzare questi nomi file estensioni e le opzioni utilizzabili con lo strumento, consulta Specifica della fase di Shader nella sezione . glslc.

Compilazione runtime

Per la compilazione JIT di Shader durante il runtime, NDK fornisce la libreria libshaderc, che include API C e C++.

Le applicazioni C++ devono utilizzare l'API C++. È consigliabile che le app in altre lingue usare l'API C, perché la C ABI è di livello inferiore e potrebbe fornire una migliore stabilità.

Nell'esempio seguente viene illustrato come utilizzare l'API C++:

#include <iostream>
#include <string>
#include <vector>
#include <shaderc/shaderc.hpp>

std::vector<uint32_t> compile_file(const std::string& name,
                                   shaderc_shader_kind kind,
                                   const std::string& data) {
  shaderc::Compiler compiler;
  shaderc::CompileOptions options;

  // Like -DMY_DEFINE=1
  options.AddMacroDefinition("MY_DEFINE", "1");

  shaderc::SpvCompilationResult module = compiler.CompileGlslToSpv(
      data.c_str(), data.size(), kind, name.c_str(), options);

  if (module.GetCompilationStatus() !=
      shaderc_compilation_status_success) {
    std::cerr << module.GetErrorMessage();
  }

  std::vector<uint32_t> result(module.cbegin(), module.cend());
  return result;
}

Integra nei tuoi progetti

Puoi integrare il compilatore Shar Vulkan nella tua app utilizzando Android.mk o Gradle.

Android.MK

Per utilizzare l'attributo Android.mk del progetto, procedi nel seguente modo per integrare il compilatore Shader.

1. Includi le seguenti righe nel file Android.mk:

   include $(CLEAR_VARS)
        ...
   LOCAL_STATIC_LIBRARIES := shaderc
        ...
   include $(BUILD_SHARED_LIBRARY)
   
   $(call import-module, third_party/shaderc)
   

2. Imposta APP_STL su uno dei seguenti valori: c++_static, c++_shared, gnustl_static, o gnustl_shared nel file Application.mk dell'app

Integrazione CMake di Gradle

1. In una finestra del terminale, accedi a ndk_root/sources/third_party/shaderc/.
2. Esegui questo comando per creare lo Shaderc di NDK. Devi eseguire questo comando una sola volta su ogni versione NDK che utilizzi:

   $ ../../../ndk-build NDK_PROJECT_PATH=. APP_BUILD_SCRIPT=Android.mk \
   APP_STL:=<stl_version> APP_ABI=all libshaderc_combined
   

   Questo comando inserisce due cartelle in <ndk_root>/sources/third_party/shaderc/. La directory è la seguente:

   include/
     shaderc/
       shaderc.h
       shaderc.hpp
   libs/
     <stl_version>/
       {all of the abis}
          libshaderc.a
   

3. Aggiungi le inclusioni e le librerie generate utilizzando target_include_directories e target_link_libraries, come fai normalmente per simili esterna librerie. Il tipo STL della tua app deve corrispondere a uno dei stl tipi specificati in stl_version. L'NDK consiglia di utilizzare c++_shared o c++_static, anche se gnustl_static e Sono supportati anche i gnustl_shared.

Scarica l'ultima versione di Shaderc

Shaderc in NDK proviene dall'albero delle origini Android, un snapshot del repository Shaderc upstream. Se hai bisogno dell'ultima versione di Shaderc, consulta le istruzioni per la creazione per informazioni dettagliate. I passaggi generali sono i seguenti:

1. Scarica l'ultima versione di Shaderc:

   git clone https://github.com/google/shaderc.git

2. Aggiorna le dipendenze:

   ./utils/git-sync-deps

3. Crea Shaderc:

   <ndk_dir>/ndk-build NDK_PROJECT_PATH=. APP_BUILD_SCRIPT=Android.mk \
       APP_STL:=c++_static APP_ABI=all libshaderc_combined -j16
   

4. Configura il progetto in modo da utilizzare la tua build Shaderc nel file di script di compilazione.