Merge pull request #238 from Fs00/more-translations

More l10n improvements and add workflow to generate POT file

.github/ISSUE_TEMPLATE/bug-report-feature-request.md

@@ -0,0 +1,34 @@
+---
+name: Bug Report / Feature Request
+about: Tech support does not belong here. You should only file an issue here if you think you have experienced an actual bug with Cemu or you are requesting a feature you believe would make Cemu better.
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+<!---
+Please keep in mind Cemu is EXPERIMENTAL SOFTWARE.
+
+Please read the FAQ:
+https://cemu.info/faq.html/
+
+THIS IS NOT A SUPPORT FORUM, FOR SUPPORT GO TO:
+https://discord.com/invite/5psYsup/
+
+If the FAQ does not answer your question, please go to:
+https://discord.com/invite/5psYsup/
+
+When submitting an issue, please check the following:
+
+- You have read the above.
+- You have provided the version (commit hash) of Cemu you are using.
+- You have provided sufficient detail for the issue to be reproduced.
+- You have provided system specs (if relevant).
+- Please also provide:
+  - For any issues, a log file
+  - For crashes, a backtrace.
+  - For graphical issues, comparison screenshots with real hardware.
+  - For emulation inaccuracies, a test-case (if able).
+
+-->

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Cemu Discord
+    url: https://discord.com/invite/5psYsup
+    about: If you are experiencing an issue with Cemu, and you need tech support, or if you have a general question, try asking in the official Cemu Discord linked here. Piracy is not allowed.

.github/workflows/build.yml

@@ -1,19 +1,14 @@
 name: Build Cemu
 
 on:
-  pull_request_target:
-    types:
-      - opened
-      - synchronize
-      - reopened
-  push:
-    branches:
-      - main
   workflow_call:
     inputs:
       deploymode:
         required: false
         type: string
+      experimentalversion:
+        required: false
+        type: string
 
 env:
   VCPKG_ROOT: "${{github.workspace}}/dependencies/vcpkg"
@@ -22,9 +17,6 @@ env:
 jobs:
   build-ubuntu:
     runs-on: ubuntu-20.04
-    env:
-      install_vulkan_folder: "$GITHUB_WORKSPACE/vulkan_sdk"
-      install_vulkan_version: "1.3.216.0"
     steps:
     - name: "Checkout repo"
       uses: actions/checkout@v3
@@ -37,7 +29,6 @@ jobs:
         echo "BUILD_MODE=release" >> $GITHUB_ENV
         echo "BUILD_FLAGS=-DPUBLIC_RELEASE=ON" >> $GITHUB_ENV
         echo "Build mode is release"
-
     - name: Setup debug mode parameters (for continous build)
       if: ${{ inputs.deploymode != 'release' }}
       run: |
@@ -45,17 +36,18 @@ jobs:
         echo "BUILD_FLAGS=" >> $GITHUB_ENV
         echo "Build mode is debug"
         
+    - name: Setup version for experimental
+      if: ${{ inputs.experimentalversion != '' }}
+      run: |
+        echo "[INFO] Experimental version ${{ inputs.experimentalversion }}"
+        echo "BUILD_FLAGS=${{ env.BUILD_FLAGS }} -DEXPERIMENTAL_VERSION=${{ inputs.experimentalversion }}" >> $GITHUB_ENV
+        
     - name: "Install system dependencies"
       run: |
         sudo apt update -qq
         sudo apt install -y ninja-build cmake libgtk-3-dev libsecret-1-dev libgcrypt20-dev libsystemd-dev freeglut3-dev clang-12 nasm
-        wget https://sdk.lunarg.com/sdk/download/${{ env.install_vulkan_version }}/linux/vulkansdk-linux-x86_64-${{ env.install_vulkan_version }}.tar.gz -q -O vulkansdk.tar.gz
-        mkdir -p "${{ env.install_vulkan_folder }}"
-        tar -xf vulkansdk.tar.gz --directory ${{ env.install_vulkan_folder }}
-
     - name: "Bootstrap vcpkg"
       run: |
-        export VULKAN_SDK="${{ env.install_vulkan_folder }}/${{ env.install_vulkan_version }}/x86_64"
         bash ./dependencies/vcpkg/bootstrap-vcpkg.sh
         
     - name: 'Setup NuGet Credentials for vcpkg'
@@ -74,7 +66,6 @@ jobs:
         
     - name: "cmake"
       run: |
-        export VULKAN_SDK="${{ env.install_vulkan_folder }}/${{ env.install_vulkan_version }}/x86_64"
         mkdir -p build
         cd build
         cmake .. ${{ env.BUILD_FLAGS }} -DCMAKE_BUILD_TYPE=${{ env.BUILD_MODE }} -DCMAKE_C_COMPILER=/usr/bin/clang-12 -DCMAKE_CXX_COMPILER=/usr/bin/clang++-12 -G Ninja -DCMAKE_MAKE_PROGRAM=/usr/bin/ninja
@@ -83,7 +74,11 @@ jobs:
       run: |
         cd build
         ninja
-        
+
+    - name: Prepare artifact
+      if: ${{ inputs.deploymode == 'release' }}
+      run: mv bin/Cemu_release bin/Cemu
+              
     - name: Upload artifact
       uses: actions/upload-artifact@v3
       if: ${{ inputs.deploymode == 'release' }}
@@ -94,9 +89,6 @@ jobs:
         
   build-windows:
     runs-on: windows-2022
