This doesn't currently fix the bugs still in the engine, but it's a checkin so I can work on other things in the tutorial and come back to this.

Integrate mikktspace tangent generation, enhance robust tangent handling for poles, unify shader refraction logic, improve transmission Fresnel, and implement thread-safe rigid body management.

Author: gpx1000

attachments/simple_engine/CMakeLists.txt

@@ -44,11 +44,6 @@ target_sources(VulkanCppModule
 )
 
 
-# Add the vulkan.cppm file directly as a source file
-target_sources(VulkanCppModule
-        PRIVATE
-        "${Vulkan_INCLUDE_DIR}/vulkan/vulkan.cppm"
-)
 
 # Platform-specific settings
 if(ANDROID)
@@ -119,6 +114,7 @@ set(SOURCES
     pipeline.cpp
     descriptor_manager.cpp
     renderdoc_debug_system.cpp
+    mikktspace.c
 )
 
 # Create executable

attachments/simple_engine/audio_system.cpp

@@ -12,6 +12,7 @@
 #include <mutex>
 #include <utility>
 #include <unordered_map>
+#include <algorithm>
 
 // OpenAL headers
 #ifdef __APPLE__

attachments/simple_engine/audio_system.h

@@ -11,6 +11,7 @@
 #include <queue>
 #include <vulkan/vulkan_raii.hpp>
 #include <vulkan/vk_platform.h>
+#include <stdexcept>
 
 /**
  * @brief Class representing an audio source.
@@ -148,6 +149,13 @@ class AudioSystem {
      */
     AudioSystem() = default;
 
+    // Constructor-based initialization to replace separate Initialize() calls
+    AudioSystem(Engine* engine, Renderer* renderer) {
+        if (!Initialize(engine, renderer)) {
+            throw std::runtime_error("AudioSystem: initialization failed");
+        }
+    }
+
     /**
      * @brief Flush audio output: clears pending processing and device buffers so playback restarts cleanly.
      */

attachments/simple_engine/engine.cpp

@@ -13,11 +13,7 @@
 // @see en/Building_a_Simple_Engine/Engine_Architecture/02_architectural_patterns.adoc
 
 Engine::Engine()
