Шейдеры для рандомизации и очистки мира

AsuRaHan · AsuRaHan · commit b877c97bf479 · 2025-02-19T23:37:14.000+04:00
diff --git a/README.md b/README.md
@@ -73,7 +73,6 @@
 - **T**: Сброс камеры, чтобы весь игровой мир был виден.
 - **R**: Случайное заполнение поля.
 - **C**: Очистка поля, убить все клетки.
-- **I**: Заполнить поле случайным числом фигур.
 - **G**: Спрятать или показать сетку.
 - **U**: Спрятать или показать пользовательский интерфейс GUI.
 - **Y**: Сменить тип мира (сетка с ограниченными краями или с тороидальными краями).
@@ -195,13 +194,13 @@ git push origin v1.0.0
 
 ### Будущие улучшения
 
-- [x] Реализация различных наборов правил для "Жизни".
-- [x] Управления изменения размера сетки.
-- [x] Оптимизация рендеринга для лучшей производительности на больших сетках или более сложных узорах.
-- [x] Реализована загрузка паттернов (сложных узорах) из файлов в дириктории `patterns` в формате *.cells* 
-- [x] Оптимизиция закгрузки и сохранения мира.
-- [x] Оптимизация динамической смены размеров мира
-- [ ] Оптимизация рандомизации и очистки сетки
+- [x] Внедрена поддержка различных наборов правил для игры "Жизнь".
+- [x] Добавлена функциональность для динамического изменения размера мира.
+- [x] Оптимизирован рендеринг для повышения производительности на больших мирах и сложных узорах.
+- [x] Реализована загрузка предустановленных узоров из файлов формата .cells, расположенных в папке patterns.
+- [x] Улучшено время загрузки и сохранения состояния мира.
+- [x] Ускорена перестройка мира при изменении его размеров.
+- [ ] Оптимизация функций случайного заполнения и полной очистки мира.
 
 ## От автора
 
diff --git a/game/GPUAutomaton.cpp b/game/GPUAutomaton.cpp
@@ -3,6 +3,8 @@
 GPUAutomaton::GPUAutomaton(int width, int height)
     : gridWidth(width), gridHeight(height), bufferIndex(0) {
     CreateComputeShader();
+    LoadClearShader();
+    LoadRandomizeShader();
     SetupBuffers();
 }
 
@@ -103,6 +105,82 @@ void main() {
 
 }
 
