Updated cmake again

.gitignore

@@ -111,7 +111,6 @@ mingw64/
 # torch
 torch.hash.yml
 build*
-cmake*
 .idea
 
 # the game

CMakeLists.txt

@@ -24,7 +24,7 @@ include(FindFontconfig)
 include(cmake/lus-cvars.cmake)
 
 if (WIN32)
-include(libultraship/cmake/automate-vcpkg.cmake)
+include(cmake/automate-vcpkg.cmake)
 set(VCPKG_TRIPLET x64-windows-static)
 set(VCPKG_TARGET_TRIPLET x64-windows-static)
 vcpkg_bootstrap()
@@ -235,7 +235,6 @@ file(DOWNLOAD "https://raw.githubusercontent.com/DLTcollab/sse2neon/refs/heads/m
 include_directories(${SSE2NEON_DIR})
 
 #=================== DRLibs ===================
-include(FetchContent)
 FetchContent_Declare(
     dr_libs
     GIT_REPOSITORY https://github.com/mackron/dr_libs.git
@@ -377,8 +376,8 @@ if(USE_NETWORKING)
     endif()
     find_package(SDL2_net REQUIRED)
     include_directories(${SDL2_NET_INCLUDE_DIRS})
-#    target_link_libraries(${PROJECT_NAME} PRIVATE SDL2_net::SDL2_net)
-#    target_compile_definitions(${PROJECT_NAME} PRIVATE USE_NETWORKING)
+    # target_link_libraries(${PROJECT_NAME} PRIVATE SDL2_net::SDL2_net)
+    # target_compile_definitions(${PROJECT_NAME} PRIVATE USE_NETWORKING)
 endif()
 
 option(USE_STANDALONE "Build as a standalone executable" OFF)
@@ -637,3 +636,39 @@ add_custom_target(
     COMMAND ${TORCH_EXECUTABLE} pack port spaghetti.o2r o2r
     COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_SOURCE_DIR}/spaghetti.o2r" "${CMAKE_BINARY_DIR}/spaghetti.o2r"
 )
+
+if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
+add_custom_target(CreateOSXIcons
+    COMMAND mkdir -p ${CMAKE_BINARY_DIR}/macosx/spaghettikart.iconset
+    COMMAND sips -z 16 16     logo.png --out ${CMAKE_BINARY_DIR}/macosx/spaghettikart.iconset/icon_16x16.png
+    COMMAND sips -z 32 32     logo.png --out ${CMAKE_BINARY_DIR}/macosx/spaghettikart.iconset/icon_16x16@2x.png
+    COMMAND sips -z 32 32     logo.png --out ${CMAKE_BINARY_DIR}/macosx/spaghettikart.iconset/icon_32x32.png
+    COMMAND sips -z 64 64     logo.png --out ${CMAKE_BINARY_DIR}/macosx/spaghettikart.iconset/icon_32x32@2x.png
+    COMMAND sips -z 128 128   logo.png --out ${CMAKE_BINARY_DIR}/macosx/spaghettikart.iconset/icon_128x128.png
+    COMMAND sips -z 256 256   logo.png --out ${CMAKE_BINARY_DIR}/macosx/spaghettikart.iconset/icon_128x128@2x.png
+    COMMAND sips -z 256 256   logo.png --out ${CMAKE_BINARY_DIR}/macosx/spaghettikart.iconset/icon_256x256.png
+    COMMAND sips -z 512 512   logo.png --out ${CMAKE_BINARY_DIR}/macosx/spaghettikart.iconset/icon_256x256@2x.png
+    COMMAND sips -z 512 512   logo.png --out ${CMAKE_BINARY_DIR}/macosx/spaghettikart.iconset/icon_512x512.png
+    COMMAND cp                logo.png ${CMAKE_BINARY_DIR}/macosx/spaghettikart.iconset/icon_512x512@2x.png
+    COMMAND iconutil -c icns -o ${CMAKE_BINARY_DIR}/macosx/spaghettikart.icns ${CMAKE_BINARY_DIR}/macosx/spaghettikart.iconset
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+    COMMENT "Creating OSX icons ..."
+    )
+    add_dependencies(${PROJECT_NAME} CreateOSXIcons)
+    configure_file("${CMAKE_SOURCE_DIR}/Info.plist" "${CMAKE_BINARY_DIR}/Info.plist" COPYONLY)
+endif()
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY APPIMAGE_DESKTOP_FILE_TERMINAL YES)
+set_property(TARGET ${PROJECT_NAME} PROPERTY APPIMAGE_DESKTOP_FILE "${CMAKE_SOURCE_DIR}/SpaghettiKart.desktop")
+set_property(TARGET ${PROJECT_NAME} PROPERTY APPIMAGE_ICON_FILE "${CMAKE_SOURCE_DIR}/logo.png")
+
+if(CMAKE_SYSTEM_NAME MATCHES "Linux")
+    set(CPACK_GENERATOR "External")
+elseif(CMAKE_SYSTEM_NAME MATCHES "Windows|NintendoSwitch|CafeOS")
+    set(CPACK_GENERATOR "ZIP")
+elseif(CMAKE_SYSTEM_NAME MATCHES "Darwin")
+    set(CPACK_GENERATOR "Bundle")
+endif()
+
+set(CPACK_PROJECT_CONFIG_FILE ${CMAKE_SOURCE_DIR}/cmake/configure-packaging.cmake)
+include(cmake/packaging.cmake)

