Move Renderdoc out of the debug_system.h and into a "real world" renderdoc_debug_system.cpp file that derives from debug_system.h and only loads a minimal amount of functionality at runtime to avoid tight integration requirements and still demonstrate what the tutorial is teaching.

Fix the install_dependencies_windows.bat script by replacing the multi-line PowerShell command with a single line version which should hopefully fix the Windows issue.
Address other issues as reported.

Author: gpx1000

attachments/simple_engine/CMakeLists.txt

@@ -119,6 +119,7 @@ set(SOURCES
     vulkan_device.cpp
     pipeline.cpp
     descriptor_manager.cpp
+    renderdoc_debug_system.cpp
 )
 
 # Create executable

attachments/simple_engine/camera_component.cpp

@@ -41,7 +41,7 @@ void CameraComponent::UpdateViewMatrix() {
         glm::vec3 position = transformComponent->GetPosition();
         viewMatrix = glm::lookAt(position, target, up);
     } else {
-        viewMatrix = glm::lookAt(glm::vec3(0.0f, 0.0f, 3.0f), target, up);
+        viewMatrix = glm::lookAt(glm::vec3(0.0f, 0.0f, 0.0f), target, up);
     }
     viewMatrixDirty = false;
 }

attachments/simple_engine/debug_system.h

@@ -8,6 +8,7 @@
 #include <mutex>
 #include <unordered_map>
 #include <functional>
+#include <ctime>
 
 /**
  * @brief Enum for different log levels.
@@ -135,8 +136,8 @@ class DebugSystem {
         }
 
         // Call registered callbacks
-        for (const auto& callback : logCallbacks) {
-            callback(level, tag, message);
+        for (const auto& kv : logCallbacks) {
+            kv.second(level, tag, message);
         }
 
         // If fatal, trigger crash handler
@@ -202,49 +203,15 @@ class DebugSystem {
             Log(LogLevel::Debug, "Performance", name + ": " + std::to_string(duration) + " us");
             measurements.erase(it);
         } else {
-            Log(LogLevel::Warning, "Performance", "No measurement started with name: " + name);
+            Log(LogLevel::Error, "Performance", "No measurement started with name: " + name);
         }
     }
 
-    /**
-     * @brief Enable or disable RenderDoc integration.
-     * @param enable Whether to enable RenderDoc integration.
-     */
-    void EnableRenderDoc(bool enable) {
-        std::lock_guard<std::mutex> lock(mutex);
-
-        renderDocEnabled = enable;
-        Log(LogLevel::Info, "DebugSystem", std::string("RenderDoc integration ") + (enable ? "enabled" : "disabled"));
-
-        // In a real implementation, this would initialize RenderDoc API
-    }
-
-    /**
-     * @brief Check if RenderDoc integration is enabled.
-     * @return True if RenderDoc integration is enabled, false otherwise.
-     */
-    bool IsRenderDocEnabled() const {
-        return renderDocEnabled;
-    }
-
-    /**
-     * @brief Trigger a RenderDoc frame capture.
-     */
-    void CaptureRenderDocFrame() {
-        std::lock_guard<std::mutex> lock(mutex);
-
-        if (renderDocEnabled) {
-            Log(LogLevel::Info, "DebugSystem", "Capturing RenderDoc frame");
-
-            // In a real implementation, this would trigger a RenderDoc frame capture
-        } else {
-            Log(LogLevel::Warning, "DebugSystem", "RenderDoc integration is not enabled");
-        }
-    }
 
-private:
-    // Private constructor for singleton
+protected:
+    // Protected constructor for inheritance
     DebugSystem() = default;
+    virtual ~DebugSystem() = default;
 
     // Delete copy constructor and assignment operator
     DebugSystem(const DebugSystem&) = delete;
@@ -269,8 +236,6 @@ class DebugSystem {
     // Performance measurements
     std::unordered_map<std::string, std::chrono::high_resolution_clock::time_point> measurements;
 
-    // RenderDoc integration
-    bool renderDocEnabled = false;
 };
 
 // Convenience macros for logging
