Турбо режим симуляции

Author: AsuRaHan

README.md

@@ -110,6 +110,27 @@
   - **8**: Красный (тип 2).
   - **9**: Синий (тип 3).
 
+# Turbo Mode (Experimental Feature)
+
+- **Turbo Mode** 
+— это экспериментальный режим симуляции, который превращает вашу "Игру Жизни" в настоящий ускоритель частиц! В этом режиме мы выжимаем максимум из GPU, позволяя выполнять несколько шагов симуляции за один кадр рендеринга. Результат? Скорость симуляции взлетает до небес, но стабильность остаётся под вопросом.
+- Как это работает?
+  - Включите Turbo Mode через кнопку в окне "Управление симуляцией" (ищите красную кнопку — её сложно пропустить!).
+  - Количество шагов симуляции за кадр (Simulation Steps) автоматически подстраивается в зависимости от текущего FPS, пытаясь удерживать рендеринг на частоте вашего монитора (по умолчанию 75 Гц).
+  - Чем больше шагов, тем быстрее эволюционирует ваша сетка — но и тем выше нагрузка на систему.
+- **Предупреждение**: Экспериментальная зона!
+  - **Стабильность**: Этот режим нестабилен и зависит от размера сетки, мощности вашего GPU и настроек параметров. На больших сетках (например, 10000×10000) возможны просадки FPS, зависания или странные глюки — от "волн" в скорости симуляции до внезапных "турбо-скачков".
+  - **По умолчанию**: Режим выключен, и игра работает в стандартном стабильном режиме с одной симуляцией на кадр. Включайте Turbo Mode только если готовы к приключениям!
+- **Почему это круто**?
+  - На маленьких сетках вы получите молниеносную симуляцию без потери FPS.
+  - На больших сетках это как тест на выносливость для вашего GPU — сможете ли вы укротить хаос?
+- **Как использовать**?
+  - Откройте окно "Управление симуляцией".
+  - Найдите кнопку "Turbo Mode" (красная, как сигнал опасности).
+  - Нажмите её, чтобы включить/выключить режим.
+  - Наблюдайте, как ваша симуляция либо взлетает, либо эпично падает — зависит от удачи и настроек!
+- **Примечание**: Мы не гарантируем, что ваша видеокарта не начнёт молить о пощаде, а игра — вести себя как космический корабль на автопилоте с пьяным штурманом. Это эксперимент, так что играйте с ним на свой риск и получайте удовольствие от хаоса!
+
 ## Установка
 
 Для настройки и запуска проекта:
@@ -190,7 +211,7 @@ git push origin v1.0.0
   - `GridRenderer.h`, `GridRenderer.cpp` - Отрисовка навигационной координатной сетки.
   - `TextureFieldRenderer.h`, `TextureFieldRenderer.cpp` - Отрисовка игрового поля на дальних расстояниях от самого поля, улучшает производительность не влияя на визуальное отображение.
   - `CellsViewportRenderer.h`, `CellsViewportRenderer.cpp` - Отрисовка игрового поля на ближних расстояниях от игрового поля, улучшает визуальное отображение.
-  - `IRendererProvider.h` - Проводник обеспечивающий обмен данными между разными классами. Это простой интерфейс, паттерн провайдер.
+  - `IRendererProvider.h` - Проводник для `Renderer` обеспечивающий обмен данными между разными классами. Это простой интерфейс, паттерн провайдер.
 
 - **./mathematics**: Математические утилиты:
   - `Matrix4x4.h`, `Matrix4x4.cpp` - Операции с матрицами (на данный момент не используется)
@@ -207,6 +228,7 @@ git push origin v1.0.0
   - `ShaderManager.h`, `ShaderManager.cpp` - Создание компиляция проверка шейдеров (GLSL) OpenGL
   - `SettingsManager.h`, `SettingsManager.cpp` - Сохранение и загрузка пользовательских настроек.
   - `InputHandler.h`, `InputHandler.cpp` - Обработчик пользовательского ввода (клавиатура мыш).
+  - `PerformanceStats.h`, `PerformanceStats.cpp` - Собирает статистику. ФПС, колличество симуляций и т.д.
   - `InputEvent.h` - Сама структура пользовательского ввода.
 
 - **main.cpp**: Точка входа приложения