-    env:
-      install_vulkan_folder: "$GITHUB_WORKSPACE/vulkan_sdk"
-      install_vulkan_version: "1.3.216.0"
     steps:
     - name: "Checkout repo"
       uses: actions/checkout@v3
@@ -116,13 +108,11 @@ jobs:
         echo "BUILD_MODE=debug" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf8 -Append
         echo "BUILD_FLAGS=" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf8 -Append
         echo "Build mode is debug"
-        
+    - name: Setup version for experimental
-    - name: Prepare Vulkan SDK
+      if: ${{ inputs.experimentalversion != '' }}
-      uses: humbletim/setup-vulkan-sdk@v1.2.0
+      run: |
-      with:
+        echo "[INFO] Experimental version ${{ inputs.experimentalversion }}"
-        vulkan-query-version: 1.3.216.0
+        echo "BUILD_FLAGS=${{ env.BUILD_FLAGS }} -DEXPERIMENTAL_VERSION=${{ inputs.experimentalversion }}" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf8 -Append
-        vulkan-components: Vulkan-Headers, Vulkan-Loader
-        vulkan-use-cache: false
     
     - name: Workaround
       run: |
@@ -153,7 +143,6 @@ jobs:
         # should be run twice
         $process = Start-Process -FilePath cmd.exe -ArgumentList $Arguments -Wait -PassThru -WindowStyle Hidden
         $process = Start-Process -FilePath cmd.exe -ArgumentList $Arguments -Wait -PassThru -WindowStyle Hidden
-
     - name: Configure MSVC
       uses: ilammy/msvc-dev-cmd@v1
       with:
@@ -183,17 +172,19 @@ jobs:
       run: |
         mkdir -p build
         cd build
+        echo "[INFO] BUILD_FLAGS: ${{ env.BUILD_FLAGS }}"
+        echo "[INFO] BUILD_MODE: ${{ env.BUILD_MODE }}"
         cmake .. ${{ env.BUILD_FLAGS }} -DCMAKE_BUILD_TYPE=${{ env.BUILD_MODE }}
         
-    - name: "Free up space"
-      run: |
-        Remove-Item './dependencies/vcpkg/downloads' -Recurse
-        
     - name: "Build Cemu"
       run: |
         cd build
         cmake --build . --config ${{ env.BUILD_MODE }} -j 2
-        
+
+    - name: Prepare artifact
+      if: ${{ inputs.deploymode == 'release' }}
+      run: Rename-Item bin/Cemu_release.exe Cemu.exe
+      
     - name: Upload artifact
       uses: actions/upload-artifact@v3
       if: ${{ inputs.deploymode == 'release' }}

.github/workflows/build_check.yml

@@ -0,0 +1,21 @@
+name: Build check
+on: 
+  pull_request:
+    paths-ignore:
+      - "*.md"
+    types:
+      - opened
+      - synchronize
+      - reopened
+  push:
+    paths-ignore:
+      - "*.md"
+    branches:
+      - main
+
+jobs:
+  build:
+    uses: ./.github/workflows/build.yml
+    with:
+      deploymode: release
+      experimentalversion: 999999

.github/workflows/deploy_experimental_release.yml

@@ -0,0 +1,66 @@
+name: Deploy experimental release
+on: 
+  workflow_dispatch:
+
+jobs:
+  call-release-build:
+    uses: ./.github/workflows/build.yml
+    with:
+      deploymode: release
+      experimentalversion: ${{ github.run_number }}
+  deploy:
+    name: Deploy experimental release
+    runs-on: ubuntu-20.04
+    needs: call-release-build
+    steps:
+      - uses: actions/checkout@v2
+ 
+      - uses: actions/download-artifact@v3
+        with:
+          name: cemu-bin-linux-x64
+          path: cemu-bin-linux-x64
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: cemu-bin-windows-x64
+          path: cemu-bin-windows-x64
+
+      - name: Initialize
+        run: |
+          mkdir upload
+          sudo apt install zip
+          
+      - name: Get version
+        run: |
+          echo "Experimental version: ${{ github.run_number }}"
+          ls
+          gcc -o getversion .github/getversion.cpp
+          ./getversion
+          echo "Cemu CI version: $(./getversion)"
+          echo "CEMU_FOLDER_NAME=Cemu_$(./getversion)-${{ github.run_number }}" >> $GITHUB_ENV
+          echo "CEMU_VERSION=$(./getversion)-${{ github.run_number }}" >> $GITHUB_ENV
+
+      - name: Create release from windows-bin
+        run: |
+          ls ./
+          ls ./bin/
+          cp -R ./bin ./${{ env.CEMU_FOLDER_NAME }}
+          mv cemu-bin-windows-x64/Cemu.exe ./${{ env.CEMU_FOLDER_NAME }}/Cemu.exe
+          zip -9 -r upload/cemu-${{ env.CEMU_VERSION }}-windows-x64.zip ${{ env.CEMU_FOLDER_NAME }}
+          rm -r ./${{ env.CEMU_FOLDER_NAME }}
+          
+      - name: Create release from linux-bin
+        run: |
+          ls ./
+          ls ./bin/
+          cp -R ./bin ./${{ env.CEMU_FOLDER_NAME }}
+          mv cemu-bin-linux-x64/Cemu ./${{ env.CEMU_FOLDER_NAME }}/Cemu
+          zip -9 -r upload/cemu-${{ env.CEMU_VERSION }}-ubuntu-20.04-x64.zip ${{ env.CEMU_FOLDER_NAME }}
+          rm -r ./${{ env.CEMU_FOLDER_NAME }}
+  
+      - name: Create release
+        run: |
+          wget -O ghr.tar.gz https://github.com/tcnksm/ghr/releases/download/v0.15.0/ghr_v0.15.0_linux_amd64.tar.gz
+          tar xvzf ghr.tar.gz; rm ghr.tar.gz
+          echo "[INFO] Release tag: v${{ env.CEMU_VERSION }}"
+          ghr_v0.15.0_linux_amd64/ghr -prerelease -t ${{ secrets.GITHUB_TOKEN }} -n "Cemu ${{ env.CEMU_VERSION }} (Experimental)" -b "Cemu experimental release - [changelog](https://cemu.info/changelog.html)" "v${{ env.CEMU_VERSION }}" ./upload

