linux_build.yml

# Inspired by: https://github.com/PCSX2/pcsx2/blob/master/.github/workflows/linux_build_qt.yml

name: Linux Build Steps

on:
  workflow_call:
    inputs:
      jobName:
        required: true
        type: string
      artifactPrefixName:
        required: true
        type: string
      os:
        required: false
        type: string
        default: ubuntu-22.04
      compiler:
        required: false
        type: string
        default: clang
      buildType:
        required: false
        type: string
        default: Release
      cmakeFlags:
        required: false
        type: string
        default: ""
      fetchTags:
        required: false
        type: boolean
        default: false
      platform:
        required: false
        type: string
        default: x64

jobs:
  build_linux:
    name: ${{ inputs.jobName }}
    runs-on: ${{ inputs.os }}
    timeout-minutes: 60
    env:
      CCACHE_BASEDIR: ${{ github.workspace }}
      CCACHE_DIR: ${{ github.workspace }}/.ccache
      CCACHE_COMPRESS: true
      CCACHE_COMPRESSLEVEL: 9
      CCACHE_MAXSIZE: 100M

    steps:
      - name: Checkout Repository
        uses: actions/checkout@v7
        with:
          submodules: recursive

      # actions/checkout elides tags, fetch them primarily for releases
      - name: Fetch Tags
        if: ${{ inputs.fetchTags }}
        run: git fetch --tags --no-recurse-submodules

      - name: Prepare Artifact Metadata
        id: artifact-metadata
        shell: bash
        env:
          PREFIX: ${{ inputs.artifactPrefixName }}
          EVENT_NAME: ${{ github.event_name }}
          PR_TITLE: ${{ github.event.pull_request.title }}
          PR_NUM: ${{ github.event.pull_request.number }}
          PR_SHA: ${{ github.event.pull_request.head.sha }}
        run: |
          ARTIFACT_NAME="${PREFIX}"
          if [ "$EVENT_NAME" == "pull_request" ]; then
            PR_SHA_SHORT="${PR_SHA:0:8}"
            ARTIFACT_NAME="${PREFIX}-pr${PR_NUM}-${PR_SHA_SHORT}"
          fi
          echo "artifact-name=${ARTIFACT_NAME}" >> $GITHUB_OUTPUT

      # -- SETUP CCACHE - https://cristianadam.eu/20200113/speeding-up-c-plus-plus-github-actions-using-ccache/
      - name: Prepare ccache timestamp
        id: ccache_cache_timestamp
        run: echo "timestamp=$(date -u "+%Y-%m-%d-%H;%M;%S")" >> $GITHUB_OUTPUT

      - name: Cache ccache
        uses: actions/cache@v6.1.0
        with:
          path: .ccache
          key: ${{ inputs.os }} ${{ inputs.platform }} ${{ inputs.compiler }} ccache ${{ steps.ccache_cache_timestamp.outputs.timestamp }}
          restore-keys: ${{ inputs.os }} ${{ inputs.platform }} ${{ inputs.compiler }} ccache

      - name: Install Packages
        run: |
          sudo apt-get update
          sudo apt-get -y install \
            build-essential \
            ccache \
            clang \
            lld \
            cmake \
            ninja-build \
            pkg-config \
            libvulkan-dev \
            libgl1-mesa-dev \
            libegl-dev \
            libwayland-dev \
            libx11-dev \
            libx11-xcb-dev \
            libxcb1-dev \
            libxrandr-dev \
            libxcursor-dev \
            libxinerama-dev \
            libxi-dev \
            libxkbcommon-x11-dev \
            libtiff5-dev \
            imagemagick \
            wget

      - name: Install Qt (x64)
        if: inputs.platform != 'arm64'
        uses: jurplel/install-qt-action@v4.3.1
        with:
          version: '6.11.1'
          host: 'linux'
          target: 'desktop'
          arch: 'linux_gcc_64'
          modules: 'qtimageformats qtwaylandcompositor'
          cache: true
          use-official: true

      - name: Install Qt (ARM64)
        if: inputs.platform == 'arm64'
        uses: jurplel/install-qt-action@v4.3.1
        with:
          version: '6.11.1'
          host: 'linux_arm64'
          target: 'desktop'
          arch: 'linux_gcc_arm64'
          modules: 'qtimageformats qtwaylandcompositor'
          cache: true
          use-official: true

      - name: Configure CMake (Clang)
        if: inputs.compiler == 'clang'
        run: |
          if [ "${{ inputs.buildType }}" = "Debug" ]; then
            if [ "${{ inputs.platform }}" = "arm64" ]; then
              PRESET="linux-arm64-dbg"
            else
              PRESET="linux-x64-dbg"
            fi
          else
            if [ "${{ inputs.platform }}" = "arm64" ]; then
              PRESET="linux-arm64-rel"
            else
              PRESET="linux-x64-rel"
            fi
          fi
          echo "PRESET=$PRESET" >> $GITHUB_ENV
          cmake --preset $PRESET \
            -DCMAKE_EXE_LINKER_FLAGS_INIT="-fuse-ld=lld" \
            -DCMAKE_MODULE_LINKER_FLAGS_INIT="-fuse-ld=lld" \
            -DCMAKE_C_COMPILER_LAUNCHER=ccache \
            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
            ${{ inputs.cmakeFlags }}

      - name: Configure CMake (GCC)
        if: inputs.compiler == 'gcc'
        run: |
          if [ "${{ inputs.buildType }}" = "Debug" ]; then
            if [ "${{ inputs.platform }}" = "arm64" ]; then
              PRESET="linux-arm64-gcc-dbg"
            else
              PRESET="linux-x64-gcc-dbg"
            fi
          else
            if [ "${{ inputs.platform }}" = "arm64" ]; then
              PRESET="linux-arm64-gcc-rel"
            else
              PRESET="linux-x64-gcc-rel"
            fi
          fi
          echo "PRESET=$PRESET" >> $GITHUB_ENV
          cmake --preset $PRESET \
            -DCMAKE_C_COMPILER_LAUNCHER=ccache \
            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
            ${{ inputs.cmakeFlags }}

      - name: Build
        run: |
          ccache -p
          ccache -z
          cmake --build --preset ${{ env.PRESET }}
          ccache -s

      - name: Create AppImage
        id: create-appimage
        shell: bash
        run: |
          set -e
          if [ "${{ inputs.buildType }}" = "Debug" ]; then
            CONF="Debug"
          else
            CONF="MinSizeRel"
          fi
          APPIMAGE_NAME="${{ steps.artifact-metadata.outputs.artifact-name }}.AppImage"
          BUILD_DIR="build/${{ env.PRESET }}/bin/$CONF"
          APPDIRNAME="myMCpp.AppDir"
          
          if [ ! -f "${BUILD_DIR}/myMCpp" ]; then
            echo "Error: Binary not found at ${BUILD_DIR}/myMCpp"
            exit 1
          fi
          
          export ARCH=$(uname -m)
          if [ "$ARCH" = "aarch64" ]; then
            APPIMAGE_ARCH="aarch64"
          else
            APPIMAGE_ARCH="x86_64"
          fi
          
          LINUXDEPLOY=./linuxdeploy-${APPIMAGE_ARCH}.AppImage
          LINUXDEPLOY_PLUGIN_QT=./linuxdeploy-plugin-qt-${APPIMAGE_ARCH}.AppImage
          APPIMAGETOOL=./appimagetool-${APPIMAGE_ARCH}.AppImage
          
          echo "Downloading linuxdeploy..."
          if [ ! -f "$LINUXDEPLOY" ]; then
            wget -q -O "$LINUXDEPLOY" https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-${APPIMAGE_ARCH}.AppImage
            chmod +x "$LINUXDEPLOY"
          fi
          
          echo "Downloading linuxdeploy Qt plugin..."
          if [ ! -f "$LINUXDEPLOY_PLUGIN_QT" ]; then
            wget -q -O "$LINUXDEPLOY_PLUGIN_QT" https://github.com/linuxdeploy/linuxdeploy-plugin-qt/releases/download/continuous/linuxdeploy-plugin-qt-${APPIMAGE_ARCH}.AppImage
            chmod +x "$LINUXDEPLOY_PLUGIN_QT"
          fi
          
          echo "Downloading appimagetool..."
          if [ ! -f "$APPIMAGETOOL" ]; then
            wget -q -O "$APPIMAGETOOL" https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-${APPIMAGE_ARCH}.AppImage
            chmod +x "$APPIMAGETOOL"
          fi
          
          OUTDIR=$(realpath "./$APPDIRNAME")
          rm -fr "$OUTDIR"
          
          echo "Copying desktop file..."
          cat > myMCpp.desktop << 'EOF'
          [Desktop Entry]
          Type=Application
          Name=myMCpp
          Comment=PlayStation 2 memory card manager
          Exec=myMCpp
          Icon=myMCpp
          Categories=Utility;
          EOF
          
          echo "Resizing icon to 256x256..."
          convert resources/icons/AppIcon.png -resize 256x256 myMCpp.png
          
          QMAKE_PATH=$(which qmake 2>/dev/null || which qmake6 2>/dev/null || echo "")
          if [ -z "$QMAKE_PATH" ]; then
            QMAKE_PATH=$(find /opt/qt -name qmake 2>/dev/null | head -n 1 || echo "")
          fi
          if [ -z "$QMAKE_PATH" ]; then
            QMAKE_PATH=$(find /usr/lib/qt6 -name qmake 2>/dev/null | head -n 1 || echo "")
          fi
          
          if [ -z "$QMAKE_PATH" ]; then
            echo "Error: qmake not found"
            exit 1
          fi
          
          echo "Using QMAKE: $QMAKE_PATH"
          
          echo "Running linuxdeploy to create AppDir..."
          EXTRA_QT_MODULES="core;gui;svg;widgets;waylandclient;waylandcompositor;xcbqpa" \
          EXTRA_PLATFORM_PLUGINS="libqwayland.so" \
          DEPLOY_PLATFORM_THEMES="1" \
          QMAKE="$QMAKE_PATH" \
          NO_STRIP="1" \
          $LINUXDEPLOY --plugin qt --appdir="$OUTDIR" --executable="${BUILD_DIR}/myMCpp" \
            --desktop-file="myMCpp.desktop" --icon-file="myMCpp.png"
          
          echo "Copying resources into AppDir..."
          if [ -d "${BUILD_DIR}/resources" ]; then
            cp -a "${BUILD_DIR}/resources" "$OUTDIR/usr/bin"
          fi

          echo "Copying translations into AppDir..."
          if [ -d "${BUILD_DIR}/translations" ]; then
            rm -fr "$OUTDIR/usr/bin/translations" "$OUTDIR/usr/translations"
            cp -a "${BUILD_DIR}/translations" "$OUTDIR/usr/bin"
          fi
          
          echo "Generating AppImage..."
          rm -f "$APPIMAGE_NAME"
          $APPIMAGETOOL -v "$OUTDIR" "$APPIMAGE_NAME"
          
          echo "AppImage created: ${APPIMAGE_NAME}"
          echo "appimage-path=${APPIMAGE_NAME}" >> $GITHUB_OUTPUT

      - name: Upload AppImage artifact
        uses: actions/upload-artifact@v7
        with:
          name: ${{ steps.artifact-metadata.outputs.artifact-name }}-AppImage
          path: ${{ steps.create-appimage.outputs.appimage-path }}
          if-no-files-found: error
          retention-days: 30