implementing support for asynchronous texture loading and improved Vulkan queue handling.

Bistro.gltf loads all textures, and creates physics geometry in under 44 seconds.  Seeing 55 fps as well.

Author: gpx1000

attachments/simple_engine/engine.cpp

@@ -285,6 +285,11 @@ void Engine::handleMouseInput(float x, float y, uint32_t buttons) {
     // Check if ImGui wants to capture mouse input first
         bool imguiWantsMouse = imguiSystem && imguiSystem->WantCaptureMouse();
 
+        // Suppress right-click while loading
+        if (renderer && renderer->IsLoading()) {
+            buttons &= ~2u; // clear right button bit
+        }
+
         if (!imguiWantsMouse) {
             // Handle mouse click for ball throwing (right mouse button)
             if (buttons & 2) { // Right mouse button (bit 1)

attachments/simple_engine/imgui_system.cpp

@@ -123,6 +123,55 @@ void ImGuiSystem::NewFrame() {
 
     ImGui::NewFrame();
 
+    // Loading overlay: show only a fullscreen progress bar while model/textures are loading
+    if (renderer) {
+        const uint32_t scheduled = renderer->GetTextureTasksScheduled();
+        const uint32_t completed = renderer->GetTextureTasksCompleted();
+        const bool modelLoading = renderer->IsLoading();
+        if (modelLoading || (scheduled > 0 && completed < scheduled)) {
+            ImGuiIO& io = ImGui::GetIO();
+            // Suppress right-click while loading
+            if (io.MouseDown[1]) io.MouseDown[1] = false;
+
+            const ImVec2 dispSize = io.DisplaySize;
+
+            ImGui::SetNextWindowPos(ImVec2(0, 0));
+            ImGui::SetNextWindowSize(dispSize);
+            ImGuiWindowFlags flags = ImGuiWindowFlags_NoTitleBar |
+                                     ImGuiWindowFlags_NoResize |
+                                     ImGuiWindowFlags_NoMove |
+                                     ImGuiWindowFlags_NoScrollbar |
+                                     ImGuiWindowFlags_NoCollapse |
+                                     ImGuiWindowFlags_NoSavedSettings |
+                                     ImGuiWindowFlags_NoBringToFrontOnFocus |
+                                     ImGuiWindowFlags_NoNav;
+
+            if (ImGui::Begin("##LoadingOverlay", nullptr, flags)) {
+                ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
+                // Center the progress elements
+                const float barWidth = dispSize.x * 0.8f;
+                const float barX = (dispSize.x - barWidth) * 0.5f;
+                const float barY = dispSize.y * 0.45f;
+                ImGui::SetCursorPos(ImVec2(barX, barY));
+                ImGui::BeginGroup();
+                float frac = (scheduled > 0) ? (float)completed / (float)scheduled : 0.0f;
+                ImGui::ProgressBar(frac, ImVec2(barWidth, 0.0f));
+                ImGui::Dummy(ImVec2(0.0f, 10.0f));
+                ImGui::SetCursorPosX(barX);
+                if (modelLoading) {
+                    ImGui::Text("Loading model...");
+                } else {
+                    ImGui::Text("Loading textures: %u / %u", completed, scheduled);
+                }
+                ImGui::EndGroup();
+                ImGui::PopStyleVar();
+            }
+            ImGui::End();
+            // Do not draw the rest of the UI until loading finishes
+            return;
+        }
+    }
+
     // Create HRTF Audio Control UI
     ImGui::Begin("HRTF Audio Controls");
     ImGui::Text("Hello, Vulkan!");
@@ -359,6 +408,19 @@ void ImGuiSystem::NewFrame() {
         ImGui::Text("Camera: Manual control (WASD + mouse)");
     }
 
+    // Texture loading progress
+    if (renderer) {
+        const uint32_t scheduled = renderer->GetTextureTasksScheduled();
+        const uint32_t completed = renderer->GetTextureTasksCompleted();
+        if (scheduled > 0 && completed < scheduled) {
+            ImGui::Separator();
+            float frac = scheduled ? (float)completed / (float)scheduled : 1.0f;
+            ImGui::Text("Loading textures: %u / %u", completed, scheduled);
+            ImGui::ProgressBar(frac, ImVec2(-FLT_MIN, 0.0f));
+            ImGui::Text("You can continue interacting while textures stream in...");
+        }
+    }
+
     ImGui::End();
 }
 

attachments/simple_engine/main.cpp

@@ -5,6 +5,7 @@
 
 #include <iostream>
 #include <stdexcept>
+#include <thread>
 
 // Constants
 constexpr int WINDOW_WIDTH = 800;
@@ -38,8 +39,13 @@ void SetupScene(Engine* engine) {
     // Set the camera as the active camera
     engine->SetActiveCamera(camera);
 
-    // Load GLTF model synchronously on the main thread
-    LoadGLTFModel(engine, "../Assets/bistro/bistro.gltf");
+    // Kick off GLTF model loading on a background thread so the main loop can start and render the UI/progress bar
+    if (auto* renderer = engine->GetRenderer()) {
+        renderer->SetLoading(true);
+    }
+    std::thread([engine]{
+        LoadGLTFModel(engine, "../Assets/bistro/bistro.gltf");
+    }).detach();
 }
 
 #if defined(PLATFORM_ANDROID)

attachments/simple_engine/memory_pool.cpp

@@ -1,11 +1,13 @@
 #include "memory_pool.h"
 #include <iostream>
 #include <algorithm>
+#include <vulkan/vulkan.hpp>
 
 MemoryPool::MemoryPool(const vk::raii::Device& device, const vk::raii::PhysicalDevice& physicalDevice)
     : device(device), physicalDevice(physicalDevice) {
 }
 
+
 MemoryPool::~MemoryPool() {
     // RAII will handle cleanup automatically
     std::lock_guard lock(poolMutex);
@@ -153,6 +155,48 @@ std::unique_ptr<MemoryPool::MemoryBlock> MemoryPool::createMemoryBlock(PoolType
     return block;
 }
 
+std::unique_ptr<MemoryPool::MemoryBlock> MemoryPool::createMemoryBlockWithType(PoolType poolType, vk::DeviceSize size, uint32_t memoryTypeIndex) {
+    auto configIt = poolConfigs.find(poolType);
+    if (configIt == poolConfigs.end()) {
+        throw std::runtime_error("Pool type not configured");
+    }
+    const PoolConfig& config = configIt->second;
+
+    // Allocate the memory block with the exact requested size
+    vk::MemoryAllocateInfo allocInfo{
+        .allocationSize = size,
+        .memoryTypeIndex = memoryTypeIndex
+    };
+
+    // Determine properties from the chosen memory type
+    const auto memProps = physicalDevice.getMemoryProperties();
+    if (memoryTypeIndex >= memProps.memoryTypeCount) {
+        throw std::runtime_error("Invalid memoryTypeIndex for createMemoryBlockWithType");
+    }
+    const vk::MemoryPropertyFlags typeProps = memProps.memoryTypes[memoryTypeIndex].propertyFlags;
+
+    auto block = std::unique_ptr<MemoryBlock>(new MemoryBlock{
+        .memory = vk::raii::DeviceMemory(device, allocInfo),
+        .size = size,
+        .used = 0,
+        .memoryTypeIndex = memoryTypeIndex,
+        .isMapped = false,
+        .mappedPtr = nullptr,
+        .freeList = {},
+        .allocationUnit = config.allocationUnit
+    });
+
+    block->isMapped = (typeProps & vk::MemoryPropertyFlagBits::eHostVisible) != vk::MemoryPropertyFlags{};
+    if (block->isMapped) {
+        block->mappedPtr = block->memory.mapMemory(0, size);
+    }
+
+    const size_t numUnits = static_cast<size_t>(block->size / config.allocationUnit);
+    block->freeList.resize(numUnits, true);
+
+    return block;
+}
+
 std::pair<MemoryPool::MemoryBlock*, size_t> MemoryPool::findSuitableBlock(PoolType poolType, vk::DeviceSize size, vk::DeviceSize alignment) {
     auto poolIt = pools.find(poolType);
     if (poolIt == pools.end()) {
@@ -162,27 +206,42 @@ std::pair<MemoryPool::MemoryBlock*, size_t> MemoryPool::findSuitableBlock(PoolTy
     auto& poolBlocks = poolIt->second;
     const PoolConfig& config = poolConfigs[poolType];
 
-    // Calculate required units (accounting for alignment)
+    // Calculate required units (accounting for size alignment)
     const vk::DeviceSize alignedSize = ((size + alignment - 1) / alignment) * alignment;
-    const size_t requiredUnits = (alignedSize + config.allocationUnit - 1) / config.allocationUnit;
+    const size_t requiredUnits = static_cast<size_t>((alignedSize + config.allocationUnit - 1) / config.allocationUnit);
 
-    // Search existing blocks for sufficient free space
+    // Search existing blocks for sufficient free space with proper offset alignment
     for (const auto& block : poolBlocks) {
-        // Find consecutive free units
-        size_t consecutiveFree = 0;
-        size_t startUnitCandidate = 0;
-        for (size_t i = 0; i < block->freeList.size(); ++i) {
-            if (block->freeList[i]) {
-                if (consecutiveFree == 0) {
-                    startUnitCandidate = i;
-                }
-                consecutiveFree++;
-                if (consecutiveFree >= requiredUnits) {
-                    return {block.get(), startUnitCandidate};
-                }
-            } else {
-                consecutiveFree = 0;
+        const vk::DeviceSize unit = config.allocationUnit;
+        const size_t totalUnits = block->freeList.size();
+
+        size_t i = 0;
+        while (i < totalUnits) {
+            // Ensure starting unit produces an offset aligned to 'alignment'
+            vk::DeviceSize startOffset = static_cast<vk::DeviceSize>(i) * unit;
+            if ((alignment > 0) && (startOffset % alignment != 0)) {
+                // Advance i to the next unit that aligns with 'alignment'
+                const vk::DeviceSize remainder = startOffset % alignment;
+                const vk::DeviceSize advanceBytes = alignment - remainder;
+                const size_t advanceUnits = static_cast<size_t>((advanceBytes + unit - 1) / unit);
+                i += std::max<size_t>(advanceUnits, 1);
+                continue;
             }
+
+            // From aligned i, check for consecutive free units
+            size_t consecutiveFree = 0;
+            size_t j = i;
+            while (j < totalUnits && block->freeList[j] && consecutiveFree < requiredUnits) {
+                ++consecutiveFree;
+                ++j;
+            }
+
+            if (consecutiveFree >= requiredUnits) {
+                return {block.get(), i};
+            }
+
+            // Move past the checked range
+            i = (j > i) ? j : (i + 1);
         }
     }
 
@@ -333,13 +392,41 @@ std::pair<vk::raii::Image, std::unique_ptr<MemoryPool::Allocation>> MemoryPool::
 
     vk::raii::Image image(device, imageInfo);
 
-    // Get memory requirements
+    // Get memory requirements for this image
     vk::MemoryRequirements memRequirements = image.getMemoryRequirements();
 
-    // Allocate from texture pool
-    auto allocation = allocate(PoolType::TEXTURE_IMAGE, memRequirements.size, memRequirements.alignment);
-    if (!allocation) {
-        throw std::runtime_error("Failed to allocate memory from texture pool");
+    // Pick a memory type compatible with this image
+    uint32_t memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties);
+
+    // Create a dedicated memory block for this image with the exact type and size
+    std::unique_ptr<Allocation> allocation;
+    {
+        std::lock_guard<std::mutex> lock(poolMutex);
+        auto poolIt = pools.find(PoolType::TEXTURE_IMAGE);
+        if (poolIt == pools.end()) {
+            poolIt = pools.try_emplace(PoolType::TEXTURE_IMAGE).first;
+        }
+        auto& poolBlocks = poolIt->second;
+        auto block = createMemoryBlockWithType(PoolType::TEXTURE_IMAGE, memRequirements.size, memoryTypeIndex);
+
+        // Prepare allocation that uses the new block from offset 0
+        allocation = std::make_unique<Allocation>();
+        allocation->memory = *block->memory;
+        allocation->offset = 0;
+        allocation->size = memRequirements.size;
+        allocation->memoryTypeIndex = memoryTypeIndex;
+        allocation->isMapped = block->isMapped;
+        allocation->mappedPtr = block->mappedPtr;
+
+        // Mark the entire block as used
+        block->used = memRequirements.size;
+        const size_t units = block->freeList.size();
+        for (size_t i = 0; i < units; ++i) {
+            block->freeList[i] = false;
+        }
+
+        // Keep the block owned by the pool for lifetime management and deallocation support
+        poolBlocks.push_back(std::move(block));
     }
 
     // Bind memory to image

attachments/simple_engine/memory_pool.h

@@ -57,6 +57,8 @@ class MemoryPool {
 private:
     const vk::raii::Device& device;
     const vk::raii::PhysicalDevice& physicalDevice;
+    vk::PhysicalDeviceMemoryProperties memPropsCache{};
+
 
     // Pool configurations
     struct PoolConfig {
@@ -78,6 +80,8 @@ class MemoryPool {
     // Helper methods
     uint32_t findMemoryType(uint32_t typeFilter, vk::MemoryPropertyFlags properties) const;
     std::unique_ptr<MemoryBlock> createMemoryBlock(PoolType poolType, vk::DeviceSize size);
+    // Create a memory block with an explicit memory type index (used for images requiring a specific type)
+    std::unique_ptr<MemoryBlock> createMemoryBlockWithType(PoolType poolType, vk::DeviceSize size, uint32_t memoryTypeIndex);
     std::pair<MemoryBlock*, size_t> findSuitableBlock(PoolType poolType, vk::DeviceSize size, vk::DeviceSize alignment);
 
 public: