Add instancing support, remove unused STB dependency, and fetch Bistro assets

- Introduced instance data structure for instanced rendering.
- Updated Vulkan pipeline to include instancing with vertex and instance attribute descriptions.
- Removed STB library from dependencies and scripts.
- Included Linux/macOS and Windows scripts to fetch Bistro example assets.

Author: gpx1000

attachments/simple_engine/CMakeLists.txt

@@ -14,7 +14,6 @@ find_package (glm REQUIRED)
 find_package (Vulkan REQUIRED)
 find_package (tinygltf REQUIRED)
 find_package (KTX REQUIRED)
-find_package (stb REQUIRED)
 find_package (OpenAL REQUIRED)
 
 # set up Vulkan C++ module
@@ -133,7 +132,6 @@ target_link_libraries(SimpleEngine PRIVATE
     glm::glm
     tinygltf::tinygltf
     KTX::ktx
-    stb::stb
     OpenAL::OpenAL
 )
 

attachments/simple_engine/camera_component.h

@@ -198,6 +198,14 @@ class CameraComponent : public Component {
         return up;
     }
 
+    /**
+     * @brief Force view matrix recalculation without modifying camera orientation.
+     * This is used when the camera's transform position changes externally (e.g., from GLTF loading).
+     */
+    void ForceViewMatrixUpdate() {
+        viewMatrixDirty = true;
+    }
+
 private:
     /**
      * @brief Update the view matrix based on the camera position and target.

attachments/simple_engine/engine.cpp

@@ -25,7 +25,7 @@ Engine::~Engine() {
 
 bool Engine::Initialize(const std::string& appName, int width, int height, bool enableValidationLayers) {
     // Create platform
-#if PLATFORM_ANDROID
+#if defined(PLATFORM_ANDROID)
     // For Android, the platform is created with the android_app
     // This will be handled in the android_main function
     return false;
@@ -213,14 +213,17 @@ void Engine::Run() {
         frameCount++;
         fpsUpdateTimer += deltaTime;
 
-        // Update window title with FPS and frame count every second
+        // Update window title with FPS and frame time every second
         if (fpsUpdateTimer >= 1.0f) {
             uint64_t framesSinceLastUpdate = frameCount - lastFPSUpdateFrame;
             currentFPS = framesSinceLastUpdate / fpsUpdateTimer;
+            // Average frame time in milliseconds over the last interval
+            double avgMs = (fpsUpdateTimer / static_cast<double>(framesSinceLastUpdate)) * 1000.0;
 
-            // Update window title with frame count and FPS
+            // Update window title with frame count, FPS, and frame time
             std::string title = "Simple Engine - Frame: " + std::to_string(frameCount) +
-                               " | FPS: " + std::to_string(static_cast<int>(currentFPS));
+                               " | FPS: " + std::to_string(static_cast<int>(currentFPS)) +
+                               " | ms: " + std::to_string(static_cast<int>(avgMs));
             platform->SetWindowTitle(title);
 
             // Reset timer and frame counter for next update
@@ -415,29 +418,26 @@ void Engine::Render() {
 }
 
 float Engine::CalculateDeltaTime() {
-    // Get current time
-    auto currentTime = static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(
-        std::chrono::high_resolution_clock::now().time_since_epoch()
-    ).count());
+    // Get current time using a steady clock to avoid system time jumps
+    uint64_t currentTime = static_cast<uint64_t>(
+        std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::steady_clock::now().time_since_epoch()
+        ).count()
+    );
 
     // Initialize lastFrameTime on first call
     if (lastFrameTime == 0) {
         lastFrameTime = currentTime;
-        return 0.016f; // Return ~16ms (60 FPS) for first frame
+        return 0.016f; // ~16ms as a sane initial guess
     }
 
-    // Calculate delta time
+    // Calculate delta time in milliseconds
     uint64_t delta = currentTime - lastFrameTime;
 
     // Update last frame time
     lastFrameTime = currentTime;
 
-    // Clamp delta time to reasonable values (prevent huge jumps)
-    if (delta > 10) { // Cap at 100ms (10 FPS minimum)
-        delta = 16; // Use 16ms instead
-    }
-
-    return delta / 1000.0f; // Convert to seconds
+    return static_cast<float>(delta) / 1000.0f;
 }
 
 void Engine::HandleResize(int width, int height) const {
@@ -754,7 +754,7 @@ void Engine::HandleMouseHover(float mouseX, float mouseY) {
 }
 
 
-#if PLATFORM_ANDROID
+#if defined(PLATFORM_ANDROID)
 // Android-specific implementation
 bool Engine::InitializeAndroid(android_app* app, const std::string& appName, bool enableValidationLayers) {
     // Create platform

attachments/simple_engine/engine.h

@@ -141,7 +141,7 @@ class Engine {
      */
     ImGuiSystem* GetImGuiSystem() const;
 
