addressing more comments.

Author: gpx1000

attachments/simple_engine/audio_system.cpp

@@ -148,6 +148,11 @@ class AudioSystem {
      */
     AudioSystem() = default;
 
+    /**
+     * @brief Flush audio output: clears pending processing and device buffers so playback restarts cleanly.
+     */
+    void FlushOutput();
+
     /**
      * @brief Destructor for proper cleanup.
      */
@@ -165,7 +170,7 @@ class AudioSystem {
      * @brief Update the audio system.
      * @param deltaTime The time elapsed since the last update.
      */
-    void Update(float deltaTime);
+    void Update(std::chrono::milliseconds deltaTime);
 
     /**
      * @brief Load an audio file.
@@ -318,8 +323,9 @@ class AudioSystem {
         std::vector<float> inputBuffer;
         std::vector<float> outputBuffer;
         float sourcePosition[3];
-        uint32_t sampleCount;
-        uint32_t actualSamplesProcessed;
+        uint32_t sampleCount;              // total frames in input/output (may include history)
+        uint32_t actualSamplesProcessed;   // frames to write this tick (new part)
+        uint32_t trimFront;                // frames to skip from output front (history length)
         AudioOutputDevice* outputDevice;
         float masterVolume;
     };
@@ -392,5 +398,5 @@ class AudioSystem {
      * @param actualSamplesProcessed The number of samples actually processed.
      * @return True if the task was submitted successfully, false otherwise.
      */
-    bool submitAudioTask(const float* inputBuffer, uint32_t sampleCount, const float* sourcePosition, uint32_t actualSamplesProcessed);
+    bool submitAudioTask(const float* inputBuffer, uint32_t sampleCount, const float* sourcePosition, uint32_t actualSamplesProcessed, uint32_t trimFront);
 };

attachments/simple_engine/audio_system.h

@@ -1,5 +1,4 @@
 #include "component.h"
-#include "entity.h"
 
 // Most of the Component class implementation is in the header file
 // This file is mainly for any methods that need to access the Entity class

attachments/simple_engine/component.cpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <memory>
+#include <chrono>
 #include <string>
 
 // Forward declaration
@@ -44,7 +44,7 @@ class Component {
      * Called every frame.
      * @param deltaTime The time elapsed since the last frame.
      */
-    virtual void Update(float deltaTime) {}
+    virtual void Update(std::chrono::milliseconds deltaTime) {}
 
     /**
      * @brief Render the component.

attachments/simple_engine/component.h

@@ -4,6 +4,7 @@
 
 #include <chrono>
 #include <algorithm>
+#include <ranges>
 #include <stdexcept>
 #include <iostream>
 #include <random>
@@ -122,11 +123,11 @@ void Engine::Run() {
         }
 
         // Calculate delta time
-        deltaTime = CalculateDeltaTime();
+        deltaTimeMs = CalculateDeltaTimeMs();
 
         // Update frame counter and FPS
         frameCount++;
-        fpsUpdateTimer += deltaTime;
+        fpsUpdateTimer += deltaTimeMs.count() * 0.001f;
 
         // Update window title with FPS and frame time every second
         if (fpsUpdateTimer >= 1.0f) {
@@ -147,7 +148,7 @@ void Engine::Run() {
         }
 
         // Update
-        Update(deltaTime);
+        Update(deltaTimeMs);
 
         // Render
         Render();
@@ -369,7 +370,7 @@ void Engine::handleKeyInput(uint32_t key, bool pressed) {
     }
 }
 
-void Engine::Update(float deltaTime) {
+void Engine::Update(TimeDelta deltaTime) {
     // Debug: Verify Update method is being called
     static int updateCallCount = 0;
     updateCallCount++;
@@ -415,27 +416,27 @@ void Engine::Render() {
     renderer->Render(entities, activeCamera, imguiSystem.get());
 }
 
-float Engine::CalculateDeltaTime() {
+std::chrono::milliseconds Engine::CalculateDeltaTimeMs() {
     // Get current time using a steady clock to avoid system time jumps
     uint64_t currentTime = static_cast<uint64_t>(
         std::chrono::duration_cast<std::chrono::milliseconds>(
             std::chrono::steady_clock::now().time_since_epoch()
         ).count()
     );
 
-    // Initialize lastFrameTime on first call
-    if (lastFrameTime == 0) {
-        lastFrameTime = currentTime;
-        return 0.016f; // ~16ms as a sane initial guess
+    // Initialize lastFrameTimeMs on first call
+    if (lastFrameTimeMs == 0) {
+        lastFrameTimeMs = currentTime;
+        return std::chrono::milliseconds(16); // ~16ms as a sane initial guess
     }
 
     // Calculate delta time in milliseconds
-    uint64_t delta = currentTime - lastFrameTime;
+    uint64_t delta = currentTime - lastFrameTimeMs;
 
     // Update last frame time
-    lastFrameTime = currentTime;
+    lastFrameTimeMs = currentTime;
 
-    return static_cast<float>(delta) / 1000.0f;
+    return std::chrono::milliseconds(static_cast<long long>(delta));
 }
 
 void Engine::HandleResize(int width, int height) const {
@@ -458,7 +459,7 @@ void Engine::HandleResize(int width, int height) const {
     }
 }
 
-void Engine::UpdateCameraControls(float deltaTime) const {
+void Engine::UpdateCameraControls(TimeDelta deltaTime) const {
     if (!activeCamera) return;
 
     // Get a camera transform component
@@ -492,7 +493,7 @@ void Engine::UpdateCameraControls(float deltaTime) const {
 
     // Manual camera controls (only when tracking is disabled)
     // Calculate movement speed
-    float velocity = cameraControl.cameraSpeed * deltaTime;
+    float velocity = cameraControl.cameraSpeed * deltaTime.count() * .001f;
 
     // Calculate camera direction vectors based on yaw and pitch
     glm::vec3 front;
@@ -859,10 +860,10 @@ void Engine::RunAndroid() {
     // We just need to update and render when the platform is ready
 
     // Calculate delta time
-    deltaTime = CalculateDeltaTime();
+    deltaTimeMs = CalculateDeltaTimeMs();
 
     // Update
-    Update(deltaTime);
+    Update(deltaTimeMs);
 
     // Render
     Render();

attachments/simple_engine/engine.cpp

@@ -4,6 +4,7 @@
 #include <vector>
 #include <memory>
 #include <unordered_map>
+#include <chrono>
 
 #include "platform.h"
 #include "renderer.h"
@@ -23,6 +24,7 @@
  */
 class Engine {
 public:
+    using TimeDelta = std::chrono::milliseconds;
     /**
      * @brief Default constructor.
      */
@@ -197,8 +199,9 @@ class Engine {
     bool running = false;
 
     // Delta time calculation
-    float deltaTime = 0.0f;
-    uint64_t lastFrameTime = 0;
+    // deltaTimeMs: time since last frame in milliseconds (for clarity)
+    std::chrono::milliseconds deltaTimeMs{0};
+    uint64_t lastFrameTimeMs = 0;
 
     // Frame counter and FPS calculation
     uint64_t frameCount = 0;
@@ -269,18 +272,19 @@ class Engine {
      * @brief Update the engine state.
      * @param deltaTime The time elapsed since the last update.
      */
-    void Update(float deltaTime);
+    // Accepts a time delta in milliseconds for clarity
+    void Update(TimeDelta deltaTime);
 
     /**
      * @brief Render the scene.
      */
     void Render();
 
     /**
-     * @brief Calculate the delta time between frames.
-     * @return The delta time in seconds.
+     * @brief Calculate the time delta between frames.
+     * @return The delta time in milliseconds (steady_clock based).
      */
-    float CalculateDeltaTime();
+    std::chrono::milliseconds CalculateDeltaTimeMs();
 
     /**
      * @brief Handle window resize events.
@@ -293,7 +297,7 @@ class Engine {
      * @brief Update camera controls based on input state.
      * @param deltaTime The time elapsed since the last update.
      */
-    void UpdateCameraControls(float deltaTime) const;
+    void UpdateCameraControls(TimeDelta deltaTime) const;
 
     /**
      * @brief Generate random PBR material properties for the ball.

attachments/simple_engine/engine.h

@@ -9,7 +9,7 @@ void Entity::Initialize() {
     }
 }
 
-void Entity::Update(float deltaTime) {
+void Entity::Update(std::chrono::milliseconds deltaTime) {
     if (!active) return;
 
     for (auto& component : components) {

attachments/simple_engine/entity.cpp

@@ -4,6 +4,7 @@
 #include <memory>
 #include <string>
 #include <algorithm>
+#include <chrono>
 #include <typeindex>
 #include <unordered_map>
 #include <type_traits>
@@ -62,7 +63,7 @@ class Entity {
      * @brief Update all components of the entity.
      * @param deltaTime The time elapsed since the last frame.
      */
-    void Update(float deltaTime);
+    void Update(std::chrono::milliseconds deltaTime);
 
     /**
      * @brief Render all components of the entity.

attachments/simple_engine/entity.h

@@ -281,6 +281,7 @@ void ImGuiSystem::NewFrame() {
     if (ImGui::Button("Play")) {
         if (currentSource) {
             currentSource->Play();
+            if (audioSystem) { audioSystem->FlushOutput(); }
             if (useDebugPing) {
                 std::cout << "Started playing debug ping (800Hz sine wave) with HRTF processing" << std::endl;
             } else {
@@ -311,34 +312,10 @@ void ImGuiSystem::NewFrame() {
         ImGui::Text("Use directional buttons to move the audio source in 3D space");
         ImGui::Text("You should hear the audio move around you!");
 
-        // HRTF Processing Mode Selection
+        // HRTF Processing Mode: GPU only (checkbox removed)
         ImGui::Separator();
         ImGui::Text("HRTF Processing Mode:");
-
-        static bool cpuOnlyMode = false;
-        static bool initialized = false;
-
-        // Initialize checkbox state to match audio system state
-        if (!initialized && audioSystem) {
-            cpuOnlyMode = audioSystem->IsHRTFCPUOnly();
-            initialized = true;
-        }
-
-        if (ImGui::Checkbox("Force CPU-only HRTF processing", &cpuOnlyMode)) {
-            if (audioSystem) {
-                audioSystem->SetHRTFCPUOnly(cpuOnlyMode);
-                std::cout << "HRTF processing mode changed to: " << (cpuOnlyMode ? "CPU-only" : "Vulkan shader (when available)") << std::endl;
-            }
-        }
-
-        // Display current processing mode
-        if (audioSystem) {
-            if (audioSystem->IsHRTFCPUOnly()) {
-                ImGui::Text("Current Mode: CPU-only processing");
-            } else {
-                ImGui::Text("Current Mode: Vulkan shader processing (when available)");
-            }
-        }
+        ImGui::Text("Current Mode: Vulkan shader processing (GPU)");
     } else {
         ImGui::Text("HRTF Processing: DISABLED");
     }

attachments/simple_engine/imgui_system.cpp

@@ -201,7 +201,7 @@ bool PhysicsSystem::Initialize() {
     return true;
 }
 
-void PhysicsSystem::Update(float deltaTime) {
+void PhysicsSystem::Update(std::chrono::milliseconds deltaTime) {
     // GPU-ONLY physics - NO CPU fallback available
 
     // Check if GPU physics is properly initialized and available
@@ -977,7 +977,7 @@ void PhysicsSystem::CleanupVulkanResources() {
     vulkanResources.physicsBufferMemory = nullptr;
 }
 
-void PhysicsSystem::UpdateGPUPhysicsData(float deltaTime) const {
+void PhysicsSystem::UpdateGPUPhysicsData(std::chrono::milliseconds deltaTime) const {
     if (!renderer) {
         return;
     }
@@ -1082,7 +1082,7 @@ void PhysicsSystem::UpdateGPUPhysicsData(float deltaTime) const {
 
     // Update params buffer
     PhysicsParams params{};
-    params.deltaTime = deltaTime; // Use actual deltaTime instead of fixed timestep
+    params.deltaTime = deltaTime.count() * 0.001f; // Use actual deltaTime instead of fixed timestep
     params.numBodies = static_cast<uint32_t>(rigidBodies.size());
     params.maxCollisions = maxGPUCollisions;
     params.padding = 0.0f; // Initialize padding to zero for proper std140 alignment
@@ -1192,7 +1192,7 @@ void PhysicsSystem::ReadbackGPUPhysicsData() const {
     }
 }
 
-void PhysicsSystem::SimulatePhysicsOnGPU(const float deltaTime) const {
+void PhysicsSystem::SimulatePhysicsOnGPU(const std::chrono::milliseconds deltaTime) const {
     if (!renderer) {
         fprintf(stderr, "SimulatePhysicsOnGPU: No renderer available");
         return;