+void GPUAutomaton::LoadClearShader() {
+    const char* clearShaderSource = R"(
+    #version 430 core
+    layout(local_size_x = 32, local_size_y = 32) in;
+    
+    layout(std430, binding = 0) buffer CellBuffer {
+        int cells[];
+    };
+    
+    layout(std430, binding = 1) buffer ColorBuffer {
+        vec4 colors[];
+    };
+    
+    uniform ivec2 gridSize;
+
+    void main() {
+        ivec2 pos = ivec2(gl_GlobalInvocationID.xy);
+        if (pos.x >= gridSize.x || pos.y >= gridSize.y) return;
+        
+        uint index = pos.y * gridSize.x + pos.x;
+        cells[index] = 0; // Мертвая клетка
+        colors[index] = vec4(0.0, 0.0, 0.0, 1.0); // Черный цвет
+    }
+    )";
+
+    shaderManager.loadComputeShader("clearShader", clearShaderSource);
+    shaderManager.linkComputeProgram("clearProgram", "clearShader");
+    clearProgram = shaderManager.getProgram("clearProgram");
+}
+
+void GPUAutomaton::LoadRandomizeShader() {
+    const char* randomizeShaderSource = R"(
+    #version 430 core
+    layout(local_size_x = 32, local_size_y = 32) in;
+    
+    layout(std430, binding = 0) buffer CellBuffer {
+        int cells[];
+    };
+    
+    layout(std430, binding = 1) buffer ColorBuffer {
+        vec4 colors[];
+    };
+    
+    uniform ivec2 gridSize;
+    uniform float density;
+    uniform unsigned int seed;
+
+unsigned int pcg_hash(unsigned int input) {
+    unsigned int state = input * 747796405u + 2891336453u; // Используйте 'u' для литералов беззнаковых чисел
+    unsigned int word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
+    return (word >> 22u) ^ word;
+}
+
+    void main() {
+        ivec2 pos = ivec2(gl_GlobalInvocationID.xy);
+        if (pos.x >= gridSize.x || pos.y >= gridSize.y) return;
+        
+        uint index = pos.y * gridSize.x + pos.x;
+        uint random = pcg_hash(index + seed);
+        float randomFloat = float(random & 0x00FFFFFF) / float(0x01000000); // Преобразование в float [0, 1)
+        
+        if (randomFloat < density) {
+            cells[index] = 1; // Живая клетка
+            colors[index] = vec4(0.0, 0.6, 0.0, 1.0); // Зеленый цвет
+        } else {
+            cells[index] = 0; // Мертвая клетка
+            colors[index] = vec4(0.0, 0.0, 0.0, 1.0); // Черный цвет
+        }
+    }
+    )";
+
+    shaderManager.loadComputeShader("randomizeShader", randomizeShaderSource);
+    shaderManager.linkComputeProgram("randomizeProgram", "randomizeShader");
+    randomizeProgram = shaderManager.getProgram("randomizeProgram");
+}
+
 void GPUAutomaton::SetupBuffers() {
     GL_CHECK(glGenBuffers(2, cellsBuffer));
     GL_CHECK(glGenBuffers(1, &colorsBuffer));
@@ -145,29 +223,56 @@ void GPUAutomaton::Update() {
 
     SwapBuffers();
 }
-//  Как это работает
-//  На каждом шаге Update() :
-//      cellsBuffer[currentBufferIndex] привязывается к binding = 0 как входной буфер(current).
-//      cellsBuffer[(currentBufferIndex + 1) % 2] привязывается к binding = 1 как выходной буфер(next).
-//      Шейдер выполняет вычисления, записывая новое состояние в next и цвета в colorsBuffer.
-//      После выполнения SwapBuffers() переключает currentBufferIndex, делая next новым current для следующего шага.
+
+/**
+* Как это работает
+* На каждом шаге Update() :
+*      cellsBuffer[currentBufferIndex] привязывается к binding = 0 как входной буфер(current).
+*      cellsBuffer[(currentBufferIndex + 1) % 2] привязывается к binding = 1 как выходной буфер(next).
+*      Шейдер выполняет вычисления, записывая новое состояние в next и цвета в colorsBuffer.
+*      После выполнения SwapBuffers() переключает currentBufferIndex, делая next новым current для следующего шага
+*/
 void GPUAutomaton::SwapBuffers() {
     currentBufferIndex = (currentBufferIndex + 1) % 2;
 }
 
 void GPUAutomaton::SetGridState(const std::vector<int>& inState) {
-    //glFinish();
     GL_CHECK(glBindBuffer(GL_SHADER_STORAGE_BUFFER, cellsBuffer[currentBufferIndex]));
     GL_CHECK(glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(int) * gridWidth * gridHeight, inState.data()));
 }
 
 void GPUAutomaton::GetGridState(std::vector<int>& outState) {
     outState.resize(gridWidth * gridHeight);
-    //glFinish();
     GL_CHECK(glBindBuffer(GL_SHADER_STORAGE_BUFFER, cellsBuffer[currentBufferIndex]));
     GL_CHECK(glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(int) * gridWidth * gridHeight, outState.data()));
 }
 
