android/
├── app/
│   ├── build.gradle            // 应用级构建配置
│   ├── src/
│   │   ├── main/
│   │   │   ├── AndroidManifest.xml  // 应用清单
│   │   │   ├── cpp/                 // 原生代码
│   │   │   │   ├── CMakeLists.txt   // CMake 构建脚本
│   │   │   │   └── game_activity_bridge.cpp // GameActivity 与 Vulkan 代码之间的桥接层
│   │   │   ├── java/                // Java 代码
│   │   │   │   └── com/example/vulkantutorial/
│   │   │   │       └── VulkanActivity.java // 主 Activity（继承 GameActivity）
│   │   │   └── res/                 // 资源
│   │   │       └── values/
│   │   │           ├── strings.xml  // 字符串资源
│   │   │           └── styles.xml   // 样式资源
├── build.gradle                // 项目级构建配置
├── gradle/                     // Gradle wrapper
├── settings.gradle             // 项目设置

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.vulkan.tutorial">

    <!-- Vulkan 要求 API 级别 24（Android 7.0）或更高 -->
    <uses-sdk android:minSdkVersion="24" />

    <!-- 声明本应用使用 Vulkan -->
    <uses-feature android:name="android.hardware.vulkan.version" android:version="0x400003" android:required="true" />
    <uses-feature android:name="android.hardware.vulkan.level" android:version="0" android:required="true" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity
            android:name=".VulkanActivity"
            android:label="@string/app_name"
            android:configChanges="orientation|keyboardHidden|screenSize"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

package com.vulkan.tutorial;

import android.os.Bundle;
import android.view.WindowManager;
import com.google.androidgamesdk.GameActivity;

public class VulkanActivity extends GameActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // 应用运行期间保持屏幕常亮
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    }

    // 加载原生库
    static {
        System.loadLibrary("vulkan_tutorial_android");
    }
}

buildscript {
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:7.2.2'
    }
}

allprojects {
    repositories {
        google()
        mavenCentral()
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}

plugins {
    id 'com.android.application'
}

android {
    compileSdkVersion 33
    defaultConfig {
        applicationId "com.vulkan.tutorial"
        minSdkVersion 24
        targetSdkVersion 33
        versionCode 1
        versionName "1.0"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    externalNativeBuild {
        cmake {
            path "src/main/cpp/CMakeLists.txt"
            version "3.22.1"
        }
    }

    ndkVersion "25.2.9519653"

    // 使用主项目的资源以及本地编译的着色器
    sourceSets {
        main {
            assets {
                srcDirs = [
                    // 指向主项目的资源目录
                    '../../../../',  // attachments 目录中的模型与纹理
                    // 对所有 ABI 使用构建目录中本地编译的着色器
                    // 这些路径相对于 app 目录
                    '.externalNativeBuild/cmake/debug/arm64-v8a/shaders',
                    '.externalNativeBuild/cmake/debug/armeabi-v7a/shaders',
                    '.externalNativeBuild/cmake/debug/x86/shaders',
                    '.externalNativeBuild/cmake/debug/x86_64/shaders',
                    // 同时包含 release 构建的路径
                    '.externalNativeBuild/cmake/release/arm64-v8a/shaders',
                    '.externalNativeBuild/cmake/release/armeabi-v7a/shaders',
                    '.externalNativeBuild/cmake/release/x86/shaders',
                    '.externalNativeBuild/cmake/release/x86_64/shaders'
                ]
            }
        }
    }
}

dependencies {
    implementation 'androidx.appcompat:appcompat:1.6.1'
    implementation 'com.google.android.material:material:1.9.0'
    implementation 'com.google.androidgamesdk:game-activity:1.2.0'
}

cmake_minimum_required(VERSION 3.22.1)

project(vulkan_tutorial_android)

# 设置主 CMakeLists.txt 相对于本文件的路径
set(MAIN_CMAKE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../../../../CMakeLists.txt")

# 查找 Vulkan 包
find_package(Vulkan REQUIRED)

# 配置着色器编译工具
add_executable(glslang::validator IMPORTED)
find_program(GLSLANG_VALIDATOR "glslangValidator" HINTS $ENV{VULKAN_SDK}/bin REQUIRED)
set_property(TARGET glslang::validator PROPERTY IMPORTED_LOCATION "${GLSLANG_VALIDATOR}")

# 定义着色器构建函数
function(add_shaders_target TARGET)
  cmake_parse_arguments("SHADER" "" "CHAPTER_NAME" "SOURCES" ${ARGN})
  set(SHADERS_DIR ${SHADER_CHAPTER_NAME}/shaders)
  add_custom_command(
    OUTPUT ${SHADERS_DIR}
    COMMAND ${CMAKE_COMMAND} -E make_directory ${SHADERS_DIR}
  )
  add_custom_command(
    OUTPUT ${SHADERS_DIR}/frag.spv ${SHADERS_DIR}/vert.spv
    COMMAND glslang::validator
    ARGS --target-env vulkan1.0 ${SHADER_SOURCES} --quiet
    WORKING_DIRECTORY ${SHADERS_DIR}
    DEPENDS ${SHADERS_DIR} ${SHADER_SOURCES}
    COMMENT "Compiling Shaders"
    VERBATIM
  )
  add_custom_target(${TARGET} DEPENDS ${SHADERS_DIR}/frag.spv ${SHADERS_DIR}/vert.spv)
endfunction()

# 引入 game-activity 库
find_package(game-activity REQUIRED CONFIG)
include_directories(${ANDROID_NDK}/sources/android/game-activity/include)

# 设置 C++ 标准，与主项目保持一致
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# （可选）当 ENABLE_CPP20_MODULE=ON 时添加 Vulkan C++ 模块
add_library(VulkanCppModule SHARED)
target_compile_definitions(VulkanCppModule
    PUBLIC VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=1 VULKAN_HPP_NO_STRUCT_CONSTRUCTORS=1
)
target_include_directories(VulkanCppModule
    PRIVATE
    "${Vulkan_INCLUDE_DIR}"
)
target_link_libraries(VulkanCppModule
    PUBLIC
    ${Vulkan_LIBRARIES}
)
set_target_properties(VulkanCppModule PROPERTIES CXX_STANDARD 20)

# 配置 C++ 模块的文件集
target_sources(VulkanCppModule
    PUBLIC
    FILE_SET cxx_modules TYPE CXX_MODULES
    BASE_DIRS
    "${Vulkan_INCLUDE_DIR}"
    FILES
    "${Vulkan_INCLUDE_DIR}/vulkan/vulkan.cppm"
)

# 为 34_android 配置着色器编译
set(SHADER_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../../../../attachments")
set(SHADER_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/shaders")
file(MAKE_DIRECTORY ${SHADER_OUTPUT_DIR})

# 把着色器源文件复制到构建目录
configure_file(
    "${SHADER_SOURCE_DIR}/27_shader_depth.frag"
    "${SHADER_OUTPUT_DIR}/27_shader_depth.frag"
    COPYONLY
)
configure_file(
    "${SHADER_SOURCE_DIR}/27_shader_depth.vert"
    "${SHADER_OUTPUT_DIR}/27_shader_depth.vert"
    COPYONLY
)

# 编译着色器
set(SHADER_SOURCES "${SHADER_OUTPUT_DIR}/27_shader_depth.frag" "${SHADER_OUTPUT_DIR}/27_shader_depth.vert")
add_shaders_target(android_shaders CHAPTER_NAME "${SHADER_OUTPUT_DIR}" SOURCES ${SHADER_SOURCES})

# 添加主原生库
add_library(vulkan_tutorial_android SHARED
    ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../../attachments/34_android.cpp
    game_activity_bridge.cpp
)

# 添加对着色器编译的依赖
add_dependencies(vulkan_tutorial_android android_shaders)

# 设置包含目录
target_include_directories(vulkan_tutorial_android PRIVATE
    ${CMAKE_CURRENT_SOURCE_DIR}
    ${Vulkan_INCLUDE_DIR}
    ${ANDROID_NDK}/sources/android/game-activity/include
)

# 链接库
target_link_libraries(vulkan_tutorial_android
    VulkanCppModule
    game-activity::game-activity
    android
    log
    ${Vulkan_LIBRARIES}
)

#include <game-activity/GameActivity.h>
#include <game-activity/native_app_glue/android_native_app_glue.h>
#include <android/log.h>

// 定义日志宏
#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "VulkanTutorial", __VA_ARGS__))
#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, "VulkanTutorial", __VA_ARGS__))
#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, "VulkanTutorial", __VA_ARGS__))

// 主入口点的前置声明
extern "C" void android_main(android_app* app);

// GameActivity 入口点
extern "C" {
    void GameActivity_onCreate(GameActivity* activity) {
        LOGI("GameActivity_onCreate");

        // 创建 android_app 结构体
        android_app* app = new android_app();
        memset(app, 0, sizeof(android_app));

        // 设置 android_app 结构体
        app->activity = activity;
        app->window = activity->window;

        // 调用原始的 android_main 函数
        android_main(app);

        // 清理
        delete app;
    }
}

void android_main(android_app* app) {
    try {
        // 创建并运行 Vulkan 应用
        HelloTriangleApplication application(app);
        application.run();
    } catch (const std::exception& e) {
        LOGE("Exception caught: %s", e.what());
    }
}

void createSurface() {
    VkSurfaceKHR _surface;
    VkResult result = VK_SUCCESS;

    // 创建 Android 表面
    result = vkCreateAndroidSurfaceKHR(
        *instance,
        &(VkAndroidSurfaceCreateInfoKHR{
            .sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR,
            .pNext = nullptr,
            .flags = 0,
            .window = androidApp->window
        }),
        nullptr,
        &_surface
    );

    if (result != VK_SUCCESS) {
        throw std::runtime_error("Failed to create Android surface");
    }

    surface = vk::raii::SurfaceKHR(instance, _surface);
}

static void handleAppCommand(android_app* app, int32_t cmd) {
    auto* vulkanApp = static_cast<VulkanApplication*>(app->userData);
    switch (cmd) {
        case APP_CMD_INIT_WINDOW:
            // 窗口已创建，初始化 Vulkan
            if (app->window != nullptr) {
                vulkanApp->initVulkan();
            }
            break;
        case APP_CMD_TERM_WINDOW:
            // 窗口已销毁，清理 Vulkan
            vulkanApp->cleanup();
            break;
        default:
            break;
    }
}

static int32_t handleInputEvent(android_app* app, AInputEvent* event) {
    auto* vulkanApp = static_cast<VulkanApplication*>(app->userData);
    if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION) {
        // 处理触摸事件
        float x = AMotionEvent_getX(event, 0);
        float y = AMotionEvent_getY(event, 0);

        // 处理触摸坐标
        // ...

        return 1;
    }
    return 0;
}

// 平台检测
#if defined(__ANDROID__)
    #define PLATFORM_ANDROID 1
#else
    #define PLATFORM_DESKTOP 1
#endif

// 跨平台应用类
class HelloTriangleApplication {
public:
#if PLATFORM_DESKTOP
    // 桌面端构造函数
    HelloTriangleApplication() {
        // 无需 Android 相关初始化
    }
#else
    // Android 构造函数
    HelloTriangleApplication(android_app* app) : androidApp(app) {
        // Android 相关初始化
    }
#endif
    // ... 类的其余部分 ...
};

// 平台相关的头文件
#if PLATFORM_ANDROID
    // Android 相关头文件
    #include <android/log.h>
    #include <android_native_app_glue.h>
    #include <android/asset_manager.h>
    #include <android/asset_manager_jni.h>
#else
    // 桌面端相关头文件
    #define GLFW_INCLUDE_VULKAN
    #include <GLFW/glfw3.h>
    #include <stb_image.h>
    #include <tiny_obj_loader.h>
#endif

// 跨平台文件读取函数
std::vector<char> readFile(const std::string& filename, std::optional<AAssetManager*> assetManager = std::nullopt) {
#if PLATFORM_ANDROID
    // 在 Android 上，如果提供了 asset manager 就使用它
    if (assetManager.has_value() && *assetManager != nullptr) {
        // 打开资源
        AAsset* asset = AAssetManager_open(*assetManager, filename.c_str(), AASSET_MODE_BUFFER);
        // ... 从资源中读取文件 ...
        return buffer;
    }
#endif

    // 桌面版本，或 Android 上回退到文件系统
    std::ifstream file(filename, std::ios::ate | std::ios::binary);
    // ... 从文件系统读取文件 ...
    return buffer;
}

// 平台相关的入口点
#if PLATFORM_ANDROID
// Android 主入口点
void android_main(android_app* app) {
    // Android 相关初始化
    try {
        HelloTriangleApplication vulkanApp(app);
        vulkanApp.run();
    } catch (const std::exception& e) {
        LOGE("Exception caught: %s", e.what());
    }
}
#else
// 桌面端主入口点
int main() {
    try {
        HelloTriangleApplication app;
        app.run();
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}
#endif

// 使用跨平台函数加载着色器文件
#if PLATFORM_ANDROID
std::optional<AAssetManager*> optionalAssetManager = assetManager;
#else
std::optional<AAssetManager*> optionalAssetManager = std::nullopt;
#endif
std::vector<char> vertShaderCode = readFile("shaders/vert.spv", optionalAssetManager);
std::vector<char> fragShaderCode = readFile("shaders/frag.spv", optionalAssetManager);

// 加载纹理图像
#if PLATFORM_ANDROID
std::optional<AAssetManager*> optionalAssetManager = assetManager;
std::vector<char> imageData = readFile(TEXTURE_PATH, optionalAssetManager);
// 处理图像数据...
#else
// 直接从文件系统加载
// ...
#endif