-#if PLATFORM_ANDROID
+#if defined(PLATFORM_ANDROID)
     /**
      * @brief Initialize the engine for Android.
      * @param app The Android app.

attachments/simple_engine/fetch_bistro_assets.bat

@@ -0,0 +1,55 @@
+@echo off
+setlocal enabledelayedexpansion
+
+REM Fetch the Bistro example assets into the desired assets directory.
+REM Default target: assets\bistro at the repository root.
+REM Usage:
+REM   fetch_bistro_assets.bat [target-dir]
+REM Examples:
+REM   fetch_bistro_assets.bat
+REM   fetch_bistro_assets.bat attachments\simple_engine\Assets\bistro
+
+set REPO_SSH=[email protected]:gpx1000/bistro.git
+set REPO_HTTPS=https://github.com/gpx1000/bistro.git
+
+if "%~1"=="" (
+    set TARGET_DIR=assets\bistro
+) else (
+    set TARGET_DIR=%~1
+)
+
+REM Ensure parent directory exists
+for %%I in ("%TARGET_DIR%") do set PARENT=%%~dpI
+if not exist "%PARENT%" mkdir "%PARENT%"
+
+REM If directory exists and is a git repo, update it; otherwise clone it
+if exist "%TARGET_DIR%\.git" (
+    echo Updating existing bistro assets in %TARGET_DIR%
+    pushd "%TARGET_DIR%"
+    git pull --ff-only
+    popd
+) else (
+    echo Cloning bistro assets into %TARGET_DIR%
+    REM Try SSH first; fall back to HTTPS on failure
+    git clone --depth 1 "%REPO_SSH%" "%TARGET_DIR%" 2>nul
+    if %ERRORLEVEL% neq 0 (
+        echo SSH clone failed, trying HTTPS
+        git clone --depth 1 "%REPO_HTTPS%" "%TARGET_DIR%"
+    )
+)
+
+REM If git-lfs is available, ensure LFS content is pulled
+where git >nul 2>nul
+if %ERRORLEVEL%==0 (
+    pushd "%TARGET_DIR%"
+    git lfs version >nul 2>nul
+    if %ERRORLEVEL%==0 (
+        git lfs install --local >nul 2>nul
+        git lfs pull
+    )
+    popd
+)
+
+echo Bistro assets ready at: %TARGET_DIR%
+endlocal
+exit /b 0

attachments/simple_engine/fetch_bistro_assets.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Fetch the Bistro example assets into the desired assets directory.
+# Default target: assets/bistro at the repository root.
+# Usage:
+#   ./fetch_bistro_assets.sh [target-dir]
+# Example:
+#   ./fetch_bistro_assets.sh            # clones to assets/bistro
+
+REPO_SSH="[email protected]:gpx1000/bistro.git"
+REPO_HTTPS="https://github.com/gpx1000/bistro.git"
+TARGET_DIR="${1:-assets/bistro}"
+
+mkdir -p "$(dirname "${TARGET_DIR}")"
+
+# If directory exists and is a git repo, update it; otherwise clone it.
+if [ -d "${TARGET_DIR}/.git" ]; then
+  echo "Updating existing bistro assets in ${TARGET_DIR}"
+  git -C "${TARGET_DIR}" pull --ff-only
+else
+  echo "Cloning bistro assets into ${TARGET_DIR}"
+  # Try SSH first; if it fails (e.g., no SSH key), fall back to HTTPS.
+  if git clone --depth 1 "${REPO_SSH}" "${TARGET_DIR}" 2>/dev/null; then
+    :
+  else
+    echo "SSH clone failed, trying HTTPS"
+    git clone --depth 1 "${REPO_HTTPS}" "${TARGET_DIR}"
+  fi
+fi
+
+# If git-lfs is available, ensure LFS content is pulled
+if command -v git >/dev/null 2>&1 && git -C "${TARGET_DIR}" lfs version >/dev/null 2>&1; then
+  git -C "${TARGET_DIR}" lfs install --local >/dev/null 2>&1 || true
+  git -C "${TARGET_DIR}" lfs pull || true
+fi
+
+echo "Bistro assets ready at: ${TARGET_DIR}"

attachments/simple_engine/install_dependencies_linux.sh

@@ -51,8 +51,7 @@ install_ubuntu_debian() {
         libglfw3-dev \
         libglm-dev \
         libopenal-dev \
-        libktx-dev \
-        libstb-dev
+        libktx-dev
 
     # Install Slang compiler (for shader compilation)
     echo "Installing Slang compiler..."
@@ -84,7 +83,7 @@ install_fedora_rhel() {
         openal-soft-devel
 
     # Note: Some packages might need to be built from source on RHEL/CentOS
-    echo "Note: Some dependencies (libktx, libstb, tinygltf) may need to be built from source"
+    echo "Note: Some dependencies (libktx, tinygltf) may need to be built from source"
     echo "Please refer to the project documentation for manual installation instructions"
 }
 
@@ -107,9 +106,9 @@ install_arch() {
 
     # Install AUR packages (requires yay or another AUR helper)
     if command -v yay &> /dev/null; then
-        yay -S --noconfirm libktx stb
+        yay -S --noconfirm libktx
     else
-        echo "Note: Please install yay or another AUR helper to install libktx and stb packages"
+        echo "Note: Please install yay or another AUR helper to install libktx packages"
         echo "Alternatively, build these dependencies from source"
     fi
 }

attachments/simple_engine/install_dependencies_windows.bat

@@ -132,13 +132,6 @@ if %errorLevel% neq 0 (
     echo Warning: Failed to install KTX via vcpkg
 )
 
-REM Install STB
-echo Installing STB...
-vcpkg install stb:x64-windows
-if %errorLevel% neq 0 (
-    echo Warning: Failed to install STB via vcpkg
-)
-
 REM Install tinygltf
 echo Installing tinygltf...
 vcpkg install tinygltf:x64-windows

attachments/simple_engine/main.cpp

@@ -38,7 +38,7 @@ void SetupScene(Engine* engine) {
     LoadGLTFModel(engine, "../Assets/bistro/bistro.gltf");
 }
 
-#if PLATFORM_ANDROID
+#if defined(PLATFORM_ANDROID)
 /**
  * @brief Android entry point.
  * @param app The Android app.

attachments/simple_engine/memory_pool.cpp

@@ -37,19 +37,21 @@ bool MemoryPool::initialize() {
         );
 
         // Uniform buffer pool: Small allocations, host-visible
+        // Use 64-byte alignment to match nonCoherentAtomSize and prevent validation errors
         configurePool(
             PoolType::UNIFORM_BUFFER,
             4 * 1024 * 1024,   // 4MB blocks
-            256,                // 256B allocation units
+            64,                 // 64B allocation units (aligned to nonCoherentAtomSize)
             vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent,
             4                   // Max 4 blocks (16MB total)
         );
 
         // Staging buffer pool: Variable allocations, host-visible
+        // Use 64-byte alignment to match nonCoherentAtomSize and prevent validation errors
         configurePool(
             PoolType::STAGING_BUFFER,
             16 * 1024 * 1024,  // 16MB blocks
-            1024,               // 1KB allocation units
+            64,                 // 64B allocation units (aligned to nonCoherentAtomSize)
             vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent,
             4                   // Max 4 blocks (64MB total)
         );
@@ -311,14 +313,16 @@ std::pair<vk::raii::Buffer, std::unique_ptr<MemoryPool::Allocation>> MemoryPool:
 
     // Determine a pool type based on usage and properties
     PoolType poolType = PoolType::VERTEX_BUFFER;
-    if (usage & vk::BufferUsageFlagBits::eVertexBuffer) {
+
+    // Check for host-visible requirements first (for instance buffers and staging)
+    if (properties & vk::MemoryPropertyFlagBits::eHostVisible) {
+        poolType = PoolType::STAGING_BUFFER;
+    } else if (usage & vk::BufferUsageFlagBits::eVertexBuffer) {
         poolType = PoolType::VERTEX_BUFFER;
     } else if (usage & vk::BufferUsageFlagBits::eIndexBuffer) {
         poolType = PoolType::INDEX_BUFFER;
     } else if (usage & vk::BufferUsageFlagBits::eUniformBuffer) {
         poolType = PoolType::UNIFORM_BUFFER;
-    } else if (properties & vk::MemoryPropertyFlagBits::eHostVisible) {
-        poolType = PoolType::STAGING_BUFFER;
     }
 
     // Create the buffer