Simple game engine

attachments/simple_engine/audio_system.h

@@ -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/component.cpp

@@ -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.h

@@ -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/engine.cpp

@@ -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.h

@@ -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.
      */
@@ -167,7 +169,11 @@ class Engine {
      * @param enableValidationLayers Whether to enable Vulkan validation layers.
      * @return True if initialization was successful, false otherwise.
      */
+    #if defined(NDEBUG)
+    bool InitializeAndroid(android_app* app, const std::string& appName, bool enableValidationLayers = false);
+    #else
     bool InitializeAndroid(android_app* app, const std::string& appName, bool enableValidationLayers = true);
+    #endif
 
     /**
      * @brief Run the engine on Android.
@@ -197,8 +203,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;
@@ -254,7 +261,7 @@ class Engine {
 
     PhysicsScaling physicsScaling;
 
-    // Pending ball creation data (to avoid memory pool constraints during rendering)
+    // Pending ball creation data
     struct PendingBall {
         glm::vec3 spawnPosition;
         glm::vec3 throwDirection;
@@ -269,18 +276,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 +301,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/entity.cpp

@@ -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.h

@@ -4,8 +4,7 @@
 #include <memory>
 #include <string>
 #include <algorithm>
-#include <typeindex>
-#include <unordered_map>
+#include <chrono>
 #include <type_traits>
 
 #include "component.h"
@@ -21,7 +20,6 @@ class Entity {
     std::string name;
     bool active = true;
     std::vector<std::unique_ptr<Component>> components;
-    std::unordered_map<std::type_index, Component*> componentMap;
 
 public:
     /**
@@ -62,7 +60,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.
@@ -87,10 +85,7 @@ class Entity {
         // Set the owner
         componentPtr->SetOwner(this);
 
-        // Add to the map for quick lookup
-        componentMap[std::type_index(typeid(T))] = componentPtr;
-
-        // Add to the vector for ownership
+        // Add to the vector for ownership and iteration
         components.push_back(std::move(component));
 
         // Initialize the component
@@ -108,11 +103,12 @@ class Entity {
     T* GetComponent() const {
         static_assert(std::is_base_of<Component, T>::value, "T must derive from Component");
 
-        auto it = componentMap.find(std::type_index(typeid(T)));
-        if (it != componentMap.end()) {
-            return static_cast<T*>(it->second);
+        // Search from the back to preserve previous behavior of returning the last-added component of type T
+        for (auto it = components.rbegin(); it != components.rend(); ++it) {
+            if (auto* casted = dynamic_cast<T*>(it->get())) {
+                return casted;
+            }
         }
-
         return nullptr;
     }
 
@@ -125,21 +121,9 @@ class Entity {
     bool RemoveComponent() {
         static_assert(std::is_base_of<Component, T>::value, "T must derive from Component");
 
-        auto it = componentMap.find(std::type_index(typeid(T)));
-        if (it != componentMap.end()) {
-            Component* componentPtr = it->second;
-
-            // Remove from the map
-            componentMap.erase(it);
-
-            // Find and remove from the vector
-            auto vecIt = std::find_if(components.begin(), components.end(),
-                [componentPtr](const std::unique_ptr<Component>& comp) {
-                    return comp.get() == componentPtr;
-                });
-
-            if (vecIt != components.end()) {
-                components.erase(vecIt);
+        for (auto it = components.rbegin(); it != components.rend(); ++it) {
+            if (dynamic_cast<T*>(it->get()) != nullptr) {
+                components.erase(std::next(it).base());
                 return true;
             }
         }
@@ -155,6 +139,6 @@ class Entity {
     template<typename T>
     bool HasComponent() const {
         static_assert(std::is_base_of<Component, T>::value, "T must derive from Component");
-        return componentMap.contains(std::type_index(typeid(T)));
+        return GetComponent<T>() != nullptr;
     }
 };

attachments/simple_engine/imgui_system.cpp

@@ -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");
     }