[*] Implement fps limiter and add maxfps command line argument

Author: IAmNotHanni

documentation/source/engine-overview/debugging/cla.rst

@@ -19,3 +19,7 @@ You can start vulkan-renderer with the following command line arguments:
 .. warning:: Vsync is currently not implemented. The command line argument will be ignored.
 
     Enables `vertical synchronization <https://en.wikipedia.org/wiki/Analog_television#Vertical_synchronization>`__ (limits FPS to monitor refresh rate).
+
+.. option:: --maxfps <fps>
+
+    Limits the max frames per seconds to a specified value. The command line argument will be clamped in between the values `1 fps` and `2000 fps` as lower and higher bounds.

include/inexor/vulkan-renderer/renderer.hpp

@@ -3,7 +3,7 @@
 #include "inexor/vulkan-renderer/imgui.hpp"
 #include "inexor/vulkan-renderer/octree_gpu_vertex.hpp"
 #include "inexor/vulkan-renderer/tools/camera.hpp"
-#include "inexor/vulkan-renderer/tools/fps_counter.hpp"
+#include "inexor/vulkan-renderer/tools/fps_limiter.hpp"
 #include "inexor/vulkan-renderer/tools/time_step.hpp"
 #include "inexor/vulkan-renderer/wrapper/debug_callback.hpp"
 #include "inexor/vulkan-renderer/wrapper/instance.hpp"
