making it a generic template

LigasN · LigasN · commit 29f731276115 · 2025-09-11T23:25:32.000+02:00
diff --git a/.github/workflows/ci-cd.yml b/.github/workflows/ci-cd.yml
@@ -0,0 +1,80 @@
+on:
+  push:
+  
+env:
+  CLANG_VERSION: "20.1.8"
+  MSVC_VERSION:  "19.44.35214"
+  VERBOSE: 1
+
+jobs:
+  CI:
+    runs-on: ${{ matrix.os }}
+    
+    strategy:
+      # Set fail-fast to false to ensure that feedback is delivered for all matrix combinations. Consider changing this to true when your workflow is stable.
+      fail-fast: false
+      matrix:
+        os: 
+          - ubuntu-latest
+          - windows-latest
+        build_type: 
+          - Release
+        compiler: 
+          - clang
+          - msvc
+        generator:
+          - "Ninja"
+        exclude:
+          - os: ubuntu-latest
+            compiler: msvc
+
+    steps:        
+      - name: Setup Cpp
+        uses: aminya/setup-cpp@v1
+        with:
+          compiler: ${{matrix.compiler}}
+          conan: true
+          cmake: true
+          ninja: true
+          vcvarsall: false
+          clangtidy: true
+          cppcheck: true
+          ccache: false
+      
+      - name: Download linux system dependencies
+        if: matrix.os == 'ubuntu-latest'
+        run: sudo apt-get update && sudo apt-get install -y libgl-dev libgl1-mesa-dev libglu1-mesa-dev
+
+      - name: Checkout
+        uses: actions/checkout@v3
+        
+      - name: Set env profile
+        shell: bash
+        run: |
+          os="${{ matrix.os}}"
+          system="${os%%-*}"
+          [[ "$system" == "ubuntu" ]] && system="linux"
+          echo "PROFILE=profiles/${system}-${{ matrix.compiler }}" >> "$GITHUB_ENV"
+          
+      - name: Install
+        run: conan install . -pr:a=${{env.PROFILE}} -s build_type=${{ matrix.build_type }} --build=missing
+        
+      - name: Build
+        run: conan build . -pr:a=${{env.PROFILE}} -s build_type=${{ matrix.build_type }} --build=missing
+        
+      - name: Set env preset and build folder
+        shell: bash
+        run: echo "PRESET=$(cmake --list-presets | tail -n 1 | awk '{print $1}' | tr -d '"')" >> "$GITHUB_ENV"
+        
+      - name: Test
+        run: ctest --preset ${{env.PRESET}}
+  
+      - name: Package
+        run: cpack --preset ${{env.PRESET}} -B ${{ github.workspace }}/packages
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4.6.2
+        with:
+          name: ${{matrix.os}}-${{matrix.compiler}}
+          path: ./packages/*.*
+          if-no-files-found: error
diff --git a/.github/workflows/configure-project b/.github/workflows/configure-project
@@ -0,0 +1,22 @@
+  - name: Configure Git
+    run: |
+      git config user.name "github-actions"
+      git config user.email "github-actions@github.com"
+
+  - name: Replace project name placeholder
+    run: |
+      # This command finds all files in the repository and uses 'sed' to replace
+      # the placeholder '{{PROJECT_NAME}}' with the name provided in the workflow input.
+      # The sed delimiter is changed from '/' to '|' to safely handle path names.
+      find . -type f -not -path './.git/*' -exec sed -i "s|{{PROJECT_NAME}}|${{ github.event.inputs.new_project_name }}|g" {} +
+      
+  - name: Create a pull request with the new name
+    uses: peter-evans/create-pull-request@v6
+    with:
+      title: 'Update project name to "${{ github.event.inputs.new_project_name }}"'
+      commit-message: 'feat: Update project name to ${{ github.event.inputs.new_project_name }}'
+      body: |
+        This pull request automatically updates all instances of the project name
+        placeholder (`{{PROJECT_NAME}}`) with the new name you specified.
+      branch: update-project-name-${{ github.run_number }}
+      token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/BUILDING.md b/BUILDING.md
@@ -1,6 +1,6 @@
 # Building and Running the Project (Conan 2.x with CMake Presets)
 
-This document provides instructions for building and running the project using **Conan 2.x** and **CMake Presets**. This approach simplifies the build process by defining all build configurations in a single `CMakePresets.json` file.
+This document provides instructions for building and running the project using **Conan 2.x** and **CMake Presets**. This approach simplifies the build process.
 
 ### Prerequisites
 
@@ -19,81 +19,47 @@ choco install conan cmake ninja llvm
 
 * **Linux**:
 ```bash
-sudo apt install conan cmake ninja-build clang clang-format clang-tidy libglu1-mesa-dev freeglut3-dev
+sudo apt install conan cmake ninja-build clang clang-format clang-tidy
 ```
 
 ### Step-by-Step Instructions
-TODO: There are also scripts that run generation phase accordingly for Windows system `configure.cmd` script and for Linux `configure.sh`.
+There are also scripts that run generation phase accordingly for Windows system `configure.cmd` and for Linux `configure.sh`.
 
 #### 1. Generate the Conan Toolchain and Dependencies
-This step uses Conan to download all project dependencies and generate the conan_toolchain.cmake file that CMake needs.
+This step uses Conan to download all project dependencies and generate the conan_toolchain.cmake file that CMake needs. This is an example, parameters like profile used or build type can be changed.
 
 * **Windows**:
 ```batch
-conan install . --output-folder=build/windows-clang-release --build=missing -pr:h=profiles/windows-clang -pr:b=profiles/windows-clang
+conan install . -pr:a=profiles/windows-clang -s build_type=Release --build=missing
 ```
 
 * **Linux**:
 ```bash
-conan install . --output-folder=build/linux-clang-release --build=missing -pr:h=profiles/linux-clang -pr:b=profiles/linux-clang
+conan install . -pr:a=profiles/linux-clang -s build_type=Release --build=missing
 ```
 
-This command will create the build directory and populate it with Conan's toolchain file and other necessary configuration.
+This command will create the build directory and populate it with Conan's toolchain file and other necessary configuration. Also `CMakeUserPresets.json` and `compile_commands.json` files will be generated.
 
-#### 2. Configure the Project
+#### 2. Build the Project
 
-The `cmake --preset` command will automatically resolve and install all project dependencies using Conan. It will create a build directory and generate the necessary files for building.
+Once the project is configured, you can build it using the same profile. This is an example, parameters like profile used or build type can be changed.
 
 * **Windows**:
-```batch
-cmake --preset windows-clang-release
 ```
-
-* **Linux**:
-```bash
-cmake --preset linux-clang-release
+conan build . -pr:a=%PROFILE% -s build_type=Release --build=missing 
 ```
 
-After this command, a new directory, `build/linux-clang-release` or `build/windows-clang-release`, will be created containing the build configuration.
-
-#### 2. Build the Project
-
-Once the project is configured, you can build it using the same preset name.
-
 * **Linux**:
 ```
-cmake --build --preset linux-clang-release
-```
-
-* **Windows**:
-```
-cmake --build --preset windows-clang-release
+conan build . -pr:a=%PROFILE% -s build_type=Release --build=missing 
 ```
 
 This will compile your source code and produce the final executable.
 
 #### 3. Run the Executable
 
-The executable is located inside the build directory. The exact name of the executable will depend on your `CMakeLists.txt` configuration.
+The executable is located inside the build directory. The exact path to the executable will depend on choosen profile and build type.
 
-* **Linux**:
-```
-./build/linux-clang-release/your_executable_name
-```
-
-* **Windows**:
-```
-`./build/windows-clang-release/your_executable_name.exe
 ```
-
-### How It Works
-
-The `cmake --preset` command is the key to this workflow. It tells CMake to:
-
-1. Read the configuration specified in the `CMakePresets.json` file.
-
-2. Automatically invoke Conan to download all the dependencies defined in your `conanfile.py`.
-
-3. Set up the build environment with Conan's toolchain file, ensuring that the compiler, C++ standard, and other settings are correctly configured for your chosen preset.
-
-This eliminates the need to run manual `conan install` and `cmake -DCMAKE_TOOLCHAIN_FILE=...` commands separately, creating a single, consistent entry point for building your project.
+./build/{compiler-compiler_version-arch"}/{{PROJECT_NAME}}.exe
+```
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,9 +1,9 @@
 cmake_minimum_required(VERSION 3.23)
 
-project(craftgl
+project({{PROJECT_NAME_LOWER}}
     VERSION 0.1.0 
-    DESCRIPTION "A simple OpenGL game project."
-    HOMEPAGE_URL "http://example.com"
+    DESCRIPTION "{{PROJECT_DESCRIPTION}}"
+    HOMEPAGE_URL "{{PROJECT_HOMEPAGE_URL}}"
     LANGUAGES CXX)
 
 # Enable export of compile commands for tools like clang-tidy
@@ -14,13 +14,10 @@ include(cmake/StaticAnalysis.cmake)
 option(ENABLE_TESTS "Enable building tests" ON)
 
 # --- Find required packages ---
-find_package(opengl_system REQUIRED)
-find_package(glu REQUIRED)
-find_package(Microsoft.GSL REQUIRED)
-find_package(glm REQUIRED)
+# find_package(glm REQUIRED)
 
 # --- Create executable ---
-add_executable(craftgl)
+add_executable({{PROJECT_NAME_LOWER}})
 
 # --- Subdirectories ---
 add_subdirectory(src)
@@ -44,13 +41,13 @@ set(CPACK_PACKAGE_VERSION "${PROJECT_VERSION}")
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "${PROJECT_DESCRIPTION}")
 set(CPACK_PACKAGE_HOMEPAGE_URL "${PROJECT_HOMEPAGE_URL}")
 set(CPACK_PACKAGE_CONTACT "norbert221198@gmail.com")
-set(CPACK_DEBIAN_PACKAGE_DEPENDS "libgl-dev, libgl1-mesa-dev, libglu1-mesa-dev")
+#set(CPACK_DEBIAN_PACKAGE_DEPENDS "libgl-dev, libgl1-mesa-dev, libglu1-mesa-dev")
 
 include(CPack)
 
 # clangd support
 add_custom_command(
-    TARGET craftgl POST_BUILD
+    TARGET {{PROJECT_NAME_LOWER}} POST_BUILD
     COMMAND ${CMAKE_COMMAND} -E copy_if_different
             "${CMAKE_BINARY_DIR}/compile_commands.json"
             "${CMAKE_SOURCE_DIR}/compile_commands.json"
diff --git a/README.md b/README.md
@@ -1,4 +1,4 @@
-# conan-cmake-cpp
-[![.github/workflows/ci-cd.yml](https://github.com/LigasN/CraftGL/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/LigasN/CraftGL/actions/workflows/ci-cd.yml)
+# {{PROJECT_NAME}}
+[![.github/workflows/ci-cd.yml](https://github.com/{{USERNAME}}/{{PROJECT_NAME}}/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/{{USERNAME}}/{{PROJECT_NAME}}/actions/workflows/ci-cd.yml)
 
 Repository template for a cross-platform project written in C++ with use of Conan and CMake. This template has also GitHub actions configured for CI/CD with static analysis by clang-tidy and cppcheck. It has also clang-format configuration file for code formatting.
diff --git a/conanfile.py b/conanfile.py
@@ -16,9 +16,9 @@ def get_version(conanfile):
         return None
 
 class CraftGLConan(ConanFile):
-    name = "craftgl"
-    url = "https://github.com/LigasN/CraftGL"
-    description = "A simple OpenGL game project."
+    name = "{{PROJECT_NAME_LOWER}}"
+    url = "{{PROJECT_HOMEPAGE_URL}}"
+    description = "{{PROJECT_DESCRIPTION}}"
     license = ""
     settings = "os", "compiler", "build_type", "arch"
 
@@ -28,13 +28,8 @@ def set_version(self):
     def validate(self):
         check_min_cppstd(self, "23")
 
-    def requirements(self):
-        self.requires("opengl/system")
-        self.requires("glu/system")
-        self.requires("glm/1.0.1")
-        self.requires("ms-gsl/4.0.0")
-        #self.requires("ktx/4.3.2")
-        #self.requires("nlohmann_json")
+#    def requirements(self):
+#        self.requires("glm/1.0.1")
 
     def build_requirements(self):
         self.test_requires("gtest/1.16.0")
diff --git a/configure.sh b/configure.sh
@@ -2,19 +2,11 @@
 
 # === Configuration variables ===
 PROFILE=profiles/linux-clang
-BUILD_TYPE=Release
-PRESET=linux-clang-release
-OUT_DIR=build/${PRESET}
 
-REM === Environment variables ===
-set ENABLE_CLANG_TIDY=ON 
-set ENABLE_CPPCHECK=ON
+# === Release ===
+conan install . -pr:a=$PROFILE -s build_type=Release --build=missing
+conan build . -pr:a=$PROFILE -s build_type=Release --build=missing 
 
-echo "Installing dependencies and generating toolchain for Linux (${BUILD_TYPE})..."
-conan install . --output-folder=${OUT_DIR} --build=missing --profile:all=${PROFILE} -s build_type=${BUILD_TYPE}
-
-echo "Configuring the project with CMake (${BUILD_TYPE})..."
-cmake --preset ${PRESET}
-
-echo "Building the project (${BUILD_TYPE})..."
-cmake --build --preset ${PRESET}
+# === Debug ===
+# conan install . -pr:a=$PROFILE -s build_type=Debug --build=missing
+# conan build . -pr:a=$PROFILE -s build_type=Debug --build=missing
diff --git a/src/engine/CMakeLists.txt b/src/engine/CMakeLists.txt
@@ -10,6 +10,6 @@ add_library(engine STATIC)
 target_sources(engine PRIVATE ${ENGINE_SOURCE} ${ENGINE_HEADERS})
 target_compile_features(engine PUBLIC cxx_std_23)
 target_include_directories(engine PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/..")
-target_link_libraries(engine PUBLIC Microsoft.GSL::GSL)
+#target_link_libraries(engine PUBLIC lib::lib)
 
 add_library(${PROJECT_NAME}::engine ALIAS engine)
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
@@ -13,12 +13,6 @@ function(add_test_target test_name test_sources test_libraries)
     target_link_libraries(${target_name} PRIVATE GTest::gtest_main ${test_libraries})
 
     add_test(NAME ${test_name} COMMAND ${target_name} WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
-
-    # TODO: check if needed
-    # Set output directory for test executables (optional, but good for organization)
-    # set_target_properties(${TARGET_NAME} PROPERTIES
-        # RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/tests"
-    # )
 endfunction()
 
 add_test_target(engine "engine/Engine.cpp" "")
