gitignore: Adding windows build directory

Some of the code is still linux only

.gitignore

@@ -5,3 +5,4 @@ _deps
 CMakeSettings.json
 .vs
 .cache
+build-win-x86_64

CMakeLists.txt

@@ -69,12 +69,15 @@ include_directories(${imgui_SOURCE_DIR} ${rlImGui_SOURCE_DIR})
 set(SRC_CXX_FILES "./src/main.cpp"
                   "./src/rules.cpp"
                   "./src/world.cpp"
+                  "./src/grid.cpp"
                   "./src/render.cpp"
                   "./src/control_menu.cpp"
                   "./src/settings_menu.cpp"
                   "./src/selection_menu.cpp"
                   "./src/selection.cpp"
                   "./src/paterns_menu.cpp"
+                  "./src/patern_preview.cpp"
+                  "./src/snapping.cpp"
                   "${rlImGui_SOURCE_DIR}/rlImGui.cpp"
                   "${imgui_SOURCE_DIR}/imgui.cpp"
                   "${imgui_SOURCE_DIR}/imgui_draw.cpp"
@@ -88,3 +91,25 @@ add_executable(${NAME} ${SRC_CXX_FILES})
 
 # Link raylib and raylib-cpp
 target_link_libraries(${NAME} PUBLIC raylib nlohmann_json::nlohmann_json)
+
+# Windows cross-compilation rule
+
+if (NOT DEFINED CMAKE_CROSSCOMPILE_WINDOWS_HELPER_ADDED)
+    set(CMAKE_CROSSCOMPILE_WINDOWS_HELPER_ADDED TRUE)
+
+    set(WIN_TOOLCHAIN_FILE "${CMAKE_SOURCE_DIR}/toolchain-mingw-w64-x86_64.cmake" CACHE PATH "Toolchain for Win x86_64")
+
+    add_custom_target(cmake-win
+        COMMAND ${CMAKE_COMMAND} -E echo "Configuring Windows x86_64 build in: ${CMAKE_SOURCE_DIR}/build-win-x86_64"
+        COMMAND ${CMAKE_COMMAND}
+            -S ${CMAKE_SOURCE_DIR}
+            -B ${CMAKE_SOURCE_DIR}/build-win-x86_64
+            -G "Ninja"
+            -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+            -DCMAKE_TOOLCHAIN_FILE=${WIN_TOOLCHAIN_FILE}
+        COMMAND ${CMAKE_COMMAND} --build ${CMAKE_SOURCE_DIR}/build-win-x86_64 -- -v
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        COMMENT "Configure & build for Windows x86_64 (MinGW-w64)"
+        VERBATIM
+    )
+endif()

README.md

@@ -6,7 +6,7 @@ This is a simple Game Of Life editor written in C++ with raylib & dearImGUI
 
 ## How to compile the project
 
-Ensure you have g++, cmake and the thendependencies of raylib
+Ensure you have g++, cmake and the dependencies of raylib
 
 ```shell
 mkdir build

includes/context.hpp

@@ -22,6 +22,7 @@ class SelectionMenu;
 class ControlMenu;
 class Selection;
 class PaternsMenu;
+class PaternPreview;
 
 typedef struct ctx {
   std::shared_ptr<World> world = nullptr;
@@ -32,6 +33,7 @@ typedef struct ctx {
   std::shared_ptr<ControlMenu> control_menu = nullptr;
   std::shared_ptr<Selection> selection = nullptr;
   std::shared_ptr<PaternsMenu> paterns_menu = nullptr;
+  std::shared_ptr<PaternPreview> patern_preview = nullptr;
   nlohmann::json config_json;
   std::filesystem::path program_dir;
 } ctx;

includes/grid.hpp

@@ -0,0 +1,28 @@
+/*
+* File name: grid.hpp
+* Author: lejulien
+* Date created: 01-01-1970 00:59:59
+// Date modified: 12-01-2026 21:30:10
+* ------
+*/
+
+#pragma once
+
+#include <context.hpp>
+#include <memory>
+#include <settings_menu.hpp>
+#include <world.hpp>
+
+namespace gol {
+
+class Grid {
+ public:
+  Grid(std::shared_ptr<ctx>);
+  ~Grid() = default;
+  void display();
+
+ private:
+  std::shared_ptr<ctx> context_;
+};
+
+};  // namespace gol

includes/patern_preview.hpp

@@ -0,0 +1,33 @@
+/*
+* File name: patern_preview.hpp
+* Author: lejulien
+* Date created: 01-01-1970 00:59:59
+// Date modified: 12-01-2026 21:30:10
+* ------
+*/
+
+#pragma once
+
+#include <memory>
+
+#include <raylib.h>
+
+#include <context.hpp>
+
+namespace gol {
+
+class PaternPreview {
+public:
+  PaternPreview(std::shared_ptr<ctx>);
+  ~PaternPreview() = default;
+  void update();
+  void display();
+  void start();
+private:
+  bool is_started = false;
+  std::shared_ptr<ctx> context_;
+  Vector2 mouse_pos_ = {0, 0};
+  bool is_unplacable_ = false;
+};
+
+} // namespace gol

includes/paterns_menu.hpp

@@ -8,17 +8,32 @@
 
 #pragma once
 
+#include <memory>
+#include <context.hpp>
+#include <vector>
+#include <map>
+#include <string>
+
 namespace gol {
 
 class PaternsMenu {
 public:
-  PaternsMenu() = default;
+  PaternsMenu(std::shared_ptr<ctx>);
   ~PaternsMenu() = default;
   void Toogle();
   bool isOpen();
   void display();
+  void refresh();
 private:
+  bool loadPatern(std::string &path);
   bool is_open_ = false;
+  std::shared_ptr<ctx> context_ = nullptr;
+  std::map<std::string,std::string> paterns_paths_list_;
+  std::vector<std::string> paterns_name_list_;
+public:
+  int patern_width_ = 0;
+  int patern_height_ = 0;
+  std::vector<uint32_t> loaded_patern_;
 };
 
 } // namespace gol

includes/snapping.hpp

@@ -1,5 +1,5 @@
 /*
-* File name: selection.cpp
+* File name: snapping.hpp
 * Author: lejulien
 * Date created: 01-01-1970 00:59:59
 // Date modified: 12-01-2026 21:30:10
@@ -13,12 +13,6 @@
 #include <raylib.h>
 #include <cmath>
 
-Vector2 snapToGrid(Vector2 screen, int cell_size) {
+Vector2 snapToGrid(Vector2 screen, int cell_size);
-  return {static_cast<float>(round(screen.x / cell_size) * cell_size),
-          static_cast<float>(round(screen.y / cell_size) * cell_size)};
-}
 
-Vector2i screenToGrid(Vector2 screen, int cell_size) {
+Vector2i screenToGrid(Vector2 screen, int cell_size);
-  return {static_cast<int>(round(screen.x / cell_size)),
-          static_cast<int>(round(screen.y / cell_size))};
-}

includes/world.hpp

@@ -37,6 +37,7 @@ public:
   void setCell(int x, int y);
   void resize(int width, int height); // destructive
   std::vector<uint32_t> getSelection(Vector2i &origin, Vector2i &size);
+  void setSelection(Vector2i &origin, Vector2i &size, std::vector<uint32_t> &data);
 
   // Private members
 private:

src/grid.cpp

@@ -0,0 +1,27 @@
+/*
+* File name: grid.cpp
+* Author: lejulien
+* Date created: 01-01-1970 00:59:59
+// Date modified: 12-01-2026 21:30:10
+* ------
+*/
+
+#include <raylib.h>
+
+#include <grid.hpp>
+
+namespace gol {
+
+Grid::Grid(std::shared_ptr<ctx> context) : context_(context) {}
+
+void Grid::display() {
+  auto cell_size = context_->settings_menu->getCellSize();
+  for (int j = 0; j < context_->world->getHeight(); j++) {
+    for (int i = 0; i < context_->world->getWidth(); i++) {
+      DrawRectangleLines(i * cell_size, j * cell_size, cell_size, cell_size,
+                         GRAY);
+    }
+  }
+}
+
+}  // namespace gol

src/main.cpp

@@ -25,6 +25,8 @@
 #include <selection_menu.hpp>
 #include <selection.hpp>
 #include <paterns_menu.hpp>
+#include <patern_preview.hpp>
+#include <grid.hpp>
 
 int main(int ac, char **av) {
   std::shared_ptr<gol::ctx> context = std::make_shared<gol::ctx>();
@@ -106,7 +108,9 @@ int main(int ac, char **av) {
   context->render = std::make_shared<Render>(context->settings_menu->getCellSize());
   context->selection_menu = std::make_shared<gol::SelectionMenu>(context);
   context->selection = std::make_shared<gol::Selection>(context);
-  context->paterns_menu = std::make_shared<gol::PaternsMenu>();
+  context->paterns_menu = std::make_shared<gol::PaternsMenu>(context);
+  context->patern_preview = std::make_shared<gol::PaternPreview>(context);
+  gol::Grid grid(context);
 
   // Speed handling values
   float sim_speed = 1.0f;
@@ -115,6 +119,7 @@ int main(int ac, char **av) {
 
   // Setups
   context->rules->setup(context->world);
+  context->paterns_menu->refresh();
   // Diplay generations
   while (!WindowShouldClose()) {
     // Frames shinenigans
@@ -135,6 +140,7 @@ int main(int ac, char **av) {
 
     // Selection behaviour
     context->selection->update();
+    context->patern_preview->update();
     context->selection_menu->update();
     context->settings_menu->update();
 
@@ -151,8 +157,10 @@ int main(int ac, char **av) {
     }
     BeginDrawing();
     ClearBackground(BLACK);
+    grid.display();
     context->render->display(context->world);
     context->selection->display();
+    context->patern_preview->display();
     // Start ImGui frame
     rlImGuiBegin();
     context->control_menu->display();

src/patern_preview.cpp

@@ -0,0 +1,69 @@
+/*
+* File name: patern_preview.cpp
+* Author: lejulien
+* Date created: 01-01-1970 00:59:59
+// Date modified: 12-01-2026 21:30:10
+* ------
+*/
+
+#include <imgui.h>
+#include <raylib.h>
+#include <rlImGui.h>
+
+#include <patern_preview.hpp>
+#include <paterns_menu.hpp>
+#include <settings_menu.hpp>
+#include <snapping.hpp>
+#include <world.hpp>
+
+namespace gol {
+
+PaternPreview::PaternPreview(std::shared_ptr<ctx> context)
+    : context_(context) {}
+
+void PaternPreview::start() { is_started = true; }
+
+void PaternPreview::update() {
+  if (!is_started) return;
+  mouse_pos_ = GetMousePosition();
+  if (ImGui::IsMouseClicked(1)) {
+    is_started = false;
+    return;
+  }
+  if (ImGui::IsMouseClicked(0) && !is_unplacable_) {
+    auto selection_pos =
+        screenToGrid(mouse_pos_, context_->settings_menu->getCellSize());
+    Vector2i size = {context_->paterns_menu->patern_width_,
+                     context_->paterns_menu->patern_height_};
+    context_->world->setSelection(selection_pos, size,
+                                  context_->paterns_menu->loaded_patern_);
+    is_started = false;
+  }
+  // mouse should pass through any present windows
+}
+
+void PaternPreview::display() {
+  if (!is_started) return;
+  auto cell_size = context_->settings_menu->getCellSize();
+  auto mouse_in_grid =
+      screenToGrid(mouse_pos_, context_->settings_menu->getCellSize());
+  is_unplacable_ =
+      ((mouse_in_grid.x + context_->paterns_menu->patern_width_ >
+        context_->world->getWidth()) ||
+       (mouse_in_grid.y + context_->paterns_menu->patern_height_ >
+        context_->world->getHeight()));
+  for (int j = 0; j < context_->paterns_menu->patern_height_; j++) {
+    for (int i = 0; i < context_->paterns_menu->patern_width_; i++) {
+      auto cell =
+          context_->paterns_menu
+              ->loaded_patern_[i + (j * context_->paterns_menu->patern_width_)];
+      if (cell) {
+        DrawRectangle((i + mouse_in_grid.x) * cell_size,
+                      (j + mouse_in_grid.y) * cell_size, cell_size, cell_size,
+                      (is_unplacable_) ? RED : BLUE);
+      }
+    }
+  }
+}
+
+};  // namespace gol

src/paterns_menu.cpp

@@ -6,30 +6,94 @@
 * ------
 */
 
-#include <paterns_menu.hpp>
-
 #include <imgui.h>
 #include <raylib.h>
 #include <rlImGui.h>
 
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <paterns_menu.hpp>
+#include <patern_preview.hpp>
+#include <sstream>
+
 namespace gol {
 
-void PaternsMenu::Toogle() {
+PaternsMenu::PaternsMenu(std::shared_ptr<ctx> ctx) : context_(ctx) {}
-  is_open_ = !is_open_;
+
+void PaternsMenu::Toogle() { is_open_ = !is_open_; }
+
+bool PaternsMenu::isOpen() { return is_open_; }
+
+void PaternsMenu::refresh() {
+  paterns_name_list_.clear();
+  paterns_paths_list_.clear();
+  auto paterns_path = context_->program_dir / "paterns";
+  if (std::filesystem::exists(paterns_path) &&
+      std::filesystem::is_directory(paterns_path)) {
+    for (const auto &entry :
+         std::filesystem::directory_iterator(paterns_path)) {
+      if (!std::filesystem::is_directory(entry) &&
+          entry.path().has_filename()) {
+        paterns_paths_list_[entry.path().filename()] = entry.path();
+        paterns_name_list_.push_back(entry.path().filename());
+      }
+    }
+  }
 }
 
-bool PaternsMenu::isOpen() {
+bool PaternsMenu::loadPatern(std::string &path) {
-  return is_open_;
+  std::ifstream file(path);
+  std::string file_data;
+  if (!file.is_open()) {
+    std::cerr << "Failure in opening patern : " << path << std::endl;
+    return false;
+  }
+  loaded_patern_.clear();
+  try {
+    std::getline(file, file_data);
+    std::stringstream ss(file_data);
+    std::string width, height, data;
+    std::getline(ss, width, '|');
+    std::getline(ss, height, '|');
+    std::getline(ss, data, '|');
+    patern_width_ = std::stoi(width);
+    patern_height_ = std::stoi(height);
+    for (int i = 0; i < patern_width_ * patern_height_; i++) {
+      loaded_patern_.push_back((data[i] == '1') ? 1 : 0);
+    }
+  } catch (std::exception &e) {
+    std::cerr << "Failure in loading patern : " << path << std::endl;
+    return false;
+  }
+  return true;
 }
 
 void PaternsMenu::display() {
   if (is_open_) {
-    ImGuiWindowFlags paterns_flags = ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize;
+    ImGuiWindowFlags paterns_flags =
-    ImGui::SetNextWindowSize(ImVec2(150, 200), ImGuiCond_Always);
+        ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize;
+    ImGui::SetNextWindowSize(ImVec2(200, 250), ImGuiCond_Always);
     ImGui::Begin("paterns", &is_open_, paterns_flags);
-    ImGui::Button("refresh");
+    for (auto patern_name : paterns_name_list_) {
+      ImGui::PushID(patern_name.c_str());
+      if (ImGui::Button(patern_name.c_str()) &&
+        loadPatern(paterns_paths_list_[patern_name])) {
+        context_->patern_preview->start();
+      }
+      ImGui::PopID();
+      ImGui::SameLine(ImGui::GetWindowWidth() - 57.);
+      std::string del_id = patern_name.c_str();
+      del_id.append("_del");
+      ImGui::PushID(del_id.c_str());
+      if (ImGui::Button("delete")) {
+        std::filesystem::remove(paterns_paths_list_[patern_name]);
+        refresh();
+      }
+      ImGui::PopID();
+    }
     ImGui::End();
   }
 }
 
-} // namespace gol
+}  // namespace gol

src/selection_menu.cpp

@@ -12,6 +12,7 @@
 #include <filesystem>
 
 #include <selection_menu.hpp>
+#include <paterns_menu.hpp>
 
 namespace gol {
 
@@ -90,6 +91,7 @@ void SelectionMenu::display() {
           }
           patern_file << std::flush;
           patern_file.close();
+          context_->paterns_menu->refresh();
         }
       }
       sel_ctrl_ = false;

src/snapping.cpp

@@ -0,0 +1,19 @@
+/*
+* File name: snapping.hpp
+* Author: lejulien
+* Date created: 01-01-1970 00:59:59
+// Date modified: 12-01-2026 21:30:10
+* ------
+*/
+
+#include <snapping.hpp>
+
+Vector2 snapToGrid(Vector2 screen, int cell_size) {
+  return {static_cast<float>(round(screen.x / cell_size) * cell_size),
+          static_cast<float>(round(screen.y / cell_size) * cell_size)};
+}
+
+Vector2i screenToGrid(Vector2 screen, int cell_size) {
+  return {static_cast<int>(round(screen.x / cell_size)),
+          static_cast<int>(round(screen.y / cell_size))};
+}

src/world.cpp

@@ -143,7 +143,6 @@ void World::resize(int width, int height) {
 }
 
 std::vector<uint32_t> World::getSelection(Vector2i &origin, Vector2i &size) {
-  // We assume the selection is in the grid for now
   std::vector<uint32_t> data = {static_cast<uint32_t>(size.x),
                                 static_cast<uint32_t>(size.y)};
   for (int y = origin.y; y < origin.y + size.y; y++) {
@@ -153,3 +152,12 @@ std::vector<uint32_t> World::getSelection(Vector2i &origin, Vector2i &size) {
   }
   return data;
 }
+
+void World::setSelection(Vector2i &origin, Vector2i &size, std::vector<uint32_t> &data) {
+  
+  for (int y = 0; y < size.y; y++) {
+    for (int x = 0; x < size.x; x++) {
+      (*_data)[(x + origin.x) + (y + origin.y) * _width] = data[x + y * size.x];
+    }
+  }
+}

toolchain-mingw-w64-x86_64.cmake

@@ -0,0 +1,21 @@
+set(CMAKE_SYSTEM_NAME Windows)
+set(CMAKE_SYSTEM_VERSION 1)
+set(CMAKE_CROSSCOMPILING TRUE)
+
+set(MINGW_TRIPLET "x86_64-w64-mingw32")
+
+set(CMAKE_C_COMPILER   ${MINGW_TRIPLET}-gcc)
+set(CMAKE_CXX_COMPILER ${MINGW_TRIPLET}-g++)
+set(CMAKE_RC_COMPILER  ${MINGW_TRIPLET}-windres)
+set(CMAKE_AR           ${MINGW_TRIPLET}-ar)
+set(CMAKE_RANLIB       ${MINGW_TRIPLET}-ranlib)
+set(CMAKE_OBJCOPY      ${MINGW_TRIPLET}-objcopy)
+
+set(CMAKE_FIND_ROOT_PATH /usr/${MINGW_TRIPLET})
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+
+set(CMAKE_C_FLAGS_INIT "-static -static-libgcc -static-libstdc++")
+set(CMAKE_CXX_FLAGS_INIT "-static -static-libgcc -static-libstdc++")
+