The bistro scene now loads. Still have some issues with PBR but I think that's due to material only looking at the vespa. This includes camera controls.

Author: gpx1000

attachments/simple_engine/CMakeLists.txt

@@ -89,6 +89,7 @@ add_custom_target(shaders DEPENDS ${SHADER_SPVS})
 set(SOURCES
     main.cpp
     engine.cpp
+    scene_loading.cpp
     platform.cpp
     renderer_core.cpp
     renderer_rendering.cpp

attachments/simple_engine/audio_system.h

@@ -9,11 +9,7 @@
 #include <condition_variable>
 #include <atomic>
 #include <queue>
-#ifdef __INTELLISENSE__
 #include <vulkan/vulkan_raii.hpp>
-#else
-import vulkan_hpp;
-#endif
 #include <vulkan/vk_platform.h>
 
 /**

attachments/simple_engine/camera_component.cpp

@@ -56,8 +56,5 @@ void CameraComponent::UpdateProjectionMatrix() {
         float halfHeight = orthoHeight * 0.5f;
         projectionMatrix = glm::ortho(-halfWidth, halfWidth, -halfHeight, halfHeight, nearPlane, farPlane);
     }
-    // Flip Y-axis for Vulkan coordinate system
-    // @see en/Building_a_Simple_Engine/Camera_Transformations/05_vulkan_integration.adoc#coordinate-system-differences
-    projectionMatrix[1][1] *= -1;
     projectionMatrixDirty = false;
 }

attachments/simple_engine/camera_component.h

@@ -150,6 +150,17 @@ class CameraComponent : public Component {
         viewMatrixDirty = true;
     }
 
+    /**
+     * @brief Make the camera look at a specific target position.
+     * @param targetPosition The position to look at.
+     * @param upVector The up vector (optional, defaults to current up vector).
+     */
+    void LookAt(const glm::vec3& targetPosition, const glm::vec3& upVector = glm::vec3(0.0f, 1.0f, 0.0f)) {
+        target = targetPosition;
+        up = upVector;
+        viewMatrixDirty = true;
+    }
+
     /**
      * @brief Get the view matrix.
      * @return The view matrix.

attachments/simple_engine/descriptor_manager.h

@@ -1,10 +1,6 @@
 #pragma once
 
-#ifdef __INTELLISENSE__
 #include <vulkan/vulkan_raii.hpp>
-#else
-import vulkan_hpp;
-#endif
 #include <vector>
 #include <unordered_map>
 #define GLM_FORCE_RADIANS

attachments/simple_engine/engine.cpp

@@ -1,8 +1,10 @@
 #include "engine.h"
+#include "scene_loading.h"
 
 #include <chrono>
 #include <algorithm>
 #include <stdexcept>
+#include <iostream>
 
 // This implementation corresponds to the Engine_Architecture chapter in the tutorial:
 // @see en/Building_a_Simple_Engine/Engine_Architecture/02_architectural_patterns.adoc
@@ -38,13 +40,72 @@ bool Engine::Initialize(const std::string& appName, int width, int height, bool
 
     // Set mouse callback
     platform->SetMouseCallback([this](float x, float y, uint32_t buttons) {
+        // Handle camera rotation when left mouse button is pressed
+        if (buttons & 1) { // Left mouse button (bit 0)
+            if (!cameraControl.mouseLeftPressed) {
+                cameraControl.mouseLeftPressed = true;
+                cameraControl.firstMouse = true;
+            }
+
+            if (cameraControl.firstMouse) {
+                cameraControl.lastMouseX = x;
+                cameraControl.lastMouseY = y;
+                cameraControl.firstMouse = false;
+            }
+
+            float xOffset = x - cameraControl.lastMouseX;
+            float yOffset = cameraControl.lastMouseY - y; // Reversed since y-coordinates go from bottom to top
+            cameraControl.lastMouseX = x;
+            cameraControl.lastMouseY = y;
+
+            xOffset *= cameraControl.mouseSensitivity;
+            yOffset *= cameraControl.mouseSensitivity;
+
+            cameraControl.yaw += xOffset;
+            cameraControl.pitch += yOffset;
+
+            // Constrain pitch to avoid gimbal lock
+            if (cameraControl.pitch > 89.0f) cameraControl.pitch = 89.0f;
+            if (cameraControl.pitch < -89.0f) cameraControl.pitch = -89.0f;
+        } else {
+            cameraControl.mouseLeftPressed = false;
+        }
+
         if (imguiSystem) {
             imguiSystem->HandleMouse(x, y, buttons);
         }
     });
 
     // Set keyboard callback
     platform->SetKeyboardCallback([this](uint32_t key, bool pressed) {
+        // Handle camera movement keys (WASD + Arrow keys)
+        switch (key) {
+            case GLFW_KEY_W:
+            case GLFW_KEY_UP:
+                cameraControl.moveForward = pressed;
+                break;
+            case GLFW_KEY_S:
+            case GLFW_KEY_DOWN:
+                cameraControl.moveBackward = pressed;
+                break;
+            case GLFW_KEY_A:
+            case GLFW_KEY_LEFT:
+                cameraControl.moveLeft = pressed;
+                break;
+            case GLFW_KEY_D:
+            case GLFW_KEY_RIGHT:
+                cameraControl.moveRight = pressed;
+                break;
+            case GLFW_KEY_Q:
+            case GLFW_KEY_PAGE_UP:
+                cameraControl.moveUp = pressed;
+                break;
+            case GLFW_KEY_E:
+            case GLFW_KEY_PAGE_DOWN:
+                cameraControl.moveDown = pressed;
+                break;
+        }
+
         if (imguiSystem) {
             imguiSystem->HandleKeyboard(key, pressed);
         }
@@ -68,6 +129,9 @@ bool Engine::Initialize(const std::string& appName, int width, int height, bool
         return false;
     }
 
+    // Connect model loader to renderer for light extraction
+    renderer->SetModelLoader(modelLoader.get());
+
     // Initialize audio system
     if (!audioSystem->Initialize(renderer.get())) {
         return false;
@@ -246,6 +310,9 @@ ImGuiSystem* Engine::GetImGuiSystem() const {
 }
 
 void Engine::Update(float deltaTime) {
+    // Check for completed background loading and create entities if ready
+    CheckAndCreateLoadedEntities();
+
     // Update physics system
     physicsSystem->Update(deltaTime);
 
@@ -255,6 +322,11 @@ void Engine::Update(float deltaTime) {
     // Update ImGui system
     imguiSystem->NewFrame();
 
+    // Update camera controls
+    if (activeCamera) {
+        UpdateCameraControls(deltaTime);
+    }
+
     // Update all entities
     for (auto& entity : entities) {
         if (entity->IsActive()) {
@@ -325,6 +397,75 @@ void Engine::HandleResize(int width, int height) {
     }
 }
 
+void Engine::UpdateCameraControls(float deltaTime) {
+    if (!activeCamera) return;
+
+    // Get camera transform component
+    TransformComponent* cameraTransform = activeCamera->GetOwner()->GetComponent<TransformComponent>();
+    if (!cameraTransform) return;
+
+    // Calculate movement speed
+    float velocity = cameraControl.cameraSpeed * deltaTime;
+
+    // Calculate camera direction vectors based on yaw and pitch
+    glm::vec3 front;
+    front.x = cos(glm::radians(cameraControl.yaw)) * cos(glm::radians(cameraControl.pitch));
+    front.y = sin(glm::radians(cameraControl.pitch));
+    front.z = sin(glm::radians(cameraControl.yaw)) * cos(glm::radians(cameraControl.pitch));
+    front = glm::normalize(front);
+
+    glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f);
+    glm::vec3 right = glm::normalize(glm::cross(front, up));
+    up = glm::normalize(glm::cross(right, front));
+
+    // Get current camera position
+    glm::vec3 position = cameraTransform->GetPosition();
+
+    // Apply movement based on input
+    if (cameraControl.moveForward) {
+        position += front * velocity;
+    }
+    if (cameraControl.moveBackward) {
+        position -= front * velocity;
+    }
+    if (cameraControl.moveLeft) {
+        position -= right * velocity;
+    }
+    if (cameraControl.moveRight) {
+        position += right * velocity;
+    }
+    if (cameraControl.moveUp) {
+        position += up * velocity;
+    }
+    if (cameraControl.moveDown) {
+        position -= up * velocity;
+    }
+
+    // Update camera position
+    cameraTransform->SetPosition(position);
+
+    // Update camera target based on direction
+    glm::vec3 target = position + front;
+    activeCamera->SetTarget(target);
+}
+
+void Engine::CheckAndCreateLoadedEntities() {
+    // Check if background loading is complete
+    if (g_loadingState.loadingComplete && !g_loadingState.loadedMaterials.empty()) {
+        // Create entities from loaded materials on the main thread
+        CreateEntitiesFromLoadedMaterials(this);
+
+        // Reset the loading complete flag
+        g_loadingState.loadingComplete = false;
+    }
+
+    // Check for loading errors
+    if (g_loadingState.loadingFailed) {
+        std::cerr << "Background loading failed: " << g_loadingState.errorMessage << std::endl;
+        g_loadingState.loadingFailed = false; // Reset the flag
+    }
+}
+
 #if PLATFORM_ANDROID
 // Android-specific implementation
 bool Engine::InitializeAndroid(android_app* app, const std::string& appName, bool enableValidationLayers) {
@@ -371,6 +512,9 @@ bool Engine::InitializeAndroid(android_app* app, const std::string& appName, boo
         return false;
     }
 
+    // Connect model loader to renderer for light extraction
+    renderer->SetModelLoader(modelLoader.get());
+
     // Initialize audio system
     if (!audioSystem->Initialize(renderer.get())) {
         return false;

attachments/simple_engine/engine.h

@@ -182,6 +182,24 @@ class Engine {
     float deltaTime = 0.0f;
     uint64_t lastFrameTime = 0;
 
+    // Camera control state
+    struct CameraControlState {
+        bool moveForward = false;
+        bool moveBackward = false;
+        bool moveLeft = false;
+        bool moveRight = false;
+        bool moveUp = false;
+        bool moveDown = false;
+        bool mouseLeftPressed = false;
+        float lastMouseX = 0.0f;
+        float lastMouseY = 0.0f;
+        float yaw = 0.0f;   // Horizontal rotation
+        float pitch = 0.0f; // Vertical rotation
+        bool firstMouse = true;
+        float cameraSpeed = 5.0f;
+        float mouseSensitivity = 0.1f;
+    } cameraControl;
+
     /**
      * @brief Update the engine state.
      * @param deltaTime The time elapsed since the last update.
@@ -205,4 +223,15 @@ class Engine {
      * @param height The new height of the window.
      */
     void HandleResize(int width, int height);
+
+    /**
+     * @brief Update camera controls based on input state.
+     * @param deltaTime The time elapsed since the last update.
+     */
+    void UpdateCameraControls(float deltaTime);
+
+    /**
+     * @brief Check for completed background loading and create entities if ready.
+     */
+    void CheckAndCreateLoadedEntities();
 };

