Simple game engine

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,