-    : resourceManager(std::make_unique<ResourceManager>()),
-      modelLoader(std::make_unique<ModelLoader>()),
-      audioSystem(std::make_unique<AudioSystem>()),
-      physicsSystem(std::make_unique<PhysicsSystem>()),
-      imguiSystem(std::make_unique<ImGuiSystem>()) {
+    : resourceManager(std::make_unique<ResourceManager>()) {
 }
 
 Engine::~Engine() {
@@ -64,37 +60,25 @@ bool Engine::Initialize(const std::string& appName, int width, int height, bool
         return false;
     }
 
-    // Initialize model loader
-    if (!modelLoader->Initialize(renderer.get())) {
-        return false;
-    }
-
-    // Connect model loader to renderer for light extraction
-    renderer->SetModelLoader(modelLoader.get());
-
-    // Initialize audio system
-    if (!audioSystem->Initialize(this, renderer.get())) {
-        return false;
-    }
-
-    // Initialize a physics system
-    physicsSystem->SetRenderer(renderer.get());
+    try {
+        // Model loader via constructor; also wire into renderer
+        modelLoader = std::make_unique<ModelLoader>(renderer.get());
+        renderer->SetModelLoader(modelLoader.get());
 
-    // Enable GPU acceleration for physics calculations to drastically speed up computations
-    physicsSystem->SetGPUAccelerationEnabled(true);
+        // Audio system via constructor
+        audioSystem = std::make_unique<AudioSystem>(this, renderer.get());
 
-    if (!physicsSystem->Initialize()) {
-        return false;
-    }
+        // Physics system via constructor (GPU enabled)
+        physicsSystem = std::make_unique<PhysicsSystem>(renderer.get(), true);
 
-    // Initialize ImGui system
-    if (!imguiSystem->Initialize(renderer.get(), width, height)) {
+        // ImGui via constructor, then connect audio system
+        imguiSystem = std::make_unique<ImGuiSystem>(renderer.get(), width, height);
+        imguiSystem->SetAudioSystem(audioSystem.get());
+    } catch (const std::exception& e) {
+        std::cerr << "Subsystem initialization failed: " << e.what() << std::endl;
         return false;
     }
 
-    // Connect ImGui system to an audio system for UI controls
-    imguiSystem->SetAudioSystem(audioSystem.get());
-
     // Generate ball material properties once at load time
     GenerateBallMaterial();
 
@@ -132,9 +116,15 @@ void Engine::Run() {
         // 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;
+            double avgMs = 0.0;
+            if (framesSinceLastUpdate > 0 && fpsUpdateTimer > 0.0f) {
+                currentFPS = static_cast<float>(static_cast<double>(framesSinceLastUpdate) / static_cast<double>(fpsUpdateTimer));
+                avgMs = (fpsUpdateTimer / static_cast<double>(framesSinceLastUpdate)) * 1000.0;
+            } else {
+                // Avoid divide-by-zero; keep previous FPS and estimate avgMs from last delta
+                currentFPS = std::max(currentFPS, 1.0f);
+                avgMs = static_cast<double>(deltaTimeMs.count());
+            }
 
             // Update window title with frame count, FPS, and frame time
             std::string title = "Simple Engine - Frame: " + std::to_string(frameCount) +
@@ -402,15 +392,19 @@ void Engine::Update(TimeDelta deltaTime) {
         UpdateCameraControls(deltaTime);
     }
 
-    // Update all entities
+    // Update all entities (guard against null unique_ptrs)
     for (auto& entity : entities) {
-        if (entity->IsActive()) {
-            entity->Update(deltaTime);
-        }
+        if (!entity) { continue; }
+        if (!entity->IsActive()) { continue; }
+        entity->Update(deltaTime);
     }
 }
 
 void Engine::Render() {
+    // Ensure renderer is ready
+    if (!renderer || !renderer->IsInitialized()) {
+        return;
+    }
 
     // Check if we have an active camera
     if (!activeCamera) {

attachments/simple_engine/imgui_system.cpp

@@ -218,7 +218,7 @@ void ImGuiSystem::NewFrame() {
         }
 
         // Exposure slider
-        static float exposure = 3.0f; // Higher default for emissive lighting
+        static float exposure = 1.2f; // Default tuned to avoid washout
         if (ImGui::SliderFloat("Exposure", &exposure, 0.1f, 10.0f, "%.2f")) {
             // Update exposure in renderer
             if (renderer) {
@@ -228,7 +228,7 @@ void ImGuiSystem::NewFrame() {
         }
         ImGui::SameLine();
         if (ImGui::Button("Reset##Exposure")) {
-            exposure = 3.0f; // Reset to higher value for emissive lighting
+            exposure = 1.2f; // Reset to a sane default to avoid washout
             if (renderer) {
                 renderer->SetExposure(exposure);
             }

attachments/simple_engine/imgui_system.h

@@ -5,6 +5,7 @@
 #include <memory>
 #include <vulkan/vulkan_raii.hpp>
 #include <vulkan/vk_platform.h>
+#include <stdexcept>
 
 // Forward declarations
 class Renderer;
@@ -25,6 +26,13 @@ class ImGuiSystem {
      */
     ImGuiSystem();
 
+    // Constructor-based initialization to replace separate Initialize() calls
+    ImGuiSystem(Renderer* renderer, uint32_t width, uint32_t height) {
+        if (!Initialize(renderer, width, height)) {
+            throw std::runtime_error("ImGuiSystem: initialization failed");
+        }
+    }
+
     /**
      * @brief Destructor for proper cleanup.
      */

attachments/simple_engine/mesh_component.cpp

@@ -36,13 +36,23 @@ void MeshComponent::CreateSphere(float radius, const glm::vec3& color, int segme
                 static_cast<float>(lat) / static_cast<float>(segments)
             };
 
-            // Calculate tangent (derivative with respect to longitude)
+            // Calculate tangent (derivative with respect to longitude). Handle poles robustly.
             glm::vec3 tangent = {
                 -sinTheta * sinPhi,
                 0.0f,
                 sinTheta * cosPhi
             };
-            tangent = glm::normalize(tangent);
+            float len2 = glm::dot(tangent, tangent);
+            if (len2 < 1e-12f) {
+                // At poles sinTheta ~ 0 -> fallback tangent orthogonal to normal
+                glm::vec3 t = glm::cross(normal, glm::vec3(0.0f, 0.0f, 1.0f));
+                if (glm::length(t) < 1e-12f) {
+                    t = glm::cross(normal, glm::vec3(1.0f, 0.0f, 0.0f));
+                }
+                tangent = glm::normalize(t);
+            } else {
+                tangent = glm::normalize(tangent);
+            }
 
             vertices.push_back({
                 position,