Оптимизация игры. Увеличил производительность примерно на 20-25% небольшие визуальные обновления

Author: AsuRaHan

.github/preview_image2.png

@@ -121,6 +121,8 @@ git push origin v1.0.0
 - **./rendering**: Код, связанный с рендерингом
   - `Camera.h`, `Camera.cpp` - Управление камерой для 3D вида
   - `Renderer.h`, `Renderer.cpp` - Логика рендеринга в OpenGL
+  - `CellInstance.h` - Структура для хранения инстанса дивых и мертвых клеток для оптимальной отрисовки в OpenGL
+  - `ICellInstanceProvider.h` - Проводник обеспечивающий обмен данными между разными классами. Это простой интерфейс, паттерн провайдер.
 
 - **./mathematics**: Математические утилиты
   - `Matrix4x4.h`, `Matrix4x4.cpp` - Операции с матрицами (на данный момент не используется)

README.md

@@ -38,9 +38,11 @@ void GameController::placePattern(int startX, int startY, const Pattern& pattern
                 grid.setCellState(startX + (patternWidth - 1 - x), startY + (patternHeight - 1 - y), pattern[y][x]);
                 if (pattern[y][x]) {
                     grid.getCell(startX + (patternWidth - 1 - x), startY + (patternHeight - 1 - y)).setColor(Vector3d(0.5f, 0.9f, 0.5f));
+                    gameOfLife.SetCellColor(startX + (patternWidth - 1 - x), startY + (patternHeight - 1 - y), Vector3d(0.5f, 0.9f, 0.5f));
                 }
                 else {
                     grid.getCell(startX + (patternWidth - 1 - x), startY + (patternHeight - 1 - y)).setColor(Vector3d(0.1f, 0.1f, 0.1f));
+                    gameOfLife.SetCellColor(startX + (patternWidth - 1 - x), startY + (patternHeight - 1 - y), Vector3d(0.1f, 0.1f, 0.1f));
                 }
 
             }
@@ -62,10 +64,12 @@ void GameController::randomizeGrid(float density) {
             if (dis(gen) < density) {
                 grid.setCellState(x, y, true);
                 grid.getCell(x, y).setColor(Vector3d(0.0f, 0.6f, 0.0f));
+                gameOfLife.SetCellColor(x, y, Vector3d(0.0f, 0.6f, 0.0f));
             }
             else {
                 grid.setCellState(x, y, false);
                 grid.getCell(x, y).setColor(Vector3d(0.0f, 0.0f, 0.0f));
+                gameOfLife.SetCellColor(x, y, Vector3d(0.0f, 0.0f, 0.0f));
             }
             //float r = static_cast<float>(rand()) / RAND_MAX;
             //float g = static_cast<float>(rand()) / RAND_MAX;
@@ -81,6 +85,7 @@ void GameController::clearGrid() {
         for (int x = 0; x < grid.getWidth(); ++x) {
             grid.setCellState(x, y, false); // Óñòàíàâëèâàåì êàæäóþ êëåòêó â ìåðòâîå ñîñòîÿíèå
             grid.getCell(x, y).setColor(Vector3d(0.0f, 0.0f, 0.0f));
+            gameOfLife.SetCellColor(x, y, Vector3d(0.0f, 0.0f, 0.0f));
         }
     }
 }
@@ -112,6 +117,7 @@ void GameController::previousGeneration() {
     if (isRunning) return;
     gameOfLife.previousGeneration();
 }
+
 bool GameController::isSimulationRunning() const {
     return isRunning;
 }
@@ -121,10 +127,12 @@ void GameController::toggleCellState(int x, int y) {
     bool currentState = grid.getCellState(x, y);
     grid.setCellState(x, y, !currentState);
     if (!currentState) {
-        grid.getCell(x, y).setColor(Vector3d(0.1f, 0.4f, 0.1f));
+        //grid.getCell(x, y).setColor(Vector3d(0.1f, 0.4f, 0.1f));
+        gameOfLife.SetCellColor(x, y, Vector3d(0.1f, 0.4f, 0.1f));
     }
     else {
-        grid.getCell(x, y).setColor(Vector3d(0.0f, 0.0f, 0.0f));
+        //grid.getCell(x, y).setColor(Vector3d(0.0f, 0.0f, 0.0f));
+        gameOfLife.SetCellColor(x, y, Vector3d(0.0f, 0.0f, 0.0f));
     }
 
 }
@@ -183,9 +191,11 @@ void GameController::setCurrentPattern(int patternNumber) {
         break;
     }
 }
+
 void GameController::setCurrentPatternRotator(int patternRotator) {
      currentPatternRotator = patternRotator;
 }
+
 void GameController::PlacePattern(int startX, int startY) {
     if (isRunning) return;
 
@@ -265,4 +275,6 @@ Pattern GameController::rotateOrFlip(const Pattern& pattern, Rotation rotation)
     }
 
     return result;