cmake/automate-vcpkg.cmake

@@ -0,0 +1,191 @@
+#------------------------------------------------------------------------------------------------------------
+#
+# Automate-VCPKG by Andre Taulien
+# ===============================
+#
+# Project Repository: https://github.com/REGoth-project/Automate-VCPKG
+# License ..........: MIT, see end of file.
+#
+# Based on: https://github.com/sutambe/cpptruths/blob/vcpkg_cmake_blog/cpp0x/vcpkg_test/CMakeLists.txt
+#
+# 
+# While [Vcpkg](https://github.com/microsoft/vcpkg) on it's own is awesome, it does add 
+# a little bit of complexity to getting a project to build. Even more if the one trying 
+# to compile your application is not too fond of the commandline. Additionally, CMake 
+# commands tend to get rather long with the toolchain path. 
+# 
+# To keep things simple for new users who just want to get the project to build, this 
+# script offers a solution.
+# 
+# Lets assume your main `CMakelists.txt` looks something like this:
+#
+#     cmake_minimum_required (VERSION 3.12.0)
+#     project (MyProject)
+#     
+#     add_executable(MyExecutable main.c)
+# 
+# To integrate Vcpkg into that `CMakelists.txt`, simple put the following lines before the 
+# call to `project(MyProject)`:
+# 
+#     include(cmake/automate-vcpkg.cmake)
+#     
+#     vcpkg_bootstrap()
+#     vcpkg_install_packages(libsquish physfs)
+# 
+# The call to `vcpkg_bootstrap()` will clone the official Vcpkg repository and bootstrap it. 
+# If it detected an existing environment variable defining a valid `VCPKG_ROOT`, it will 
+# update the existing installation of Vcpkg.
+# 
+# Arguments to `vcpkg_install_packages()` are the packages you want to install using Vcpkg.
+# 
+# If you want to keep the possibility for users to chose their own copy of Vcpkg, you can 
+# simply not run the code snippet mentioned above, something like this will work:
+# 
+#     option(SKIP_AUTOMATE_VCPKG "When ON, you will need to built the packages 
+#      required by MyProject on your own or supply your own vcpkg toolchain.")
+#     
+#     if (NOT SKIP_AUTOMATE_VCPKG)
+#       include(cmake/automate-vcpkg.cmake)
+#     
+#       vcpkg_bootstrap()
+#       vcpkg_install_packages(libsquish physfs)
+#     endif()
+#  
+# Then, the user has to supply the packages on their own, be it through Vcpkg or manually 
+# specifying their locations.
+#------------------------------------------------------------------------------------------------------------
+
+cmake_minimum_required (VERSION 3.12)
+
+if(WIN32)
+    set(VCPKG_FALLBACK_ROOT ${CMAKE_CURRENT_BINARY_DIR}/vcpkg CACHE STRING "vcpkg configuration directory to use if vcpkg was not installed on the system before")
+else()
+    set(VCPKG_FALLBACK_ROOT ${CMAKE_CURRENT_BINARY_DIR}/.vcpkg CACHE STRING  "vcpkg configuration directory to use if vcpkg was not installed on the system before")
+endif()
+
+# On Windows, Vcpkg defaults to x86, even on x64 systems. If we're 
+# doing a 64-bit build, we need to fix that.
+if (WIN32)
+
+    # Since the compiler checks haven't run yet, we need to figure
+    # out the value of CMAKE_SIZEOF_VOID_P ourselfs
+
+    include(CheckTypeSize)
+    enable_language(C)
+    check_type_size("void*" SIZEOF_VOID_P BUILTIN_TYPES_ONLY)
+    
+    if (SIZEOF_VOID_P EQUAL 8)
+        message(STATUS "Using Vcpkg triplet 'x64-windows'")
+        
+        set(VCPKG_TRIPLET x64-windows)
+    endif()
+endif()
+
+if(NOT DEFINED VCPKG_ROOT)
+    if(NOT DEFINED ENV{VCPKG_ROOT})
+	    set(VCPKG_ROOT ${VCPKG_FALLBACK_ROOT})
+    else()
+        set(VCPKG_ROOT $ENV{VCPKG_ROOT})
+    endif()
+endif()
+
+# Installs a new copy of Vcpkg or updates an existing one
+macro(vcpkg_bootstrap)
+    _install_or_update_vcpkg()
+
+    # Find out whether the user supplied their own VCPKG toolchain file
+    if(NOT DEFINED ${CMAKE_TOOLCHAIN_FILE})
+        # We know this wasn't set before so we need point the toolchain file to the newly found VCPKG_ROOT
+        set(CMAKE_TOOLCHAIN_FILE ${VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake CACHE STRING "")
+    
+        # Just setting vcpkg.cmake as toolchain file does not seem to actually pull in the code
+        include(${VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake)
+    
+        set(AUTOMATE_VCPKG_USE_SYSTEM_VCPKG OFF)
+    else()
+        # VCPKG_ROOT has been defined by the toolchain file already
+        set(AUTOMATE_VCPKG_USE_SYSTEM_VCPKG ON)
+    endif()
+    
+    message(STATUS "Automate VCPKG status:")
+    message(STATUS "  VCPKG_ROOT.....: ${VCPKG_ROOT}")
+    message(STATUS "  VCPKG_EXEC.....: ${VCPKG_EXEC}")
+    message(STATUS "  VCPKG_BOOTSTRAP: ${VCPKG_BOOTSTRAP}")
+endmacro()
+
+macro(_install_or_update_vcpkg)
+    if(NOT EXISTS ${VCPKG_ROOT})
+        message(STATUS "Cloning vcpkg in ${VCPKG_ROOT}")
+        execute_process(COMMAND git clone https://github.com/Microsoft/vcpkg.git ${VCPKG_ROOT})
+
+        # If a reproducible build is desired (and potentially old libraries are # ok), uncomment the
+        # following line and pin the vcpkg repository to a specific githash.
+        # execute_process(COMMAND git checkout 745a0aea597771a580d0b0f4886ea1e3a94dbca6 WORKING_DIRECTORY ${VCPKG_ROOT})
+    else()
+        # The following command has no effect if the vcpkg repository is in a detached head state.
+        message(STATUS "Auto-updating vcpkg in ${VCPKG_ROOT}")
+        execute_process(COMMAND git pull WORKING_DIRECTORY ${VCPKG_ROOT})
+    endif()
+
+    if(NOT EXISTS ${VCPKG_ROOT}/README.md)
+        message(FATAL_ERROR "***** FATAL ERROR: Could not clone vcpkg *****")
+    endif()
+
+    if(WIN32)
+        set(VCPKG_EXEC ${VCPKG_ROOT}/vcpkg.exe)
+        set(VCPKG_BOOTSTRAP ${VCPKG_ROOT}/bootstrap-vcpkg.bat)
+    else()
+        set(VCPKG_EXEC ${VCPKG_ROOT}/vcpkg)
+        set(VCPKG_BOOTSTRAP ${VCPKG_ROOT}/bootstrap-vcpkg.sh)
+    endif()
+
+    if(NOT EXISTS ${VCPKG_EXEC})
+        message("Bootstrapping vcpkg in ${VCPKG_ROOT}")
+        execute_process(COMMAND ${VCPKG_BOOTSTRAP} WORKING_DIRECTORY ${VCPKG_ROOT})
+    endif()
+
+    if(NOT EXISTS ${VCPKG_EXEC})
+        message(FATAL_ERROR "***** FATAL ERROR: Could not bootstrap vcpkg *****")
+    endif()
+   
+endmacro()
+
+# Installs the list of packages given as parameters using Vcpkg
+macro(vcpkg_install_packages)
+    
+    # Need the given list to be space-separated
+    #string (REPLACE ";" " " PACKAGES_LIST_STR "${ARGN}")
+
+    message(STATUS "Installing/Updating the following vcpkg-packages: ${PACKAGES_LIST_STR}")
+
+    if (VCPKG_TRIPLET)
+        set(ENV{VCPKG_DEFAULT_TRIPLET} "${VCPKG_TRIPLET}")
+    endif()
+
+    execute_process(
+        COMMAND ${VCPKG_EXEC} install ${ARGN}
+        WORKING_DIRECTORY ${VCPKG_ROOT}
+        )
+endmacro()
+    
+# MIT License
+# 
+# Copyright (c) 2019 REGoth-project
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.

cmake/configure-packaging.cmake

@@ -0,0 +1,29 @@
+set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
+set(CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY 0)
+set(CPACK_COMPONENTS_ALL "Starship")
+
+if (CPACK_GENERATOR STREQUAL "External")
+  list(APPEND CPACK_COMPONENTS_ALL "extractor" "appimage")
+endif()
+
+if (CPACK_GENERATOR MATCHES "DEB|RPM")
+# https://unix.stackexchange.com/a/11552/254512
+set(CPACK_PACKAGING_INSTALL_PREFIX "/opt/ship/bin")#/${CMAKE_PROJECT_VERSION}")
+set(CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY 0)
+elseif (CPACK_GENERATOR MATCHES "ZIP")
+set(CPACK_PACKAGING_INSTALL_PREFIX "")
+endif()
+
+if (CPACK_GENERATOR MATCHES "External")
+set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
+SET(CPACK_MONOLITHIC_INSTALL 1)
+set(CPACK_PACKAGING_INSTALL_PREFIX "/usr/bin")
+endif()
+
+if (CPACK_GENERATOR MATCHES "Bundle")
+    set(CPACK_BUNDLE_NAME "Starship")
+    set(CPACK_BUNDLE_PLIST "macosx/Info.plist")
+    set(CPACK_BUNDLE_ICON "macosx/Starship.icns")
+    # set(CPACK_BUNDLE_STARTUP_COMMAND "macosx/Starship-macos.sh")
+    set(CPACK_BUNDLE_APPLE_CERT_APP "-")
+endif()

cmake/modules/FindOgg.cmake

@@ -0,0 +1,61 @@
+# - Find ogg
+# Find the native ogg includes and libraries
+#
+#  OGG_INCLUDE_DIRS - where to find ogg.h, etc.
+#  OGG_LIBRARIES    - List of libraries when using ogg.
+#  OGG_FOUND        - True if ogg found.
+
+if (OGG_INCLUDE_DIR)
+	# Already in cache, be silent
+	set(OGG_FIND_QUIETLY TRUE)
+endif ()
+
+find_package (PkgConfig QUIET)
+pkg_check_modules (PC_OGG QUIET ogg>=1.3.0)
+
+set (OGG_VERSION ${PC_OGG_VERSION})
+
+find_path (OGG_INCLUDE_DIR ogg/ogg.h
+	HINTS
+		${PC_OGG_INCLUDEDIR}
+		${PC_OGG_INCLUDE_DIRS}
+		${OGG_ROOT}
+	)
+# MSVC built ogg may be named ogg_static.
+# The provided project files name the library with the lib prefix.
+find_library (OGG_LIBRARY
+	NAMES
+		ogg
+		ogg_static
+		libogg
+		libogg_static
+	HINTS
+		${PC_OGG_LIBDIR}
+		${PC_OGG_LIBRARY_DIRS}
+		${OGG_ROOT}
+	)
+# Handle the QUIETLY and REQUIRED arguments and set OGG_FOUND
+# to TRUE if all listed variables are TRUE.
+include (FindPackageHandleStandardArgs)
+find_package_handle_standard_args (Ogg
+	REQUIRED_VARS
+		OGG_LIBRARY
+		OGG_INCLUDE_DIR
+	VERSION_VAR
+		OGG_VERSION
+	)
+
+if (OGG_FOUND)
+	set (OGG_LIBRARIES ${OGG_LIBRARY})
+	set (OGG_INCLUDE_DIRS ${OGG_INCLUDE_DIR})
+
+	if(NOT TARGET Ogg::ogg)
+	add_library(Ogg::ogg UNKNOWN IMPORTED)
+		set_target_properties(Ogg::ogg PROPERTIES
+			INTERFACE_INCLUDE_DIRECTORIES "${OGG_INCLUDE_DIRS}"
+			IMPORTED_LOCATION "${OGG_LIBRARIES}"
+		)
+  endif ()
+endif ()
+
+mark_as_advanced (OGG_INCLUDE_DIR OGG_LIBRARY)

cmake/modules/FindPulseAudio.cmake

@@ -0,0 +1,34 @@
+# - Find PulseAudio includes and libraries
+#
+#   PULSEAUDIO_FOUND        - True if PULSEAUDIO_INCLUDE_DIR &
+#                             PULSEAUDIO_LIBRARY are found
+#
+#   PULSEAUDIO_INCLUDE_DIR - where to find pulse/pulseaudio.h, etc.
+#   PULSEAUDIO_LIBRARY     - the pulse library
+#   PULSEAUDIO_VERSION_STRING - the version of PulseAudio found
+#
+
+find_path(PULSEAUDIO_INCLUDE_DIR
+          NAMES pulse/pulseaudio.h
+          DOC "The PulseAudio include directory"
+)
+
+find_library(PULSEAUDIO_LIBRARY
+             NAMES pulse
+             DOC "The PulseAudio library"
+)
+
+if(PULSEAUDIO_INCLUDE_DIR AND EXISTS "${PULSEAUDIO_INCLUDE_DIR}/pulse/version.h")
+    file(STRINGS "${PULSEAUDIO_INCLUDE_DIR}/pulse/version.h" pulse_version_str
+         REGEX "^#define[\t ]+pa_get_headers_version\\(\\)[\t ]+\\(\".*\"\\)")
+
+    string(REGEX REPLACE "^.*pa_get_headers_version\\(\\)[\t ]+\\(\"([^\"]*)\"\\).*$" "\\1"
+           PULSEAUDIO_VERSION_STRING "${pulse_version_str}")
+    unset(pulse_version_str)
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(PulseAudio
+    REQUIRED_VARS PULSEAUDIO_LIBRARY PULSEAUDIO_INCLUDE_DIR
+    VERSION_VAR PULSEAUDIO_VERSION_STRING
+)

cmake/modules/FindVorbis.cmake

@@ -0,0 +1,197 @@
+#[=======================================================================[.rst:
+FindVorbis
+----------
+Finds the native vorbis, vorbisenc amd vorbisfile includes and libraries.
+Imported Targets
+^^^^^^^^^^^^^^^^
+This module provides the following imported targets, if found:
+``Vorbis::vorbis``
+  The Vorbis library
+``Vorbis::vorbisenc``
+  The VorbisEnc library
+``Vorbis::vorbisfile``
+  The VorbisFile library
+Result Variables
+^^^^^^^^^^^^^^^^
+This will define the following variables:
+``Vorbis_Vorbis_INCLUDE_DIRS``
+  List of include directories when using vorbis.
+``Vorbis_Enc_INCLUDE_DIRS``
+  List of include directories when using vorbisenc.
+``Vorbis_File_INCLUDE_DIRS``
+  List of include directories when using vorbisfile.
+``Vorbis_Vorbis_LIBRARIES``
+  List of libraries when using vorbis.
+``Vorbis_Enc_LIBRARIES``
+  List of libraries when using vorbisenc.
+``Vorbis_File_LIBRARIES``
+  List of libraries when using vorbisfile.
+``Vorbis_FOUND``
+  True if vorbis and requested components found.
+``Vorbis_Vorbis_FOUND``
+  True if vorbis found.
+``Vorbis_Enc_FOUND``
+  True if vorbisenc found.
+``Vorbis_Enc_FOUND``
+  True if vorbisfile found.
+Cache variables
+^^^^^^^^^^^^^^^
+The following cache variables may also be set:
+``Vorbis_Vorbis_INCLUDE_DIR``
+  The directory containing ``vorbis/vorbis.h``.
+``Vorbis_Enc_INCLUDE_DIR``
+  The directory containing ``vorbis/vorbisenc.h``.
+``Vorbis_File_INCLUDE_DIR``
+  The directory containing ``vorbis/vorbisenc.h``.
+``Vorbis_Vorbis_LIBRARY``
+  The path to the vorbis library.
+``Vorbis_Enc_LIBRARY``
+  The path to the vorbisenc library.
+``Vorbis_File_LIBRARY``
+  The path to the vorbisfile library.
+Hints
+^^^^^
+A user may set ``Vorbis_ROOT`` to a vorbis installation root to tell this module where to look.
+#]=======================================================================]
+
+if (Vorbis_Vorbis_INCLUDE_DIR)
+	# Already in cache, be silent
+	set (Vorbis_FIND_QUIETLY TRUE)
+endif ()
+
+set (Vorbis_Vorbis_FIND_QUIETLY TRUE)
+set (Vorbis_Enc_FIND_QUIETLY TRUE)
+set (Vorbis_File_FIND_QUIETLY TRUE)
+
+find_package (Ogg QUIET)
+
+find_package (PkgConfig QUIET)
+pkg_check_modules (PC_Vorbis_Vorbis QUIET vorbis)
+pkg_check_modules (PC_Vorbis_Enc QUIET vorbisenc)
+pkg_check_modules (PC_Vorbis_File QUIET vorbisfile)
+
+set (Vorbis_VERSION ${PC_Vorbis_Vorbis_VERSION})
+
+find_path (Vorbis_Vorbis_INCLUDE_DIR vorbis/codec.h
+	HINTS
+		${PC_Vorbis_Vorbis_INCLUDEDIR}
+		${PC_Vorbis_Vorbis_INCLUDE_DIRS}
+		${Vorbis_ROOT}
+	)
+
+find_path (Vorbis_Enc_INCLUDE_DIR vorbis/vorbisenc.h
+	HINTS
+		${PC_Vorbis_Enc_INCLUDEDIR}
+		${PC_Vorbis_Enc_INCLUDE_DIRS}
+		${Vorbis_ROOT}
+	)
+
+find_path (Vorbis_File_INCLUDE_DIR vorbis/vorbisfile.h
+	HINTS
+		${PC_Vorbis_File_INCLUDEDIR}
+		${PC_Vorbis_File_INCLUDE_DIRS}
+		${Vorbis_ROOT}
+	)
+
+find_library (Vorbis_Vorbis_LIBRARY
+	NAMES
+		vorbis
+		vorbis_static
+		libvorbis
+		libvorbis_static
+	HINTS
+		${PC_Vorbis_Vorbis_LIBDIR}
+		${PC_Vorbis_Vorbis_LIBRARY_DIRS}
+		${Vorbis_ROOT}
+	)
+
+find_library (Vorbis_Enc_LIBRARY
+	NAMES
+		vorbisenc
+		vorbisenc_static
+		libvorbisenc
+		libvorbisenc_static
+	HINTS
+		${PC_Vorbis_Enc_LIBDIR}
+		${PC_Vorbis_Enc_LIBRARY_DIRS}
+		${Vorbis_ROOT}
+	)
+
+find_library (Vorbis_File_LIBRARY
+	NAMES
+		vorbisfile
+		vorbisfile_static
+		libvorbisfile
+		libvorbisfile_static
+	HINTS
+		${PC_Vorbis_File_LIBDIR}
+		${PC_Vorbis_File_LIBRARY_DIRS}
+		${Vorbis_ROOT}
+	)
+
+include (FindPackageHandleStandardArgs)
+
+if (Vorbis_Vorbis_LIBRARY AND Vorbis_Vorbis_INCLUDE_DIR AND Ogg_FOUND)
+    set (Vorbis_Vorbis_FOUND TRUE)
+endif ()
+
+if (Vorbis_Enc_LIBRARY AND Vorbis_Enc_INCLUDE_DIR AND Vorbis_Vorbis_FOUND)
+    set (Vorbis_Enc_FOUND TRUE)
+endif ()
+
+if (Vorbis_Vorbis_FOUND AND Vorbis_File_LIBRARY AND Vorbis_File_INCLUDE_DIR)
+    set (Vorbis_File_FOUND TRUE)
+endif ()
+
+find_package_handle_standard_args (Vorbis
+	REQUIRED_VARS
+		Vorbis_Vorbis_LIBRARY
+		Vorbis_Vorbis_INCLUDE_DIR
+		Ogg_FOUND
+	HANDLE_COMPONENTS
+	VERSION_VAR Vorbis_VERSION)
+
+
+if (Vorbis_Vorbis_FOUND)
+	set (Vorbis_Vorbis_INCLUDE_DIRS ${VORBIS_INCLUDE_DIR})
+	set (Vorbis_Vorbis_LIBRARIES ${VORBIS_LIBRARY} ${OGG_LIBRARIES})
+    if (NOT TARGET Vorbis::vorbis)
+		add_library (Vorbis::vorbis UNKNOWN IMPORTED)
+		set_target_properties (Vorbis::vorbis PROPERTIES
+			INTERFACE_INCLUDE_DIRECTORIES "${Vorbis_Vorbis_INCLUDE_DIR}"
+			IMPORTED_LOCATION "${Vorbis_Vorbis_LIBRARY}"
+			INTERFACE_LINK_LIBRARIES Ogg::ogg
+		)
+	endif ()
+
+	if (Vorbis_Enc_FOUND)
+		set (Vorbis_Enc_INCLUDE_DIRS ${Vorbis_Enc_INCLUDE_DIR})
+		set (Vorbis_Enc_LIBRARIES ${Vorbis_Enc_LIBRARY} ${Vorbis_Enc_LIBRARIES})
+		if (NOT TARGET Vorbis::vorbisenc)
+			add_library (Vorbis::vorbisenc UNKNOWN IMPORTED)
+			set_target_properties (Vorbis::vorbisenc PROPERTIES
+				INTERFACE_INCLUDE_DIRECTORIES "${Vorbis_Enc_INCLUDE_DIR}"
+				IMPORTED_LOCATION "${Vorbis_Enc_LIBRARY}"
+				INTERFACE_LINK_LIBRARIES Vorbis::vorbis
+			)
+		endif ()
+	endif ()
+
+	if (Vorbis_File_FOUND)
+		set (Vorbis_File_INCLUDE_DIRS ${Vorbis_File_INCLUDE_DIR})
+		set (Vorbis_File_LIBRARIES ${Vorbis_File_LIBRARY} ${Vorbis_File_LIBRARIES})
+		if (NOT TARGET Vorbis::vorbisfile)
+			add_library (Vorbis::vorbisfile UNKNOWN IMPORTED)
+			set_target_properties (Vorbis::vorbisfile PROPERTIES
+				INTERFACE_INCLUDE_DIRECTORIES "${Vorbis_File_INCLUDE_DIR}"
+				IMPORTED_LOCATION "${Vorbis_File_LIBRARY}"
+				INTERFACE_LINK_LIBRARIES Vorbis::vorbis
+			)
+		endif ()
+	endif ()
+
+endif ()
+
+mark_as_advanced (Vorbis_Vorbis_INCLUDE_DIR Vorbis_Vorbis_LIBRARY)
+mark_as_advanced (Vorbis_Enc_INCLUDE_DIR Vorbis_Enc_LIBRARY)
+mark_as_advanced (Vorbis_File_INCLUDE_DIR Vorbis_File_LIBRARY)

cmake/modules/FindlibUsb.cmake

@@ -0,0 +1,48 @@
+if (MSVC)
+   set(WINDOWS_LIBUSB_PATH "$ENV{LIBUSB_PATH}/VS2019/MS64/static")
+
+   # check if we're using something else than 64bit..
+   if (NOT "${CMAKE_SIZEOF_VOID_P}" STREQUAL "8")
+      set(WINDOWS_LIBUSB_PATH "$ENV{LIBUSB_PATH}/VS2019/MS32/static")
+   endif()
+endif()
+
+if (MINGW)
+   set(WINDOWS_LIBUSB_PATH "$ENV{LIBUSB_PATH}/MinGW64/static")
+   # check if we're using something else than 64bit..
+   if (NOT "${CMAKE_SIZEOF_VOID_P}" STREQUAL "8")
+      set(WINDOWS_LIBUSB_PATH "$ENV{LIBUSB_PATH}/MinGW32/static")
+   endif()
+endif()
+
+find_library (LIBUSB_LIBRARY
+   NAMES libusb libusb-1.0 usb-1.0
+   PATHS "/usr/lib" "/usr/local/lib/" "${WINDOWS_LIBUSB_PATH}")
+
+find_path (LIBUSB_INCLUDEDIR
+   NAMES libusb.h libusb-1.0.h
+   PATHS "/usr/local/include/" "$ENV{LIBUSB_PATH}/include/libusb-1.0"
+   PATH_SUFFIXES "include" "libusb" "libusb-1.0")
+
+include(FindPackageHandleStandardArgs)
+
+find_package_handle_standard_args(libUsb DEFAULT_MSG
+                                  LIBUSB_LIBRARY
+                                  LIBUSB_INCLUDEDIR)
+
+if (LIBUSB_FOUND AND NOT TARGET libUsb::libUsb)
+   add_library(libUsb::libUsb STATIC IMPORTED)
+   set_target_properties(
+      libUsb::libUsb
+      PROPERTIES
+         INTERFACE_INCLUDE_DIRECTORIES "${LIBUSB_INCLUDEDIR}"
+         IMPORTED_LOCATION "${LIBUSB_LIBRARY}")
+   if (MSVC OR MINGW)
+      set_target_properties(
+         libUsb::libUsb
+         PROPERTIES
+            IMPORTED_IMPLIB "${LIBUSB_LIBRARY}"
+      )
+   endif()
+endif()
+

cmake/modules/Findudev.cmake

@@ -0,0 +1,84 @@
+# - try to find the udev library
+#
+# Cache Variables: (probably not for direct use in your scripts)
+#  UDEV_INCLUDE_DIR
+#  UDEV_SOURCE_DIR
+#  UDEV_LIBRARY
+#
+# Non-cache variables you might use in your CMakeLists.txt:
+#  UDEV_FOUND
+#  UDEV_INCLUDE_DIRS
+#  UDEV_LIBRARIES
+#
+# Requires these CMake modules:
+#  FindPackageHandleStandardArgs (known included with CMake >=2.6.2)
+#
+# Original Authors:
+# 2014, Kevin M. Godby <kevin@godby.org>
+# 2021, Ryan Pavlik <ryan.pavlik@collabora.com> <abiryan@ryand.net>
+#
+# Copyright 2014, Kevin M. Godby <kevin@godby.org>
+# Copyright 2021, Collabora, Ltd.
+#
+# SPDX-License-Identifier: BSL-1.0
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+set(UDEV_ROOT_DIR
+        "${UDEV_ROOT_DIR}"
+        CACHE
+        PATH
+        "Directory to search for udev")
+
+if(NOT ANDROID)
+    find_package(PkgConfig QUIET)
+    if(PKG_CONFIG_FOUND)
+        pkg_check_modules(PC_LIBUDEV QUIET libudev)
+    endif()
+endif()
+
+find_library(UDEV_LIBRARY
+        NAMES
+        udev
+        PATHS
+        ${PC_LIBUDEV_LIBRARY_DIRS}
+        ${PC_LIBUDEV_LIBDIR}
+        HINTS
+        "${UDEV_ROOT_DIR}"
+        PATH_SUFFIXES
+        lib
+        )
+
+get_filename_component(_libdir "${UDEV_LIBRARY}" PATH)
+
+find_path(UDEV_INCLUDE_DIR
+        NAMES
+        libudev.h
+        PATHS
+        ${PC_LIBUDEV_INCLUDE_DIRS}
+        ${PC_LIBUDEV_INCLUDEDIR}
+        HINTS
+        "${_libdir}"
+        "${_libdir}/.."
+        "${UDEV_ROOT_DIR}"
+        PATH_SUFFIXES
+        include
+        )
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(udev
+        DEFAULT_MSG
+        UDEV_LIBRARY
+        UDEV_INCLUDE_DIR
+        )
+
+if(UDEV_FOUND)
+    list(APPEND UDEV_LIBRARIES ${UDEV_LIBRARY})
+    list(APPEND UDEV_INCLUDE_DIRS ${UDEV_INCLUDE_DIR})
+    mark_as_advanced(UDEV_ROOT_DIR)
+endif()
+
+mark_as_advanced(UDEV_INCLUDE_DIR
+        UDEV_LIBRARY)

cmake/packaging.cmake

@@ -0,0 +1,90 @@
+# these are cache variables, so they could be overwritten with -D,
+
+set(CPACK_PACKAGE_NAME "${PROJECT_NAME}"
+    CACHE STRING "The resulting package name"
+)
+
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Simple C++ application"
+    CACHE STRING "Package description for the package metadata"
+)
+set(CPACK_PACKAGE_VENDOR "Some Company")
+
+set(CPACK_VERBATIM_VARIABLES YES)
+
+set(CPACK_PACKAGE_INSTALL_DIRECTORY ${CPACK_PACKAGE_NAME})
+SET(CPACK_OUTPUT_FILE_PREFIX "${CMAKE_SOURCE_DIR}/_packages")
+
+set(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
+set(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR})
+set(CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH})
+set(CPACK_PACKAGE_VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}")
+
+set(CPACK_PACKAGE_CONTACT "YOUR@E-MAIL.net")
+set(CPACK_DEBIAN_PACKAGE_MAINTAINER "YOUR NAME")
+
+set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.md")
+set(CPACK_RESOURCE_FILE_README "${CMAKE_SOURCE_DIR}/README.md")
+
+if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+set(CPACK_SYSTEM_NAME ${LSB_RELEASE_CODENAME_SHORT})
+# package name for deb
+# if set, then instead of some-application-0.9.2-Linux.deb
+# you'll get some-application_0.9.2_amd64.deb (note the underscores too)
+#set(CPACK_DEBIAN_FILE_NAME DEB-DEFAULT)
+execute_process(COMMAND dpkg --print-architecture OUTPUT_VARIABLE ARCHITECTURE OUTPUT_STRIP_TRAILING_WHITESPACE)
+set( CPACK_DEBIAN_FILE_NAME ${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${CPACK_SYSTEM_NAME}-${ARCHITECTURE}.deb )
+# if you want every group to have its own package,
+# although the same happens if this is not sent (so it defaults to ONE_PER_GROUP)
+# and CPACK_DEB_COMPONENT_INSTALL is set to YES
+set(CPACK_COMPONENTS_GROUPING ALL_COMPONENTS_IN_ONE)#ONE_PER_GROUP)
+# without this you won't be able to pack only specified component
+set(CPACK_DEB_COMPONENT_INSTALL YES)
+
+set(CPACK_EXTERNAL_ENABLE_STAGING YES)
+set(CPACK_EXTERNAL_PACKAGE_SCRIPT "${PROJECT_BINARY_DIR}/appimage-generate.cmake")
+
+file(GENERATE
+  OUTPUT "${PROJECT_BINARY_DIR}/appimage-generate.cmake"
+  CONTENT [[
+include(CMakePrintHelpers)
+cmake_print_variables(CPACK_TEMPORARY_DIRECTORY)
+cmake_print_variables(CPACK_TOPLEVEL_DIRECTORY)
+cmake_print_variables(CPACK_PACKAGE_DIRECTORY)
+cmake_print_variables(CPACK_PACKAGE_FILE_NAME)
+
+find_program(LINUXDEPLOY_EXECUTABLE
+  NAMES linuxdeploy linuxdeploy-x86_64.AppImage
+  PATHS ${CPACK_PACKAGE_DIRECTORY}/linuxdeploy)
+
+if (NOT LINUXDEPLOY_EXECUTABLE)
+  message(STATUS "Downloading linuxdeploy")
+  set(LINUXDEPLOY_EXECUTABLE ${CPACK_PACKAGE_DIRECTORY}/linuxdeploy/linuxdeploy)
+  file(DOWNLOAD 
+      https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage
+      ${LINUXDEPLOY_EXECUTABLE}
+      INACTIVITY_TIMEOUT 10
+      LOG ${CPACK_PACKAGE_DIRECTORY}/linuxdeploy/download.log
+      STATUS LINUXDEPLOY_DOWNLOAD)
+  execute_process(COMMAND chmod +x ${LINUXDEPLOY_EXECUTABLE} COMMAND_ECHO STDOUT)
+endif()
+
+execute_process(
+  COMMAND
+    ${CMAKE_COMMAND} -E env
+      OUTPUT=${CPACK_PACKAGE_FILE_NAME}.appimage
+      VERSION=$<IF:$<BOOL:${CPACK_PACKAGE_VERSION}>,${CPACK_PACKAGE_VERSION},0.1.0>
+      NO_STRIP=true
+    ${LINUXDEPLOY_EXECUTABLE}
+    --appimage-extract-and-run
+    --appdir=${CPACK_TEMPORARY_DIRECTORY}
+    --executable=$<TARGET_FILE:Starship>
+    $<$<BOOL:$<TARGET_PROPERTY:Starship,APPIMAGE_DESKTOP_FILE>>:--desktop-file=$<TARGET_PROPERTY:Starship,APPIMAGE_DESKTOP_FILE>>
+    $<$<BOOL:$<TARGET_PROPERTY:Starship,APPIMAGE_ICON_FILE>>:--icon-file=$<TARGET_PROPERTY:Starship,APPIMAGE_ICON_FILE>>
+    --output=appimage
+    --verbosity=2
+)
+]])
+
+endif()
+
+include(CPack)

cmake/toolchain-x86_64-w64-mingw32.cmake

@@ -0,0 +1,26 @@
+set (CMAKE_SYSTEM_NAME Windows)
+set(CMAKE_SYSTEM_PROCESSOR x86_64)
+
+# specify the cross compiler
+set (CMAKE_C_COMPILER x86_64-w64-mingw32-gcc CACHE STRING "The C compiler to use")
+set (CMAKE_CXX_COMPILER x86_64-w64-mingw32-g++ CACHE STRING "The C++ compiler to use")
+
+# where is the target environment
+set (CMAKE_FIND_ROOT_PATH /usr/x86_64-w64-mingw32)
+
+# search for programs in the build host directories
+set (CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+# for libraries and headers in the target directories
+set (CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set (CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set (CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+
+# set the resource compiler (RHBZ #652435)
+set (CMAKE_RC_COMPILER windres)
+set (CMAKE_MC_COMPILER windmc)
+
+# override boost thread component suffix as mingw-w64-boost is compiled with threadapi=win32
+set (Boost_THREADAPI win32)
+
+set (CMAKE_AR:FILEPATH x86_64-w64-mingw32-ar)
+set (CMAKE_RANLIB:FILEPATH x86_64-w64-mingw32-ranlib)