@@ -43,8 +43,6 @@ class VulkanRenderer {
 
     std::string m_window_title;
 
-    tools::FPSCounter m_fps_counter;
-
     bool m_vsync_enabled{false};
 
     std::unique_ptr<tools::Camera> m_camera;
@@ -75,6 +73,7 @@ class VulkanRenderer {
     void render_frame();
 
 public:
+    tools::FPSLimiter m_fps_limiter;
     ~VulkanRenderer();
 
     bool m_window_resized{false};

include/inexor/vulkan-renderer/tools/fps_counter.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <chrono>
+#include <cstdint>
+#include <optional>
+
+namespace inexor::vulkan_renderer::tools {
+
+/// A wrapper class for counting and limiting frames per second.
+class FPSLimiter {
+private:
+    static constexpr std::uint32_t DEFAULT_FPS{60};
+    std::uint32_t m_max_fps{DEFAULT_FPS};
+    std::chrono::milliseconds m_frame_time{DEFAULT_FPS / 1000};
+    std::chrono::time_point<std::chrono::high_resolution_clock> m_last_time;
+    std::chrono::time_point<std::chrono::high_resolution_clock> m_last_fps_update_time;
+    std::chrono::milliseconds m_fps_update_interval{1000};
+    std::uint32_t m_frames{0};
+
+    // The requested max_fps will be clamped in between these limits.
+    static constexpr std::uint32_t MIN_FPS{1};
+    static constexpr std::uint32_t MAX_FPS{2000};
+
+public:
+    FPSLimiter(std::uint32_t max_fps = DEFAULT_FPS);
+
+    void set_max_fps(std::uint32_t max_fps);
+
+    /// Ask if the next frame is allowed to be rendered.
+    [[nodiscard]] bool is_next_frame_allowed();
+
+    /// Return the fps every second, std::nullopt otherwise.
+    [[nodiscard]] std::optional<std::uint32_t> get_fps();
+};
+
+} // namespace inexor::vulkan_renderer::tools

include/inexor/vulkan-renderer/tools/fps_limiter.hpp

@@ -13,7 +13,7 @@ set(INEXOR_SOURCE_FILES
     vulkan-renderer/tools/enumerate.cpp
     vulkan-renderer/tools/exception.cpp
     vulkan-renderer/tools/file.cpp
-    vulkan-renderer/tools/fps_counter.cpp
+    vulkan-renderer/tools/fps_limiter.cpp
     vulkan-renderer/tools/queue_selection.cpp
     vulkan-renderer/tools/representation.cpp
     vulkan-renderer/tools/time_step.cpp

src/CMakeLists.txt

@@ -282,8 +282,12 @@ Application::Application(int argc, char **argv) {
     app.add_flag("--vsync", m_vsync_enabled);
     std::optional<std::uint32_t> preferred_gpu;
     app.add_option("--gpu", preferred_gpu);
+    std::uint32_t max_fps = 60;
+    app.add_option("--maxfps", max_fps);
     app.parse(argc, argv);
 
+    m_fps_limiter.set_max_fps(max_fps);
+
     load_toml_configuration_file("configuration/renderer.toml");
 
     spdlog::trace("Creating Vulkan instance");
@@ -516,20 +520,22 @@ void Application::run() {
 
     while (!m_window->should_close()) {
         m_window->poll();
-        m_input->update_gamepad_data();
-        update_uniform_buffers();
-        update_imgui_overlay();
-        render_frame();
-        process_input();
-        if (m_input->kbm_data().was_key_pressed_once(GLFW_KEY_N)) {
-            load_octree_geometry(false);
-            generate_octree_indices();
-            m_index_buffer->upload_data(m_octree_indices);
-            m_vertex_buffer->upload_data(m_octree_vertices);
+        if (m_fps_limiter.is_next_frame_allowed()) {
+            m_input->update_gamepad_data();
+            update_uniform_buffers();
+            update_imgui_overlay();
+            render_frame();
+            process_input();
+            if (m_input->kbm_data().was_key_pressed_once(GLFW_KEY_N)) {
+                load_octree_geometry(false);
+                generate_octree_indices();
+                m_index_buffer->upload_data(m_octree_indices);
+                m_vertex_buffer->upload_data(m_octree_vertices);
+            }
+            m_camera->update(m_time_passed);
+            m_time_passed = m_stopwatch.time_step();
+            check_octree_collisions();
         }
-        m_camera->update(m_time_passed);
-        m_time_passed = m_stopwatch.time_step();
-        check_octree_collisions();
     }
 }
 

src/vulkan-renderer/application.cpp

@@ -112,7 +112,7 @@ void VulkanRenderer::render_frame() {
 
     m_swapchain->present(image_index);
 
-    if (auto fps_value = m_fps_counter.update()) {
+    if (auto fps_value = m_fps_limiter.get_fps()) {
         m_window->set_title("Inexor Vulkan API renderer demo - " + std::to_string(*fps_value) + " FPS");
         spdlog::trace("FPS: {}, window size: {} x {}", *fps_value, m_window->width(), m_window->height());
     }

src/vulkan-renderer/renderer.cpp

@@ -0,0 +1,43 @@
+#include "inexor/vulkan-renderer/tools/fps_limiter.hpp"
+
+#include <spdlog/spdlog.h>
+
+#include <algorithm>
+
+namespace inexor::vulkan_renderer::tools {
+
+FPSLimiter::FPSLimiter(const std::uint32_t max_fps) {
+    set_max_fps(max_fps);
+}
+
+void FPSLimiter::set_max_fps(std::uint32_t max_fps) {
+    m_max_fps = std::clamp(max_fps, MIN_FPS, MAX_FPS);
+    m_frame_time = std::chrono::milliseconds(1000) / m_max_fps;
+}
+
+bool FPSLimiter::is_next_frame_allowed() {
+    const auto current_time = std::chrono::high_resolution_clock::now();
+    const auto elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(current_time - m_last_time);
+    if (elapsed_ms >= m_frame_time) {
+        m_last_time = current_time;
+        return true;
+    }
+    return false;
+}
+
+std::optional<std::uint32_t> FPSLimiter::get_fps() {
+    m_frames++;
+    const auto current_time = std::chrono::high_resolution_clock::now();
+    const auto elapsed_ms =
+        std::chrono::duration_cast<std::chrono::milliseconds>(current_time - m_last_fps_update_time);
+    if (elapsed_ms >= m_fps_update_interval) {
+        m_last_fps_update_time = current_time;
+        auto fps_value = static_cast<std::uint32_t>(m_frames * 1000.0f / elapsed_ms.count());
+        m_frames = 0;
+        return fps_value;
+    }
+
+    return std::nullopt;
+}
+
+} // namespace inexor::vulkan_renderer::tools