.github/workflows/generate_pot.yml

@@ -0,0 +1,42 @@
+name: Generate translation template
+
+on:
+  pull_request:
+    paths-ignore:
+      - "*.md"
+    types:
+      - opened
+      - synchronize
+      - reopened
+  push:
+    paths-ignore:
+      - "*.md"
+    branches:
+      - main
+
+jobs:
+  generate-pot:
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Checkout repo"
+        uses: actions/checkout@v3
+
+      - name: "Install gettext"
+        run: |
+          sudo apt update -qq
+          sudo apt install -y gettext
+
+      - name: "Generate POT file using xgettext"
+        run: >
+          find src -name *.cpp -o -name *.hpp -o -name *.h | 
+          xargs xgettext --from-code=utf-8
+          -k_ -kwxTRANSLATE -w 100
+          --check=space-ellipsis --omit-header
+          -o cemu.pot
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: POT file
+          path: ./cemu.pot
+          if-no-files-found: error

.gitignore

@@ -13,10 +13,33 @@
 *.out
 *.app
 .vs
+.idea/
 
 build/
 out/
+.cache/
+bin/Cemu_*
+bin/Cemu_*.exe
 
 # Cemu bin files
-otp.bin
+bin/otp.bin
-seeprom.bin
+bin/seeprom.bin
+bin/log.txt
+bin/Cemu_*.pdb
+bin/Cemu_*.ilk
+bin/Cemu.exe.backup
+bin/mlc01/*
+bin/settings.xml
+bin/title_list_cache.xml
+bin/debugger/*
+bin/sdcard/*
+
+!bin/shaderCache/info.txt
+bin/shaderCache/*
+
+bin/controllerProfiles/*
+
+!bin/gameProfiles/default/*
+bin/gameProfiles/*
+
+bin/graphicPacks/*

.gitmodules

@@ -10,3 +10,6 @@
 	path = dependencies/vcpkg
 	url = https://github.com/microsoft/vcpkg
 	shallow = true
+[submodule "dependencies/Vulkan-Headers"]
+	path = dependencies/Vulkan-Headers
+	url = https://github.com/KhronosGroup/Vulkan-Headers

BUILD.md

@@ -0,0 +1,59 @@
+# Build instructions
+
+## Windows
+
+Prerequisites:
+- A recent version of Visual Studio 2022 (recommended but not required) with the following additional components:
+  - C++ CMake tools for Windows
+  - Windows 10/11 SDK
+- git
+
+Instructions:
+
+1. Run `git clone --recursive https://github.com/cemu-project/Cemu`
+2. Launch `Cemu/generate_vs_solution.bat`.
+    - If you installed VS to a custom location or use VS 2019, you may need to manually change the path inside the .bat file
+3. Wait until it's done, then open `Cemu/build/Cemu.sln` in Visual Studio
+4. Then build the solution and once finished you can run and debug it, or build it and check the /bin folder for the final Cemu_release.exe.
+
+You can also skip steps 3-5 and open the root folder of the cloned repo directly in Visual Studio (as a folder) and use the built-in cmake support but be warned that cmake support in VS can be a bit finicky.
+
+## Linux
+
+To compile Cemu, a recent enough compiler and STL with C++20 support is required! clang-12 or higher is what we recommend.
+
+### Installing dependencies
+
+#### For Ubuntu and derivatives:
+`sudo apt install -y git curl cmake ninja-build nasm libgtk-3-dev libsecret-1-dev libgcrypt20-dev libsystemd-dev freeglut3-dev libpulse-dev`  
+Additionally, for ubuntu 20.04 only:
+ - `sudo apt install -y clang-12`
+ - At step 3 while building, use  
+   `cmake -S . -B build -DCMAKE_BUILD_TYPE=release -DCMAKE_C_COMPILER=/usr/bin/clang-12 -DCMAKE_CXX_COMPILER=/usr/bin/clang++-12 -G Ninja -DCMAKE_MAKE_PROGRAM=/usr/bin/ninja`
+
+#### For Arch and derivatives:
+`sudo pacman -S git cmake clang ninja nasm base-devel linux-headers gtk3 libsecret libgcrypt systemd freeglut zip libpulse`
+
+#### For Fedora and derivatives:
+`sudo dnf install git cmake clang ninja-build nasm kernel-headers gtk3-devel libsecret-devel libgcrypt-devel systemd-devel freeglut-devel perl-core zlib-devel cubeb-devel`
+
+### Build Cemu using cmake and clang
+1. `git clone --recursive https://github.com/cemu-project/Cemu`
+2. `cd Cemu`
+3. `cmake -S . -B build -DCMAKE_BUILD_TYPE=release -DCMAKE_C_COMPILER=/usr/bin/clang -DCMAKE_CXX_COMPILER=/usr/bin/clang++ -G Ninja`
+4. `cmake --build build`
+5. You should now have a Cemu executable file in the /bin folder, which you can run using `./bin/Cemu_release`.
+
+#### Using GCC
+While we use and test Cemu using clang, using GCC might work better with your distro (they should be fairly similar performance/issues wise and should only be considered if compilation is the issue).  
+You can use it by replacing the step 3 with the following:
+`cmake -S . -B build -DCMAKE_BUILD_TYPE=release -DCMAKE_C_COMPILER=/usr/bin/gcc -DCMAKE_CXX_COMPILER=/usr/bin/g++ -G Ninja`
+
+#### Troubleshooting steps
+ - If step 3 gives you an error about not being able to find ninja, try appending `-DCMAKE_MAKE_PROGRAM=/usr/bin/ninja` to the command and running it again.
+ - If step 3 fails while compiling the boost-build dependency, it means you don't have a working/good standard library installation. Check the integrity of your system headers and making sure that C++ related packages are installed and intact.
+ - If step 3 gives a random error, read the `[package-name-and-platform]-out.log` and `[package-name-and-platform]-err.log` for the actual reason to see if you might be lacking the headers from a dependency.
+ - If step 3 is still failing or if you're not able to find the cause, please make an issue on our Github about it!
+ - If step 4 gives you an error that contains something like `main.cpp.o: in function 'std::__cxx11::basic_string...`, you likely are experiencing a clang-14 issue. This can only be fixed by either lowering the clang version or using GCC, see below.
+ - If step 4 gives you a different error, you could report it to this repo or try using GCC. Just make sure your standard library and compilers are updated since Cemu uses a lot of modern features!
+- If step 4 gives you undefined libdecor_xx, you are likely experiencing an issue with sdl2 package that comes with vcpkg. Delete sdl2 from vcpkg.json in source file and recompile

CMakeLists.txt

@@ -1,116 +1,143 @@
 cmake_minimum_required(VERSION 3.21.1)
 
 option(PUBLIC_RELEASE "Compile with debug asserts disabled and no console" OFF)
+option(ENABLE_VCPKG "Enable the vcpkg package manager" ON)
+set(EXPERIMENTAL_VERSION "" CACHE STRING "") # used by CI script to set experimental version
 
-if (PUBLIC_RELEASE)
+if (EXPERIMENTAL_VERSION)
-  add_definitions(-DPUBLIC_RELEASE)
+  add_definitions(-DEMULATOR_VERSION_MINOR=${EXPERIMENTAL_VERSION})
-  set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE) # enable LTO
 endif()
 
-if(WIN32)
+if (ENABLE_VCPKG)
-set(VCPKG_TARGET_TRIPLET "x64-windows-static" CACHE STRING "")
+	set(VCPKG_OVERLAY_PORTS "${CMAKE_CURRENT_LIST_DIR}/dependencies/vcpkg_overlay_ports")
+	set(CMAKE_TOOLCHAIN_FILE "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/vcpkg/scripts/buildsystems/vcpkg.cmake"
+		CACHE STRING "Vcpkg toolchain file")
+	# Set this so that all the various find_package() calls don't need an explicit
+	# CONFIG option
+	set(CMAKE_FIND_PACKAGE_PREFER_CONFIG TRUE)
+	if (WIN32)
+		set(VCPKG_TARGET_TRIPLET "x64-windows-static" CACHE STRING "")
+	endif()
 endif()
 
-set(VCPKG_OVERLAY_PORTS "${CMAKE_CURRENT_LIST_DIR}/dependencies/vcpkg_overlay_ports")
+project(Cemu VERSION 2.0)
-set(CMAKE_TOOLCHAIN_FILE "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/vcpkg/scripts/buildsystems/vcpkg.cmake"
+
-  CACHE STRING "Vcpkg toolchain file")
+list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")
 
-project(Cemu VERSION 0.1)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
+if (PUBLIC_RELEASE)
+	add_compile_definitions(PUBLIC_RELEASE)
+	set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE) # enable LTO
+endif()
+
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
-IF(MSVC)
+if (MSVC)
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc")
+	set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT CemuBin)
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /fp:precise") # floating point model: precise
+	# floating point model: precise, fiber safe optimizations
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GT") # fiber safe optimizations
+	add_compile_options(/EHsc /fp:precise)
-ENDIF()
+	if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-
+		# Speeds up static linking (especially helpful in incremental compilation)
-IF(MSVC AND PUBLIC_RELEASE)
+		if((CMAKE_LINKER MATCHES ".*lld-link.*") AND (CMAKE_AR MATCHES ".*llvm-lib.*"))
-    message(STATUS "Using additional optimization flags for MSVC")
+			set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY STATIC_LIBRARY_OPTIONS /llvmlibthin)
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Oi /Ot") # enable intrinsic functions, favor speed
+		endif()
-ENDIF()
+  	else()
+	  add_compile_options(/GT)
+	endif()
+	if (PUBLIC_RELEASE)
+		message(STATUS "Using additional optimization flags for MSVC")
+		add_compile_options(/Oi /Ot) # enable intrinsic functions, favor speed
+	endif()
+endif()
 
 option(ENABLE_OPENGL "Enables the OpenGL backend" ON)
 option(ENABLE_VULKAN "Enables the Vulkan backend" ON)
 option(ENABLE_DISCORD_RPC "Enables the Discord Rich Presence feature" ON)
 
-if(WIN32)
-    option(ENABLE_CEMUHOOK "Enables Cemuhook compatibility" ON)
-endif()
-
 # input backends
-if(WIN32)
+if (WIN32)
-    option(ENABLE_XINPUT "Enables the usage of XInput" ON)
+	option(ENABLE_XINPUT "Enables the usage of XInput" ON)
-    option(ENABLE_DIRECTINPUT "Enables the usage of DirectInput" ON)
+	option(ENABLE_DIRECTINPUT "Enables the usage of DirectInput" ON)
-    add_definitions(-DHAS_DIRECTINPUT)
+	add_compile_definitions(HAS_DIRECTINPUT)
 endif()
 option(ENABLE_SDL "Enables the SDLController backend" ON)
 
 # audio backends
-if(WIN32)
+if (WIN32)
-option(ENABLE_DIRECTAUDIO "Enables the directaudio backend" ON)
+	option(ENABLE_DIRECTAUDIO "Enables the directaudio backend" ON)
-option(ENABLE_XAUDIO "Enables the xaudio backend" ON)
+	option(ENABLE_XAUDIO "Enables the xaudio backend" ON)
 endif()
 option(ENABLE_CUBEB "Enabled cubeb backend" ON)
 
 option(ENABLE_WXWIDGETS "Build with wxWidgets UI (Currently required)" ON)
 
-find_package(SDL2 CONFIG REQUIRED)
+set(THREADS_PREFER_PTHREAD_FLAG true)
-find_package(CURL CONFIG REQUIRED)
+find_package(Threads REQUIRED)
-find_package(pugixml CONFIG REQUIRED)
+find_package(SDL2 REQUIRED)
-find_package(imgui CONFIG REQUIRED)
+find_package(CURL REQUIRED)
-find_package(RapidJSON CONFIG REQUIRED)
+find_package(pugixml REQUIRED)
+find_package(imgui REQUIRED)
+find_package(RapidJSON REQUIRED)
 find_package(Boost COMPONENTS program_options filesystem nowide REQUIRED)
 find_package(libzip REQUIRED)
 find_package(glslang REQUIRED)
 find_package(ZLIB REQUIRED)
-find_package(zstd CONFIG REQUIRED)
+find_package(zstd MODULE REQUIRED) # MODULE so that zstd::zstd is available
+find_package(OpenSSL COMPONENTS Crypto SSL REQUIRED)
+find_package(glm REQUIRED)
+find_package(fmt 9.1.0 REQUIRED)
+find_package(PNG REQUIRED)
 
-if(ENABLE_VULKAN)
+# glslang versions older than 11.11.0 define targets without a namespace
-    find_package(Vulkan REQUIRED)
+if (NOT TARGET glslang::SPIRV AND TARGET SPIRV)
-    include_directories("${Vulkan_INCLUDE_DIRS}")
+	add_library(glslang::SPIRV ALIAS SPIRV)
-endif()
-if(ENABLE_OPENGL)
-    find_package(OpenGL REQUIRED)
-endif()
-if(ENABLE_DISCORD_RPC)
-    add_definitions(-DENABLE_DISCORD_RPC)
-    add_subdirectory(dependencies/discord-rpc EXCLUDE_FROM_ALL)
-    target_include_directories(discord-rpc INTERFACE ./dependencies/discord-rpc/include)
 endif()
 
-if(ENABLE_WXWIDGETS)
+if (UNIX AND NOT APPLE)
-    find_package(wxWidgets CONFIG REQUIRED)
+	find_package(X11 REQUIRED)
 endif()
 
-find_package(OpenSSL REQUIRED)
+if (ENABLE_VULKAN)
-find_package(X11)
+	include_directories("dependencies/Vulkan-Headers/include")
-
-# find a better way to handle this
-link_libraries(${Boost_LIBRARIES})
-link_libraries(${X11_LIBRARIES})
-link_libraries(SDL2::SDL2 SDL2::SDL2main SDL2::SDL2-static)
-if(ENABLE_WXWIDGETS)
-link_libraries(wx::core wx::base)
 endif()
 
-if(ENABLE_CUBEB)
+if (ENABLE_OPENGL)
-    option(BUILD_TESTS "" OFF)
+	find_package(OpenGL REQUIRED)
-    option(BUILD_TOOLS "" OFF)
-    option(BUNDLE_SPEEX "" OFF)
-    set(USE_WINMM OFF CACHE BOOL "")
-    add_subdirectory(dependencies/cubeb)
-    set_property(TARGET cubeb PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-    link_libraries(cubeb)
-    add_compile_definitions(HAS_CUBEB=1)
 endif()
 
-add_subdirectory(dependencies/ih264d)
+if (ENABLE_DISCORD_RPC)
-add_subdirectory(dependencies/ZArchive)
+	add_compile_definitions(ENABLE_DISCORD_RPC)
+	add_subdirectory(dependencies/discord-rpc EXCLUDE_FROM_ALL)
+	target_include_directories(discord-rpc INTERFACE ./dependencies/discord-rpc/include)
+endif()
+
+if (ENABLE_WXWIDGETS)
+	find_package(wxWidgets 3.2 REQUIRED COMPONENTS base core gl propgrid xrc)
+endif()
+
+if (ENABLE_CUBEB)
+	find_package(cubeb)
+	if (NOT cubeb_FOUND)
+		option(BUILD_TESTS "" OFF)
+		option(BUILD_TOOLS "" OFF)
+		option(BUNDLE_SPEEX "" OFF)
+		set(USE_WINMM OFF CACHE BOOL "")
+		add_subdirectory("dependencies/cubeb" EXCLUDE_FROM_ALL)
+		set_property(TARGET cubeb PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+		add_library(cubeb::cubeb ALIAS cubeb)
+	endif()
+	add_compile_definitions("HAS_CUBEB=1")
+endif()
+
+add_subdirectory("dependencies/ih264d" EXCLUDE_FROM_ALL)
+
+find_package(ZArchive)
+if (NOT ZArchive_FOUND)
+	add_subdirectory("dependencies/ZArchive" EXCLUDE_FROM_ALL)
+endif()
 
 add_subdirectory(src)
-

CMakeSettings.json

@@ -1,37 +1,29 @@
 {
   "configurations": [
     {
-      "name": "x64-Debug",
+      "name": "Release",
+      "configurationType": "RelWithDebInfo",
+      "generator": "Ninja",
+      "inheritEnvironments": [ "msvc_x64_x64" ],
+      "buildRoot": "${projectDir}\\out\\build\\${name}",
+      "installRoot": "${projectDir}\\out\\install\\${name}"
+    },
+    {
+      "name": "Public Release",
+      "configurationType": "RelWithDebInfo",
       "generator": "Ninja",
-      "configurationType": "Debug",
       "inheritEnvironments": [ "msvc_x64_x64" ],
       "buildRoot": "${projectDir}\\out\\build\\${name}",
       "installRoot": "${projectDir}\\out\\install\\${name}",
-      "cmakeCommandArgs": "",
+      "cmakeCommandArgs": "-DPUBLIC_RELEASE=ON"
-      "buildCommandArgs": "",
-      "ctestCommandArgs": ""
     },
     {
-      "name": "x64-Release",
+      "name": "Debug",
+      "configurationType": "Debug",
       "generator": "Ninja",
-      "configurationType": "RelWithDebInfo",
+      "inheritEnvironments": [ "msvc_x64_x64" ],
       "buildRoot": "${projectDir}\\out\\build\\${name}",
-      "installRoot": "${projectDir}\\out\\install\\${name}",
+      "installRoot": "${projectDir}\\out\\install\\${name}"
-      "cmakeCommandArgs": "",
-      "buildCommandArgs": "",
-      "ctestCommandArgs": "",
-      "inheritEnvironments": [ "msvc_x64_x64" ]
-    },
-    {
-      "name": "x64-Public-Release",
-      "generator": "Ninja",
-      "configurationType": "RelWithDebInfo",
-      "buildRoot": "${projectDir}\\out\\build\\${name}",
-      "installRoot": "${projectDir}\\out\\install\\${name}",
-      "cmakeCommandArgs": "-DPUBLIC_RELEASE=ON",
-      "buildCommandArgs": "",
-      "ctestCommandArgs": "",
-      "inheritEnvironments": [ "msvc_x64_x64" ]
     }
   ]
 }

README.md

@@ -0,0 +1,52 @@
+# **Cemu - Wii U emulator**
+
+[![Build Process](https://github.com/cemu-project/Cemu/actions/workflows/build.yml/badge.svg)](https://github.com/cemu-project/Cemu/actions/workflows/build.yml)
+[![Discord](https://img.shields.io/discord/286429969104764928?label=Cemu&logo=discord&logoColor=FFFFFF)](https://discord.gg/5psYsup)
+[![Matrix Server](https://img.shields.io/matrix/dev:cemu.info?server_fqdn=matrix.cemu.info&label=dev:cemu.info&logo=matrix&logoColor=FFFFFF)](https://matrix.to/#/#dev:cemu.info)
+
+This is the code repository of Cemu, a Wii U emulator that is able to run most Wii U games and homebrew in a playable state.
+It's written in C/C++ and is being actively developed with new features and fixes to increase compatibility, convenience and usability.
+
+Cemu is currently only available for 64-bit Windows and Linux devices.
+
+### Links:
+ - [Original 2.0 announcement post](https://www.reddit.com/r/cemu/comments/wwa22c/cemu_20_announcement_linux_builds_opensource_and/)
+ - [Official Website](https://cemu.info)
+ - [Compatibility List/Wiki](https://wiki.cemu.info/wiki/Main_Page)
+ - [Official Subreddit](https://reddit.com/r/Cemu)
+ - [Official Discord](https://discord.gg/5psYsup)
+ - [Unofficial Setup Guide](https://cemu.cfw.guide)
+
+#### Other relevant repositories:
+ - [Cemu-Language](https://github.com/cemu-project/Cemu-Language)
+ - [Cemu's Community Graphic Packs](https://github.com/ActualMandM/cemu_graphic_packs)
+
+## Download
+
+You can download the latest Cemu releases from the [GitHub Releases](https://github.com/cemu-project/Cemu/releases/) or from [Cemu's website](https://cemu.info).
+
+Cemu is currently only available in a portable format so no installation is required besides extracting it in a safe place.
+
+See [Current State Of Linux builds](https://github.com/cemu-project/Cemu/issues/1) for information on using Cemu natively on Linux.
+
+Pre-2.0 releases can be found on Cemu's [changelog page](https://cemu.info/changelog.html).
+
+## Build Instructions
+
+To compile Cemu yourself on Windows or Linux, view the [BUILD.md file](/BUILD.md).
+
+## Issues
+
+Issues with the emulator should be filed using [GitHub Issues](https://github.com/cemu-project/Cemu/issues).  
+The old bug tracker can be found at [bugs.cemu.info](https://bugs.cemu.info) and still contains relevant issues and feature suggestions.
+
+## Contributing
+
+Pull requests are very welcome. For easier coordination you can visit the developer discussion channel on Discord: [https://discord.gg/5psYsup](https://discord.gg/5psYsup).
+
+If coding isn't your thing, testing games and making detailed bug reports or updating the (usually outdated) compatibility wiki is also appreciated!
+
+Questions about Cemu's software architecture can also be answered on Discord. Alternative communication channels (like IRC) are being considered.
+
+## License
+Cemu is licensed under [Mozilla Public License 2.0](/LICENSE.txt). Exempt from this are all files in the dependencies directory for which the licenses of the original code apply as well as some individual files in the src folder, as specified in those file headers respectively.

bin/gameProfiles/example.ini

@@ -1,27 +0,0 @@
-# This is an example configuration file. You can use this file as a guideline on how to create your own game profiles.
-
-# Overview:
-# The filename of the game profile can be found by looking at log.txt after a game was launched in Cemu.
-# A '#' character starts a one-line comment. Any text afterwards will be ignored.
-# If an option is not given in the .ini file, Cemu will use the value from the global settings instead.
-
-[General]
-loadSharedLibraries = true # If set to true, system rpl files will be loaded from /cafeLibs/ if present. Default value is true
-useRDTSC = true # Use RDTSC instruction as timer source for emulated CPU, OS and audio
-
-[Graphics]
-accurateShaderMul = true # If set to true, Cemu will correctly emulate the non-IEEE behavior of the shader MUL instruction. Can fix graphic issues but also decreases shader performance and increases shader compile time. Default value is true.
-# Since Cemu 1.7.5 the option accurateShaderMul also supports a third mode, enabled by using the value 'min' (e.g. accurateShaderMul = min). In this mode, Cemu will emulate non-ieee MUL instructions in a more GPU-friendly way which generates less complex shaders. However, this mode might not be 100% accurate
-
-disableGPUFence = false # If set to true, GPU fence operations will be skipped. Default value is false. Enabling this option can lead to instability and crashes
-
-GPUBufferCacheAccuracy = 0 # Controls the accuracy of vertex and uniform data caching. A higher accuracy means more expensive checks which can slow down rendering. Possible values: 0 = high, 1 = medium, 2 = low
-
-streamoutBufferCacheSize = 24 # buffer cache size of the streamout buffer in MB.
-
-extendedTextureReadback = false # If set to true, Cemu will try to mirror data written by GPU operations to CPU RAM (but only if access by CPU is assumed to be likely) Default value is false
-
-[CPU]
-cpuTimer = cycleCounter # Timer source for OS and CPU time. Supported values are 'hostBased' (timers are based on actual OS time) and 'cycleCounter' (timers are based on speed of emulated CPU). 
-emulateSinglePrecision = true # If set to false, the recompiler won't correctly round the result of single-precision instructions in certain situations. This can introduce gameplay bugs, but might also improve performance.
-cpuMode = Singlecore-Recompiler # CPU mode. Possible values: Singlecore-Interpreter, Singlecore-Recompiler, Dualcore-Recompiler, Triplecore-Recompiler 

building.md

@@ -1,33 +0,0 @@
-# Build instructions
-
-## Windows
-
-Prerequisites:
-- A recent version of Visual Studio 2022 with CMake tools component
-- git
-- Vulkan SDK ([https://vulkan.lunarg.com/](https://vulkan.lunarg.com/)). Don't forget to restart after installing.
-
-Instructions:
-
-1) Run `git clone --recursive https://github.com/cemu-project/Cemu`
-2) Launch `Cemu/build_vs_solution.bat`. If you installed VS to a custom location you may need to manually adjust the path inside the bat file
-3) Wait until done, then open build/Cemu.sln in Visual Studio
-4) Right click 'CemuBin' project -> Set as startup project
-5) Then build the solution and once finished you can run and debug it
-
-You can also skip steps 3-5 and open the root folder of the cloned repo directly in Visual Studio (as a folder) and use the inbuilt cmake support, but be warned that cmake support in VS can be a bit finicky.
-
-## Linux
-
-To compile Cemu, a recent enough compiler and STL with C++20 support is required! We use clang 12, other compilers may work as well.
-
-For ubuntu and most derivatives:
-
-1) Make sure vulkansdk is installed and the VULKAN_SDK environment variable is set correctly.
-2) `sudo apt install -y libgtk-3-dev libsecret-1-dev libgcrypt20-dev libsystemd-dev freeglut3-dev clang-12 nasm`
-3) Run `git clone --recursive https://github.com/cemu-project/Cemu`
-4) `cd Cemu`
-5) `mkdir build && cd build`
-6) `cmake .. -DCMAKE_BUILD_TYPE=release -DCMAKE_C_COMPILER=/usr/bin/clang-12 -DCMAKE_CXX_COMPILER=/usr/bin/clang++-12 -G Ninja -DCMAKE_MAKE_PROGRAM=/usr/bin/ninja`
-
-Build instructions for other distributions will be added in the future!

cmake/FindZArchive.cmake

@@ -0,0 +1,20 @@
+# SPDX-FileCopyrightText: 2022 Andrea Pappacoda <andrea@pappacoda.it>
+# SPDX-License-Identifier: ISC
+
+find_package(PkgConfig)
+
+if (PKG_CONFIG_FOUND)
+	pkg_search_module(zarchive IMPORTED_TARGET GLOBAL zarchive)
+	if (zarchive_FOUND)
+		add_library(ZArchive::zarchive ALIAS PkgConfig::zarchive)
+	endif()
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(ZArchive
+	REQUIRED_VARS
+		zarchive_LINK_LIBRARIES
+		zarchive_FOUND
+	VERSION_VAR
+		zarchive_VERSION
+)

cmake/Findimgui.cmake

@@ -0,0 +1,27 @@
+# SPDX-FileCopyrightText: 2022 Andrea Pappacoda <andrea@pappacoda.it>
+# SPDX-License-Identifier: ISC
+
+include(FindPackageHandleStandardArgs)
+
+find_package(imgui CONFIG)
+if (imgui_FOUND)
+	# Use upstream imguiConfig.cmake if possible
+	find_package_handle_standard_args(imgui CONFIG_MODE)
+else()
+	# Fallback to pkg-config otherwise
+	find_package(PkgConfig)
+	if (PKG_CONFIG_FOUND)
+		pkg_search_module(imgui IMPORTED_TARGET GLOBAL imgui)
+		if (imgui_FOUND)
+			add_library(imgui::imgui ALIAS PkgConfig::imgui)
+		endif()
+	endif()
+
+	find_package_handle_standard_args(imgui
+		REQUIRED_VARS
+			imgui_LINK_LIBRARIES
+			imgui_FOUND
+		VERSION_VAR
+			imgui_VERSION
+	)
+endif()

cmake/FindwxWidgets.cmake

@@ -0,0 +1,49 @@
+# SPDX-FileCopyrightText: 2022 Andrea Pappacoda <andrea@pappacoda.it>
+# SPDX-License-Identifier: ISC
+
+include(FindPackageHandleStandardArgs)
+find_package(wxWidgets CONFIG COMPONENTS ${wxWidgets_FIND_COMPONENTS})
+
+if (wxWidgets_FOUND)
+	# Use upstream wxWidgetsConfig.cmake if possible
+	find_package_handle_standard_args(wxWidgets CONFIG_MODE)
+else()
+	# Fall back to CMake's FindwxWidgets
+	# Temporarily unset CMAKE_MODULE_PATH to avoid calling the current find
+	# module recursively
+	set(_tmp_module_path "${CMAKE_MODULE_PATH}")
+	set(CMAKE_MODULE_PATH "")
+
+	find_package(wxWidgets MODULE QUIET COMPONENTS ${wxWidgets_FIND_COMPONENTS})
+
+	set(CMAKE_MODULE_PATH "${_tmp_module_path}")
+	unset(_tmp_module_path)
+
+	if (wxWidgets_FOUND)
+		add_library(wx::base IMPORTED INTERFACE)
+		target_include_directories(wx::base INTERFACE ${wxWidgets_INCLUDE_DIRS})
+		target_link_libraries(wx::base INTERFACE ${wxWidgets_LIBRARIES})
+		target_link_directories(wx::base INTERFACE ${wxWidgets_LIBRARY_DIRS})
+		target_compile_definitions(wx::base INTERFACE ${wxWidgets_DEFINITIONS})
+		target_compile_options(wx::base INTERFACE ${wxWidgets_CXX_FLAGS})
+
+		# FindwxWidgets sets everything into a single set of variables, so it is
+		# impossible to tell what libraries are required for what component.
+		# To be compatible with wxWidgetsConfig, we create an alias for each
+		# component so that the user can still use target_link_libraries(wx::gl)
+		foreach(component ${wxWidgets_FIND_COMPONENTS})
+			if (NOT component STREQUAL "base")
+				# don't alias base to itself
+				add_library(wx::${component} ALIAS wx::base)
+			endif()
+		endforeach()
+	endif()
+
+	find_package_handle_standard_args(wxWidgets
+		REQUIRED_VARS
+			wxWidgets_LIBRARIES
+			wxWidgets_FOUND
+		VERSION_VAR
+			wxWidgets_VERSION_STRING
+	)
+endif()

cmake/Findzstd.cmake

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: 2022 Andrea Pappacoda <andrea@pappacoda.it>
+# SPDX-License-Identifier: ISC
+
+include(FindPackageHandleStandardArgs)
+
+find_package(zstd CONFIG)
+if (zstd_FOUND)
+	# Use upstream zstdConfig.cmake if possible
+	if (NOT TARGET zstd::zstd)
+		if (TARGET zstd::libzstd_static)
+			add_library(zstd::zstd ALIAS zstd::libzstd_static)
+		elseif (TARGET zstd::libzstd_shared)
+			add_library(zstd::zstd ALIAS zstd::libzstd_shared)
+		endif()
+	endif()
+	find_package_handle_standard_args(zstd CONFIG_MODE)
+else()
+	# Fallback to pkg-config otherwise
+	find_package(PkgConfig)
+	if (PKG_CONFIG_FOUND)
+		pkg_search_module(libzstd IMPORTED_TARGET GLOBAL libzstd)
+		if (libzstd_FOUND)
+			add_library(zstd::zstd ALIAS PkgConfig::libzstd)
+		endif()
+	endif()
+
+	find_package_handle_standard_args(zstd
+		REQUIRED_VARS
+			libzstd_LINK_LIBRARIES
+			libzstd_FOUND
+		VERSION_VAR libzstd_VERSION
+	)
+endif()