+void GPUAutomaton::ClearGrid() {
+    glUseProgram(clearProgram);
+
+    glUniform2i(glGetUniformLocation(clearProgram, "gridSize"), gridWidth, gridHeight);
+
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, cellsBuffer[currentBufferIndex]);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, colorsBuffer);
+
+    glDispatchCompute((gridWidth + 31) / 32, (gridHeight + 31) / 32, 1);
+    glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
+}
+
+void GPUAutomaton::RandomizeGrid(float density, unsigned int seed) {
+    glUseProgram(randomizeProgram);
+
+    glUniform2i(glGetUniformLocation(randomizeProgram, "gridSize"), gridWidth, gridHeight);
+    glUniform1f(glGetUniformLocation(randomizeProgram, "density"), density);
+    glUniform1ui(glGetUniformLocation(randomizeProgram, "seed"), seed);
+
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, cellsBuffer[currentBufferIndex]);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, colorsBuffer);
+
+    glDispatchCompute((gridWidth + 31) / 32, (gridHeight + 31) / 32, 1);
+    glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
+}
+
 void GPUAutomaton::SetCellState(int x, int y, int state) {
     if (x < 0 || x >= gridWidth || y < 0 || y >= gridHeight) {
         std::cerr << "SetCellState: Invalid coordinates (" << x << ", " << y << ")" << std::endl;
diff --git a/game/GPUAutomaton.h b/game/GPUAutomaton.h
@@ -45,11 +45,12 @@ class GPUAutomaton {
     void SetColorsBuf(const std::vector<float>& colors);
     void GetColorsBuf(std::vector<float>& colors);
 
-
+    void ClearGrid(); // метод для очистки
+    void RandomizeGrid(float density, unsigned int seed); // метод для рандомизации
 private:
     void CreateComputeShader();
     void SetupBuffers();
-    void SwapBuffers(); // Новый метод для переключения буферов
+    void SwapBuffers(); // метод для переключения буферов
 
     ShaderManager shaderManager;
     GLuint computeProgram;
@@ -61,6 +62,11 @@ class GPUAutomaton {
 
     int gridWidth, gridHeight;
     
+    GLuint clearProgram; // свойство для программы очистки
+    void LoadClearShader(); // приватный метод для загрузки шейдера очистки
+
+    GLuint randomizeProgram; // свойство для программы рандомизации
+    void LoadRandomizeShader(); // метод для загрузки шейдера рандомизации
 };
 
 #endif // GPU_AUTOMATON_H
diff --git a/game/GameController.cpp b/game/GameController.cpp
@@ -15,25 +15,6 @@ GameController::GameController(int width, int height, float cellSize)
     
 }
 
-void GameController::randomizeGrid() {
-    if (isRunning) return;
-    std::random_device rd;  // Только для инициализации генератора
-    std::mt19937 gen(rd()); // Стандартный мерсенновский твистер
-    std::uniform_int_distribution<> disGliders(3, 15); // Генерация количества глайдеров
-    std::uniform_int_distribution<> disX(0, grid.getWidth() - 3); // Генерация X-координаты
-    std::uniform_int_distribution<> disY(0, grid.getHeight() - 3); // Генерация Y-координаты
-    std::uniform_int_distribution<> disTipe(0, 3); // Генерация чисел от 0 до 3
-
-    int numberOfGliders = disGliders(gen); // Случайное количество глайдеров
-
-    for (auto i = 0; i < numberOfGliders; ++i) {
-        int startX = disX(gen);
-        int startY = disY(gen);
-        // Размещаем фигуру на сетке в случайном месте
-        placePattern(startX, startY, gosperGliderGun);
-    }
-}
-
 void GameController::placePattern(int startX, int startY, const Pattern& pattern) {
     if (isRunning) return;
     int patternHeight = static_cast<int>(pattern.size());
@@ -90,33 +71,36 @@ void GameController::setWoldToroidal(bool wt)
 void GameController::randomizeGrid(float density) {
     if (isRunning) return;
     // Генератор случайных чисел
-    std::random_device rd;  // Только для инициализации генератора
-    std::mt19937 gen(rd()); // Стандартный мерсенновский твистер
-    std::uniform_real_distribution<> dis(0.0, 1.0); // Равномерное распределение
-
-    for (int y = 0; y < grid.getHeight(); ++y) {
-        for (int x = 0; x < grid.getWidth(); ++x) {
-            // Если случайное число меньше density, клетка становится живой
-            if (dis(gen) < density) {
-                grid.setCellState(x, y, true);
-                grid.setCellColor(x, y, 0.0f, 0.6f, 0.0f);
-            }
-            else {
-                grid.setCellState(x, y, false);
-                grid.setCellColor(x, y, 0.0f, 0.0f, 0.0f);
-            }
-        }
-    }
+    //std::random_device rd;  // Только для инициализации генератора
+    //std::mt19937 gen(rd()); // Стандартный мерсенновский твистер
+    //std::uniform_real_distribution<> dis(0.0, 1.0); // Равномерное распределение
+
+    //for (int y = 0; y < grid.getHeight(); ++y) {
+    //    for (int x = 0; x < grid.getWidth(); ++x) {
+    //        // Если случайное число меньше density, клетка становится живой
+    //        if (dis(gen) < density) {
+    //            grid.setCellState(x, y, true);
+    //            grid.setCellColor(x, y, 0.0f, 0.6f, 0.0f);
+    //        }
+    //        else {
+    //            grid.setCellState(x, y, false);
+    //            grid.setCellColor(x, y, 0.0f, 0.0f, 0.0f);
+    //        }
+    //    }
+    //}
+
+        // Генерация случайного seed
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    unsigned int seed = gen(); // Генерируем случайное число для seed
+
+    // Вызов метода RandomizeGrid с density и seed
+    gpuAutomaton.RandomizeGrid(density, seed);
 }
 
 void GameController::clearGrid() {
     if (isRunning) return;
-    for (int y = 0; y < grid.getHeight(); ++y) {
-        for (int x = 0; x < grid.getWidth(); ++x) {
-            grid.setCellState(x, y, false); // Устанавливаем каждую клетку в мертвое состояние
-            grid.setCellColor(x, y, 0.0f, 0.0f, 0.0f);
-        }
-    }
+    gpuAutomaton.ClearGrid();
 }
 
 void GameController::update(float deltaTime) {
diff --git a/game/GameController.h b/game/GameController.h
@@ -106,7 +106,6 @@ class GameController {
     GameController(int width, int height, float cellSize = 0.5f);
 
     void randomizeGrid(float density);
-    void randomizeGrid();
 
     void placePattern(int startX, int startY, const Pattern& pattern);
     void PlacePattern(int startX, int startY);
diff --git a/rendering/UIRenderer.cpp b/rendering/UIRenderer.cpp
@@ -112,21 +112,6 @@ void UIRenderer::DrawSimulationWindow() {
         }
     }
 
-    //if (gameController->getGpuSimulated()) {
-    //    if (ImGui::Button("Симуляция на CPU", buttonSize)) {
-    //        if (!gameController->isSimulationRunning()) {
-    //            gameController->setGpuSimulated(false); // установить симуляцию через ЦП
-    //        }
-    //    }
-    //}
-    //else {
-    //    if (ImGui::Button("Симуляция на GPU", buttonSize)) {
-    //        if (!gameController->isSimulationRunning()) {
-    //            gameController->setGpuSimulated(true); // установить симуляцию через видеокарту 
-    //        }
-    //    }
-    //}
-
     if (ImGui::Button("Шаг симуляции", buttonSize)) {
         gameController->stepSimulation();
     }
diff --git a/system/GLFunctions.cpp b/system/GLFunctions.cpp
@@ -56,6 +56,7 @@ PFNGLGETINTEGERI_VPROC glGetIntegeri_v = nullptr;
 PFNGLGETBUFFERPARAMETERIVPROC glGetBufferParameteriv = nullptr;
 
 PFNGLISBUFFERPROC glIsBuffer = nullptr;
+PFNGLUNIFORM1UIPROC glUniform1ui = nullptr;
 
 void LoadOpenGLFunctions() {
         // Загрузка функций для работы с буферами
@@ -169,6 +170,9 @@ void LoadOpenGLFunctions() {
     
     glIsBuffer = (PFNGLISBUFFERPROC)wglGetProcAddress("glIsBuffer");
     CHECK_LOAD_FUNCTION(glIsBuffer);
+    
+    glUniform1ui = (PFNGLUNIFORM1UIPROC)wglGetProcAddress("glUniform1ui");
+    CHECK_LOAD_FUNCTION(glUniform1ui);
 
 
 
diff --git a/system/GLFunctions.h b/system/GLFunctions.h
@@ -449,6 +449,8 @@ typedef void (APIENTRY* PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pna
 
 typedef GLboolean(APIENTRY* PFNGLISBUFFERPROC)(GLuint buffer);
 
+typedef void (APIENTRY* PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0);
+
 // Объявление указателей на функции
 extern PFNGLGENBUFFERSPROC glGenBuffers;
 extern PFNGLBINDBUFFERPROC glBindBuffer;
@@ -505,6 +507,7 @@ extern PFNGLGETINTEGERI_VPROC glGetIntegeri_v;
 extern PFNGLGETBUFFERPARAMETERIVPROC glGetBufferParameteriv;
 
 extern PFNGLISBUFFERPROC glIsBuffer;
+extern PFNGLUNIFORM1UIPROC glUniform1ui;
 
 // Функции для работы с OpenGL
 void LoadOpenGLFunctions();
diff --git a/windowing/WindowController.cpp b/windowing/WindowController.cpp
@@ -171,11 +171,6 @@ void WindowController::HandleEvent(UINT message, WPARAM wParam, LPARAM lParam) {
                 pGameController->setWoldToroidal(!pGameController->getWoldToroidal()); // сделать мир безграничным или на оборот ограничеть его
             }
             break;
-        case 'I':
-            if (!pGameController->isSimulationRunning()) {
-                pGameController->randomizeGrid(); // засеять поле рандомными фигурами
-            }
-            break;
         case 'G':
             pGameController->setShowGrid(!pGameController->getShowGrid());
             break;        