-}
+}
+
+

game/GameController.cpp

@@ -5,15 +5,15 @@
 #include "GameOfLife.h"
 #include "Grid.h"
 #include "GameStateManager.h"
+//#include "../rendering/ICellInstanceProvider.h"
+
 #include <random> // Äëÿ ãåíåðàöèè ñëó÷àéíûõ ÷èñåë
 #include <string>
 #include <fstream>
 #include <sstream>
 #include <vector>
 #include <array>
 
-
-
 // Îïðåäåëèì òèï ôèãóðû êàê äâóìåðíûé ìàññèâ
 using Pattern = std::vector<std::vector<bool>>;
 
@@ -130,7 +130,10 @@ class GameController {
     bool saveGameStateCSV(const std::string& filename) const {
         return GameStateManager::saveGameStateCSV(grid, filename);
     }
-
     Pattern rotateOrFlip(const Pattern& pattern, Rotation rotation);
+
+    void SetCellInstanceProvider(ICellInstanceProvider* provider) {
+        gameOfLife.SetCellProvider(provider); // Ïåðåäàåì ïðîâàéäåðà â GameOfLife
+    }
 };
 #endif // GAMECONTROLLER_H_

game/GameController.h

@@ -1,7 +1,8 @@
 #include "GameOfLife.h"
 
 GameOfLife::GameOfLife(Grid& g) : grid(g), nextGrid(g.getWidth(), g.getHeight()),
-gpuAutomaton(g.getWidth(), g.getHeight()), isToroidal(true), isGpuSimulated(true)
+gpuAutomaton(g.getWidth(), g.getHeight()), isToroidal(true), isGpuSimulated(true),
+cellInstances(nullptr),cellProvider(nullptr)
 {
     gpuAutomaton.SetToroidal(isToroidal); // Óñòàíîâêà isToroidal
 }
@@ -129,10 +130,33 @@ void GameOfLife::nextGenerationGPU() {
                 if (bc < 0) bc = 0.0f;
                 cell.setColor(Vector3d(rc, bc, gc));
             }
+
+            SetCellColor(x, y, cell.getColor());
+
+        }
+    }
+}
+
+void GameOfLife::SetCellColor(int x, int y, const Vector3d& color) {
+    if (cellProvider && cellInstances) {
+        int GW = grid.getWidth();
+        int index = y * GW + x;
+        if (index < cellInstances->size()) {
+            (*cellInstances)[index].color = color;
         }
     }
 }
 
