Add deferred mesh uploads, batch resource staging, priority-based texture uploads, and thread-safe texture tracking. Refactor Vulkan queue handling and improve modern C++ usage.

BRDF now works as intended so we have true PBR scene.  We're going to add environment mapping in the complex samples, so this should complete the tutorial verison of the game engine.

Author: gpx1000

attachments/simple_engine/engine.cpp

@@ -198,20 +198,20 @@ bool Engine::RemoveEntity(Entity* entity) {
     std::string name = entity->GetName();
 
     // Find the entity in the vector
-    auto it = std::find_if(entities.begin(), entities.end(),
-        [entity](const std::unique_ptr<Entity>& e) {
-            return e.get() == entity;
-        });
+    auto it = std::ranges::find_if(entities,
+                                   [entity](const std::unique_ptr<Entity>& e) {
+                                       return e.get() == entity;
+                                   });
 
     if (it != entities.end()) {
         // Remove from the vector (ownership)
         entities.erase(it);
 
         // Update the map: point to another entity with the same name if one exists
-        auto remainingIt = std::find_if(entities.begin(), entities.end(),
-            [&name](const std::unique_ptr<Entity>& e) {
-                return e->GetName() == name;
-            });
+        auto remainingIt = std::ranges::find_if(entities,
+                                                [&name](const std::unique_ptr<Entity>& e) {
+                                                    return e->GetName() == name;
+                                                });
 
         if (remainingIt != entities.end()) {
             entityMap[name] = remainingIt->get();
@@ -357,6 +357,8 @@ void Engine::handleKeyInput(uint32_t key, bool pressed) {
         case GLFW_KEY_PAGE_DOWN:
             cameraControl.moveDown = pressed;
             break;
+        case GLFW_KEY_0:
+            break;
         default: break;
     }
 
@@ -366,13 +368,20 @@ void Engine::handleKeyInput(uint32_t key, bool pressed) {
 }
 
 void Engine::Update(TimeDelta deltaTime) {
-    // Debug: Verify Update method is being called
-    static int updateCallCount = 0;
-    updateCallCount++;
+    // During background scene loading we avoid touching the live entity
+    // list from the main thread. This lets the loading thread construct
+    // entities/components safely while the main thread only drives the
+    // UI/loading overlay.
+    if (renderer && renderer->IsLoading()) {
+        if (imguiSystem) {
+            imguiSystem->NewFrame();
+        }
+        return;
+    }
+
     // Process pending ball creations (outside rendering loop to avoid memory pool constraints)
     ProcessPendingBalls();
 
-
     if (activeCamera) {
         glm::vec3 currentCameraPosition = activeCamera->GetPosition();
         physicsSystem->SetCameraPosition(currentCameraPosition);

attachments/simple_engine/engine.h

@@ -355,4 +355,5 @@ class Engine {
      */
     void HandleMouseHover(float mouseX, float mouseY);
 
+
 };

attachments/simple_engine/imgui_system.cpp

@@ -123,12 +123,14 @@ void ImGuiSystem::NewFrame() {
 
     ImGui::NewFrame();
 
-    // Loading overlay: show only a fullscreen progress bar while model/textures are loading
+    // Loading overlay: show only a fullscreen progress bar while the model
+    // itself is loading. Once the scene is ready and geometry is visible,
+    // we no longer block the view with a full-screen progress bar.
     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)) {
+        if (modelLoading) {
             ImGuiIO& io = ImGui::GetIO();
             // Suppress right-click while loading
             if (io.MouseDown[1]) io.MouseDown[1] = false;
@@ -158,11 +160,7 @@ void ImGuiSystem::NewFrame() {
                 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::Text("Loading scene...");
                 ImGui::EndGroup();
                 ImGui::PopStyleVar();
             }
@@ -172,6 +170,41 @@ void ImGuiSystem::NewFrame() {
         }
     }
 
+    // --- Streaming status: small progress indicator in the upper-right ---
+    // Once the scene is visible, textures may continue streaming to the GPU.
+    // Show a compact progress bar in the top-right while there are still
+    // outstanding texture tasks, and hide it once everything is fully loaded.
+    if (renderer) {
+        const uint32_t uploadTotal = renderer->GetUploadJobsTotal();
+        const uint32_t uploadDone  = renderer->GetUploadJobsCompleted();
+        const bool modelLoading = renderer->IsLoading();
+
+        if (!modelLoading && uploadTotal > 0 && uploadDone < uploadTotal) {
+            ImGuiIO& io = ImGui::GetIO();
+            const ImVec2 dispSize = io.DisplaySize;
+
+            const float windowWidth  = std::min(260.0f, dispSize.x * 0.35f);
+            const float windowHeight = 60.0f;
+            const ImVec2 winPos(dispSize.x - windowWidth - 10.0f, 10.0f);
+
+            ImGui::SetNextWindowPos(winPos, ImGuiCond_Always);
+            ImGui::SetNextWindowSize(ImVec2(windowWidth, windowHeight));
+            ImGuiWindowFlags flags = ImGuiWindowFlags_NoTitleBar |
+                                     ImGuiWindowFlags_NoResize   |
+                                     ImGuiWindowFlags_NoMove     |
+                                     ImGuiWindowFlags_NoScrollbar|
+                                     ImGuiWindowFlags_NoSavedSettings |
+                                     ImGuiWindowFlags_NoCollapse;
+
+            if (ImGui::Begin("##StreamingTextures", nullptr, flags)) {
+                ImGui::TextUnformatted("Streaming textures to GPU");
+                float frac = (uploadTotal > 0) ? (float)uploadDone / (float)uploadTotal : 0.0f;
+                ImGui::ProgressBar(frac, ImVec2(-1.0f, 0.0f));
+            }
+            ImGui::End();
+        }
+    }
+
     // Create HRTF Audio Control UI
     ImGui::Begin("HRTF Audio Controls");
     ImGui::Text("Hello, Vulkan!");
@@ -241,22 +274,6 @@ void ImGuiSystem::NewFrame() {
         ImGui::Text("Note: Quality controls affect BRDF rendering only");
     }
 
-    ImGui::Separator();
-
-    // Sun position control (punctual light in GLTF)
-    ImGui::Text("Sun Position in Sky:");
-    if (renderer) {
-        float sun = renderer->GetSunPosition();
-        if (ImGui::SliderFloat("Sun Position", &sun, 0.0f, 1.0f, "%.2f")) {
-            renderer->SetSunPosition(sun);
-        }
-        ImGui::SameLine();
-        if (ImGui::Button("Noon")) { sun = 0.5f; renderer->SetSunPosition(sun); }
-        ImGui::SameLine();
-        if (ImGui::Button("Night")) { sun = 0.0f; renderer->SetSunPosition(sun); }
-        ImGui::Text("Tip: 0/1 = Night, 0.5 = Noon. Warmer tint near horizon simulates evening.");
-    }
-
     ImGui::Separator();
     ImGui::Text("3D Audio Position Control");
 

attachments/simple_engine/main.cpp

@@ -39,7 +39,10 @@ void SetupScene(Engine* engine) {
     // Set the camera as the active camera
     engine->SetActiveCamera(camera);
 
-    // Kick off GLTF model loading on a background thread so the main loop can start and render the UI/progress bar
+    // Kick off GLTF model loading on a background thread so the main loop
+    // can start and render the UI/progress bar while the scene is being
+    // constructed. Engine::Update will avoid updating entities while
+    // loading is in progress to prevent data races.
     if (auto* renderer = engine->GetRenderer()) {
         renderer->SetLoading(true);
     }

attachments/simple_engine/mesh_component.cpp

@@ -11,14 +11,14 @@ void MeshComponent::CreateSphere(float radius, const glm::vec3& color, int segme
 
     // Generate sphere vertices using parametric equations
     for (int lat = 0; lat <= segments; ++lat) {
-        auto theta = static_cast<float>(lat * M_PI / segments); // Latitude angle (0 to PI)
-        float sinTheta = sinf(theta);
-        float cosTheta = cosf(theta);
+        const auto theta = static_cast<float>(lat * M_PI / segments); // Latitude angle (0 to PI)
+        const float sinTheta = sinf(theta);
+        const float cosTheta = cosf(theta);
 
         for (int lon = 0; lon <= segments; ++lon) {
-            auto phi = static_cast<float>(lon * 2.0 * M_PI / segments); // Longitude angle (0 to 2*PI)
-            float sinPhi = sinf(phi);
-            float cosPhi = cosf(phi);
+            const auto phi = static_cast<float>(lon * 2.0 * M_PI / segments); // Longitude angle (0 to 2*PI)
+            const float sinPhi = sinf(phi);
+            const float cosPhi = cosf(phi);
 
             // Calculate position
             glm::vec3 position = {
@@ -31,7 +31,7 @@ void MeshComponent::CreateSphere(float radius, const glm::vec3& color, int segme
             glm::vec3 normal = glm::normalize(position);
 
             // Texture coordinates
-            glm::vec2 texCoord = {
+            const glm::vec2 texCoord = {
                 static_cast<float>(lon) / static_cast<float>(segments),
                 static_cast<float>(lat) / static_cast<float>(segments)
             };
@@ -66,8 +66,8 @@ void MeshComponent::CreateSphere(float radius, const glm::vec3& color, int segme
     // Generate indices for triangles
     for (int lat = 0; lat < segments; ++lat) {
         for (int lon = 0; lon < segments; ++lon) {
-            int current = lat * (segments + 1) + lon;
-            int next = current + segments + 1;
+            const int current = lat * (segments + 1) + lon;
+            const int next = current + segments + 1;
 
             // Create two triangles for each quad
             indices.push_back(current);

attachments/simple_engine/mesh_component.h

@@ -66,7 +66,7 @@ struct InstanceData {
 
 
     static vk::VertexInputBindingDescription getBindingDescription() {
-        vk::VertexInputBindingDescription bindingDescription(
+        constexpr vk::VertexInputBindingDescription bindingDescription(
             1,                                  // binding (binding 1 for instance data)
             sizeof(InstanceData),               // stride
             vk::VertexInputRate::eInstance      // inputRate
@@ -78,7 +78,7 @@ struct InstanceData {
         constexpr uint32_t modelBase = offsetof(InstanceData, modelMatrix);
         constexpr uint32_t normalBase = offsetof(InstanceData, normalMatrix);
         constexpr uint32_t vec4Size = sizeof(glm::vec4);
-        std::array<vk::VertexInputAttributeDescription, 7> attributeDescriptions = {
+        constexpr std::array<vk::VertexInputAttributeDescription, 7> attributeDescriptions = {
             // Model matrix columns (locations 4-7)
             vk::VertexInputAttributeDescription{
                 .location = 4,
@@ -131,7 +131,7 @@ struct InstanceData {
     static std::array<vk::VertexInputAttributeDescription, 4> getModelMatrixAttributeDescriptions() {
         constexpr uint32_t modelBase = offsetof(InstanceData, modelMatrix);
         constexpr uint32_t vec4Size = sizeof(glm::vec4);
-        std::array<vk::VertexInputAttributeDescription, 4> attributeDescriptions = {
+        constexpr std::array<vk::VertexInputAttributeDescription, 4> attributeDescriptions = {
             vk::VertexInputAttributeDescription{
                 .location = 4,
                 .binding = 1,
@@ -164,7 +164,7 @@ struct InstanceData {
     static std::array<vk::VertexInputAttributeDescription, 3> getNormalMatrixAttributeDescriptions() {
         constexpr uint32_t normalBase = offsetof(InstanceData, normalMatrix);
         constexpr uint32_t vec4Size = sizeof(glm::vec4);
-        std::array<vk::VertexInputAttributeDescription, 3> attributeDescriptions = {
+        constexpr std::array<vk::VertexInputAttributeDescription, 3> attributeDescriptions = {
             vk::VertexInputAttributeDescription{
                 .location = 8,
                 .binding = 1,
@@ -205,7 +205,7 @@ struct Vertex {
     }
 
     static vk::VertexInputBindingDescription getBindingDescription() {
-        vk::VertexInputBindingDescription bindingDescription(
+        constexpr vk::VertexInputBindingDescription bindingDescription(
             0,                                  // binding
             sizeof(Vertex),                     // stride
             vk::VertexInputRate::eVertex        // inputRate
@@ -214,7 +214,7 @@ struct Vertex {
     }
 
     static std::array<vk::VertexInputAttributeDescription, 4> getAttributeDescriptions() {
-        std::array<vk::VertexInputAttributeDescription, 4> attributeDescriptions = {
+        constexpr std::array<vk::VertexInputAttributeDescription, 4> attributeDescriptions = {
             vk::VertexInputAttributeDescription{
                 .location = 0,
                 .binding = 0,
@@ -247,7 +247,7 @@ struct Vertex {
 /**
  * @brief Component that handles the mesh data for rendering.
  */
-class MeshComponent : public Component {
+class MeshComponent final : public Component {
 private:
     std::vector<Vertex> vertices;
     std::vector<uint32_t> indices;