Add ccache and sccache support in CI workflows

- Introduced `ccache` on Linux and `sccache` on Windows for improved compilation caching in GitHub workflows.
- Updated build scripts with compiler launcher configurations to leverage caching tools.
- Added steps to install and configure `ccache`/`sccache` based on the runner's platform.
- Enhanced CI efficiency with cache restoration for Vulkan SDK and compiler caches.
- Defined platform-specific `AssetManagerType` for better Android and desktop compatibility.

Author: gpx1000

.github/workflows/workflow.yml

@@ -14,6 +14,7 @@ jobs:
         os: [ubuntu-latest, windows-latest]
         include:
           - os: ubuntu-latest
+            ccache: ccache
             vulkan-install: |
               # Download and install Vulkan SDK using the tar.gz method
               VULKAN_VERSION=$(curl -s https://vulkan.lunarg.com/sdk/latest/linux.txt)
@@ -64,6 +65,7 @@ jobs:
                 exit 1
               fi
           - os: windows-latest
+            ccache: sccache
             vulkan-install: |
               # Download the Vulkan SDK installer
               Invoke-WebRequest -Uri "https://sdk.lunarg.com/sdk/download/latest/windows/vulkan-sdk.exe" -OutFile "$env:TEMP\vulkan-sdk.exe"
@@ -163,6 +165,17 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-apt-
 
+      # Cache ccache files
+      - name: Cache ccache files
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.ccache
+            ~/.cache/sccache
+          key: ${{ runner.os }}-${{ matrix.ccache }}-${{ github.sha }}
+          restore-keys: |
+            ${{ runner.os }}-${{ matrix.ccache }}-
+
       # Cache Vulkan SDK for Ubuntu
       - name: Cache Vulkan SDK (Ubuntu)
         if: runner.os == 'Linux'
@@ -175,6 +188,27 @@ jobs:
             ${{ runner.os }}-vulkan-sdk-${{ hashFiles('**/CMakeLists.txt') }}-
             ${{ runner.os }}-vulkan-sdk-
 
+      # Install ccache or sccache
+      - name: Install ccache (Ubuntu)
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y ccache
+          ccache --max-size=2G
+          ccache -z
+          echo "CCACHE_DIR=$HOME/.ccache" >> $GITHUB_ENV
+          echo "PATH=/usr/lib/ccache:$PATH" >> $GITHUB_ENV
+
+      - name: Install sccache (Windows)
+        if: runner.os == 'Windows'
+        run: |
+          Invoke-WebRequest -Uri "https://github.com/mozilla/sccache/releases/download/v0.5.4/sccache-v0.5.4-x86_64-pc-windows-msvc.tar.gz" -OutFile "sccache.tar.gz"
+          tar -xzf sccache.tar.gz
+          $sccachePath = Join-Path -Path (Get-Location) -ChildPath "sccache-v0.5.4-x86_64-pc-windows-msvc"
+          echo "$sccachePath" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          echo "SCCACHE_DIR=$HOME/.cache/sccache" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+          echo "SCCACHE_CACHE_SIZE=2G" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+
       - name: Install dependencies
         run: ${{ matrix.deps-install }}
 
@@ -237,7 +271,9 @@ jobs:
             -DVulkan_INCLUDE_DIR="$env:Vulkan_INCLUDE_DIR" `
             -DVulkan_LIBRARY="$env:Vulkan_LIBRARY" `
             -DCMAKE_PREFIX_PATH="$env:VULKAN_SDK" `
-            -DCMAKE_TOOLCHAIN_FILE="$env:CMAKE_TOOLCHAIN_FILE"
+            -DCMAKE_TOOLCHAIN_FILE="$env:CMAKE_TOOLCHAIN_FILE" `
+            -DCMAKE_C_COMPILER_LAUNCHER=sccache `
+            -DCMAKE_CXX_COMPILER_LAUNCHER=sccache
 
           # Display CMake cache to debug Vulkan detection
           if (Test-Path "build/CMakeCache.txt") {
@@ -273,17 +309,28 @@ jobs:
         if: runner.os != 'Windows'
         run: |
           # Use Clang for better C++20 module support
-          export CC=clang
-          export CXX=clang++
+          export CC="ccache clang"
+          export CXX="ccache clang++"
 
           cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Release \
             -DCMAKE_CXX_SCAN_FOR_MODULES=ON \
-            -DCMAKE_CXX_FLAGS="-std=c++20"
+            -DCMAKE_CXX_FLAGS="-std=c++20" \
+            -DCMAKE_C_COMPILER_LAUNCHER=ccache \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
 
       - name: Build
         working-directory: ${{github.workspace}}/attachments
         run: cmake --build build --config Release
 
+      # Display ccache/sccache statistics
+      - name: ccache statistics
+        if: runner.os == 'Linux'
+        run: ccache -s
+
+      - name: sccache statistics
+        if: runner.os == 'Windows'
+        run: sccache -s
+
       - name: Test Build Output
         working-directory: ${{github.workspace}}/attachments/build
         run: ${{ matrix.test-cmd }}

attachments/34_android.cpp

@@ -36,18 +36,26 @@ import vulkan_hpp;
     #include <android/asset_manager.h>
     #include <android/asset_manager_jni.h>
 
+    // Define AAssetManager type for Android
+    typedef AAssetManager AssetManagerType;
+
     // Define logging macros for Android
     #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__))
     #define LOG_INFO(msg) LOGI("%s", msg)
     #define LOG_ERROR(msg) LOGE("%s", msg)
 #else
+    // Define AAssetManager type for non-Android platforms
+    typedef void AssetManagerType;
     // Desktop-specific includes
     #define GLFW_INCLUDE_VULKAN
     #include <GLFW/glfw3.h>
 
     // Define logging macros for Desktop
+    #define LOGI(...) printf(__VA_ARGS__); printf("\n")
+    #define LOGW(...) printf(__VA_ARGS__); printf("\n")
+    #define LOGE(...) fprintf(stderr, __VA_ARGS__); fprintf(stderr, "\n")
     #define LOG_INFO(msg) std::cout << msg << std::endl
     #define LOG_ERROR(msg) std::cerr << msg << std::endl
 #endif
@@ -107,7 +115,7 @@ struct UniformBufferObject {
 };
 
 // Cross-platform file reading function
-std::vector<char> readFile(const std::string& filename, std::optional<AAssetManager*> assetManager = std::nullopt) {
+std::vector<char> readFile(const std::string& filename, std::optional<AssetManagerType*> assetManager = std::nullopt) {
 #if PLATFORM_ANDROID
     // On Android, use asset manager if provided
     if (assetManager.has_value() && *assetManager != nullptr) {
@@ -224,47 +232,13 @@ class HelloTriangleApplication {
     void cleanup() {
         if (initialized) {
             // Wait for device to finish operations
-            if (device) {
+            if (*device) {
                 device.waitIdle();
             }
 
             // Cleanup resources
             cleanupSwapChain();
 
-            // Cleanup other resources
-            for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
-                uniformBuffers[i] = nullptr;
-                uniformBuffersMemory[i] = nullptr;
-            }
-
-            descriptorPool = nullptr;
-            descriptorSetLayout = nullptr;
-
-            textureImageView = nullptr;
-            textureImage = nullptr;
-            textureImageMemory = nullptr;
-            textureSampler = nullptr;
-
-            indexBuffer = nullptr;
-            indexBufferMemory = nullptr;
-            vertexBuffer = nullptr;
-            vertexBufferMemory = nullptr;
-
-            for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
-                imageAvailableSemaphores[i] = nullptr;
-                renderFinishedSemaphores[i] = nullptr;
-                inFlightFences[i] = nullptr;
-            }
-
-            commandPool = nullptr;
-            graphicsPipeline = nullptr;
-            pipelineLayout = nullptr;
-            renderPass = nullptr;
-
-            device = nullptr;
-            surface = nullptr;
-            instance = nullptr;
-
             initialized = false;
         }
     }
@@ -273,7 +247,7 @@ class HelloTriangleApplication {
 #if PLATFORM_ANDROID
     // Android-specific members
     android_app* androidApp = nullptr;
-    AAssetManager* assetManager = nullptr;
+    AssetManagerType* assetManager = nullptr;
 #else
     // Desktop-specific members
     GLFWwindow* window = nullptr;
@@ -466,7 +440,7 @@ class HelloTriangleApplication {
 
             // Print device information
             vk::PhysicalDeviceProperties deviceProperties = physicalDevice.getProperties();
-            LOGI("Selected GPU: %s", deviceProperties.deviceName);
+            LOGI("Selected GPU: %s", deviceProperties.deviceName.data());
         } else {
             throw std::runtime_error("Failed to find a suitable GPU");
         }
@@ -711,9 +685,9 @@ class HelloTriangleApplication {
 
         // Load shader files using cross-platform function
 #if PLATFORM_ANDROID
-        std::optional<AAssetManager*> optionalAssetManager = assetManager;
+        std::optional<AssetManagerType*> optionalAssetManager = assetManager;
 #else
-        std::optional<AAssetManager*> optionalAssetManager = std::nullopt;
+        std::optional<void*> optionalAssetManager = std::nullopt;
 #endif
         std::vector<char> vertShaderCode = readFile("shaders/vert.spv", optionalAssetManager);
         std::vector<char> fragShaderCode = readFile("shaders/frag.spv", optionalAssetManager);
@@ -882,7 +856,7 @@ class HelloTriangleApplication {
 
 #if PLATFORM_ANDROID
         // Load image from Android assets
-        std::optional<AAssetManager*> optionalAssetManager = assetManager;
+        std::optional<AssetManagerType*> optionalAssetManager = assetManager;
         std::vector<char> imageData = readFile(TEXTURE_PATH, optionalAssetManager);
         pixels = stbi_load_from_memory(
             reinterpret_cast<const stbi_uc*>(imageData.data()),
@@ -990,7 +964,7 @@ class HelloTriangleApplication {
 
 #if PLATFORM_ANDROID
         // Load OBJ file from Android assets
-        std::optional<AAssetManager*> optionalAssetManager = assetManager;
+        std::optional<AssetManagerType*> optionalAssetManager = assetManager;
         std::vector<char> objData = readFile(MODEL_PATH, optionalAssetManager);
         std::string objString(objData.begin(), objData.end());
         std::istringstream objStream(objString);
@@ -1076,8 +1050,13 @@ class HelloTriangleApplication {
     void createUniformBuffers() {
         vk::DeviceSize bufferSize = sizeof(UniformBufferObject);
 
-        uniformBuffers.resize(MAX_FRAMES_IN_FLIGHT);
-        uniformBuffersMemory.resize(MAX_FRAMES_IN_FLIGHT);
+        uniformBuffers.clear();
+        uniformBuffersMemory.clear();
+
+        for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
+            uniformBuffers.push_back(nullptr);
+            uniformBuffersMemory.push_back(nullptr);
+        }
 
         for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
             createBuffer(bufferSize, vk::BufferUsageFlagBits::eUniformBuffer, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent, uniformBuffers[i], uniformBuffersMemory[i]);
@@ -1211,7 +1190,8 @@ class HelloTriangleApplication {
             }
         };
 
-        vk::ClearValue clearColor = {{{0.0f, 0.0f, 0.0f, 1.0f}}};
+        vk::ClearValue clearColor;
+        clearColor.color.float32 = std::array<float, 4>{0.0f, 0.0f, 0.0f, 1.0f};
         renderPassInfo.clearValueCount = 1;
         renderPassInfo.pClearValues = &clearColor;
 
@@ -1256,6 +1236,9 @@ class HelloTriangleApplication {
             return;
         }
 
+        // Update uniform buffer with current transformation
+        updateUniformBuffer(currentFrame);
+
         device.resetFences({*inFlightFences[currentFrame]});
 
         commandBuffers[currentFrame].reset();