game/GameController.cpp

@@ -4,7 +4,7 @@ GameController::GameController(int width, int height, float cellSize)
     : grid(width, height), 
     gpuAutomaton(grid.getWidth(), grid.getHeight()),
     cellSize(cellSize), 
-    isRunning(false), showGrid(true), showUI(true), isWorldToroidal(true), isPatternPlacementMode(false),
+    isRunning(false), showGrid(true), showUI(true), isWorldToroidal(true), isPatternPlacementMode(false), isTurboBoost(false),
     currentPatternRotator(0), isSelectionActive(false),
     rendererProvider(nullptr)
 {
@@ -16,7 +16,6 @@ GameController::GameController(int width, int height, float cellSize)
 
     frameTimeAccumulator = GetTickCount64(); // Инициализация
     isRunning = false;
-    simulationSpeed = 0;
 
 }
 
@@ -82,7 +81,7 @@ void GameController::update() {
     static auto lastUpdate = std::chrono::steady_clock::now();
     if (isRunning) {
         auto now = std::chrono::steady_clock::now();
-        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - lastUpdate).count();
+        auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(now - lastUpdate).count();
 
         if (elapsed >= simulationSpeed) {
             gpuAutomaton.Update();

game/GameController.h

@@ -32,6 +32,7 @@ class GameController {
     bool showGrid;
     bool showUI;
     bool isWorldToroidal;
+    bool isTurboBoost;
     int simulationSpeed = 1; // Значение 1000 может соответствовать одной секунде реального времени
     float frameTimeAccumulator = 0.0f;
 
@@ -132,6 +133,9 @@ class GameController {
     bool getShowGrid() const {return showGrid;};
     void setShowGrid(bool isShow) {showGrid = isShow;};
 
+    void setTurboBoost(bool turboBoost) { isTurboBoost = turboBoost;};
+    bool getTurboBoost() const { return isTurboBoost; };
+
     bool getShowUI() const { return showUI; };
     void setShowUI(bool isShow) { showUI = isShow;};
 

main.cpp

@@ -167,6 +167,7 @@ int GetMonitorRefreshRate() {
     return 60; // Значение по умолчанию, если не удалось получить
 }
 
+
 int wWinMain(
     _In_ HINSTANCE hInstance,
     _In_opt_ HINSTANCE hPrevInstance,
@@ -251,7 +252,14 @@ int wWinMain(
         // ===================================================================================
         MSG msg;
         bool MainLoop = true;
-        
+        // так как у нас есть вертикальная синхронизация то колличество симуляций не сможет превысить частоту обновление монитора. поэтому мы обошли такие ограничения
+        int monitorHz = GetMonitorRefreshRate();
+        float frameIntervalMs = 1000.0f / monitorHz; // Например, 13.33 мс для 75 Гц
+        PerformanceStats::getInstance().setTargetRefreshRate(monitorHz);
+        auto lastFrameTime = std::chrono::steady_clock::now();
+        float targetFPS = static_cast<float>(monitorHz); // Целевая частота монитора
+        float simulationSteps = 1.0f; // Теперь float для плавности
+        int needSteps = 1;
         while (MainLoop) {
             while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) { 
                 TranslateMessage(&msg);
@@ -260,10 +268,46 @@ int wWinMain(
                     MainLoop = false; // Завершение приложения
                 }
             }
-            // Здесь вызываем update с deltaTime
-            gameController.update();
-            PerformanceStats::getInstance().recordFrame();
-            renderer.Draw();
+            if (gameController.getTurboBoost()) { // экстперементальный турбо режим. работает не стабильно может повесить ОС
+                auto now = std::chrono::steady_clock::now();
+                auto elapsedFrameNs = std::chrono::duration_cast<std::chrono::nanoseconds>(now - lastFrameTime).count();
+                float elapsedFrameMs = elapsedFrameNs / 1000000.0f;
+
+                // Обновляем статистику один раз за кадр
+                PerformanceStats::getInstance().updateStats();
+                float currentFPS = PerformanceStats::getInstance().getFPS();
+
+                // Плавная регулировка числа шагов симуляции
+                float fpsError = targetFPS - currentFPS;
+                float adjustment = fpsError * 0.05f; // Коэффициент сглаживания (можно настроить)
+                simulationSteps += adjustment;
+
+                // Ограничиваем simulationSteps
+                if (simulationSteps < 1.0f) simulationSteps = 1.0f;
+                if (simulationSteps > 20.0f) simulationSteps = 20.0f;
+                needSteps = static_cast<int>(simulationSteps + 0.5f);
+                //if (currentFPS < (monitorHz / 2)) {
+                //    needSteps = 1;
+                //}
+                if (elapsedFrameMs >= frameIntervalMs) {
+                    // Выполняем симуляцию перед рендерингом
+                    for (int i = 0; i < needSteps; i++) {
+                        gameController.update();
+                    }
+                    renderer.Draw();
+                    lastFrameTime = now;
+                    PerformanceStats::getInstance().recordFrame();
+                }
+            }
+            else {
+                needSteps = 1;
+                PerformanceStats::getInstance().updateStats();
+                gameController.update();
+                renderer.Draw();
+                PerformanceStats::getInstance().recordFrame();
+            }
+
+
         }
 
     }

rendering/UIRenderer.cpp

@@ -58,7 +58,12 @@ void UIRenderer::DrawMenuBar() {
             ImGui::MenuItem("О программе", NULL, &aboutWindowVisible);
             ImGui::EndMenu();
         }
-
+        if (gameController->isSimulationRunning()) {
+            ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.5f, 0.3f, 1.0f)); // Красный цвет для "Выход"
+            ImGui::Text("Симуляция запущена");
+            ImGui::PopStyleColor();
+        }
+        
         // Получаем статистику
         std::string statsText = PerformanceStats::getInstance().getStatsString();
 
@@ -88,7 +93,7 @@ void UIRenderer::DrawSimulationWindow() {
     if (!simulationWindowVisible) return;
 
     ImGui::Begin("Симуляция", &simulationWindowVisible, ImGuiWindowFlags_NoResize);
-    ImGui::SetWindowSize(ImVec2(0, 300), ImGuiCond_Once);
+    ImGui::SetWindowSize(ImVec2(0, 350), ImGuiCond_Once);
     // Управление симуляцией
     if (gameController->isSimulationRunning()) {
         if (ImGui::Button("Остановить симуляцию", buttonSize)) {
@@ -125,24 +130,48 @@ void UIRenderer::DrawSimulationWindow() {
     if (ImGui::Button("Случайные клетки", buttonSize)) {
         gameController->randomizeGrid(0.1f);
     }
-    ImGui::Text("Задержка симуляции");
-    static float simulateTime = 1;
-    float minSimulationSpeed = static_cast<int>(PerformanceStats::getInstance().getMinSimulationDelayMs());
-    ImGui::SetNextItemWidth(buttonSize.x);
-    if (ImGui::SliderFloat("##simulateTime", &simulateTime, 1, 500)) {
-        // Здесь код выполнится, если значение слайдера изменилось
-        gameController->setSimulationSpeed(simulateTime);
-    }
-
     ImGui::Separator();
-    ImGui::Text("Необходимо: %.2f мс", minSimulationSpeed);
 
-    if (PerformanceStats::getInstance().shouldUpdateSimulationSpeed()) {
-        ImGui::PushStyleColor(ImGuiCol_Text, IM_COL32(255, 0, 0, 255)); // Красный (R=255, G=0, B=0, A=255)
-        ImGui::Text("Необходимо увеличить");
-        // Возвращаем стандартный цвет текста
-        ImGui::PopStyleColor();
+    static float simulateTime = 0;
+    if (gameController->getTurboBoost()) {
+
+        ImGui::Text("Задержка симуляции");
+        ImGui::SetNextItemWidth(buttonSize.x);
+        if (ImGui::SliderFloat("##simulateTime", &simulateTime, 0.0f, 100.0f)) {
+            // Здесь код выполнится, если значение слайдера изменилось
+            gameController->setSimulationSpeed(simulateTime * 100);
+        }
+        if (ImGui::Button("Выключить Turbo Mode", buttonSize)) {
+            gameController->setTurboBoost(false);
+        }
+        float minSimulationSpeed = static_cast<int>(PerformanceStats::getInstance().getMinSimulationDelayMs());
+        
+        ImGui::Text("Необходимо: %.2f мс", minSimulationSpeed*10);
+        if (PerformanceStats::getInstance().shouldUpdateSimulationSpeed()) {
+            ImGui::PushStyleColor(ImGuiCol_Text, IM_COL32(255, 0, 0, 255)); // Красный (R=255, G=0, B=0, A=255)
+            ImGui::Text("Увеличить !!!");
+            // Возвращаем стандартный цвет текста
+            ImGui::PopStyleColor();
+        }
+    }
+    else {
+        ImGui::Text("Задержка симуляции");
+        ImGui::SetNextItemWidth(buttonSize.x);
+        if (ImGui::SliderFloat("##simulateTime", &simulateTime, 0.0f, 5000.0f)) {
+            // Здесь код выполнится, если значение слайдера изменилось
+            gameController->setSimulationSpeed(simulateTime * 100000);
+        }
+        ImGui::PushStyleColor(ImGuiCol_Button, IM_COL32(255, 0, 0, 255)); // Красный цвет кнопки
+        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, IM_COL32(255, 50, 50, 255)); // Чуть светлее при наведении
+        ImGui::PushStyleColor(ImGuiCol_ButtonActive, IM_COL32(200, 0, 0, 255)); // Темнее при нажатии
+        if (ImGui::Button("Включить Turbo Mode", buttonSize)) {
+            simulateTime = 0;
+            gameController->setTurboBoost(true);
+            gameController->setSimulationSpeed(0);
+        }
+        ImGui::PopStyleColor(3); // Сбрасываем три изменения цвета
     }
+
     ImGui::End();
 }
 

system/PerformanceStats.cpp

@@ -16,28 +16,37 @@ PerformanceStats::PerformanceStats()
 
 void PerformanceStats::recordFrame() {
     frameCount++;
-    updateStats();
+    //updateStats();
 }
 
 void PerformanceStats::recordSimulation() {
     simulationCount++;
-    updateStats();
+    //updateStats();
 }
 
 void PerformanceStats::updateStats() {
     LONGLONG currentTime = GetTickCount64();
     LONGLONG elapsedTime = currentTime - lastUpdateTime;
 
     if (elapsedTime >= updateInterval) {
-        // Вычисляем FPS и симуляции в секунду
         fps = static_cast<float>(frameCount) * 1000.0f / elapsedTime;
         simulationsPerSecond = static_cast<float>(simulationCount) * 1000.0f / elapsedTime;
 
-        // Среднее время на кадр и симуляцию
+        // Считаем среднее время на кадр и симуляцию
         avgFrameTimeMs = (frameCount > 0) ? (1000.0f / fps) : 0.0f;
         avgSimulationTimeMs = (simulationCount > 0) ? (1000.0f / simulationsPerSecond) : 0.0f;
 
-        // Сбрасываем счетчики и время
+        // Обновляем историю FPS
+        fpsHistory[historyIndex] = fps;
+        historyIndex = (historyIndex + 1) % 5; // Циклический индекс
+
+        // Считаем сглаженное FPS
+        smoothedFPS = 0.0f;
+        for (int i = 0; i < 5; i++) {
+            smoothedFPS += fpsHistory[i];
+        }
+        smoothedFPS /= 5.0f;
+
         frameCount = 0;
         simulationCount = 0;
         lastUpdateTime = currentTime;

system/PerformanceStats.h

@@ -18,7 +18,7 @@ class PerformanceStats {
     void recordSimulation();         // Для подсчета симуляций (вызов Update)
 
     // Получение текущих значений
-    float getFPS() const { return fps; }
+    float getFPS() const { return smoothedFPS; } // Возвращаем сглаженное значение
     float getSimulationsPerSecond() const { return simulationsPerSecond; }
 
     float getMinSimulationDelayMs() const; // Минимальная задержка симуляции
@@ -52,7 +52,9 @@ class PerformanceStats {
     float avgFrameTimeMs = 0.0f;     // Среднее время кадра (мс)
     float avgSimulationTimeMs = 0.0f;// Среднее время симуляции (мс)
 
-
+    float fpsHistory[5] = { 75.0f, 75.0f, 75.0f, 75.0f, 75.0f }; // История FPS (5 значений)
+    int historyIndex = 0; // Индекс для записи
+    float smoothedFPS = 75.0f; // Сглаженное значение FPS
 
 };