@@ -282,4 +247,4 @@ class DebugSystem {
 
 // Convenience macros for performance measurement
 #define MEASURE_START(name) DebugSystem::GetInstance().StartMeasurement(name)
-#define MEASURE_END(name) DebugSystem::GetInstance().EndMeasurement(name)
+#define MEASURE_END(name) DebugSystem::GetInstance().StopMeasurement(name)

attachments/simple_engine/install_dependencies_windows.bat

@@ -122,16 +122,7 @@ if defined SLANGC_EXE (
         set "SLANG_ROOT=%LOCALAPPDATA%\slang"
         if not exist "%SLANG_ROOT%" mkdir "%SLANG_ROOT%"
         echo Downloading latest Slang release...
-        powershell -NoProfile -ExecutionPolicy Bypass -Command "\
-$ErrorActionPreference='Stop'; \
-$r=Invoke-RestMethod 'https://api.github.com/repos/shader-slang/slang/releases/latest'; \
-$asset=$r.assets | Where-Object { $_.name -match 'win64.*\\.zip$' } | Select-Object -First 1; \
-if(-not $asset){ throw 'No win64 asset found'; } \
-$out=Join-Path $env:TEMP $asset.name; \
-Invoke-WebRequest $asset.browser_download_url -OutFile $out; \
-Expand-Archive -Path $out -DestinationPath $env:LOCALAPPDATA\slang -Force; \
-Write-Host ('Downloaded Slang ' + $r.tag_name) \
-"
+        powershell -NoProfile -ExecutionPolicy Bypass -Command "$ErrorActionPreference='Stop'; $r=Invoke-RestMethod 'https://api.github.com/repos/shader-slang/slang/releases/latest'; $asset=$r.assets | Where-Object { $_.name -match 'win64.*\.zip$' } | Select-Object -First 1; if(-not $asset){ throw 'No win64 asset found'; } $out=Join-Path $env:TEMP $asset.name; Invoke-WebRequest $asset.browser_download_url -OutFile $out; Expand-Archive -Path $out -DestinationPath $env:LOCALAPPDATA\slang -Force; Write-Host ('Downloaded Slang ' + $r.tag_name)"
         echo Locating slangc.exe...
         set "SLANGC_PATH="
         for /f "delims=" %%F in ('dir /b /s "%LOCALAPPDATA%\slang\slangc.exe" 2^>nul') do (

attachments/simple_engine/renderdoc_debug_system.cpp

@@ -0,0 +1,121 @@
+#include "renderdoc_debug_system.h"
+
+#include <cstring>
+#include <iostream>
+
+#if defined(_WIN32)
+  #define WIN32_LEAN_AND_MEAN
+  #include <windows.h>
+#elif defined(__APPLE__) || defined(__linux__)
+  #include <dlfcn.h>
+#endif
+
+// Value for eRENDERDOC_API_Version_1_4_1 from RenderDoc's header to avoid including it
+#ifndef RENDERDOC_API_VERSION_1_4_1
+#define RENDERDOC_API_VERSION_1_4_1 10401
+#endif
+
+// Minimal local typedefs and struct to receive function pointers without including renderdoc_app.h
+using pTriggerCaptureLocal = void (*)();
+using pStartFrameCaptureLocal = void (*)(void*, void*);
+using pEndFrameCaptureLocal = unsigned int (*)(void*, void*);
+
+struct RENDERDOC_API_1_4_1_MIN {
+    pTriggerCaptureLocal TriggerCapture;
+    void* _pad0; // We don't rely on layout beyond the subset we read via memcpy
+    pStartFrameCaptureLocal StartFrameCapture;
+    pEndFrameCaptureLocal EndFrameCapture;
+};
+
+bool RenderDocDebugSystem::LoadRenderDocAPI() {
+    if (renderdocAvailable) return true;
+
+    // Try to fetch RENDERDOC_GetAPI from a loaded module without forcing a dependency
+    pRENDERDOC_GetAPI getAPI = nullptr;
+
+#if defined(_WIN32)
+    HMODULE mod = GetModuleHandleA("renderdoc.dll");
+    if (!mod) {
+        // If not already injected/loaded, do not force-load. We can attempt LoadLibraryA as a fallback
+        mod = LoadLibraryA("renderdoc.dll");
+        if (!mod) {
+            LOG_INFO("RenderDoc", "RenderDoc not loaded into process");
+            return false;
+        }
+    }
+    getAPI = reinterpret_cast<pRENDERDOC_GetAPI>(GetProcAddress(mod, "RENDERDOC_GetAPI"));
+#elif defined(__APPLE__) || defined(__linux__)
+    void* mod = dlopen("librenderdoc.so", RTLD_NOW | RTLD_NOLOAD);
+    if (!mod) {
+        // Try to load if not already loaded; if unavailable, just no-op
+        mod = dlopen("librenderdoc.so", RTLD_NOW);
+        if (!mod) {
+            LOG_INFO("RenderDoc", "RenderDoc not loaded into process");
+            return false;
+        }
+    }
+    getAPI = reinterpret_cast<pRENDERDOC_GetAPI>(dlsym(mod, "RENDERDOC_GetAPI"));
+#endif
+
+    if (!getAPI) {
+        LOG_WARNING("RenderDoc", "RENDERDOC_GetAPI symbol not found");
+        return false;
+    }
+
+    // Request API 1.4.1 into a temporary buffer and then extract needed functions
+    RENDERDOC_API_1_4_1_MIN apiMin{};
+    void* apiPtr = nullptr;
+    int result = getAPI(RENDERDOC_API_VERSION_1_4_1, &apiPtr);
+    if (result == 0 || apiPtr == nullptr) {
+        LOG_WARNING("RenderDoc", "Failed to acquire RenderDoc API 1.4.1");
+        return false;
+    }
+
+    // Copy only the subset we care about; layout is stable for these early members
+    std::memcpy(&apiMin, apiPtr, sizeof(apiMin));
+
+    fnTriggerCapture = apiMin.TriggerCapture;
+    fnStartFrameCapture = apiMin.StartFrameCapture;
+    fnEndFrameCapture = apiMin.EndFrameCapture;
+
+    renderdocAvailable = (fnTriggerCapture || fnStartFrameCapture || fnEndFrameCapture);
+
+    if (renderdocAvailable) {
+        LOG_INFO("RenderDoc", "RenderDoc API loaded");
+    } else {
+        LOG_WARNING("RenderDoc", "RenderDoc API did not provide expected functions");
+    }
+
+    return renderdocAvailable;
+}
+
+void RenderDocDebugSystem::TriggerCapture() {
+    if (!renderdocAvailable && !LoadRenderDocAPI()) return;
+    if (fnTriggerCapture) {
+        fnTriggerCapture();
+        LOG_INFO("RenderDoc", "Triggered capture");
+    } else {
+        LOG_WARNING("RenderDoc", "TriggerCapture not available");
+    }
+}
+
+void RenderDocDebugSystem::StartFrameCapture(void* device, void* window) {
+    if (!renderdocAvailable && !LoadRenderDocAPI()) return;
+    if (fnStartFrameCapture) {
+        fnStartFrameCapture(device, window);
+        LOG_DEBUG("RenderDoc", "StartFrameCapture called");
+    } else {
+        LOG_WARNING("RenderDoc", "StartFrameCapture not available");
+    }
+}
+
+bool RenderDocDebugSystem::EndFrameCapture(void* device, void* window) {
+    if (!renderdocAvailable && !LoadRenderDocAPI()) return false;
+    if (fnEndFrameCapture) {
+        unsigned int ok = fnEndFrameCapture(device, window);
+        LOG_DEBUG("RenderDoc", ok ? "EndFrameCapture succeeded" : "EndFrameCapture failed");
+        return ok != 0;
+    }
+    LOG_WARNING("RenderDoc", "EndFrameCapture not available");
+    return false;
+}

attachments/simple_engine/renderdoc_debug_system.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "debug_system.h"
+
+// RenderDoc integration is optional and loaded at runtime.
+// This header intentionally does NOT include <renderdoc_app.h> to avoid a hard dependency.
+// Instead, we declare a minimal interface and dynamically resolve the API if present.
+
+class RenderDocDebugSystem : public DebugSystem {
+public:
+    static RenderDocDebugSystem& GetInstance() {
+        static RenderDocDebugSystem instance;
+        return instance;
+    }
+
+    // Attempt to load the RenderDoc API from the current process.
+    // Safe to call multiple times.
+    bool LoadRenderDocAPI();
+
+    // Returns true if the RenderDoc API has been successfully loaded.
+    bool IsAvailable() const { return renderdocAvailable; }
+
+    // Triggers an immediate capture (equivalent to pressing the capture hotkey in the UI).
+    void TriggerCapture();
+
+    // Starts a frame capture for the given device/window (can be nullptr to auto-detect on many backends).
+    void StartFrameCapture(void* device = nullptr, void* window = nullptr);
+
+    // Ends a frame capture previously started. Returns true on success.
+    bool EndFrameCapture(void* device = nullptr, void* window = nullptr);
+
+private:
+    RenderDocDebugSystem() = default;
+    ~RenderDocDebugSystem() override = default;
+
+    RenderDocDebugSystem(const RenderDocDebugSystem&) = delete;
+    RenderDocDebugSystem& operator=(const RenderDocDebugSystem&) = delete;
+
+    // Internal function pointers matching the subset of RenderDoc API we use.
+    // We avoid including the official header by declaring minimal signatures.
+    using pRENDERDOC_GetAPI = int (*)(int, void**);
+
+    // Subset of API function pointers
+    typedef void (*pRENDERDOC_TriggerCapture)();
+    typedef void (*pRENDERDOC_StartFrameCapture)(void* device, void* window);
+    typedef unsigned int (*pRENDERDOC_EndFrameCapture)(void* device, void* window); // returns bool in C API
+
+    // Storage for resolved API
+    pRENDERDOC_TriggerCapture fnTriggerCapture = nullptr;
+    pRENDERDOC_StartFrameCapture fnStartFrameCapture = nullptr;
+    pRENDERDOC_EndFrameCapture fnEndFrameCapture = nullptr;
+
+    bool renderdocAvailable = false;
+};