+void GameOfLife::SetCellProvider(const ICellInstanceProvider* provider) {
+    cellProvider = provider;
+    if (cellProvider) {
+        cellInstances = &const_cast<std::vector<CellInstance>&>(cellProvider->GetCellInstances());
+    }
+    else {
+        cellInstances = nullptr;
+    }
+}
+
 void GameOfLife::nextGenerationCPU() {
     //saveCurrentState(); // Ñîõðàíÿåì òåêóùåå ñîñòîÿíèå
     int neighbors;

game/GameOfLife.cpp

@@ -3,6 +3,8 @@
 #define GAMEOFLIFE_H
 
 #include "GPUAutomaton.h"
+#include "../rendering/ICellInstanceProvider.h"
+
 #include "Grid.h"
 #include <vector>
 #include <future>  
@@ -17,6 +19,10 @@ class GameOfLife {
     bool getWoldToroidal() const { return isToroidal; };
 
     void updateGridReference(Grid& newGrid) { grid = newGrid; } // ìåòîä äëÿ îáíîâëåíèÿ ññûëêè
+
+    void SetCellProvider(const ICellInstanceProvider* provider);
+
+    void SetCellColor(int x, int y, const Vector3d& color);
 private:
     Grid& grid;
     Grid nextGrid; // Äîáàâëÿåì nextGrid äëÿ äâîéíîãî áóôåðà
@@ -26,6 +32,9 @@ class GameOfLife {
     bool isToroidal;
     bool isGpuSimulated;
 
+    std::vector<CellInstance>* cellInstances;
+    const ICellInstanceProvider* cellProvider;
+
     void nextGenerationGPU();
     void nextGenerationCPU();
 

game/GameOfLife.h

@@ -184,7 +184,9 @@
     <ClInclude Include="mathematics\Matrix4x4.h" />
     <ClInclude Include="mathematics\Vector3d.h" />
     <ClInclude Include="rendering\Camera.h" />
+    <ClInclude Include="rendering\CellInstance.h" />
     <ClInclude Include="rendering\CubeRenderer.h" />
+    <ClInclude Include="rendering\ICellInstanceProvider.h" />
     <ClInclude Include="rendering\Renderer.h" />
     <ClInclude Include="rendering\UIController.h" />
     <ClInclude Include="res\resource.h" />

life.vcxproj

@@ -148,6 +148,12 @@
     <ClInclude Include="rendering\CubeRenderer.h">
       <Filter>rendering</Filter>
     </ClInclude>
+    <ClInclude Include="rendering\ICellInstanceProvider.h">
+      <Filter>rendering</Filter>
+    </ClInclude>
+    <ClInclude Include="rendering\CellInstance.h">
+      <Filter>rendering</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Filter Include="game">

life.vcxproj.filters

@@ -178,6 +178,7 @@ int wWinMain(
 
         Renderer renderer(width, height);
         renderer.SetGameController(&gameController);
+        gameController.SetCellInstanceProvider(&renderer);
 
         // Передаем один и тот же экземпляр gameController в WindowController
         WindowController controller(&mainWindow, &renderer, &gameController);
@@ -208,6 +209,7 @@ int wWinMain(
 
             // Здесь вызываем update с deltaTime
             gameController.update(deltaTime.count()); // .count() возвращает значение в секундах как float
+            
             renderer.Draw();
         }
 

main.cpp

@@ -16,7 +16,14 @@ class Vector3d {
     Vector3d operator-(const Vector3d& other) const;
     Vector3d operator*(float scalar) const;
     Vector3d operator/(float scalar) const;
-
+    //Vector3d& operator=(const Vector3d& other) {
+    //    if (this != &other) { // çàùèòà îò ñàìîïðèñâàèâàíèÿ
+    //        x = other.x;
+    //        y = other.y;
+    //        z = other.z;
+    //    }
+    //    return *this;
+    //}
     // Ìåòîäû
     float length() const;
     Vector3d normalize() const;

mathematics/Vector3d.h

@@ -0,0 +1,6 @@
+#include "../mathematics/Vector3d.h"
+
+struct CellInstance {
+    float x, y; // Ïîçèöèÿ êëåòêè
+    Vector3d color; // Öâåò êëåòêè
+};

rendering/CellInstance.h

@@ -0,0 +1,10 @@
+#pragma once
+#include <vector>
+//#include "Renderer.h"
+#include "CellInstance.h" // Включаем определение CellInstance
+
+class ICellInstanceProvider {
+public:
+    virtual ~ICellInstanceProvider() = default;
+    virtual const std::vector<CellInstance> &GetCellInstances() const = 0;
+};

rendering/ICellInstanceProvider.h

@@ -242,12 +242,12 @@ void Renderer::DrawCells() {
     if (!pGameController) return;
     int GW = pGameController->getGridWidth();
     // Îáíîâëÿåì äàííûå î êëåòêàõ
-    for (size_t i = 0; i < cellInstances.size(); ++i) {
-        int x = i % GW;
-        int y = i / GW;
-        Cell cell = pGameController->getGrid().getCell(x, y);
-        cellInstances[i].color = cell.getColor(); // Îáíîâëÿåì òîëüêî öâåò
-    }
+    //for (size_t i = 0; i < cellInstances.size(); ++i) {
+    //    int x = i % GW;
+    //    int y = i / GW;
+    //    Cell cell = pGameController->getGrid().getCell(x, y);
+    //    cellInstances[i].color = cell.getColor(); // Îáíîâëÿåì òîëüêî öâåò
+    //}
     // Ïðèâÿçûâàåì VAO ïåðåä íàñòðîéêîé àòðèáóòîâ
     GL_CHECK(glBindVertexArray(cellsVAO));
 

rendering/Renderer.cpp

@@ -6,6 +6,7 @@
 #include "Camera.h"
 #include "UIController.h"
 #include "../game/GameController.h"
+#include "ICellInstanceProvider.h"
 
 #include "CubeRenderer.h"
 
@@ -16,7 +17,7 @@
 #include "imgui_impl_opengl3.h"
 #include "imgui_impl_win32.h" 
 
-class Renderer {
+class Renderer : public ICellInstanceProvider {
 public:
     Renderer(int width, int height);
     ~Renderer();
@@ -34,6 +35,14 @@ class Renderer {
 
     void DrawCubes();
 
+    // Ãåòòåð äëÿ cellInstances
+    const std::vector<CellInstance> &GetCellInstances() const override {
+        return cellInstances;
+    }
+
+    // Ñåòòåð äëÿ cellInstances
+    void SetCellInstances(const std::vector<CellInstance>& instances) { cellInstances = instances; }
+
 private:
     int width, height;
     Camera camera;
@@ -53,10 +62,6 @@ class Renderer {
     GLuint cellsVAO;
 
     std::vector<GLfloat> gridVertices;
-    struct CellInstance {
-        float x, y; // Ïîçèöèÿ êëåòêè
-        Vector3d color; // Öâåò êëåòêè
-    };
     GLuint cellInstanceVBO;
     std::vector<CellInstance> cellInstances;