attachments/simple_engine/imgui_system.cpp

@@ -109,6 +109,22 @@ void ImGuiSystem::NewFrame() {
     // Create HRTF Audio Control UI
     ImGui::Begin("HRTF Audio Controls");
     ImGui::Text("Hello, Vulkan!");
+    // PBR Rendering Controls
+    ImGui::Separator();
+    ImGui::Text("PBR Rendering Controls:");
+
+    if (ImGui::Checkbox("Enable PBR Rendering", &pbrEnabled)) {
+        std::cout << "PBR rendering " << (pbrEnabled ? "enabled" : "disabled") << std::endl;
+    }
+
+    if (pbrEnabled) {
+        ImGui::Text("Status: PBR pipeline active for supported models");
+        ImGui::Text("Models using PBR: Bistro scene");
+    } else {
+        ImGui::Text("Status: Using basic rendering pipeline");
+        ImGui::Text("All models rendered with basic shading");
+    }
+
     ImGui::Text("3D Audio Position Control");
 
     // Audio source selection

attachments/simple_engine/imgui_system.h

@@ -3,11 +3,7 @@
 #include <string>
 #include <vector>
 #include <memory>
-#ifdef __INTELLISENSE__
 #include <vulkan/vulkan_raii.hpp>
-#else
-import vulkan_hpp;
-#endif
 #include <vulkan/vk_platform.h>
 
 // Forward declarations
@@ -105,6 +101,12 @@ class ImGuiSystem {
      */
     void SetAudioSystem(AudioSystem* audioSystem);
 
+    /**
+     * @brief Get the current PBR rendering state.
+     * @return True if PBR rendering is enabled, false otherwise.
+     */
+    bool IsPBREnabled() const { return pbrEnabled; }
+
 private:
     // ImGui context
     ImGuiContext* context = nullptr;
@@ -151,6 +153,9 @@ class ImGuiSystem {
     // Initialization flag
     bool initialized = false;
 
+    // PBR rendering state
+    bool pbrEnabled = false;
+
     /**
      * @brief Create Vulkan resources for ImGui.
      * @return True if creation was successful, false otherwise.