From 6aaedb813fa11ba0679c3051bc2eb28646b9506c Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 30 Aug 2025 16:53:58 -0700 Subject: Update to SDL3 --- src/contrib/SDL-3.2.20/CMakeLists.txt | 3812 +++++++++++++++++++++++++++++++++ 1 file changed, 3812 insertions(+) create mode 100644 src/contrib/SDL-3.2.20/CMakeLists.txt (limited to 'src/contrib/SDL-3.2.20/CMakeLists.txt') diff --git a/src/contrib/SDL-3.2.20/CMakeLists.txt b/src/contrib/SDL-3.2.20/CMakeLists.txt new file mode 100644 index 0000000..5873957 --- /dev/null +++ b/src/contrib/SDL-3.2.20/CMakeLists.txt @@ -0,0 +1,3812 @@ +cmake_minimum_required(VERSION 3.16) + +if(NOT DEFINED CMAKE_BUILD_TYPE) + set(cmake_build_type_undefined 1) +endif() + +# See docs/release_checklist.md +project(SDL3 LANGUAGES C VERSION "3.2.20") + +if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR) + set(SDL3_MAINPROJECT ON) +else() + set(SDL3_MAINPROJECT OFF) +endif() + +# Add UTF-8 encoding support for MSVC compiler. +# This ensures that the MSVC compiler interprets source files as UTF-8 encoded, +# which is useful for projects containing non-ASCII characters in source files. +add_compile_options("$<$:/utf-8>") +add_compile_options("$<$:/utf-8>") + +# By default, configure SDL3 in RelWithDebInfo configuration +if(SDL3_MAINPROJECT) + get_property(is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) + if(is_multi_config) + # The first item in CMAKE_CONFIGURATION_TYPES is the default configuration + if(DEFINED CMAKE_CONFIGURATION_TYPES AND "RelWithDebInfo" IN_LIST CMAKE_CONFIGURATION_TYPES) + list(REMOVE_ITEM CMAKE_CONFIGURATION_TYPES "RelWithDebInfo") + list(INSERT CMAKE_CONFIGURATION_TYPES 0 "RelWithDebInfo") + set(CMAKE_CONFIGURATION_TYPES "${CMAKE_CONFIGURATION_TYPES}" CACHE STRING "CMake configuration types" FORCE) + endif() + else() + if(cmake_build_type_undefined) + set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING "CMake build type" FORCE) + endif() + endif() +endif() + +# CMake 3.0 expands the "if(${A})" in "set(OFF 1);set(A OFF);if(${A})" to "if(1)" +# CMake 3.24+ emits a warning when not set. +unset(OFF) +unset(ON) +if(POLICY CMP0054) + cmake_policy(SET CMP0054 NEW) +endif() + +include(CheckLibraryExists) +include(CheckIncludeFile) +include(CheckLanguage) +include(CheckSymbolExists) +include(CheckCSourceCompiles) +include(CheckCSourceRuns) +include(CheckCCompilerFlag) +include(CheckCXXCompilerFlag) +include(CheckStructHasMember) +include(CMakeDependentOption) +include(CMakeParseArguments) +include(CMakePushCheckState) +include(GNUInstallDirs) + +if(NOT DEFINED OpenGL_GL_PREFERENCE) + set(OpenGL_GL_PREFERENCE GLVND) +endif() + +find_package(PkgConfig) + +list(APPEND CMAKE_MODULE_PATH "${SDL3_SOURCE_DIR}/cmake") +include("${SDL3_SOURCE_DIR}/cmake/macros.cmake") +include("${SDL3_SOURCE_DIR}/cmake/sdlchecks.cmake") +include("${SDL3_SOURCE_DIR}/cmake/sdlcompilers.cmake") +include("${SDL3_SOURCE_DIR}/cmake/sdlcpu.cmake") +include("${SDL3_SOURCE_DIR}/cmake/sdlmanpages.cmake") +include("${SDL3_SOURCE_DIR}/cmake/sdlplatform.cmake") +include("${SDL3_SOURCE_DIR}/cmake/sdltargets.cmake") +include("${SDL3_SOURCE_DIR}/cmake/GetGitRevisionDescription.cmake") +include("${SDL3_SOURCE_DIR}/cmake/3rdparty.cmake") +include("${SDL3_SOURCE_DIR}/cmake/PreseedMSVCCache.cmake") +include("${SDL3_SOURCE_DIR}/cmake/PreseedEmscriptenCache.cmake") + +SDL_DetectCompiler() +SDL_DetectTargetCPUArchitectures(SDL_CPUS) + +# Increment this if there is an incompatible change - but if that happens, +# we should rename the library from SDL3 to SDL4, at which point this would +# reset to 0 anyway. +set(SDL_SO_VERSION_MAJOR "0") +set(SDL_SO_VERSION_MINOR "${PROJECT_VERSION_MINOR}") +set(SDL_SO_VERSION_PATCH "${PROJECT_VERSION_PATCH}") +set(SDL_SO_VERSION "${SDL_SO_VERSION_MAJOR}.${SDL_SO_VERSION_MINOR}.${SDL_SO_VERSION_PATCH}") + +if(PROJECT_VERSION_MINOR MATCHES "[02468]$") + math(EXPR SDL_DYLIB_COMPAT_VERSION_MAJOR "100 * ${PROJECT_VERSION_MINOR} + 1") + set(SDL_DYLIB_COMPAT_VERSION_MINOR "0") + math(EXPR SDL_DYLIB_CURRENT_VERSION_MAJOR "${SDL_DYLIB_COMPAT_VERSION_MAJOR}") + set(SDL_DYLIB_CURRENT_VERSION_MINOR "${PROJECT_VERSION_PATCH}") +else() + math(EXPR SDL_DYLIB_COMPAT_VERSION_MAJOR "100 * ${PROJECT_VERSION_MINOR} + ${PROJECT_VERSION_PATCH} + 1") + set(SDL_DYLIB_COMPAT_VERSION_MINOR "0") + math(EXPR SDL_DYLIB_CURRENT_VERSION_MAJOR "${SDL_DYLIB_COMPAT_VERSION_MAJOR}") + set(SDL_DYLIB_CURRENT_VERSION_MINOR "0") +endif() +set(SDL_DYLIB_CURRENT_VERSION_PATCH "0") +set(SDL_DYLIB_COMPAT_VERSION_PATCH "0") + +set(SDL_DYLIB_CURRENT_VERSION "${SDL_DYLIB_CURRENT_VERSION_MAJOR}.${SDL_DYLIB_CURRENT_VERSION_MINOR}.${SDL_DYLIB_CURRENT_VERSION_PATCH}") +set(SDL_DYLIB_COMPAT_VERSION "${SDL_DYLIB_COMPAT_VERSION_MAJOR}.${SDL_DYLIB_COMPAT_VERSION_MINOR}.${SDL_DYLIB_COMPAT_VERSION_PATCH}") + +message(DEBUG "SDL_SO_VERSION=${SDL_SO_VERSION} SDL_DYLIB_CURRENT_VERSION=${SDL_DYLIB_CURRENT_VERSION} SDL_DYLIB_COMPAT_VERSION=${SDL_DYLIB_COMPAT_VERSION}") + +set(SDL_FRAMEWORK_VERSION "A") + +set(SDL_CHECK_REQUIRED_INCLUDES "" CACHE STRING "Extra includes (for CMAKE_REQUIRED_INCLUDES)") +set(SDL_CHECK_REQUIRED_LINK_OPTIONS "" CACHE STRING "Extra link options (for CMAKE_REQUIRED_LINK_OPTIONS)") +mark_as_advanced(SDL_CHECK_REQUIRED_INCLUDES SDL_CHECK_REQUIRED_LINK_OPTIONS) + +string(APPEND CMAKE_REQUIRED_FLAGS " -D_GNU_SOURCE=1") +list(APPEND CMAKE_REQUIRED_INCLUDES ${SDL_CHECK_REQUIRED_INCLUDES}) +list(APPEND CMAKE_REQUIRED_LINK_OPTIONS ${SDL_CHECK_REQUIRED_LINK_OPTIONS}) + +# Get the platform +SDL_DetectCMakePlatform() + +# Don't mistake macOS for unix +if(UNIX AND NOT ANDROID AND NOT APPLE AND NOT RISCOS) + set(UNIX_SYS ON) +else() + set(UNIX_SYS OFF) +endif() + +if(UNIX OR APPLE) + set(UNIX_OR_MAC_SYS ON) +else() + set(UNIX_OR_MAC_SYS OFF) +endif() + +# Emscripten pthreads work, but you need to have a non-pthread fallback build +# for systems without support. It's not currently enough to not use +# pthread functions in a pthread-build; it won't start up on unsupported +# browsers. As such, you have to explicitly enable it on Emscripten builds +# for the time being. This default will change to ON once this becomes +# commonly supported in browsers or the Emscripten team makes a single +# binary work everywhere. +if (UNIX_OR_MAC_SYS AND NOT EMSCRIPTEN) + set(SDL_PTHREADS_DEFAULT ON) +else() + set(SDL_PTHREADS_DEFAULT OFF) +endif() + +if(UNIX_SYS OR ANDROID) + set(SDL_CLOCK_GETTIME_DEFAULT ON) +else() + set(SDL_CLOCK_GETTIME_DEFAULT OFF) +endif() + +# The hidraw support doesn't catch Xbox, PS4 and Nintendo controllers, +# so we'll just use libusb when it's available. libusb does not support iOS, +# so we default to yes on iOS. +if(IOS OR TVOS OR VISIONOS OR WATCHOS OR ANDROID) + set(SDL_HIDAPI_LIBUSB_AVAILABLE FALSE) +else() + set(SDL_HIDAPI_LIBUSB_AVAILABLE TRUE) +endif() + +set(SDL_ASSEMBLY_DEFAULT OFF) +if(USE_CLANG OR USE_GCC OR USE_INTELCC OR MSVC_VERSION GREATER 1400) + set(SDL_ASSEMBLY_DEFAULT ON) +endif() + +set(SDL_GCC_ATOMICS_DEFAULT OFF) +if(USE_GCC OR USE_CLANG OR USE_INTELCC OR USE_QCC) + set(SDL_GCC_ATOMICS_DEFAULT ON) +endif() + +# Default option knobs +set(SDL_LIBC_DEFAULT ON) +set(SDL_SYSTEM_ICONV_DEFAULT ON) +if(WINDOWS OR MACOS OR IOS OR TVOS OR VISIONOS OR WATCHOS) + set(SDL_SYSTEM_ICONV_DEFAULT OFF) +endif() + +set(SDL_RELOCATABLE_DEFAULT OFF) +if(MSVC) + set(SDL_RELOCATABLE_DEFAULT ON) +endif() + +if(MSVC) + if(NOT SDL_LIBC) + # Make sure /RTC1 is disabled, otherwise it will use functions from the CRT + foreach(flag_var + CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE + CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO + CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE + CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO) + string(REGEX REPLACE "/RTC(su|[1su])" "" ${flag_var} "${${flag_var}}") + endforeach(flag_var) + set(CMAKE_MSVC_RUNTIME_CHECKS "") + endif() + + if(MSVC_CLANG) + # clang-cl treats /W4 as '-Wall -Wextra' -- we don't need -Wextra + foreach(flag_var + CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE + CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO) + string(REGEX REPLACE "/W4" "/W3" ${flag_var} "${${flag_var}}") + endforeach(flag_var) + endif() +endif() + +set(SDL_SHARED_DEFAULT ON) +set(SDL_STATIC_DEFAULT ON) + +set(SDL_SHARED_AVAILABLE ON) +set(SDL_STATIC_AVAILABLE ON) + +# All these *_DEFAULT vars will default to ON if not specified, +# so you only need to override them if they need to be disabled. +if(EMSCRIPTEN) + # Set up default values for the currently supported set of subsystems: + # Emscripten/Javascript does not have assembly support, a dynamic library + # loading architecture, or low-level CPU inspection. + set(SDL_ASSEMBLY_DEFAULT OFF) + set(SDL_SHARED_AVAILABLE OFF) +endif() + +if(VITA OR PSP OR PS2 OR N3DS OR RISCOS) + set(SDL_SHARED_AVAILABLE OFF) +endif() + +if((RISCOS OR UNIX_SYS) AND NOT (LINUX OR NETBSD OR OPENBSD)) + set(SDL_OSS_DEFAULT ON) +else() + set(SDL_OSS_DEFAULT OFF) +endif() + +if(SDL_SHARED_DEFAULT AND SDL_STATIC_DEFAULT AND SDL_SHARED_AVAILABLE) + if(DEFINED BUILD_SHARED_LIBS) + # When defined, use BUILD_SHARED_LIBS as default + if(BUILD_SHARED_LIBS) + set(SDL_STATIC_DEFAULT OFF) + else() + set(SDL_SHARED_DEFAULT OFF) + endif() + else() + # Default to just building the shared library + set(SDL_STATIC_DEFAULT OFF) + endif() +endif() + +dep_option(SDL_DEPS_SHARED "Load dependencies dynamically" ON SDL_SHARED_AVAILABLE OFF) + +set(SDL_SUBSYSTEMS ) + +macro(define_sdl_subsystem _name) + cmake_parse_arguments("_ds" "" "" "DEPS" ${ARGN}) + string(TOUPPER ${_name} _uname) + if(NOT DEFINED SDL_${_uname}_DEFAULT) + set(SDL_${_uname}_DEFAULT ON) + endif() + if(_ds_DEPS) + cmake_dependent_option(SDL_${_uname} "Enable the ${_name} subsystem" "${SDL_${_uname}_DEFAULT}" "${_ds_DEPS}" OFF) + else() + option(SDL_${_uname} "Enable the ${_name} subsystem" "${SDL_${_uname}_DEFAULT}") + endif() + list(APPEND SDL_SUBSYSTEMS "${_name}") +endmacro() + +define_sdl_subsystem(Audio) +define_sdl_subsystem(Video) +define_sdl_subsystem(GPU DEPS SDL_VIDEO) +define_sdl_subsystem(Render DEPS SDL_VIDEO) +define_sdl_subsystem(Camera DEPS SDL_VIDEO) +define_sdl_subsystem(Joystick) +define_sdl_subsystem(Haptic) +define_sdl_subsystem(Hidapi) +define_sdl_subsystem(Power) +define_sdl_subsystem(Sensor) +define_sdl_subsystem(Dialog) + +cmake_dependent_option(SDL_FRAMEWORK "Build SDL libraries as Apple Framework" OFF "APPLE" OFF) +if(SDL_FRAMEWORK) + set(SDL_STATIC_AVAILABLE FALSE) +endif() + +if(UNIX AND NOT ANDROID AND NOT RISCOS AND NOT SDL_FRAMEWORK) + set(SDL_RPATH_DEFAULT ON) +else() + set(SDL_RPATH_DEFAULT OFF) +endif() + +set(SDL_PRESEED_AVAILABLE OFF) +if(COMMAND SDL_Preseed_CMakeCache) + set(SDL_PRESEED_AVAILABLE ON) +endif() + +set(SDL_X11_XRANDR_DEFAULT ON) +if(SOLARIS) + set(SDL_X11_XRANDR_DEFAULT OFF) +endif() + +# Allow some projects to be built conditionally. +set_option(SDL_INSTALL "Enable installation of SDL3" ${SDL3_MAINPROJECT}) +cmake_dependent_option(SDL_INSTALL_CPACK "Create binary SDL3 archive using CPack" ${SDL3_MAINPROJECT} "SDL_INSTALL" ON) +cmake_dependent_option(SDL_INSTALL_DOCS "Install docs for SDL3" OFF "SDL_INSTALL;NOT SDL_FRAMEWORK" ON) +set_option(SDL_UNINSTALL "Enable uninstallation of SDL3" ${SDL3_MAINPROJECT}) +cmake_dependent_option(SDL_PRESEED "Preseed CMake cache to speed up configuration" ON "${SDL_PRESEED_AVAILABLE}" OFF) +cmake_dependent_option(SDL_RELOCATABLE "Create relocatable SDL package" ${SDL_RELOCATABLE_DEFAULT} "SDL_INSTALL" OFF) + +cmake_dependent_option(SDL_ANDROID_JAR "Enable creation of SDL3.jar" ${SDL3_MAINPROJECT} "ANDROID" ON) + +option_string(SDL_ASSERTIONS "Enable internal sanity checks (auto/disabled/release/enabled/paranoid)" "auto") +set_option(SDL_ASSEMBLY "Enable assembly routines" ${SDL_ASSEMBLY_DEFAULT}) +dep_option(SDL_AVX "Use AVX assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF) +dep_option(SDL_AVX2 "Use AVX2 assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF) +dep_option(SDL_AVX512F "Use AVX512F assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF) +dep_option(SDL_SSE "Use SSE assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF) +dep_option(SDL_SSE2 "Use SSE2 assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF) +dep_option(SDL_SSE3 "Use SSE3 assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF) +dep_option(SDL_SSE4_1 "Use SSE4.1 assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF) +dep_option(SDL_SSE4_2 "Use SSE4.2 assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF) +dep_option(SDL_MMX "Use MMX assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF) +dep_option(SDL_ALTIVEC "Use Altivec assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_POWERPC32 OR SDL_CPU_POWERPC64" OFF) +dep_option(SDL_ARMNEON "Use NEON assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_ARM32 OR SDL_CPU_ARM64" OFF) +dep_option(SDL_LSX "Use LSX assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_LOONGARCH64" OFF) +dep_option(SDL_LASX "Use LASX assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_LOONGARCH64" OFF) + +set_option(SDL_LIBC "Use the system C library" ${SDL_LIBC_DEFAULT}) +set_option(SDL_SYSTEM_ICONV "Use iconv() from system-installed libraries" ${SDL_SYSTEM_ICONV_DEFAULT}) +set_option(SDL_LIBICONV "Prefer iconv() from libiconv, if available, over libc version" OFF) +set_option(SDL_GCC_ATOMICS "Use gcc builtin atomics" ${SDL_GCC_ATOMICS_DEFAULT}) +dep_option(SDL_DBUS "Enable D-Bus support" ON "${UNIX_SYS}" OFF) +dep_option(SDL_LIBURING "Enable liburing support" ON "${UNIX_SYS}" OFF) +dep_option(SDL_DISKAUDIO "Support the disk writer audio driver" ON "SDL_AUDIO" OFF) +dep_option(SDL_DUMMYAUDIO "Support the dummy audio driver" ON "SDL_AUDIO" OFF) +dep_option(SDL_DUMMYVIDEO "Use dummy video driver" ON "SDL_VIDEO" OFF) +dep_option(SDL_IBUS "Enable IBus support" ON "${UNIX_SYS}" OFF) +dep_option(SDL_OPENGL "Include OpenGL support" ON "SDL_VIDEO;NOT IOS;NOT VISIONOS;NOT TVOS;NOT WATCHOS" OFF) +dep_option(SDL_OPENGLES "Include OpenGL ES support" ON "SDL_VIDEO;NOT VISIONOS;NOT TVOS;NOT WATCHOS" OFF) +set_option(SDL_PTHREADS "Use POSIX threads for multi-threading" ${SDL_PTHREADS_DEFAULT}) +dep_option(SDL_PTHREADS_SEM "Use pthread semaphores" ON "SDL_PTHREADS" OFF) +dep_option(SDL_OSS "Support the OSS audio API" ${SDL_OSS_DEFAULT} "UNIX_SYS OR RISCOS;SDL_AUDIO" OFF) +dep_option(SDL_ALSA "Support the ALSA audio API" ${UNIX_SYS} "SDL_AUDIO" OFF) +dep_option(SDL_ALSA_SHARED "Dynamically load ALSA audio support" ON "SDL_ALSA;SDL_DEPS_SHARED" OFF) +dep_option(SDL_JACK "Support the JACK audio API" ${UNIX_SYS} "SDL_AUDIO" OFF) +dep_option(SDL_JACK_SHARED "Dynamically load JACK audio support" ON "SDL_JACK;SDL_DEPS_SHARED" OFF) +set_option(SDL_PIPEWIRE "Use Pipewire audio" ${UNIX_SYS}) +dep_option(SDL_PIPEWIRE_SHARED "Dynamically load Pipewire support" ON "SDL_PIPEWIRE;SDL_DEPS_SHARED" OFF) +dep_option(SDL_PULSEAUDIO "Use PulseAudio" ${UNIX_SYS} "SDL_AUDIO" OFF) +dep_option(SDL_PULSEAUDIO_SHARED "Dynamically load PulseAudio support" ON "SDL_PULSEAUDIO;SDL_DEPS_SHARED" OFF) +dep_option(SDL_SNDIO "Support the sndio audio API" ${UNIX_SYS} "SDL_AUDIO" OFF) +dep_option(SDL_SNDIO_SHARED "Dynamically load the sndio audio API" ON "SDL_SNDIO;SDL_DEPS_SHARED" OFF) +set_option(SDL_RPATH "Use an rpath when linking SDL" ${SDL_RPATH_DEFAULT}) +set_option(SDL_CLOCK_GETTIME "Use clock_gettime() instead of gettimeofday()" ${SDL_CLOCK_GETTIME_DEFAULT}) +dep_option(SDL_X11 "Use X11 video driver" ${UNIX_SYS} "SDL_VIDEO" OFF) +dep_option(SDL_X11_SHARED "Dynamically load X11 support" ON "SDL_X11;SDL_DEPS_SHARED" OFF) +dep_option(SDL_X11_XCURSOR "Enable Xcursor support" ON SDL_X11 OFF) +dep_option(SDL_X11_XDBE "Enable Xdbe support" ON SDL_X11 OFF) +dep_option(SDL_X11_XINPUT "Enable XInput support" ON SDL_X11 OFF) +dep_option(SDL_X11_XFIXES "Enable Xfixes support" ON SDL_X11 OFF) +dep_option(SDL_X11_XRANDR "Enable Xrandr support" "${SDL_X11_XRANDR_DEFAULT}" SDL_X11 OFF) +dep_option(SDL_X11_XSCRNSAVER "Enable Xscrnsaver support" ON SDL_X11 OFF) +dep_option(SDL_X11_XSHAPE "Enable XShape support" ON SDL_X11 OFF) +dep_option(SDL_X11_XSYNC "Enable Xsync support" ON SDL_X11 OFF) +dep_option(SDL_WAYLAND "Use Wayland video driver" ${UNIX_SYS} "SDL_VIDEO" OFF) +dep_option(SDL_WAYLAND_SHARED "Dynamically load Wayland support" ON "SDL_WAYLAND;SDL_DEPS_SHARED" OFF) +dep_option(SDL_WAYLAND_LIBDECOR "Use client-side window decorations on Wayland" ON "SDL_WAYLAND" OFF) +dep_option(SDL_WAYLAND_LIBDECOR_SHARED "Dynamically load libdecor support" ON "SDL_WAYLAND_LIBDECOR;SDL_WAYLAND_SHARED;SDL_DEPS_SHARED" OFF) +dep_option(SDL_RPI "Use Raspberry Pi video driver" ON "SDL_VIDEO;UNIX_SYS;SDL_CPU_ARM32 OR SDL_CPU_ARM64" OFF) +dep_option(SDL_ROCKCHIP "Use ROCKCHIP Hardware Acceleration video driver" ON "SDL_VIDEO;UNIX_SYS;SDL_CPU_ARM32 OR SDL_CPU_ARM64" OFF) +dep_option(SDL_COCOA "Use Cocoa video driver" ON "APPLE" OFF) +dep_option(SDL_DIRECTX "Use DirectX for Windows audio/video" ON "SDL_AUDIO OR SDL_VIDEO;WINDOWS" OFF) +dep_option(SDL_XINPUT "Use Xinput for Windows" ON "WINDOWS" OFF) +dep_option(SDL_WASAPI "Use the Windows WASAPI audio driver" ON "WINDOWS;SDL_AUDIO" OFF) +dep_option(SDL_RENDER_D3D "Enable the Direct3D 9 render driver" ON "SDL_RENDER;SDL_DIRECTX" OFF) +dep_option(SDL_RENDER_D3D11 "Enable the Direct3D 11 render driver" ON "SDL_RENDER;SDL_DIRECTX" OFF) +dep_option(SDL_RENDER_D3D12 "Enable the Direct3D 12 render driver" ON "SDL_RENDER;SDL_DIRECTX" OFF) +dep_option(SDL_RENDER_METAL "Enable the Metal render driver" ON "SDL_RENDER;${APPLE}" OFF) +dep_option(SDL_RENDER_GPU "Enable the SDL_GPU render driver" ON "SDL_RENDER;SDL_GPU" OFF) +dep_option(SDL_VIVANTE "Use Vivante EGL video driver" ON "${UNIX_SYS};SDL_CPU_ARM32" OFF) +dep_option(SDL_VULKAN "Enable Vulkan support" ON "SDL_VIDEO;ANDROID OR APPLE OR LINUX OR FREEBSD OR WINDOWS" OFF) +dep_option(SDL_RENDER_VULKAN "Enable the Vulkan render driver" ON "SDL_RENDER;SDL_VULKAN" OFF) +dep_option(SDL_METAL "Enable Metal support" ON "APPLE" OFF) +set_option(SDL_OPENVR "Use OpenVR video driver" OFF) +dep_option(SDL_KMSDRM "Use KMS DRM video driver" ${UNIX_SYS} "SDL_VIDEO" OFF) +dep_option(SDL_KMSDRM_SHARED "Dynamically load KMS DRM support" ON "SDL_KMSDRM;SDL_DEPS_SHARED" OFF) +set_option(SDL_OFFSCREEN "Use offscreen video driver" ON) +dep_option(SDL_DUMMYCAMERA "Support the dummy camera driver" ON SDL_CAMERA OFF) +option_string(SDL_BACKGROUNDING_SIGNAL "number to use for magic backgrounding signal or 'OFF'" OFF) +option_string(SDL_FOREGROUNDING_SIGNAL "number to use for magic foregrounding signal or 'OFF'" OFF) +dep_option(SDL_HIDAPI "Enable the HIDAPI subsystem" ON "NOT VISIONOS" OFF) +dep_option(SDL_HIDAPI_LIBUSB "Use libusb for low level joystick drivers" ON SDL_HIDAPI_LIBUSB_AVAILABLE OFF) +dep_option(SDL_HIDAPI_LIBUSB_SHARED "Dynamically load libusb support" ON "SDL_HIDAPI_LIBUSB;SDL_DEPS_SHARED" OFF) +dep_option(SDL_HIDAPI_JOYSTICK "Use HIDAPI for low level joystick drivers" ON SDL_HIDAPI OFF) +dep_option(SDL_VIRTUAL_JOYSTICK "Enable the virtual-joystick driver" ON SDL_HIDAPI OFF) +set_option(SDL_LIBUDEV "Enable libudev support" ON) +set_option(SDL_ASAN "Use AddressSanitizer to detect memory errors" OFF) +set_option(SDL_CCACHE "Use Ccache to speed up build" OFF) +set_option(SDL_CLANG_TIDY "Run clang-tidy static analysis" OFF) +set_option(SDL_GPU_DXVK "Build SDL_GPU with DXVK support" OFF) + +set(SDL_VENDOR_INFO "" CACHE STRING "Vendor name and/or version to add to SDL_REVISION") + +cmake_dependent_option(SDL_SHARED "Build a shared version of the library" ${SDL_SHARED_DEFAULT} ${SDL_SHARED_AVAILABLE} OFF) +cmake_dependent_option(SDL_STATIC "Build a static version of the library" ${SDL_STATIC_DEFAULT} ${SDL_STATIC_AVAILABLE} OFF) +option(SDL_TEST_LIBRARY "Build the SDL3_test library" ON) + +dep_option(SDL_TESTS "Build the test directory" OFF SDL_TEST_LIBRARY OFF) +dep_option(SDL_INSTALL_TESTS "Install test-cases" OFF "SDL_INSTALL;NOT SDL_FRAMEWORK" OFF) +dep_option(SDL_TESTS_LINK_SHARED "link tests to shared SDL library" "${SDL_SHARED}" "SDL_SHARED;SDL_STATIC" "${SDL_SHARED}") +set(SDL_TESTS_TIMEOUT_MULTIPLIER "1" CACHE STRING "Timeout multiplier to account for really slow machines") + +set_option(SDL_EXAMPLES "Build the examples directory") +dep_option(SDL_EXAMPLES_LINK_SHARED "link examples to shared SDL library" "${SDL_SHARED}" "SDL_SHARED;SDL_STATIC" "${SDL_SHARED}") + +if(VITA) + set_option(VIDEO_VITA_PIB "Build with PSVita piglet gles2 support" OFF) + set_option(VIDEO_VITA_PVR "Build with PSVita PVR gles/gles2 support" OFF) +endif() + +if(NOT (SDL_SHARED OR SDL_STATIC)) + message(FATAL_ERROR "SDL_SHARED and SDL_STATIC cannot both be disabled") +endif() + +if(SDL_PRESEED) + SDL_Preseed_CMakeCache() +endif() + +if(SDL_SHARED) + add_library(SDL3-shared SHARED) + add_library(SDL3::SDL3-shared ALIAS SDL3-shared) + SDL_AddCommonCompilerFlags(SDL3-shared) + if ("c_std_99" IN_LIST CMAKE_C_COMPILE_FEATURES) + target_compile_features(SDL3-shared PRIVATE c_std_99) + else() + message(WARNING "target_compile_features does not know c_std_99 for C compiler") + endif() +endif() + +if(SDL_STATIC) + add_library(SDL3-static STATIC) + add_library(SDL3::SDL3-static ALIAS SDL3-static) + SDL_AddCommonCompilerFlags(SDL3-static) + if ("c_std_99" IN_LIST CMAKE_C_COMPILE_FEATURES) + target_compile_features(SDL3-static PRIVATE c_std_99) + else() + message(WARNING "target_compile_features does not know c_std_99 for C compiler") + endif() +endif() + +if(SDL_TEST_LIBRARY) + add_library(SDL3_test STATIC) + add_library(SDL3::SDL3_test ALIAS SDL3_test) + SDL_AddCommonCompilerFlags(SDL3_test) +endif() + +# Make sure SDL3::SDL3 always exists +if(TARGET SDL3::SDL3-shared) + add_library(SDL3::SDL3 ALIAS SDL3-shared) +else() + add_library(SDL3::SDL3 ALIAS SDL3-static) +endif() + +sdl_pc_link_options("-lSDL3") + +# Enable large file support on 32-bit glibc, so that we can access files +# with large inode numbers +check_symbol_exists("__GLIBC__" "stdlib.h" LIBC_IS_GLIBC) +if (LIBC_IS_GLIBC AND CMAKE_SIZEOF_VOID_P EQUAL 4) + # Enable large file support on 32-bit glibc, so that we can access files with large inode numbers + sdl_compile_definitions(PRIVATE "_FILE_OFFSET_BITS=64") + # Enable 64-bit time_t on 32-bit glibc, so that time stamps remain correct beyond January 2038 + sdl_compile_definitions(PRIVATE "_TIME_BITS=64") +endif() + +check_linker_supports_version_file(HAVE_WL_VERSION_SCRIPT) +if(HAVE_WL_VERSION_SCRIPT) + sdl_shared_link_options("-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/src/dynapi/SDL_dynapi.sym") +else() + if((LINUX AND LIBC_IS_GLIBC) OR ANDROID) + message(FATAL_ERROR "Linker does not support '-Wl,--version-script=xxx.sym'. This is required on the current host platform (${SDL_CMAKE_PLATFORM}).") + endif() +endif() + +if(CYGWIN) + # We build SDL on cygwin without the UNIX emulation layer + sdl_include_directories(PUBLIC SYSTEM "/usr/include/mingw") + cmake_push_check_state() + string(APPEND CMAKE_REQUIRED_FLAGS " -mno-cygwin") + check_c_source_compiles("int main(int argc, char **argv) { return 0; }" + HAVE_GCC_NO_CYGWIN) + cmake_pop_check_state() + if(HAVE_GCC_NO_CYGWIN) + sdl_shared_link_options("-mno-cygwin") + endif() +endif() + +# General includes +sdl_compile_definitions(PRIVATE "USING_GENERATED_CONFIG_H") +sdl_include_directories( + PRIVATE + "${SDL3_BINARY_DIR}/include-config-$>/build_config" + "${SDL3_BINARY_DIR}/include-revision" + "${SDL3_SOURCE_DIR}/include" +) +# Note: The clang toolset for Visual Studio does not support the '-idirafter' option. +if(USE_GCC OR USE_INTELCC OR (USE_CLANG AND NOT MSVC_CLANG)) + sdl_compile_options(NO_EXPORT PRIVATE "$") +else() + sdl_include_directories(NO_EXPORT SYSTEM PRIVATE "$") +endif() + +if(MSVC AND TARGET SDL3-shared AND NOT SDL_LIBC) + if(SDL_CPU_X64) + enable_language(ASM_MASM) + set(asm_src "${SDL3_SOURCE_DIR}/src/stdlib/SDL_mslibc_x64.masm") + target_compile_options(SDL3-shared PRIVATE "$<$:/nologo>") + set_property(SOURCE "${asm_src}" PROPERTY LANGUAGE "ASM_MASM") + target_sources(SDL3-shared PRIVATE "${asm_src}") + elseif(SDL_CPU_ARM64) + enable_language(ASM_MARMASM) + set(asm_src "${SDL3_SOURCE_DIR}/src/stdlib/SDL_mslibc_arm64.masm") + target_compile_options(SDL3-shared PRIVATE "$<$:/nologo>") + set_property(SOURCE "${asm_src}" PROPERTY LANGUAGE "ASM_MARMASM") + target_sources(SDL3-shared PRIVATE "${asm_src}") + elseif(SDL_CPU_ARM32) + # FIXME + endif() +endif() + +if(USE_INTELCC) + # warning #39: division by zero + # warning #239: floating point underflow + # warning #264: floating-point value does not fit in required floating-point type + set_property(SOURCE "${SDL3_SOURCE_DIR}/src/libm/e_exp.c" APPEND_STRING PROPERTY COMPILE_FLAGS " -wd239 -wd264") + set_property(SOURCE "${SDL3_SOURCE_DIR}/src/libm/e_log.c" APPEND_STRING PROPERTY COMPILE_FLAGS " -wd39") + set_property(SOURCE "${SDL3_SOURCE_DIR}/src/libm/e_log10.c" APPEND_STRING PROPERTY COMPILE_FLAGS " -wd39") + set_property(SOURCE + "${SDL3_SOURCE_DIR}/src/libm/e_exp.c" + "${SDL3_SOURCE_DIR}/src/libm/e_log.c" + "${SDL3_SOURCE_DIR}/src/libm/e_log10.c" + PROPERTY SKIP_PRECOMPILE_HEADERS 1) +endif() + +set(SDL_DEFAULT_ASSERT_LEVEL_CONFIGURED 1) +if(SDL_ASSERTIONS MATCHES "^(auto|)$") + # Do nada - use optimization settings to determine the assertion level + set(SDL_DEFAULT_ASSERT_LEVEL ) + set(SDL_DEFAULT_ASSERT_LEVEL_CONFIGURED 0) +elseif(SDL_ASSERTIONS MATCHES "^(disabled|0)$") + set(SDL_DEFAULT_ASSERT_LEVEL 0) +elseif(SDL_ASSERTIONS MATCHES "^(release|1)$") + set(SDL_DEFAULT_ASSERT_LEVEL 1) +elseif(SDL_ASSERTIONS MATCHES "^(enabled|2)$") + set(SDL_DEFAULT_ASSERT_LEVEL 2) +elseif(SDL_ASSERTIONS MATCHES "^(paranoid|3)$") + set(SDL_DEFAULT_ASSERT_LEVEL 3) +else() + message(FATAL_ERROR "unknown assertion level") +endif() +set(HAVE_ASSERTIONS ${SDL_ASSERTIONS}) + +if(NOT SDL_BACKGROUNDING_SIGNAL STREQUAL "OFF") + sdl_compile_definitions(PRIVATE "SDL_BACKGROUNDING_SIGNAL=${SDL_BACKGROUNDING_SIGNAL}") +endif() + +if(NOT SDL_FOREGROUNDING_SIGNAL STREQUAL "OFF") + sdl_compile_definitions(PRIVATE "SDL_FOREGROUNDING_SIGNAL=${SDL_FOREGROUNDING_SIGNAL}") +endif() + +# Compiler option evaluation +if(USE_GCC OR USE_CLANG OR USE_INTELCC OR USE_QCC) + if(SDL_GCC_ATOMICS) + check_c_source_compiles("int main(int argc, char **argv) { + int a; + void *x, *y, *z; + __sync_lock_test_and_set(&a, 4); + __sync_lock_test_and_set(&x, y); + __sync_fetch_and_add(&a, 1); + __sync_bool_compare_and_swap(&a, 5, 10); + __sync_bool_compare_and_swap(&x, y, z); + return 0; }" COMPILER_SUPPORTS_GCC_ATOMICS) + set(HAVE_GCC_ATOMICS ${COMPILER_SUPPORTS_GCC_ATOMICS}) + if(NOT HAVE_GCC_ATOMICS) + check_c_source_compiles("int main(int argc, char **argv) { + int a; + __sync_lock_test_and_set(&a, 1); + __sync_lock_release(&a); + return 0; }" COMPILER_SUPPORTS_SYNC_LOCK_TEST_AND_SET) + set(HAVE_GCC_SYNC_LOCK_TEST_AND_SET ${COMPILER_SUPPORTS_SYNC_LOCK_TEST_AND_SET}) + endif() + endif() + + cmake_push_check_state() + string(APPEND CMAKE_REQUIRED_FLAGS " -fvisibility=hidden -Werror") + check_c_source_compiles(" + #if !defined(__GNUC__) || __GNUC__ < 4 + #error SDL only uses visibility attributes in GCC 4 or newer + #endif + __attribute__((visibility(\"default\"))) int foo(void); + __attribute__((visibility(\"hidden\"))) int bar(void); + int foo(void) { return 0; } + int bar(void) { return 1; } + int main(void) { return 0; }" HAVE_GCC_FVISIBILITY) + cmake_pop_check_state() + + if(APPLE) + check_c_compiler_flag(-Wno-error=deprecated-declarations COMPILER_SUPPORTS_WNO_ERROR_DEPRECATED_DECLARATIONS) + if(COMPILER_SUPPORTS_WNO_ERROR_DEPRECATED_DECLARATIONS) + sdl_compile_options(PRIVATE "-Wno-error=deprecated-declarations") + endif() + endif() + + if(APPLE) + check_linker_flag(C "-Wl,-undefined,error" LINKER_SUPPORTS_WL_UNDEFINED_ERROR) + if(LINKER_SUPPORTS_WL_UNDEFINED_ERROR) + sdl_shared_link_options("-Wl,-undefined,error") + endif() + elseif(NOT OPENBSD) + cmake_push_check_state() + check_linker_flag(C "-Wl,--no-undefined" LINKER_SUPPORTS_WL_NO_UNDEFINED) + #FIXME: originally this if had an additional "AND NOT (USE_CLANG AND WINDOWS)" + if(LINKER_SUPPORTS_WL_NO_UNDEFINED) + sdl_shared_link_options("-Wl,--no-undefined") + endif() + endif() +endif() + +if(MSVC) + sdl_compile_definitions( + PRIVATE + "_CRT_SECURE_NO_DEPRECATE" + "_CRT_NONSTDC_NO_DEPRECATE" + "_CRT_SECURE_NO_WARNINGS" + ) + + # CET support was added in VS 2019 16.7 + if(MSVC_VERSION GREATER 1926 AND CMAKE_GENERATOR_PLATFORM MATCHES "Win32|x64") + # Mark SDL3.dll as compatible with Control-flow Enforcement Technology (CET) + sdl_shared_link_options("-CETCOMPAT") + endif() + + # for VS >= 17.14 targeting ARM64: inline the Interlocked funcs + if(MSVC_VERSION GREATER 1943 AND SDL_CPU_ARM64 AND NOT SDL_LIBC) + sdl_compile_options(PRIVATE "/forceInterlockedFunctions-") + endif() +endif() + +if(CMAKE_C_COMPILER_ID STREQUAL "MSVC") + # Due to a limitation of Microsoft's LTO implementation, LTO must be disabled for memcpy and memset. + # The same applies to various functions normally belonging in the C library (for x86 architecture). + set_property(SOURCE "${SDL3_SOURCE_DIR}/src/stdlib/SDL_mslibc.c" APPEND_STRING PROPERTY COMPILE_FLAGS " /GL-") +endif() + +if(SDL_ASSEMBLY) + set(HAVE_ASSEMBLY TRUE) + + if(SDL_MMX) + cmake_push_check_state() + if(USE_GCC OR USE_CLANG OR USE_INTELCC) + string(APPEND CMAKE_REQUIRED_FLAGS " -mmmx") + endif() + check_c_source_compiles(" + #include + void ints_add(int *dest, int *a, int *b, unsigned size) { + for (; size >= 2; size -= 2, dest += 2, a += 2, b += 2) { + *(__m64*)dest = _mm_add_pi32(*(__m64*)a, *(__m64*)b); + } + } + int main(int argc, char *argv[]) { + ints_add((int*)0, (int*)0, (int*)0, 0); + return 0; + }" COMPILER_SUPPORTS_MMX) + cmake_pop_check_state() + if(COMPILER_SUPPORTS_MMX) + set(HAVE_MMX TRUE) + endif() + endif() + if(SDL_SSE) + cmake_push_check_state() + if(USE_GCC OR USE_CLANG OR USE_INTELCC) + string(APPEND CMAKE_REQUIRED_FLAGS " -msse") + endif() + check_c_source_compiles(" + #include + void floats_add(float *dest, float *a, float *b, unsigned size) { + for (; size >= 4; size -= 4, dest += 4, a += 4, b += 4) { + _mm_storeu_ps(dest, _mm_add_ps(_mm_loadu_ps(a), _mm_loadu_ps (b))); + } + } + int main(int argc, char **argv) { + floats_add((float*)0, (float*)0, (float*)0, 0); + return 0; + }" COMPILER_SUPPORTS_SSE) + cmake_pop_check_state() + if(COMPILER_SUPPORTS_SSE) + set(HAVE_SSE TRUE) + endif() + endif() + if(SDL_SSE2) + cmake_push_check_state() + if(USE_GCC OR USE_CLANG OR USE_INTELCC) + string(APPEND CMAKE_REQUIRED_FLAGS " -msse2") + endif() + check_c_source_compiles(" + #include + void doubles_add(double *dest, double *a, double *b, unsigned size) { + for (; size >= 4; size -= 4, dest += 4, a += 4, b += 4) { + _mm_store_pd(dest, _mm_add_pd(_mm_loadu_pd(a), _mm_loadu_pd(b))); + } + } + int main(int argc, char **argv) { + doubles_add((double*)0, (double*)0, (double*)0, 0); + return 0; + }" COMPILER_SUPPORTS_SSE2) + cmake_pop_check_state() + if(COMPILER_SUPPORTS_SSE2) + set(HAVE_SSE2 TRUE) + endif() + endif() + if(SDL_SSE3) + cmake_push_check_state() + if(USE_GCC OR USE_CLANG OR USE_INTELCC) + string(APPEND CMAKE_REQUIRED_FLAGS " -msse3") + endif() + check_c_source_compiles(" + #include + void ints_add(int *dest, int *a, int *b, unsigned size) { + for (; size >= 4; size -= 4, dest += 4, a += 4, b += 4) { + _mm_storeu_si128((__m128i*)dest, _mm_add_epi32(_mm_lddqu_si128((__m128i*)a), _mm_lddqu_si128((__m128i*)b))); + } + } + int main(int argc, char **argv) { + ints_add((int*)0, (int*)0, (int*)0, 0); + return 0; + }" COMPILER_SUPPORTS_SSE3) + cmake_pop_check_state() + if(COMPILER_SUPPORTS_SSE3) + set(HAVE_SSE3 TRUE) + endif() + endif() + if(SDL_SSE4_1) + cmake_push_check_state() + if(USE_GCC OR USE_CLANG OR USE_INTELCC) + string(APPEND CMAKE_REQUIRED_FLAGS " -msse4.1") + endif() + check_c_source_compiles(" + #include + void ints_mul(int *dest, int *a, int *b, unsigned size) { + for (; size >= 4; size -= 4, dest += 4, a += 4, b += 4) { + _mm_storeu_si128((__m128i*)dest, _mm_mullo_epi32(_mm_lddqu_si128((__m128i*)a), _mm_lddqu_si128((__m128i*)b))); + } + } + int main(int argc, char **argv) { + ints_mul((int*)0, (int*)0, (int*)0, 0); + return 0; + }" COMPILER_SUPPORTS_SSE4_1) + cmake_pop_check_state() + if(COMPILER_SUPPORTS_SSE4_1) + set(HAVE_SSE4_1 TRUE) + endif() + endif() + if(SDL_SSE4_2) + cmake_push_check_state() + if(USE_GCC OR USE_CLANG OR USE_INTELCC) + string(APPEND CMAKE_REQUIRED_FLAGS " -msse4.2 -mcrc32") + endif() + check_c_source_compiles(" + #include + unsigned calc_crc32c(const char *text, unsigned len) { + unsigned crc32c = ~0; + for (; len >= 4; len -= 4, text += 4) { + crc32c = (unsigned)_mm_crc32_u32(crc32c, *(unsigned*)text); + } + return crc32c; + } + int main(int argc, char **argv) { + calc_crc32c(\"SDL_SSE4\",8); + return 0; + }" COMPILER_SUPPORTS_SSE4_2) + cmake_pop_check_state() + if(COMPILER_SUPPORTS_SSE4_2) + set(HAVE_SSE4_2 TRUE) + endif() + endif() + if(SDL_AVX) + cmake_push_check_state() + if(USE_GCC OR USE_CLANG OR USE_INTELCC) + string(APPEND CMAKE_REQUIRED_FLAGS " -mavx") + endif() + check_c_source_compiles(" + #include + void floats_add(float *dest, float *a, float *b, unsigned size) { + for (; size >= 8; size -= 8, dest += 8, a += 8, b += 8) { + _mm256_storeu_ps(dest, _mm256_add_ps(_mm256_loadu_ps(a), _mm256_loadu_ps(b))); + } + } + int main(int argc, char **argv) { + floats_add((float*)0, (float*)0, (float*)0, 0); + return 0; + }" COMPILER_SUPPORTS_AVX) + cmake_pop_check_state() + if(COMPILER_SUPPORTS_AVX) + set(HAVE_AVX TRUE) + endif() + endif() + if(SDL_AVX2) + cmake_push_check_state() + if(USE_GCC OR USE_CLANG OR USE_INTELCC) + string(APPEND CMAKE_REQUIRED_FLAGS " -mavx2") + endif() + check_c_source_compiles(" + #include + void ints_add(int *dest, int *a, int *b, unsigned size) { + for (; size >= 8; size -= 8, dest += 8, a += 8, b += 8) { + _mm256_storeu_si256((__m256i*)dest, _mm256_add_epi32(_mm256_loadu_si256((__m256i*)a), _mm256_loadu_si256((__m256i*)b))); + } + } + int main(int argc, char **argv) { + ints_add((int*)0, (int*)0, (int*)0, 0); + return 0; + }" COMPILER_SUPPORTS_AVX2) + cmake_pop_check_state() + if(COMPILER_SUPPORTS_AVX2) + set(HAVE_AVX2 TRUE) + endif() + endif() + if(SDL_AVX512F) + cmake_push_check_state() + if(USE_GCC OR USE_CLANG OR USE_INTELCC) + string(APPEND CMAKE_REQUIRED_FLAGS " -mavx512f") + endif() + check_c_source_compiles(" + #include + void floats_add(float *dest, float *a, float *b, unsigned size) { + for (; size >= 16; size -= 16, dest += 16, a += 16, b += 16) { + _mm512_storeu_ps(dest, _mm512_add_ps(_mm512_loadu_ps(a), _mm512_loadu_ps(b))); + } + } + int main(int argc, char **argv) { + floats_add((float*)0, (float*)0, (float*)0, 0); + return 0; + }" COMPILER_SUPPORTS_AVX512F) + cmake_pop_check_state() + if(COMPILER_SUPPORTS_AVX512F) + set(HAVE_AVX512F TRUE) + endif() + endif() + + if(SDL_ARMNEON) + check_c_source_compiles(" + #include + void floats_add(float *dest, float *a, float *b, unsigned size) { + for (; size >= 4; size -= 4, dest += 4, a += 4, b += 4) { + vst1q_f32(dest, vaddq_f32(vld1q_f32(a), vld1q_f32(b))); + } + } + int main(int argc, char *argv[]) { + floats_add((float*)0, (float*)0, (float*)0, 0); + return 0; + }" COMPILER_SUPPORTS_ARMNEON) + + if(COMPILER_SUPPORTS_ARMNEON) + set(HAVE_ARMNEON TRUE) + endif() + endif() + + if(USE_GCC OR USE_CLANG) + # TODO: Those all seem to be quite GCC specific - needs to be + # reworked for better compiler support + + if(SDL_ALTIVEC) + cmake_push_check_state() + string(APPEND CMAKE_REQUIRED_FLAGS " -maltivec") + check_c_source_compiles(" + #include + vector unsigned int vzero() { + return vec_splat_u32(0); + } + int main(int argc, char **argv) { return 0; }" COMPILER_SUPPORTS_ALTIVEC) + cmake_pop_check_state() + if(COMPILER_SUPPORTS_ALTIVEC) + set(HAVE_ALTIVEC TRUE) + set(SDL_ALTIVEC_BLITTERS 1) + sdl_compile_options(PRIVATE "-maltivec") + set_property(SOURCE "${SDL3_SOURCE_DIR}/src/video/SDL_blit_N.c" APPEND PROPERTY COMPILE_DEFINITIONS "SDL_ENABLE_ALTIVEC") + set_property(SOURCE "${SDL3_SOURCE_DIR}/src/video/SDL_blit_N.c" PROPERTY SKIP_PRECOMPILE_HEADERS 1) + endif() + endif() + + if(SDL_LSX) + cmake_push_check_state() + string(APPEND CMAKE_REQUIRED_FLAGS " -mlsx") + check_c_source_compiles(" + #ifndef __loongarch_sx + #error Assembler CPP flag not enabled + #endif + int main(int argc, char **argv) { return 0; }" COMPILER_SUPPORTS_LSX) + check_include_file("lsxintrin.h" HAVE_LSXINTRIN_H) + cmake_pop_check_state() + + if(COMPILER_SUPPORTS_LSX AND HAVE_LSXINTRIN_H) + set_property(SOURCE "${SDL3_SOURCE_DIR}/src/video/yuv2rgb/yuv_rgb_lsx.c" APPEND PROPERTY COMPILE_OPTIONS "-mlsx") + set(HAVE_LSX TRUE) + endif() + endif() + + if(SDL_LASX) + cmake_push_check_state() + string(APPEND CMAKE_REQUIRED_FLAGS " -mlasx") + check_c_source_compiles(" + #ifndef __loongarch_asx + #error Assembler CPP flag not enabled + #endif + int main(int argc, char **argv) { return 0; }" COMPILER_SUPPORTS_LASX) + check_include_file("lasxintrin.h" HAVE_LASXINTRIN_H) + cmake_pop_check_state() + if(COMPILER_SUPPORTS_LASX AND HAVE_LASXINTRIN_H) + set(HAVE_LASX TRUE) + endif() + endif() + endif() +endif() + +if(NOT HAVE_MMX) + set(SDL_DISABLE_MMX 1) +endif() + +if(NOT HAVE_SSE) + set(SDL_DISABLE_SSE 1) +endif() + +if(NOT HAVE_SSE2) + set(SDL_DISABLE_SSE2 1) +endif() + +if(NOT HAVE_SSE3) + set(SDL_DISABLE_SSE3 1) +endif() + +if(NOT HAVE_SSE4_1) + set(SDL_DISABLE_SSE4_1 1) +endif() + +if(NOT HAVE_SSE4_2) + set(SDL_DISABLE_SSE4_2 1) +endif() + +if(NOT HAVE_AVX) + set(SDL_DISABLE_AVX 1) +endif() + +if(NOT HAVE_AVX2) + set(SDL_DISABLE_AVX2 1) +endif() + +if(NOT HAVE_AVX512F) + set(SDL_DISABLE_AVX512F 1) +endif() + +if(NOT HAVE_LSX) + set(SDL_DISABLE_LSX 1) +endif() + +if(NOT HAVE_LASX) + set(SDL_DISABLE_LASX 1) +endif() + +if(NOT HAVE_ARMNEON) + set(SDL_DISABLE_NEON 1) +endif() + +set(SDL_DISABLE_ALLOCA 0) +check_include_file("alloca.h" "HAVE_ALLOCA_H") +if(MSVC) + check_include_file("malloc.h" "HAVE_MALLOC_H") + check_symbol_exists("_alloca" "malloc.h" _ALLOCA_IN_MALLOC_H) + if(NOT HAVE_ALLOCA_H AND NOT _ALLOCA_IN_MALLOC_H) + set(SDL_DISABLE_ALLOCA 1) + endif() +endif() + +# TODO: Can't deactivate on FreeBSD? w/o LIBC, SDL_stdinc.h can't define anything. +if(SDL_LIBC) + set(available_headers) + set(HAVE_LIBC TRUE) + set(headers_to_check + float.h + iconv.h + inttypes.h + limits.h + malloc.h + math.h + memory.h + signal.h + stdarg.h + stdbool.h + stddef.h + stdint.h + stdio.h + stdlib.h + string.h + strings.h + sys/types.h + time.h + wchar.h + ) + foreach(_HEADER IN LISTS headers_to_check) + string(TOUPPER "${_HEADER}" HEADER_IDENTIFIER) + string(REGEX REPLACE "[./]" "_" HEADER_IDENTIFIER "${HEADER_IDENTIFIER}") + set(LIBC_HAS_VAR "LIBC_HAS_${HEADER_IDENTIFIER}") + check_include_file("${_HEADER}" "${LIBC_HAS_VAR}") + set(HAVE_${HEADER_IDENTIFIER} ${${LIBC_HAS_VAR}}) + if(HAVE_${HEADER_IDENTIFIER}) + list(APPEND available_headers "${_HEADER}") + endif() + endforeach() + + set(symbols_to_check + abs acos acosf asin asinf atan atan2 atan2f atanf atof atoi + bcopy + ceil ceilf copysign copysignf cos cosf + _Exit exp expf + fabs fabsf floor floorf fmod fmodf fopen64 fseeko fseeko64 + getenv + _i64toa index itoa + log log10 log10f logf lround lroundf _ltoa + malloc memcmp memcpy memmove memset modf modff + pow powf putenv + rindex round roundf + scalbn scalbnf setenv sin sinf sqr sqrt sqrtf sscanf strchr + strcmp strlcat strlcpy strlen strncmp strnlen strpbrk + strrchr strstr strnstr strtod strtok_r strtol strtoll strtoul strtoull + tan tanf trunc truncf + unsetenv + vsnprintf vsscanf + wcsnlen wcscmp wcsdup wcslcat wcslcpy wcslen wcsncmp wcsstr wcstol + ) + if(WINDOWS) + list(APPEND symbols_to_check + _copysign _fseeki64 _strrev _ui64toa _uitoa _ultoa _wcsdup + ) + else() + list(APPEND symbols_to_check + strcasestr + ) + endif() + check_library_exists(m pow "" HAVE_LIBM) + cmake_push_check_state() + if(HAVE_LIBM) + sdl_link_dependency(math LIBS m) + list(APPEND CMAKE_REQUIRED_LIBRARIES m) + endif() + foreach(_FN IN LISTS symbols_to_check) + string(TOUPPER ${_FN} _UPPER) + set(LIBC_HAS_VAR "LIBC_HAS_${_UPPER}") + check_symbol_exists("${_FN}" "${available_headers}" ${LIBC_HAS_VAR}) + set(HAVE_${_UPPER} ${${LIBC_HAS_VAR}}) + endforeach() + cmake_pop_check_state() + + cmake_push_check_state() + if(MSVC) + string(APPEND CMAKE_REQUIRED_FLAGS " -we4244 -WX") # 'conversion' conversion from 'type1' to 'type2', possible loss of data + else() + string(APPEND CMAKE_REQUIRED_FLAGS " -Wfloat-conversion -Werror") + endif() + foreach(math_fn isinf isnan) + string(TOUPPER "${math_fn}" MATH_FN) + check_c_source_compiles(" + #include + int main() { + double d = 3.14159; + return ${math_fn}(d); + } + " LIBC_HAS_${MATH_FN}) + set(HAVE_${MATH_FN} ${LIBC_HAS_${MATH_FN}}) + + check_c_source_compiles(" + #include + int main() { + float f = 3.14159f; + return ${math_fn}(f); + } + " LIBC_${MATH_FN}_HANDLES_FLOAT) + set(HAVE_${MATH_FN}_FLOAT_MACRO ${LIBC_${MATH_FN}_HANDLES_FLOAT}) + + check_c_source_compiles(" + #include + int main() { + float f = 3.14159f; + return ${math_fn}f(f); + } + " LIBC_HAS_${MATH_FN}F) + set(HAVE_${MATH_FN}F "${LIBC_HAS_${MATH_FN}F}") + endforeach() + cmake_pop_check_state() + + if(NOT WINDOWS) + check_symbol_exists(fdatasync "unistd.h" HAVE_FDATASYNC) + check_symbol_exists(gethostname "unistd.h" HAVE_GETHOSTNAME) + check_symbol_exists(getpagesize "unistd.h" HAVE_GETPAGESIZE) + check_symbol_exists(sigaction "signal.h" HAVE_SIGACTION) + check_symbol_exists(setjmp "setjmp.h" HAVE_SETJMP) + check_symbol_exists(nanosleep "time.h" HAVE_NANOSLEEP) + check_symbol_exists(gmtime_r "time.h" HAVE_GMTIME_R) + check_symbol_exists(localtime_r "time.h" HAVE_LOCALTIME_R) + check_symbol_exists(nl_langinfo "langinfo.h" HAVE_NL_LANGINFO) + check_symbol_exists(sysconf "unistd.h" HAVE_SYSCONF) + check_symbol_exists(sysctlbyname "sys/types.h;sys/sysctl.h" HAVE_SYSCTLBYNAME) + check_symbol_exists(getauxval "sys/auxv.h" HAVE_GETAUXVAL) + check_symbol_exists(elf_aux_info "sys/auxv.h" HAVE_ELF_AUX_INFO) + check_symbol_exists(poll "poll.h" HAVE_POLL) + check_symbol_exists(memfd_create "sys/mman.h" HAVE_MEMFD_CREATE) + check_symbol_exists(posix_fallocate "fcntl.h" HAVE_POSIX_FALLOCATE) + + if(SDL_SYSTEM_ICONV) + check_c_source_compiles(" + #define LIBICONV_PLUG 1 /* in case libiconv header is in include path */ + #include + #include + int main(int argc, char **argv) { + return !iconv_open(NULL,NULL); + }" ICONV_IN_LIBC) + + cmake_push_check_state() + list(APPEND CMAKE_REQUIRED_LIBRARIES iconv) + check_c_source_compiles(" + #include + #include + int main(int argc, char **argv) { + return !iconv_open(NULL,NULL); + }" ICONV_IN_LIBICONV) + cmake_pop_check_state() + + if(ICONV_IN_LIBC OR ICONV_IN_LIBICONV) + set(HAVE_ICONV 1) + set(HAVE_SYSTEM_ICONV TRUE) + if(ICONV_IN_LIBICONV AND (SDL_LIBICONV OR (NOT ICONV_IN_LIBC))) + sdl_link_dependency(iconv LIBS iconv) + set(SDL_USE_LIBICONV 1) + set(HAVE_LIBICONV TRUE) + endif() + endif() + endif() + + check_struct_has_member("struct sigaction" "sa_sigaction" "signal.h" HAVE_SA_SIGACTION) + check_struct_has_member("struct stat" "st_mtim" "sys/stat.h" HAVE_ST_MTIM) + endif() +else() + set(headers + stdarg.h + stddef.h + stdint.h + ) + foreach(_HEADER ${headers}) + string(TOUPPER "${_HEADER}" HEADER_IDENTIFIER) + string(REGEX REPLACE "[./]" "_" HEADER_IDENTIFIER "${HEADER_IDENTIFIER}") + set(LIBC_HAS_VAR "LIBC_HAS_${HEADER_IDENTIFIER}") + check_include_file("${_HEADER}" "${LIBC_HAS_VAR}") + set(HAVE_${HEADER_IDENTIFIER} ${${LIBC_HAS_VAR}}) + endforeach() + + if(MSVC AND USE_CLANG) + check_c_compiler_flag("/Q_no-use-libirc" HAS_Q_NO_USE_LIBIRC) + endif() +endif() + +# General source files +sdl_glob_sources( + "${SDL3_SOURCE_DIR}/src/*.c" + "${SDL3_SOURCE_DIR}/src/atomic/*.c" + "${SDL3_SOURCE_DIR}/src/audio/*.c" + "${SDL3_SOURCE_DIR}/src/camera/*.c" + "${SDL3_SOURCE_DIR}/src/core/*.c" + "${SDL3_SOURCE_DIR}/src/cpuinfo/*.c" + "${SDL3_SOURCE_DIR}/src/dynapi/*.c" + "${SDL3_SOURCE_DIR}/src/events/*.c" + "${SDL3_SOURCE_DIR}/src/io/*.c" + "${SDL3_SOURCE_DIR}/src/io/generic/*.c" + "${SDL3_SOURCE_DIR}/src/filesystem/*.c" + "${SDL3_SOURCE_DIR}/src/gpu/*.c" + "${SDL3_SOURCE_DIR}/src/joystick/*.c" + "${SDL3_SOURCE_DIR}/src/haptic/*.c" + "${SDL3_SOURCE_DIR}/src/hidapi/*.c" + "${SDL3_SOURCE_DIR}/src/locale/*.c" + "${SDL3_SOURCE_DIR}/src/main/*.c" + "${SDL3_SOURCE_DIR}/src/misc/*.c" + "${SDL3_SOURCE_DIR}/src/power/*.c" + "${SDL3_SOURCE_DIR}/src/render/*.c" + "${SDL3_SOURCE_DIR}/src/render/*/*.c" + "${SDL3_SOURCE_DIR}/src/sensor/*.c" + "${SDL3_SOURCE_DIR}/src/stdlib/*.c" + "${SDL3_SOURCE_DIR}/src/storage/*.c" + "${SDL3_SOURCE_DIR}/src/thread/*.c" + "${SDL3_SOURCE_DIR}/src/time/*.c" + "${SDL3_SOURCE_DIR}/src/timer/*.c" + "${SDL3_SOURCE_DIR}/src/video/*.c" + "${SDL3_SOURCE_DIR}/src/video/yuv2rgb/*.c" +) + +# Build uclibc as a static library such that non-used symbols don't end up in the SDL3 shared library. +file(GLOB SDL_UCLIBC_SOURCES "${SDL3_SOURCE_DIR}/src/libm/*.c") +add_library(SDL_uclibc STATIC "${SDL_UCLIBC_SOURCES}") +target_compile_definitions(SDL_uclibc PRIVATE USING_GENERATED_CONFIG_H) +target_include_directories(SDL_uclibc PRIVATE "${SDL3_BINARY_DIR}/include-config-$>/build_config") +target_include_directories(SDL_uclibc PRIVATE "${SDL3_SOURCE_DIR}/src") +target_include_directories(SDL_uclibc PRIVATE "${SDL3_SOURCE_DIR}/include") +SDL_AddCommonCompilerFlags(SDL_uclibc) +sdl_sources(STATIC "$") +if(TARGET SDL3-shared) + target_link_libraries(SDL3-shared PRIVATE SDL_uclibc) +endif() +if(HAVE_GCC_FVISIBILITY) + set_property(TARGET SDL_uclibc PROPERTY C_VISIBILITY_PRESET "hidden") +endif() + +# Enable/disable various subsystems of the SDL library +foreach(_SUB ${SDL_SUBSYSTEMS}) + string(TOUPPER ${_SUB} _OPT) + if(NOT SDL_${_OPT}) + set(SDL_${_OPT}_DISABLED 1) + endif() +endforeach() +if(SDL_HAPTIC) + if(NOT SDL_JOYSTICK) + # Haptic requires some private functions from the joystick subsystem. + message(FATAL_ERROR "SDL_HAPTIC requires SDL_JOYSTICK, which is not enabled") + endif() +endif() + + +# General SDL subsystem options, valid for all platforms +if(SDL_AUDIO) + # CheckDummyAudio/CheckDiskAudio - valid for all platforms + if(SDL_DUMMYAUDIO) + set(SDL_AUDIO_DRIVER_DUMMY 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/audio/dummy/*.c") + set(HAVE_DUMMYAUDIO TRUE) + set(HAVE_SDL_AUDIO TRUE) + endif() + if(SDL_DISKAUDIO) + set(SDL_AUDIO_DRIVER_DISK 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/audio/disk/*.c") + set(HAVE_DISKAUDIO TRUE) + set(HAVE_SDL_AUDIO TRUE) + endif() +endif() + +if(SDL_CAMERA) + # CheckDummyCamera/CheckDiskCamera - valid for all platforms + if(SDL_DUMMYCAMERA) + set(SDL_CAMERA_DRIVER_DUMMY 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/camera/dummy/*.c") + set(HAVE_DUMMYCAMERA TRUE) + set(HAVE_SDL_CAMERA TRUE) + endif() + # !!! FIXME: for later. + #if(SDL_DISKCAMERA) + # set(SDL_CAMERA_DRIVER_DISK 1) + # sdl_glob_sources("${SDL3_SOURCE_DIR}/src/camera/disk/*.c") + # set(HAVE_DISKCAMERA TRUE) + # set(HAVE_SDL_CAMERA TRUE) + #endif() +endif() + +if(UNIX OR APPLE) + # Relevant for Unix/Darwin only + set(DYNAPI_NEEDS_DLOPEN 1) + CheckDLOPEN() + if(HAVE_DLOPEN) + set(SDL_LOADSO_DLOPEN 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/loadso/dlopen/*.c") + set(HAVE_SDL_LOADSO TRUE) + endif() +endif() + +if(UNIX OR APPLE OR HAIKU OR RISCOS) + CheckO_CLOEXEC() +endif() + +if(SDL_JOYSTICK) + if(SDL_VIRTUAL_JOYSTICK) + set(HAVE_VIRTUAL_JOYSTICK TRUE) + set(SDL_JOYSTICK_VIRTUAL 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/joystick/virtual/*.c") + endif() +endif() + +if(SDL_VIDEO) + if(SDL_DUMMYVIDEO) + set(SDL_VIDEO_DRIVER_DUMMY 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/video/dummy/*.c") + set(HAVE_DUMMYVIDEO TRUE) + set(HAVE_SDL_VIDEO TRUE) + endif() +endif() + +# Platform-specific options and settings +if(ANDROID) + list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake/android") + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/core/android/*.c") + sdl_sources("${CMAKE_ANDROID_NDK}/sources/android/cpufeatures/cpu-features.c") + set_property(SOURCE "${CMAKE_ANDROID_NDK}/sources/android/cpufeatures/cpu-features.c" APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-declaration-after-statement") + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/misc/android/*.c") + set(HAVE_SDL_MISC TRUE) + + # SDL_spinlock.c Needs to be compiled in ARM mode. + # There seems to be no better way currently to set the ARM mode. + # see: https://issuetracker.google.com/issues/62264618 + # Another option would be to set ARM mode to all compiled files + cmake_push_check_state() + string(APPEND CMAKE_REQUIRED_FLAGS " -Werror=unused-command-line-argument") + check_c_compiler_flag(-marm HAVE_ARM_MODE) + cmake_pop_check_state() + if(HAVE_ARM_MODE) + set_property(SOURCE "${SDL3_SOURCE_DIR}/src/atomic/SDL_spinlock.c" APPEND_STRING PROPERTY COMPILE_FLAGS " -marm") + set_source_files_properties(src/atomic/SDL_spinlock.c PROPERTIES SKIP_PRECOMPILE_HEADERS 1) + endif() + + if(SDL_AUDIO) + set(SDL_AUDIO_DRIVER_OPENSLES 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/audio/openslES/*.c") + + sdl_link_dependency(opensles LIBS ${ANDROID_DL_LIBRARY} OpenSLES) + + set(SDL_AUDIO_DRIVER_AAUDIO 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/audio/aaudio/*.c") + + set(HAVE_SDL_AUDIO TRUE) + endif() + + set(SDL_FILESYSTEM_ANDROID 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/filesystem/android/*.c") + set(HAVE_SDL_FILESYSTEM TRUE) + + set(SDL_FSOPS_POSIX 1) # !!! FIXME: this might need something else for .apk data? + sdl_sources("${SDL3_SOURCE_DIR}/src/filesystem/posix/SDL_sysfsops.c") + set(HAVE_SDL_FSOPS TRUE) + + if(SDL_HAPTIC) + set(SDL_HAPTIC_ANDROID 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/haptic/android/*.c") + set(HAVE_SDL_HAPTIC TRUE) + endif() + + CheckHIDAPI() + + if(SDL_JOYSTICK) + set(SDL_JOYSTICK_ANDROID 1) + sdl_glob_sources( + "${SDL3_SOURCE_DIR}/src/joystick/android/*.c" + ) + set(HAVE_SDL_JOYSTICK TRUE) + endif() + + set(SDL_LOADSO_DLOPEN 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/loadso/dlopen/*.c") + set(HAVE_SDL_LOADSO TRUE) + + if(SDL_POWER) + set(SDL_POWER_ANDROID 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/power/android/*.c") + set(HAVE_SDL_POWER TRUE) + endif() + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/locale/android/*.c") + set(HAVE_SDL_LOCALE TRUE) + + set(SDL_TIME_UNIX 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/time/unix/*.c") + set(HAVE_SDL_TIME TRUE) + + set(SDL_TIMER_UNIX 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/timer/unix/*.c") + set(HAVE_SDL_TIMERS TRUE) + + if(SDL_SENSOR) + set(SDL_SENSOR_ANDROID 1) + set(HAVE_SDL_SENSORS TRUE) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/sensor/android/*.c") + endif() + + if(SDL_CAMERA) + set(SDL_CAMERA_DRIVER_ANDROID 1) + set(HAVE_CAMERA TRUE) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/camera/android/*.c") + endif() + + if(SDL_VIDEO) + set(SDL_VIDEO_DRIVER_ANDROID 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/video/android/*.c") + set(HAVE_SDL_VIDEO TRUE) + + # Core stuff + # find_library(ANDROID_DL_LIBRARY dl) + # FIXME failing dlopen https://github.com/android-ndk/ndk/issues/929 + sdl_link_dependency(android_video LIBS dl log android) + sdl_compile_definitions(PRIVATE "GL_GLEXT_PROTOTYPES") + + #enable gles + if(SDL_OPENGLES) + set(SDL_VIDEO_OPENGL_EGL 1) + set(HAVE_OPENGLES TRUE) + set(SDL_VIDEO_OPENGL_ES 1) + set(SDL_VIDEO_OPENGL_ES2 1) + set(SDL_VIDEO_RENDER_OGL_ES2 1) + + sdl_link_dependency(opengles LIBS GLESv1_CM GLESv2) + endif() + + if(SDL_VULKAN) + check_c_source_compiles(" + #if defined(__ARM_ARCH) && __ARM_ARCH < 7 + #error Vulkan doesn't work on this configuration + #endif + int main(int argc, char **argv) { return 0; } + " VULKAN_PASSED_ANDROID_CHECKS) + if(VULKAN_PASSED_ANDROID_CHECKS) + set(SDL_VIDEO_VULKAN 1) + set(HAVE_VULKAN TRUE) + if(SDL_RENDER_VULKAN) + set(SDL_VIDEO_RENDER_VULKAN 1) + set(HAVE_RENDER_VULKAN TRUE) + endif() + endif() + endif() + endif() + + CheckPTHREAD() + if(SDL_CLOCK_GETTIME) + set(HAVE_CLOCK_GETTIME 1) + endif() + + if(SDL_ANDROID_JAR) + find_package(Java) + find_package(SdlAndroidPlatform MODULE) + + if(Java_FOUND AND SdlAndroidPlatform_FOUND AND NOT CMAKE_VERSION VERSION_LESS "3.19") + include(UseJava) + set(path_android_jar "${SDL_ANDROID_PLATFORM_ROOT}/android.jar") + set(android_java_sources_root "${SDL3_SOURCE_DIR}/android-project/app/src/main/java") + file(GLOB SDL_JAVA_SOURCES "${android_java_sources_root}/org/libsdl/app/*.java") + set(CMAKE_JAVA_COMPILE_FLAGS "-encoding;utf-8") + add_jar(SDL3-jar + SOURCES ${SDL_JAVA_SOURCES} + INCLUDE_JARS "${path_android_jar}" + OUTPUT_NAME "SDL3" + VERSION "${SDL3_VERSION}" + ) + set_property(TARGET SDL3-jar PROPERTY OUTPUT "${SDL3_BINARY_DIR}/SDL3-${SDL3_VERSION}.jar") + add_library(SDL3__Jar INTERFACE) + add_library(SDL3::Jar ALIAS SDL3__Jar) + get_property(sdl3_jar_location TARGET SDL3-jar PROPERTY JAR_FILE) + set_property(TARGET SDL3__Jar PROPERTY JAR_FILE "${sdl3_jar_location}") + set(javasourcesjar "${SDL3_BINARY_DIR}/SDL3-${SDL3_VERSION}-sources.jar") + string(REGEX REPLACE "${android_java_sources_root}/" "" sdl_relative_java_sources "${SDL_JAVA_SOURCES}") + add_custom_command( + OUTPUT "${javasourcesjar}" + COMMAND ${Java_JAR_EXECUTABLE} cf "${javasourcesjar}" ${sdl_relative_java_sources} + WORKING_DIRECTORY "${android_java_sources_root}" + DEPENDS ${SDL_JAVA_SOURCES} + ) + add_custom_target(SDL3-javasources ALL DEPENDS "${javasourcesjar}") + if(SDL_INSTALL_DOCS) + set(javadocdir "${SDL3_BINARY_DIR}/docs/javadoc") + set(javadocjar "${SDL3_BINARY_DIR}/SDL3-${SDL3_VERSION}-javadoc.jar") + set(javadoc_index_html "${javadocdir}/index.html") + add_custom_command( + OUTPUT "${javadoc_index_html}" + COMMAND ${CMAKE_COMMAND} -E rm -rf "${javadocdir}" "${javadocjar}" + COMMAND ${Java_JAVADOC_EXECUTABLE} -encoding utf8 -d "${javadocdir}" + -classpath "${path_android_jar}" + -author -use -version ${SDL_JAVA_SOURCES} + DEPENDS ${SDL_JAVA_SOURCES} "${path_android_jar}" + ) + add_custom_command( + OUTPUT "${javadocjar}" + COMMAND ${Java_JAR_EXECUTABLE} -c -f "${javadocjar}" + -C "${javadocdir}" * + WORKING_DIRECTORY "${javadocdir}" + DEPENDS ${javadoc_index_html} + ) + add_custom_target(SDL3-javadoc ALL DEPENDS "${javadoc_index_html}" "${javadocjar}") + set_property(TARGET SDL3-javadoc PROPERTY OUTPUT_DIR "${javadocdir}") + endif() + endif() + endif() + +if(TARGET SDL3-shared) + target_link_options(SDL3-shared PRIVATE "-Wl,-z,max-page-size=16384") + target_link_options(SDL3-shared PRIVATE "-Wl,-z,common-page-size=16384") +endif() + +elseif(EMSCRIPTEN) + # Hide noisy warnings that intend to aid mostly during initial stages of porting a new + # project. Uncomment at will for verbose cross-compiling -I/../ path info. + sdl_compile_options(PRIVATE "-Wno-warn-absolute-paths") + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/main/emscripten/*.c") + set(HAVE_SDL_MAIN_CALLBACKS TRUE) + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/misc/emscripten/*.c") + set(HAVE_SDL_MISC TRUE) + + if(SDL_AUDIO) + set(SDL_AUDIO_DRIVER_EMSCRIPTEN 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/audio/emscripten/*.c") + set(HAVE_SDL_AUDIO TRUE) + endif() + + set(SDL_FILESYSTEM_EMSCRIPTEN 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/filesystem/emscripten/*.c") + set(HAVE_SDL_FILESYSTEM TRUE) + + set(SDL_FSOPS_POSIX 1) + sdl_sources("${SDL3_SOURCE_DIR}/src/filesystem/posix/SDL_sysfsops.c") + set(HAVE_SDL_FSOPS TRUE) + + if(SDL_CAMERA) + set(SDL_CAMERA_DRIVER_EMSCRIPTEN 1) + set(HAVE_CAMERA TRUE) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/camera/emscripten/*.c") + endif() + + if(SDL_JOYSTICK) + set(SDL_JOYSTICK_EMSCRIPTEN 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/joystick/emscripten/*.c") + set(HAVE_SDL_JOYSTICK TRUE) + endif() + + if(SDL_POWER) + set(SDL_POWER_EMSCRIPTEN 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/power/emscripten/*.c") + set(HAVE_SDL_POWER TRUE) + endif() + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/locale/emscripten/*.c") + set(HAVE_SDL_LOCALE TRUE) + + set(SDL_TIME_UNIX 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/time/unix/*.c") + set(HAVE_SDL_TIME TRUE) + + set(SDL_TIMER_UNIX 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/timer/unix/*.c") + set(HAVE_SDL_TIMERS TRUE) + + if(SDL_CLOCK_GETTIME) + set(HAVE_CLOCK_GETTIME 1) + endif() + + if(SDL_VIDEO) + set(SDL_VIDEO_DRIVER_EMSCRIPTEN 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/video/emscripten/*.c") + set(HAVE_SDL_VIDEO TRUE) + + #enable gles + if(SDL_OPENGLES) + set(SDL_VIDEO_OPENGL_EGL 1) + set(HAVE_OPENGLES TRUE) + set(SDL_VIDEO_OPENGL_ES2 1) + set(SDL_VIDEO_RENDER_OGL_ES2 1) + endif() + endif() + + CheckPTHREAD() + CheckLibUnwind() + +elseif(UNIX AND NOT APPLE AND NOT RISCOS AND NOT HAIKU) + if(SDL_AUDIO) + if(NETBSD) + set(SDL_AUDIO_DRIVER_NETBSD 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/audio/netbsd/*.c") + set(HAVE_SDL_AUDIO TRUE) + elseif(QNX) + set(SDL_AUDIO_DRIVER_QNX 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/audio/qnx/*.c") + sdl_link_dependency(asound LIBS asound) + set(HAVE_SDL_AUDIO TRUE) + endif() + CheckOSS() + CheckALSA() + CheckJACK() + CheckPipewire() + CheckPulseAudio() + CheckSNDIO() + endif() + + if(SDL_VIDEO) + # Need to check for Raspberry PI first and add platform specific compiler flags, otherwise the test for GLES fails! + CheckRPI() + # Need to check for ROCKCHIP platform and get rid of "Can't window GBM/EGL surfaces on window creation." + CheckROCKCHIP() + CheckX11() + # Need to check for EGL first because KMSDRM and Wayland depend on it. + CheckEGL() + CheckKMSDRM() + CheckGLX() + CheckOpenGL() + CheckOpenGLES() + CheckWayland() + CheckOpenVR() + CheckVivante() + CheckVulkan() + CheckQNXScreen() + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/tray/unix/*.c") + set(HAVE_SDL_TRAY TRUE) + endif() + + if(UNIX) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/core/unix/*.c") + + check_c_source_compiles(" + #include + #ifndef EVIOCGNAME + #error EVIOCGNAME() ioctl not available + #endif + int main(int argc, char** argv) { return 0; }" HAVE_LINUX_INPUT_H) + + if(LINUX) + check_c_source_compiles(" + #include + #include + #include + int main(int argc, char **argv) { + struct kbentry kbe; + kbe.kb_table = KG_CTRL; + ioctl(0, KDGKBENT, &kbe); + return 0; + }" HAVE_INPUT_KD) + check_c_source_compiles(" + #include + int main(int argc, char** argv) { return 0; }" HAVE_LINUX_VIDEODEV2_H) + elseif(FREEBSD) + check_c_source_compiles(" + #include + #include + int main(int argc, char **argv) { + accentmap_t accTable; + ioctl(0, KDENABIO, 1); + return 0; + }" HAVE_INPUT_KBIO) + elseif(OPENBSD OR NETBSD) + check_c_source_compiles(" + #include + #include + #include + #include + #include + int main(int argc, char **argv) { + struct wskbd_map_data data; + ioctl(0, WSKBDIO_GETMAP, &data); + return 0; + }" HAVE_INPUT_WSCONS) + endif() + + if(SDL_CAMERA AND HAVE_LINUX_VIDEODEV2_H) + set(SDL_CAMERA_DRIVER_V4L2 1) + set(HAVE_CAMERA TRUE) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/camera/v4l2/*.c") + endif() + + if(HAVE_LINUX_INPUT_H) + set(SDL_INPUT_LINUXEV 1) + endif() + + if(SDL_HAPTIC AND HAVE_LINUX_INPUT_H) + set(SDL_HAPTIC_LINUX 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/haptic/linux/*.c") + set(HAVE_SDL_HAPTIC TRUE) + endif() + + if(HAVE_INPUT_KD) + set(SDL_INPUT_LINUXKD 1) + endif() + + if(HAVE_INPUT_KBIO) + set(SDL_INPUT_FBSDKBIO 1) + endif() + + if(HAVE_INPUT_WSCONS) + set(SDL_INPUT_WSCONS 1) + endif() + + CheckLibUDev() + check_include_file("sys/inotify.h" HAVE_SYS_INOTIFY_H) + check_symbol_exists(inotify_init "sys/inotify.h" HAVE_INOTIFY_INIT) + check_symbol_exists(inotify_init1 "sys/inotify.h" HAVE_INOTIFY_INIT1) + + if(HAVE_SYS_INOTIFY_H AND HAVE_INOTIFY_INIT) + set(HAVE_INOTIFY 1) + endif() + + if(PKG_CONFIG_FOUND) + if(SDL_DBUS) + pkg_search_module(DBUS dbus-1 dbus) + if(DBUS_FOUND) + set(HAVE_DBUS_DBUS_H TRUE) + sdl_include_directories(PRIVATE SYSTEM ${DBUS_INCLUDE_DIRS}) + # Fcitx need only dbus. + set(HAVE_FCITX TRUE) + set(HAVE_DBUS TRUE) + endif() + endif() + + if(SDL_IBUS) + pkg_search_module(IBUS ibus-1.0 ibus) + find_path(HAVE_SYS_INOTIFY_H NAMES sys/inotify.h) + if(IBUS_FOUND AND HAVE_SYS_INOTIFY_H) + set(HAVE_IBUS_IBUS_H TRUE) + sdl_include_directories(PRIVATE SYSTEM ${IBUS_INCLUDE_DIRS}) + set(HAVE_IBUS TRUE) + endif() + endif() + + if (HAVE_IBUS_IBUS_H OR HAVE_FCITX) + set(SDL_USE_IME 1) + endif() + + if(SDL_LIBURING) + pkg_search_module(LIBURING liburing-ffi) + find_path(HAVE_LIBURING_H NAMES liburing.h) + if(LIBURING_FOUND AND HAVE_LIBURING_H) + set(HAVE_LIBURING_LIBURING_H TRUE) + sdl_include_directories(PRIVATE SYSTEM ${LIBURING_INCLUDE_DIRS}) + set(HAVE_LIBURING TRUE) + endif() + endif() + + if((FREEBSD OR NETBSD) AND NOT HAVE_INOTIFY) + set(LibInotify_PKG_CONFIG_SPEC libinotify) + pkg_check_modules(PC_LIBINOTIFY IMPORTED_TARGET ${LibInotify_PKG_CONFIG_SPEC}) + if(PC_LIBINOTIFY_FOUND) + set(HAVE_INOTIFY 1) + sdl_link_dependency(libinotify LIBS PkgConfig::PC_LIBINOTIFY PKG_CONFIG_PREFIX PC_LIBINOTIFY PKG_CONFIG_SPECS ${LibInotify_PKG_CONFIG_SPEC}) + endif() + endif() + + CheckLibUnwind() + endif() + + if(HAVE_DBUS_DBUS_H) + sdl_sources( + "${SDL3_SOURCE_DIR}/src/core/linux/SDL_dbus.c" + "${SDL3_SOURCE_DIR}/src/core/linux/SDL_system_theme.c" + ) + endif() + + if(SDL_USE_IME) + sdl_sources("${SDL3_SOURCE_DIR}/src/core/linux/SDL_ime.c") + endif() + + if(HAVE_IBUS_IBUS_H) + sdl_sources("${SDL3_SOURCE_DIR}/src/core/linux/SDL_ibus.c") + endif() + + if(HAVE_FCITX) + sdl_sources("${SDL3_SOURCE_DIR}/src/core/linux/SDL_fcitx.c") + endif() + + if(HAVE_LIBUDEV_H) + sdl_sources("${SDL3_SOURCE_DIR}/src/core/linux/SDL_udev.c") + endif() + + if(HAVE_LINUX_INPUT_H) + sdl_sources( + "${SDL3_SOURCE_DIR}/src/core/linux/SDL_evdev.c" + "${SDL3_SOURCE_DIR}/src/core/linux/SDL_evdev_kbd.c" + ) + endif() + + if(HAVE_INPUT_KBIO) + sdl_sources("${SDL3_SOURCE_DIR}/src/core/freebsd/SDL_evdev_kbd_freebsd.c") + endif() + + if(HAVE_INPUT_WSCONS) + sdl_sources( + "${SDL3_SOURCE_DIR}/src/core/openbsd/SDL_wscons_kbd.c" + "${SDL3_SOURCE_DIR}/src/core/openbsd/SDL_wscons_mouse.c" + ) + endif() + + if(SDL_GPU AND SDL_GPU_DXVK) + if(PKG_CONFIG_FOUND) + pkg_search_module(DXVK_NATIVE dxvk-dxgi) + if(DXVK_NATIVE_FOUND) + set(HAVE_D3D11_H TRUE) + sdl_include_directories(PRIVATE SYSTEM ${DXVK_NATIVE_INCLUDE_DIRS}) + endif() + endif() + endif() + + if(HAVE_LIBURING_H) + sdl_sources("${SDL3_SOURCE_DIR}/src/io/io_uring/SDL_asyncio_liburing.c") + endif() + + # Always compiled for Linux, unconditionally: + sdl_sources( + "${SDL3_SOURCE_DIR}/src/core/linux/SDL_evdev_capabilities.c" + "${SDL3_SOURCE_DIR}/src/core/linux/SDL_threadprio.c" + ) + + # src/core/unix/*.c is included in a generic if(UNIX) section, elsewhere. + endif() + + if(SDL_HIDAPI) + CheckHIDAPI() + endif() + + if(SDL_JOYSTICK) + if(FREEBSD OR NETBSD OR OPENBSD OR BSDI) + CheckUSBHID() + endif() + if((LINUX OR FREEBSD) AND HAVE_LINUX_INPUT_H AND NOT ANDROID) + set(SDL_JOYSTICK_LINUX 1) + sdl_glob_sources( + "${SDL3_SOURCE_DIR}/src/joystick/linux/*.c" + ) + set(HAVE_SDL_JOYSTICK TRUE) + endif() + endif() + + CheckPTHREAD() + + if(SDL_CLOCK_GETTIME) + check_library_exists(c clock_gettime "" FOUND_CLOCK_GETTIME_LIBC) + if(FOUND_CLOCK_GETTIME_LIBC) + set(HAVE_CLOCK_GETTIME 1) + else() + check_library_exists(rt clock_gettime "" FOUND_CLOCK_GETTIME_LIBRT) + if(FOUND_CLOCK_GETTIME_LIBRT) + set(HAVE_CLOCK_GETTIME 1) + sdl_link_dependency(clock LIBS rt) + endif() + endif() + endif() + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/misc/unix/*.c") + set(HAVE_SDL_MISC TRUE) + + if(SDL_POWER) + if(LINUX) + set(SDL_POWER_LINUX 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/power/linux/*.c") + set(HAVE_SDL_POWER TRUE) + endif() + endif() + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/locale/unix/*.c") + set(HAVE_SDL_LOCALE TRUE) + + set(SDL_FILESYSTEM_UNIX 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/filesystem/unix/*.c") + set(HAVE_SDL_FILESYSTEM TRUE) + + set(SDL_STORAGE_GENERIC 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/storage/generic/*.c") + if(LINUX) + set(SDL_STORAGE_STEAM 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/storage/steam/*.c") + endif() + set(HAVE_SDL_STORAGE 1) + + set(SDL_FSOPS_POSIX 1) + sdl_sources("${SDL3_SOURCE_DIR}/src/filesystem/posix/SDL_sysfsops.c") + set(HAVE_SDL_FSOPS TRUE) + + set(SDL_TIME_UNIX 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/time/unix/*.c") + set(HAVE_SDL_TIME TRUE) + + set(SDL_TIMER_UNIX 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/timer/unix/*.c") + set(HAVE_SDL_TIMERS TRUE) + + set(SDL_RLD_FLAGS "") + if(SDL_RPATH AND SDL_SHARED) + if(BSDI OR FREEBSD OR LINUX OR NETBSD) + cmake_push_check_state() + string(APPEND CMAKE_REQUIRED_FLAGS " -Wl,--enable-new-dtags") + check_c_compiler_flag("" HAVE_ENABLE_NEW_DTAGS) + cmake_pop_check_state() + if(HAVE_ENABLE_NEW_DTAGS) + set(SDL_RLD_FLAGS "-Wl,-rpath,\${libdir} -Wl,--enable-new-dtags") + else() + set(SDL_RLD_FLAGS "-Wl,-rpath,\${libdir}") + endif() + set(HAVE_RPATH TRUE) + elseif(SOLARIS) + set(SDL_RLD_FLAGS "-R\${libdir}") + set(HAVE_RPATH TRUE) + endif() + endif() + + if(QNX) + # QNX's *printf() family generates a SIGSEGV if NULL is passed for a string + # specifier (on purpose), but SDL expects "(null)". Use the built-in + # implementation. + set (HAVE_VSNPRINTF 0) + set (USE_POSIX_SPAWN 1) + endif() +elseif(WINDOWS) + check_c_source_compiles(" + #include + int main(int argc, char **argv) { return 0; }" HAVE_WIN32_CC) + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/core/windows/*.c") + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/main/windows/*.c") + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/io/windows/*.c") + + if(TARGET SDL3-shared AND MSVC AND NOT SDL_LIBC) + # Prevent codegen that would use the VC runtime libraries. + target_compile_options(SDL3-shared PRIVATE $<$:/GS-> $<$:/Gs1048576>) + target_compile_options(SDL_uclibc PRIVATE $<$:/GS-> $<$:/Gs1048576>) + if(SDL_CPU_X86) + target_compile_options(SDL3-shared PRIVATE "/arch:SSE") + target_compile_options(SDL3-SDL_uclibc PRIVATE "/arch:SSE") + endif() + endif() + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/misc/windows/*.c") + + set(HAVE_SDL_MISC TRUE) + + # Check for DirectX + if(SDL_DIRECTX) + cmake_push_check_state() + if(DEFINED MSVC_VERSION AND NOT ${MSVC_VERSION} LESS 1700) + set(USE_WINSDK_DIRECTX TRUE) + endif() + if(NOT MINGW AND NOT USE_WINSDK_DIRECTX) + if("$ENV{DXSDK_DIR}" STREQUAL "") + message(FATAL_ERROR "DIRECTX requires the \$DXSDK_DIR environment variable to be set") + endif() + string(APPEND CMAKE_REQUIRED_FLAGS " /I\"$ENV{DXSDK_DIR}\\Include\"") + endif() + + check_include_file(d3d9.h HAVE_D3D9_H) + check_include_file(d3d11_1.h HAVE_D3D11_H) + check_include_file(ddraw.h HAVE_DDRAW_H) + check_include_file(dsound.h HAVE_DSOUND_H) + check_include_file(dinput.h HAVE_DINPUT_H) + if(SDL_CPU_ARM32) # !!! FIXME: this should probably check if we're !(x86 or x86-64) instead of arm. + set(HAVE_DINPUT_H 0) + endif() + check_include_file(dxgi.h HAVE_DXGI_H) + cmake_pop_check_state() + if(HAVE_D3D9_H OR HAVE_D3D11_H OR HAVE_DDRAW_H OR HAVE_DSOUND_H OR HAVE_DINPUT_H) + set(HAVE_DIRECTX TRUE) + if(NOT MINGW AND NOT USE_WINSDK_DIRECTX) + if(CMAKE_SIZEOF_VOID_P EQUAL 8) + set(PROCESSOR_ARCH "x64") + else() + set(PROCESSOR_ARCH "x86") + endif() + sdl_link_directories("$") + sdl_include_directories(PRIVATE SYSTEM "$") + endif() + endif() + endif() + + if(SDL_XINPUT) + # xinput.h may need windows.h, but does not include it itself. + check_c_source_compiles(" + #include + #include + int main(int argc, char **argv) { return 0; }" HAVE_XINPUT_H) + endif() + + # headers needed elsewhere + check_c_source_compiles(" + #define COBJMACROS + #include + static __x_ABI_CWindows_CGaming_CInput_CIGamepadStatics2 *s2; + int main(int argc, char **argv) { return 0; }" HAVE_WINDOWS_GAMING_INPUT_H + ) + check_c_source_compiles(" + #include + #define COBJMACROS + #include + int main(int argc, char **argv) { return 0; }" HAVE_GAMEINPUT_H + ) + check_include_file(dxgi1_6.h HAVE_DXGI1_6_H) + check_include_file(tpcshrd.h HAVE_TPCSHRD_H) + check_include_file(roapi.h HAVE_ROAPI_H) + check_include_file(mmdeviceapi.h HAVE_MMDEVICEAPI_H) + check_include_file(audioclient.h HAVE_AUDIOCLIENT_H) + check_include_file(sensorsapi.h HAVE_SENSORSAPI_H) + check_include_file(shellscalingapi.h HAVE_SHELLSCALINGAPI_H) + check_c_source_compiles(" + #include + #include + #include + #include + int main(int argc, char **argv) { return 0; } + " HAVE_MFAPI_H + ) + + if(SDL_AUDIO) + if(HAVE_DSOUND_H) + set(SDL_AUDIO_DRIVER_DSOUND 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/audio/directsound/*.c") + set(HAVE_SDL_AUDIO TRUE) + endif() + + if(SDL_WASAPI AND HAVE_AUDIOCLIENT_H AND HAVE_MMDEVICEAPI_H) + set(SDL_AUDIO_DRIVER_WASAPI 1) + set(HAVE_WASAPI TRUE) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/audio/wasapi/*.c") + set(HAVE_SDL_AUDIO TRUE) + endif() + endif() + + if(SDL_VIDEO) + set(SDL_VIDEO_DRIVER_WINDOWS 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/video/windows/*.c") + + CheckOpenVR() + + if(SDL_RENDER_D3D AND HAVE_D3D9_H) + set(SDL_VIDEO_RENDER_D3D 1) + set(HAVE_RENDER_D3D TRUE) + endif() + if(SDL_RENDER_D3D11 AND HAVE_D3D11_H) + set(SDL_VIDEO_RENDER_D3D11 1) + set(HAVE_RENDER_D3D11 TRUE) + endif() + if(SDL_RENDER_D3D12) + set(SDL_VIDEO_RENDER_D3D12 1) + set(HAVE_RENDER_D3D12 TRUE) + endif() + set(HAVE_SDL_VIDEO TRUE) + endif() + + set(SDL_THREAD_GENERIC_COND_SUFFIX 1) + set(SDL_THREAD_GENERIC_RWLOCK_SUFFIX 1) + set(SDL_THREAD_WINDOWS 1) + sdl_sources( + "${SDL3_SOURCE_DIR}/src/thread/generic/SDL_syscond.c" + "${SDL3_SOURCE_DIR}/src/thread/generic/SDL_sysrwlock.c" + "${SDL3_SOURCE_DIR}/src/thread/windows/SDL_syscond_cv.c" + "${SDL3_SOURCE_DIR}/src/thread/windows/SDL_sysmutex.c" + "${SDL3_SOURCE_DIR}/src/thread/windows/SDL_sysrwlock_srw.c" + "${SDL3_SOURCE_DIR}/src/thread/windows/SDL_syssem.c" + "${SDL3_SOURCE_DIR}/src/thread/windows/SDL_systhread.c" + "${SDL3_SOURCE_DIR}/src/thread/windows/SDL_systls.c" + ) + + set(HAVE_SDL_THREADS TRUE) + + if(SDL_SENSOR AND HAVE_SENSORSAPI_H) + set(SDL_SENSOR_WINDOWS 1) + set(HAVE_SDL_SENSORS TRUE) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/sensor/windows/*.c") + endif() + + if(SDL_POWER) + set(SDL_POWER_WINDOWS 1) + sdl_sources("${SDL3_SOURCE_DIR}/src/power/windows/SDL_syspower.c") + set(HAVE_SDL_POWER TRUE) + endif() + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/locale/windows/*.c") + set(HAVE_SDL_LOCALE TRUE) + + set(SDL_FILESYSTEM_WINDOWS 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/filesystem/windows/*.c") + set(HAVE_SDL_FILESYSTEM TRUE) + + set(SDL_FSOPS_WINDOWS 1) + set(HAVE_SDL_FSOPS TRUE) + + set(SDL_STORAGE_GENERIC 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/storage/generic/*.c") + set(SDL_STORAGE_STEAM 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/storage/steam/*.c") + set(HAVE_SDL_STORAGE 1) + + # Libraries for Win32 native and MinGW + sdl_link_dependency(base LIBS kernel32 user32 gdi32 winmm imm32 ole32 oleaut32 version uuid advapi32 setupapi shell32) + + set(SDL_TIME_WINDOWS 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/time/windows/*.c") + set(HAVE_SDL_TIME TRUE) + + set(SDL_TIMER_WINDOWS 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/timer/windows/*.c") + set(HAVE_SDL_TIMERS TRUE) + + set(SDL_LOADSO_WINDOWS 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/loadso/windows/*.c") + set(HAVE_SDL_LOADSO TRUE) + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/core/windows/*.c") + + if(SDL_VIDEO) + if(SDL_OPENGL) + set(SDL_VIDEO_OPENGL 1) + set(SDL_VIDEO_OPENGL_WGL 1) + set(SDL_VIDEO_RENDER_OGL 1) + set(HAVE_OPENGL TRUE) + endif() + + if(SDL_OPENGLES) + set(SDL_VIDEO_OPENGL_EGL 1) + set(SDL_VIDEO_OPENGL_ES2 1) + set(SDL_VIDEO_RENDER_OGL_ES2 1) + set(HAVE_OPENGLES TRUE) + endif() + + if(SDL_VULKAN) + set(SDL_VIDEO_VULKAN 1) + set(HAVE_VULKAN TRUE) + if(SDL_RENDER_VULKAN) + set(SDL_VIDEO_RENDER_VULKAN 1) + set(HAVE_RENDER_VULKAN TRUE) + endif() + endif() + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/tray/windows/*.c") + set(HAVE_SDL_TRAY TRUE) + endif() + + if(SDL_HIDAPI) + CheckHIDAPI() + endif() + + if(SDL_JOYSTICK) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/joystick/windows/*.c") + + set(SDL_JOYSTICK_RAWINPUT 1) + if(HAVE_DINPUT_H) + set(SDL_JOYSTICK_DINPUT 1) + sdl_link_dependency(joystick LIBS dinput8) + endif() + if(HAVE_XINPUT_H) + set(SDL_JOYSTICK_XINPUT 1) + set(HAVE_XINPUT TRUE) + endif() + if(HAVE_WINDOWS_GAMING_INPUT_H) + set(SDL_JOYSTICK_WGI 1) + endif() + if(HAVE_GAMEINPUT_H) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/joystick/gdk/*.c") + set(SDL_JOYSTICK_GAMEINPUT 1) + endif() + set(HAVE_SDL_JOYSTICK TRUE) + + if(SDL_HAPTIC) + if(HAVE_DINPUT_H) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/haptic/windows/*.c") + set(SDL_HAPTIC_DINPUT 1) + set(HAVE_SDL_HAPTIC TRUE) + endif() + endif() + endif() + + if(SDL_CAMERA) + if(HAVE_MFAPI_H) + set(HAVE_CAMERA TRUE) + set(SDL_CAMERA_DRIVER_MEDIAFOUNDATION 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/camera/mediafoundation/*.c") + endif() + endif() + + enable_language(RC) + sdl_glob_sources(SHARED "${SDL3_SOURCE_DIR}/src/core/windows/*.rc") + if(MINGW OR CYGWIN) + sdl_pc_link_options("-mwindows") + endif() + +elseif(APPLE) + # TODO: rework this all for proper macOS, iOS and Darwin support + + # !!! FIXME: all the `if(IOS OR TVOS OR VISIONOS)` checks should get merged into one variable, so we're ready for the next platform (or just WatchOS). + + # We always need these libs on macOS at the moment. + # !!! FIXME: we need Carbon for some very old API calls in + # !!! FIXME: src/video/cocoa/SDL_cocoakeyboard.c, but we should figure out + # !!! FIXME: how to dump those. + if(MACOS) + set(SDL_FRAMEWORK_COCOA 1) + set(SDL_FRAMEWORK_CARBON 1) + set(SDL_FRAMEWORK_UTTYPES 1) + endif() + set(SDL_FRAMEWORK_FOUNDATION 1) + set(SDL_FRAMEWORK_COREVIDEO 1) + + # iOS can use a CADisplayLink for main callbacks. macOS just uses the generic one atm. + if(IOS OR TVOS OR VISIONOS OR WATCHOS) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/main/ios/*.m") + set(HAVE_SDL_MAIN_CALLBACKS TRUE) + endif() + + if(SDL_CAMERA) + if(MACOS OR IOS) + set(SDL_CAMERA_DRIVER_COREMEDIA 1) + set(HAVE_CAMERA TRUE) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/camera/coremedia/*.m") + set(SDL_FRAMEWORK_AVFOUNDATION 1) + endif() + endif() + + if(IOS OR TVOS OR VISIONOS OR WATCHOS) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/misc/ios/*.m") + else() + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/misc/macos/*.m") + endif() + set(HAVE_SDL_MISC TRUE) + + if(SDL_AUDIO) + set(SDL_AUDIO_DRIVER_COREAUDIO 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/audio/coreaudio/*.m") + set(HAVE_SDL_AUDIO TRUE) + set(SDL_FRAMEWORK_COREAUDIO 1) + set(SDL_FRAMEWORK_AUDIOTOOLBOX 1) + set(SDL_FRAMEWORK_AVFOUNDATION 1) + endif() + + if(SDL_HIDAPI) + CheckHIDAPI() + endif() + + if(SDL_JOYSTICK) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/joystick/apple/*.m") + if(IOS OR TVOS OR VISIONOS OR WATCHOS) + set(SDL_JOYSTICK_MFI 1) + if(IOS OR VISIONOS OR WATCHOS) + set(SDL_FRAMEWORK_COREMOTION 1) + endif() + set(SDL_FRAMEWORK_GAMECONTROLLER 1) + set(SDL_FRAMEWORK_COREHAPTICS 1) + else() + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/joystick/darwin/*.c") + set_property(SOURCE ${MFI_JOYSTICK_SOURCES} APPEND_STRING PROPERTY COMPILE_FLAGS " -fobjc-weak") + check_objc_source_compiles(" + #include + #include + #import + #import + #if MAC_OS_X_VERSION_MIN_REQUIRED < 1080 + #error GameController framework doesn't work on this configuration + #endif + #if TARGET_CPU_X86 + #error GameController framework doesn't work on this configuration + #endif + int main() { return 0; }" HAVE_FRAMEWORK_GAMECONTROLLER) + check_objc_source_compiles(" + #include + #include + #import + #import + int main() { return 0; }" HAVE_FRAMEWORK_COREHAPTICS) + if(HAVE_FRAMEWORK_GAMECONTROLLER AND HAVE_FRAMEWORK_COREHAPTICS) + # Only enable MFI if we also have CoreHaptics to ensure rumble works + set(SDL_JOYSTICK_MFI 1) + set(SDL_FRAMEWORK_GAMECONTROLLER 1) + set(SDL_FRAMEWORK_COREHAPTICS 1) + endif() + if(NOT VISIONOS) + set(SDL_JOYSTICK_IOKIT 1) + set(SDL_FRAMEWORK_IOKIT 1) + endif() + set(SDL_FRAMEWORK_FF 1) + endif() + set(HAVE_SDL_JOYSTICK TRUE) + endif() + + if(SDL_HAPTIC) + if (IOS OR TVOS OR VISIONOS OR WATCHOS) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/haptic/dummy/*.c") + set(SDL_HAPTIC_DUMMY 1) + else() + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/haptic/darwin/*.c") + set(SDL_HAPTIC_IOKIT 1) + set(SDL_FRAMEWORK_IOKIT 1) + set(SDL_FRAMEWORK_FF 1) + endif() + set(HAVE_SDL_HAPTIC TRUE) + endif() + + if(SDL_POWER) + if (IOS OR TVOS OR VISIONOS OR WATCHOS) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/power/uikit/*.m") + set(SDL_POWER_UIKIT 1) + else() + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/power/macos/*.c") + set(SDL_POWER_MACOSX 1) + set(SDL_FRAMEWORK_IOKIT 1) + endif() + set(HAVE_SDL_POWER TRUE) + endif() + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/locale/macos/*.m") + set(HAVE_SDL_LOCALE TRUE) + + set(SDL_TIME_UNIX 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/time/unix/*.c") + set(HAVE_SDL_TIME TRUE) + + set(SDL_TIMER_UNIX 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/timer/unix/*.c") + set(HAVE_SDL_TIMERS TRUE) + + set(SDL_FILESYSTEM_COCOA 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/filesystem/cocoa/*.m") + set(HAVE_SDL_FILESYSTEM TRUE) + + # TODO: SDL_STORAGE_ICLOUD + set(SDL_STORAGE_GENERIC 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/storage/generic/*.c") + if(MACOS) + set(SDL_STORAGE_STEAM 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/storage/steam/*.c") + endif() + set(HAVE_SDL_STORAGE 1) + + set(SDL_FSOPS_POSIX 1) + sdl_sources("${SDL3_SOURCE_DIR}/src/filesystem/posix/SDL_sysfsops.c") + set(HAVE_SDL_FSOPS TRUE) + + if(SDL_SENSOR) + if(IOS OR VISIONOS OR WATCHOS) + set(SDL_SENSOR_COREMOTION 1) + set(HAVE_SDL_SENSORS TRUE) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/sensor/coremotion/*.m") + endif() + endif() + + # iOS hack needed - http://code.google.com/p/ios-cmake/ ? + if(SDL_VIDEO) + if(IOS OR TVOS OR VISIONOS OR WATCHOS) + set(SDL_VIDEO_DRIVER_UIKIT 1) + set(SDL_FRAMEWORK_COREGRAPHICS 1) + set(SDL_FRAMEWORK_QUARTZCORE 1) + set(SDL_FRAMEWORK_UIKIT 1) + set(SDL_IPHONE_KEYBOARD 1) + set(SDL_IPHONE_LAUNCHSCREEN 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/video/uikit/*.m") + set(HAVE_SDL_VIDEO TRUE) + else() + CheckCOCOA() + if(SDL_OPENGL) + set(SDL_VIDEO_OPENGL 1) + set(SDL_VIDEO_OPENGL_CGL 1) + set(SDL_VIDEO_RENDER_OGL 1) + set(HAVE_OPENGL TRUE) + endif() + endif() + + if(SDL_OPENGLES) + if(IOS OR TVOS OR VISIONOS OR WATCHOS) + set(SDL_FRAMEWORK_OPENGLES 1) + set(SDL_VIDEO_OPENGL_ES 1) + else() + set(SDL_VIDEO_OPENGL_EGL 1) + endif() + set(SDL_VIDEO_OPENGL_ES2 1) + set(SDL_VIDEO_RENDER_OGL_ES2 1) + set(HAVE_OPENGLES TRUE) + endif() + + if(SDL_VULKAN OR SDL_METAL OR SDL_RENDER_METAL) + check_objc_source_compiles(" + #include + #import + #import + + #if (!TARGET_CPU_X86_64 && !TARGET_CPU_ARM64) + #error Metal doesn't work on this configuration + #endif + int main(int argc, char **argv) { return 0; }" HAVE_FRAMEWORK_METAL) + if(HAVE_FRAMEWORK_METAL) + set(SDL_FRAMEWORK_METAL 1) + set(SDL_FRAMEWORK_QUARTZCORE 1) + if(SDL_VULKAN) + set(SDL_VIDEO_VULKAN 1) + set(HAVE_VULKAN TRUE) + if(SDL_RENDER_VULKAN) + set(SDL_VIDEO_RENDER_VULKAN 1) + set(HAVE_RENDER_VULKAN TRUE) + endif() + endif() + if(SDL_METAL) + set(SDL_VIDEO_METAL 1) + set(HAVE_METAL TRUE) + endif() + if(SDL_RENDER_METAL) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/render/metal/*.m") + set(SDL_VIDEO_RENDER_METAL 1) + set(HAVE_RENDER_METAL TRUE) + endif() + if (SDL_GPU) + set(SDL_GPU_METAL 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/gpu/metal/*.m") + endif() + endif() + endif() + + if(MACOS) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/tray/cocoa/*.m") + set(HAVE_SDL_TRAY TRUE) + endif() + endif() + + # Minimum version for $ + cmake_minimum_required(VERSION 3.24) + + # Actually load the frameworks at the end so we don't duplicate include. + if(SDL_FRAMEWORK_COREVIDEO) + find_library(COREMEDIA CoreMedia) + if(COREMEDIA) + sdl_link_dependency(corevideo LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,CoreMedia") + endif() + sdl_link_dependency(corevideo LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,CoreVideo") + endif() + if(SDL_FRAMEWORK_COCOA) + sdl_link_dependency(cocoa LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,Cocoa") + # macOS 11.0+ iOS 14.0+ tvOS 14.0+ + sdl_link_dependency(uniformtypeidentifiers LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-weak_framework,UniformTypeIdentifiers") + endif() + if(SDL_FRAMEWORK_IOKIT) + sdl_link_dependency(iokit LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,IOKit") + endif() + if(SDL_FRAMEWORK_FF) + sdl_link_dependency(ff LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,ForceFeedback") + endif() + if(SDL_FRAMEWORK_CARBON) + sdl_link_dependency(carbon LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,Carbon") + endif() + if(SDL_FRAMEWORK_COREAUDIO) + sdl_link_dependency(core_audio LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,CoreAudio") + endif() + if(SDL_FRAMEWORK_AUDIOTOOLBOX) + sdl_link_dependency(audio_toolbox LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,AudioToolbox") + endif() + if(SDL_FRAMEWORK_AVFOUNDATION) + sdl_link_dependency(av_foundation LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,AVFoundation") + endif() + if(SDL_FRAMEWORK_COREBLUETOOTH) + sdl_link_dependency(core_bluetooth LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,CoreBluetooth") + endif() + if(SDL_FRAMEWORK_COREGRAPHICS) + sdl_link_dependency(core_graphics LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,CoreGraphics") + endif() + if(SDL_FRAMEWORK_COREMOTION) + sdl_link_dependency(core_motion LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,CoreMotion") + endif() + if(SDL_FRAMEWORK_FOUNDATION) + sdl_link_dependency(foundation LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,Foundation") + endif() + if(SDL_FRAMEWORK_GAMECONTROLLER) + find_library(GAMECONTROLLER GameController) + if(GAMECONTROLLER) + sdl_link_dependency(game_controller LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,GameController") + endif() + endif() + if(SDL_FRAMEWORK_METAL) + sdl_link_dependency(metal LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,Metal") + endif() + if(SDL_FRAMEWORK_OPENGLES) + sdl_link_dependency(opengles LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,OpenGLES") + endif() + if(SDL_FRAMEWORK_QUARTZCORE) + sdl_link_dependency(quartz_core LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,QuartzCore") + endif() + if(SDL_FRAMEWORK_UIKIT) + sdl_link_dependency(ui_kit LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,UIKit") + endif() + if(SDL_FRAMEWORK_COREHAPTICS) + find_library(COREHAPTICS CoreHaptics) + if(COREHAPTICS) + # macOS 10.15+ iOS 13.0+ tvOS 14.0+ + sdl_link_dependency(core_haptics LIBS "$" PKG_CONFIG_LINK_OPTIONS "-Wl,-weak_framework,CoreHaptics") + endif() + endif() + + CheckPTHREAD() + + if(SDL_RPATH AND SDL_SHARED) + set(SDL_RLD_FLAGS "-Wl,-rpath,\${libdir}") + set(HAVE_RPATH TRUE) + endif() + +elseif(HAIKU) + enable_language(CXX) + if(SDL_AUDIO) + set(SDL_AUDIO_DRIVER_HAIKU 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/audio/haiku/*.cc") + set(HAVE_SDL_AUDIO TRUE) + endif() + + if(SDL_JOYSTICK) + set(SDL_JOYSTICK_HAIKU 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/joystick/haiku/*.cc") + set(HAVE_SDL_JOYSTICK TRUE) + endif() + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/misc/haiku/*.cc") + set(HAVE_SDL_MISC TRUE) + + if(SDL_VIDEO) + set(SDL_VIDEO_DRIVER_HAIKU 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/video/haiku/*.cc") + set(HAVE_SDL_VIDEO TRUE) + + if(SDL_OPENGL) + # TODO: Use FIND_PACKAGE(OpenGL) instead + set(SDL_VIDEO_OPENGL 1) + set(SDL_VIDEO_OPENGL_HAIKU 1) + set(SDL_VIDEO_RENDER_OGL 1) + sdl_link_dependency(opengl LIBS GL) + set(HAVE_OPENGL TRUE) + endif() + endif() + + set(SDL_FILESYSTEM_HAIKU 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/filesystem/haiku/*.cc") + set(HAVE_SDL_FILESYSTEM TRUE) + + set(SDL_FSOPS_POSIX 1) + sdl_sources("${SDL3_SOURCE_DIR}/src/filesystem/posix/SDL_sysfsops.c") + set(HAVE_SDL_FSOPS TRUE) + + set(SDL_TIME_UNIX 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/time/unix/*.c") + set(HAVE_SDL_TIME TRUE) + + set(SDL_TIMER_HAIKU 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/timer/haiku/*.c") + set(HAVE_SDL_TIMERS TRUE) + + if(SDL_POWER) + set(SDL_POWER_HAIKU 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/power/haiku/*.c") + set(HAVE_SDL_POWER TRUE) + endif() + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/locale/haiku/*.cc") + set(HAVE_SDL_LOCALE TRUE) + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/core/haiku/*.cc") + + CheckPTHREAD() + sdl_link_dependency(base LIBS root be media game device textencoding tracker) + +elseif(RISCOS) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/misc/riscos/*.c") + set(HAVE_SDL_MISC TRUE) + + if(SDL_VIDEO) + set(SDL_VIDEO_DRIVER_RISCOS 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/video/riscos/*.c") + set(HAVE_SDL_VIDEO TRUE) + endif() + + set(SDL_FILESYSTEM_RISCOS 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/filesystem/riscos/*.c") + set(HAVE_SDL_FILESYSTEM TRUE) + + set(SDL_FSOPS_POSIX 1) + sdl_sources("${SDL3_SOURCE_DIR}/src/filesystem/posix/SDL_sysfsops.c") + set(HAVE_SDL_FSOPS TRUE) + + set(SDL_TIME_UNIX 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/time/unix/*.c") + set(HAVE_SDL_TIME TRUE) + + set(SDL_TIMER_UNIX 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/timer/unix/*.c") + set(HAVE_SDL_TIMERS TRUE) + + if(SDL_CLOCK_GETTIME) + set(HAVE_CLOCK_GETTIME 1) + endif() + + CheckPTHREAD() + + if(SDL_AUDIO) + CheckOSS() + endif() + +elseif(VITA) + # SDL_spinlock.c Needs to be compiled in ARM mode. + cmake_push_check_state() + string(APPEND CMAKE_REQUIRED_FLAGS " -Werror=unused-command-line-argument") + check_c_compiler_flag(-marm HAVE_ARM_MODE) + cmake_pop_check_state() + if(HAVE_ARM_MODE) + set_property(SOURCE "${SDL3_SOURCE_DIR}/src/atomic/SDL_spinlock.c" APPEND_STRING PROPERTY COMPILE_FLAGS " -marm") + endif() + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/misc/vita/*.c") + set(HAVE_SDL_MISC TRUE) + + if(SDL_AUDIO) + set(SDL_AUDIO_DRIVER_VITA 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/audio/vita/*.c") + set(HAVE_SDL_AUDIO TRUE) + endif() + + set(SDL_FILESYSTEM_VITA 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/filesystem/vita/*.c") + set(HAVE_SDL_FILESYSTEM TRUE) + + set(SDL_FSOPS_POSIX 1) + sdl_sources("${SDL3_SOURCE_DIR}/src/filesystem/posix/SDL_sysfsops.c") + set(HAVE_SDL_FSOPS TRUE) + + if(SDL_JOYSTICK) + set(SDL_JOYSTICK_VITA 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/joystick/vita/*.c") + set(HAVE_SDL_JOYSTICK TRUE) + endif() + + if(SDL_POWER) + set(SDL_POWER_VITA 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/power/vita/*.c") + set(HAVE_SDL_POWER TRUE) + endif() + + set(SDL_THREAD_VITA 1) + sdl_sources( + "${SDL3_SOURCE_DIR}/src/thread/vita/SDL_sysmutex.c" + "${SDL3_SOURCE_DIR}/src/thread/vita/SDL_syssem.c" + "${SDL3_SOURCE_DIR}/src/thread/vita/SDL_systhread.c" + "${SDL3_SOURCE_DIR}/src/thread/generic/SDL_syscond.c" + "${SDL3_SOURCE_DIR}/src/thread/generic/SDL_sysrwlock.c" + "${SDL3_SOURCE_DIR}/src/thread/generic/SDL_systls.c" + ) + set(HAVE_SDL_THREADS TRUE) + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/locale/vita/*.c") + set(HAVE_SDL_LOCALE TRUE) + + set(SDL_TIME_VITA 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/time/vita/*.c") + set(HAVE_SDL_TIME TRUE) + + set(SDL_TIMER_VITA 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/timer/vita/*.c") + set(HAVE_SDL_TIMERS TRUE) + + if(SDL_SENSOR) + set(SDL_SENSOR_VITA 1) + set(HAVE_SDL_SENSORS TRUE) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/sensor/vita/*.c") + endif() + + if(SDL_CAMERA) + set(SDL_CAMERA_DRIVER_VITA 1) + set(HAVE_CAMERA TRUE) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/camera/vita/*.c") + endif() + + if(SDL_VIDEO) + set(SDL_VIDEO_DRIVER_VITA 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/video/vita/*.c") + set(HAVE_SDL_VIDEO TRUE) + + if(VIDEO_VITA_PIB) + check_include_file(pib.h HAVE_PIGS_IN_BLANKET_H) + + if(HAVE_PIGS_IN_BLANKET_H) + set(SDL_VIDEO_OPENGL_ES2 1) + sdl_link_dependency(pib + LIBS + pib + libScePiglet_stub_weak + taihen_stub_weak + SceShaccCg_stub_weak + ) + set(HAVE_VIDEO_VITA_PIB ON) + set(SDL_VIDEO_VITA_PIB 1) + else() + set(HAVE_VIDEO_VITA_PIB OFF) + endif() + endif() + + if(VIDEO_VITA_PVR) + check_include_file(gpu_es4/psp2_pvr_hint.h HAVE_PVR_H) + if(HAVE_PVR_H) + sdl_compile_definitions(PRIVATE "__psp2__") + set(SDL_VIDEO_OPENGL_EGL 1) + set(HAVE_OPENGLES TRUE) + set(SDL_VIDEO_OPENGL_ES 1) + set(SDL_VIDEO_OPENGL_ES2 1) + set(SDL_VIDEO_RENDER_OGL_ES2 1) + + sdl_link_dependency(pvr + LIBS + libgpu_es4_ext_stub_weak + libIMGEGL_stub_weak + SceIme_stub + ) + + set(HAVE_VIDEO_VITA_PVR ON) + set(SDL_VIDEO_VITA_PVR 1) + + if(SDL_OPENGL) + check_include_file(gl4esinit.h HAVE_GL4ES_H) + if(HAVE_GL4ES_H) + set(HAVE_OPENGL TRUE) + set(SDL_VIDEO_OPENGL 1) + set(SDL_VIDEO_RENDER_OGL 1) + sdl_link_dependency(opengl LIBS libGL_stub) + set(SDL_VIDEO_VITA_PVR_OGL 1) + endif() + endif() + + else() + set(HAVE_VIDEO_VITA_PVR OFF) + endif() + endif() + + set(SDL_VIDEO_RENDER_VITA_GXM 1) + sdl_link_dependency(base + LIBS + SceGxm_stub + SceDisplay_stub + SceCtrl_stub + SceAppMgr_stub + SceAppUtil_stub + SceAudio_stub + SceAudioIn_stub + SceSysmodule_stub + SceDisplay_stub + SceCtrl_stub + SceIofilemgr_stub + SceCommonDialog_stub + SceTouch_stub + SceHid_stub + SceMotion_stub + ScePower_stub + SceProcessmgr_stub + SceCamera_stub + ) + endif() + + sdl_compile_definitions(PRIVATE "__VITA__") + +elseif(PSP) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/main/psp/*.c") + + if(SDL_AUDIO) + set(SDL_AUDIO_DRIVER_PSP 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/audio/psp/*.c") + set(HAVE_SDL_AUDIO TRUE) + endif() + + set(SDL_FILESYSTEM_PSP 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/filesystem/psp/*.c") + set(HAVE_SDL_FILESYSTEM TRUE) + + set(SDL_FSOPS_POSIX 1) + sdl_sources("${SDL3_SOURCE_DIR}/src/filesystem/posix/SDL_sysfsops.c") + set(HAVE_SDL_FSOPS TRUE) + + if(SDL_JOYSTICK) + set(SDL_JOYSTICK_PSP 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/joystick/psp/*.c") + set(HAVE_SDL_JOYSTICK TRUE) + endif() + + if(SDL_POWER) + set(SDL_POWER_PSP 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/power/psp/*.c") + set(HAVE_SDL_POWER TRUE) + endif() + + set(SDL_THREAD_PSP 1) + sdl_glob_sources( + "${SDL3_SOURCE_DIR}/src/thread/generic/SDL_syscond.c" + "${SDL3_SOURCE_DIR}/src/thread/generic/SDL_systls.c" + "${SDL3_SOURCE_DIR}/src/thread/generic/SDL_sysrwlock.c" + "${SDL3_SOURCE_DIR}/src/thread/psp/*.c" + ) + set(HAVE_SDL_THREADS TRUE) + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/locale/psp/*.c") + set(HAVE_SDL_LOCALE TRUE) + + set(SDL_TIME_PSP 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/time/psp/*.c") + set(HAVE_SDL_TIME TRUE) + + set(SDL_TIMER_PSP 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/timer/psp/*.c") + set(HAVE_SDL_TIMERS TRUE) + + if(SDL_VIDEO) + set(SDL_VIDEO_DRIVER_PSP 1) + set(SDL_VIDEO_RENDER_PSP 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/video/psp/*.c") + set(SDL_VIDEO_OPENGL 1) + set(HAVE_SDL_VIDEO TRUE) + endif() + + sdl_link_dependency(base + LIBS + GL + pspvram + pspaudio + pspvfpu + pspdisplay + pspgu + pspge + psphprm + pspctrl + psppower + ) + +elseif(PS2) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/main/ps2/*.c") + + if(SDL_AUDIO) + set(SDL_AUDIO_DRIVER_PS2 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/audio/ps2/*.c") + set(HAVE_SDL_AUDIO TRUE) + endif() + + set(SDL_FILESYSTEM_PS2 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/filesystem/ps2/*.c") + set(HAVE_SDL_FILESYSTEM TRUE) + + set(SDL_FSOPS_POSIX 1) + sdl_sources("${SDL3_SOURCE_DIR}/src/filesystem/posix/SDL_sysfsops.c") + set(HAVE_SDL_FSOPS TRUE) + + if(SDL_JOYSTICK) + set(SDL_JOYSTICK_PS2 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/joystick/ps2/*.c") + set(HAVE_SDL_JOYSTICK TRUE) + endif() + + set(SDL_THREAD_PS2 1) + sdl_glob_sources( + "${SDL3_SOURCE_DIR}/src/thread/generic/SDL_syscond.c" + "${SDL3_SOURCE_DIR}/src/thread/generic/SDL_sysmutex.c" + "${SDL3_SOURCE_DIR}/src/thread/generic/SDL_sysrwlock.c" + "${SDL3_SOURCE_DIR}/src/thread/generic/SDL_systls.c" + "${SDL3_SOURCE_DIR}/src/thread/ps2/*.c" + ) + set(HAVE_SDL_THREADS TRUE) + + set(SDL_TIME_PS2 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/time/ps2/*.c") + set(HAVE_SDL_TIME TRUE) + + set(SDL_TIMER_PS2 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/timer/ps2/*.c") + set(HAVE_SDL_TIMERS TRUE) + + if(SDL_VIDEO) + set(SDL_VIDEO_DRIVER_PS2 1) + set(SDL_VIDEO_RENDER_PS2 1) + sdl_glob_sources( + "${SDL3_SOURCE_DIR}/src/video/ps2/*.c" + "${SDL3_SOURCE_DIR}/src/render/ps2/*.c" + ) + set(SDL_VIDEO_OPENGL 0) + set(HAVE_SDL_VIDEO TRUE) + endif() + + sdl_link_dependency(base + LIBS + patches + gskit + dmakit + ps2_drivers + ) +elseif(N3DS) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/main/n3ds/*.c") + + if(SDL_AUDIO) + set(SDL_AUDIO_DRIVER_N3DS 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/audio/n3ds/*.c") + set(HAVE_SDL_AUDIO TRUE) + endif() + + set(SDL_FILESYSTEM_N3DS 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/filesystem/n3ds/*.c") + set(HAVE_SDL_FILESYSTEM TRUE) + + # !!! FIXME: do we need a FSops implementation for this? + + if(SDL_JOYSTICK) + set(SDL_JOYSTICK_N3DS 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/joystick/n3ds/*.c") + set(HAVE_SDL_JOYSTICK TRUE) + endif() + + if(SDL_POWER) + set(SDL_POWER_N3DS 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/power/n3ds/*.c") + set(HAVE_SDL_POWER TRUE) + endif() + + set(SDL_THREAD_N3DS 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/thread/n3ds/*.c") + sdl_sources( + "${SDL3_SOURCE_DIR}/src/thread/generic/SDL_syscond.c" + "${SDL3_SOURCE_DIR}/src/thread/generic/SDL_systls.c" + "${SDL3_SOURCE_DIR}/src/thread/generic/SDL_sysrwlock.c" + ) + set(HAVE_SDL_THREADS TRUE) + + set(SDL_TIME_N3DS 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/time/n3ds/*.c") + set(HAVE_SDL_TIME TRUE) + + set(SDL_TIMER_N3DS 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/timer/n3ds/*.c") + set(HAVE_SDL_TIMERS TRUE) + + set(SDL_FSOPS_POSIX 1) + sdl_sources("${SDL3_SOURCE_DIR}/src/filesystem/posix/SDL_sysfsops.c") + set(HAVE_SDL_FSOPS TRUE) + + if(SDL_SENSOR) + set(SDL_SENSOR_N3DS 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/sensor/n3ds/*.c") + set(HAVE_SDL_SENSORS TRUE) + endif() + + if(SDL_VIDEO) + set(SDL_VIDEO_DRIVER_N3DS 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/video/n3ds/*.c") + set(HAVE_SDL_VIDEO TRUE) + endif() + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/locale/n3ds/*.c") + set(HAVE_SDL_LOCALE TRUE) + + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/io/n3ds/*.c") +endif() + +sdl_sources(${SDL3_SOURCE_DIR}/src/dialog/SDL_dialog.c) +if (SDL_DIALOG) + sdl_sources(${SDL3_SOURCE_DIR}/src/dialog/SDL_dialog_utils.c) + if(ANDROID) + sdl_sources(${SDL3_SOURCE_DIR}/src/dialog/android/SDL_androiddialog.c) + set(HAVE_SDL_DIALOG TRUE) + elseif(UNIX AND NOT APPLE AND NOT RISCOS AND NOT HAIKU) + sdl_sources(${SDL3_SOURCE_DIR}/src/dialog/unix/SDL_unixdialog.c) + sdl_sources(${SDL3_SOURCE_DIR}/src/dialog/unix/SDL_portaldialog.c) + sdl_sources(${SDL3_SOURCE_DIR}/src/dialog/unix/SDL_zenitydialog.c) + set(HAVE_SDL_DIALOG TRUE) + elseif(HAIKU) + sdl_sources(${SDL3_SOURCE_DIR}/src/dialog/haiku/SDL_haikudialog.cc) + set(HAVE_SDL_DIALOG TRUE) + elseif(WINDOWS) + sdl_sources(${SDL3_SOURCE_DIR}/src/dialog/windows/SDL_windowsdialog.c) + set(HAVE_SDL_DIALOG TRUE) + elseif(MACOS) + sdl_sources(${SDL3_SOURCE_DIR}/src/dialog/cocoa/SDL_cocoadialog.m) + set(HAVE_SDL_DIALOG TRUE) + endif() +endif() + +sdl_sources("${SDL3_SOURCE_DIR}/src/process/SDL_process.c") +if(WINDOWS) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/process/windows/*.c") + set(SDL_PROCESS_WINDOWS 1) + set(HAVE_SDL_PROCESS TRUE) +else() + check_c_source_compiles(" +#include +#include + +int main(void) +{ + int pipes[2]; + int pid; + + const char * args[] = { + \"/bin/false\", + NULL + }; + + const char * env[] = { NULL }; + + pipe(pipes); + + posix_spawnattr_t attr; + posix_spawn_file_actions_t fa; + + posix_spawnattr_init(&attr); + posix_spawn_file_actions_init(&fa); + + posix_spawn_file_actions_addclose(&fa, pipes[0]); + posix_spawn_file_actions_adddup2(&fa, pipes[1], STDOUT_FILENO); + + posix_spawn(&pid, args[0], &fa, &attr, (char * const *) args, (char * const *) env); + posix_spawnp(&pid, args[0], &fa, &attr, (char * const *) args, (char * const *) env); + + posix_spawn_file_actions_destroy(&fa); + posix_spawnattr_destroy(&attr); + + return 0; +} +" HAVE_POSIX_SPAWN) + if(HAVE_POSIX_SPAWN) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/process/posix/*.c") + set(SDL_PROCESS_POSIX 1) + set(HAVE_SDL_PROCESS TRUE) + endif() +endif() + +# Platform-independent options + +if(SDL_VIDEO) + if(SDL_OFFSCREEN) + set(SDL_VIDEO_DRIVER_OFFSCREEN 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/video/offscreen/*.c") + set(HAVE_OFFSCREEN TRUE) + set(HAVE_SDL_VIDEO TRUE) + endif() +endif() + +sdl_glob_sources(${SDL3_SOURCE_DIR}/src/tray/*.c) + +if(SDL_GPU) + if(HAVE_D3D11_H) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/gpu/d3d11/*.c") + set(SDL_GPU_D3D11 1) + set(HAVE_SDL_GPU TRUE) + endif() + if(WINDOWS) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/gpu/d3d12/*.c") + set(SDL_GPU_D3D12 1) + set(HAVE_SDL_GPU TRUE) + endif() + if(SDL_VIDEO_VULKAN) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/gpu/vulkan/*.c") + set(SDL_GPU_VULKAN 1) + set(HAVE_SDL_GPU TRUE) + endif() + if(SDL_RENDER_GPU) + set(SDL_VIDEO_RENDER_GPU 1) + set(HAVE_RENDER_GPU TRUE) + endif() +endif() + +# Dummies +# configure.ac does it differently: +# if not have X +# if enable_X { SDL_X_DISABLED = 1 } +# [add dummy sources] +# so it always adds a dummy, without checking, if it was actually requested. +# This leads to missing internal references on building, since the +# src/X/*.c does not get included. +if(NOT HAVE_SDL_AUDIO) + set(SDL_AUDIO_DRIVER_DUMMY 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/audio/dummy/*.c") +endif() +if(NOT HAVE_SDL_VIDEO) + set(SDL_VIDEO_DRIVER_DUMMY 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/video/dummy/*.c") +endif() +if(NOT HAVE_SDL_JOYSTICK) + set(SDL_JOYSTICK_DUMMY 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/joystick/dummy/*.c") +endif() +if(NOT HAVE_SDL_HAPTIC) + set(SDL_HAPTIC_DUMMY 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/haptic/dummy/*.c") +endif() +if(NOT HAVE_SDL_SENSORS) + set(SDL_SENSOR_DUMMY 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/sensor/dummy/*.c") +endif() +if(NOT HAVE_SDL_LOADSO) + set(SDL_LOADSO_DUMMY 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/loadso/dummy/*.c") +endif() +if(NOT HAVE_SDL_FILESYSTEM) + set(SDL_FILESYSTEM_DUMMY 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/filesystem/dummy/*.c") +endif() +if(NOT HAVE_SDL_STORAGE) + set(SDL_STORAGE_GENERIC 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/storage/generic/*.c") +endif() +if(NOT HAVE_SDL_FSOPS) + set(SDL_FSOPS_DUMMY 1) + sdl_sources("${SDL3_SOURCE_DIR}/src/filesystem/dummy/SDL_sysfsops.c") +endif() +if(NOT HAVE_SDL_LOCALE) + set(SDL_LOCALE_DUMMY 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/locale/dummy/*.c") +endif() +if(NOT HAVE_SDL_MISC) + set(SDL_MISC_DUMMY 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/misc/dummy/*.c") +endif() +if(NOT HAVE_SDL_DIALOG) + set(SDL_DIALOG_DUMMY 1) + sdl_sources(${SDL3_SOURCE_DIR}/src/dialog/dummy/SDL_dummydialog.c) +endif() +if(NOT HAVE_SDL_PROCESS) + set(SDL_PROCESS_DUMMY 1) + sdl_glob_sources(${SDL3_SOURCE_DIR}/src/process/dummy/*.c) +endif() +if(NOT HAVE_SDL_TRAY) + set(SDL_TRAY_DUMMY 1) + sdl_glob_sources(${SDL3_SOURCE_DIR}/src/tray/dummy/*.c) +endif() +if(NOT HAVE_CAMERA) + set(SDL_CAMERA_DRIVER_DUMMY 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/camera/dummy/*.c") +endif() + +# We always need to have threads and timers around +if(NOT HAVE_SDL_THREADS) + # The emscripten platform has been carefully vetted to work without threads + if(EMSCRIPTEN) + set(SDL_THREADS_DISABLED 1) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/thread/generic/*.c") + else() + message(FATAL_ERROR "Threads are needed by many SDL subsystems and may not be disabled") + endif() +endif() +if(NOT HAVE_SDL_TIMERS) + message(FATAL_ERROR "Timers are needed by many SDL subsystems and may not be disabled") +endif() + +# Most platforms use this. +if(NOT HAVE_SDL_MAIN_CALLBACKS) + sdl_glob_sources("${SDL3_SOURCE_DIR}/src/main/generic/*.c") +endif() + +# config variables may contain generator expression, so we need to generate SDL_build_config.h in 2 steps: +# 1. replace all `#cmakedefine`'s and `@abc@` +configure_file("${SDL3_SOURCE_DIR}/include/build_config/SDL_build_config.h.cmake" + "${SDL3_BINARY_DIR}/CMakeFiles/SDL_build_config.h.intermediate") +# 2. generate SDL_build_config.h in an build_type-dependent folder (which should be first in the include search path) +file(GENERATE + OUTPUT "${SDL3_BINARY_DIR}/include-config-$>/build_config/SDL_build_config.h" + INPUT "${SDL3_BINARY_DIR}/CMakeFiles/SDL_build_config.h.intermediate" +) + +file(GLOB SDL3_INCLUDE_FILES "${SDL3_SOURCE_DIR}/include/SDL3/*.h") +file(GLOB SDL3_TEST_INCLUDE_FILES "${SDL3_SOURCE_DIR}/include/SDL3/SDL_test*.h") +foreach(_hdr IN LISTS SDL3_INCLUDE_FILES) + if(_hdr MATCHES ".*SDL_revision\\.h" OR _hdr MATCHES ".*SDL_test.*\\.h") + list(REMOVE_ITEM SDL3_INCLUDE_FILES "${_hdr}") + endif() +endforeach() + +# If REVISION.txt exists, then we are building from a SDL release. +# SDL_revision.h(.cmake) in source releases have SDL_REVISION baked into them. +if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/REVISION.txt") + file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/REVISION.txt" revisions) + list(GET revisions 0 revisions_0) + string(STRIP "${revisions_0}" SDL_REVISION) +else() + set(SDL_REVISION "" CACHE STRING "Custom SDL revision (only used when REVISION.txt does not exist)") +endif() +if(NOT SDL_REVISION) + # If SDL_REVISION is not overrided, use git to describe + git_describe(SDL_REVISION_GIT) + set(SDL_REVISION "SDL3-${SDL3_VERSION}-${SDL_REVISION_GIT}") +endif() + +execute_process(COMMAND "${CMAKE_COMMAND}" -E make_directory "${SDL3_BINARY_DIR}/include-revision/SDL3") +configure_file(include/build_config/SDL_revision.h.cmake include-revision/SDL3/SDL_revision.h @ONLY) +list(APPEND SDL3_INCLUDE_FILES "${SDL3_BINARY_DIR}/include-revision/SDL3/SDL_revision.h") + +if(SDL_FRAMEWORK) + # With Apple frameworks, headers in the PUBLIC_HEADER property also need to be added as sources + list(APPEND SDL3_INCLUDE_FILES ${SDL3_TEST_INCLUDE_FILES}) + sdl_sources(${SDL3_INCLUDE_FILES}) +endif() + +if((CMAKE_STATIC_LIBRARY_PREFIX STREQUAL "" AND CMAKE_STATIC_LIBRARY_SUFFIX STREQUAL ".lib") OR SDL_FRAMEWORK) + # - Avoid conflict between the dll import library and the static library + # - Create SDL3-static Apple Framework + set(sdl_static_libname "SDL3-static") +else() + set(sdl_static_libname "SDL3") +endif() + +macro(check_add_debug_flag FLAG SUFFIX) + check_c_compiler_flag(${FLAG} HAS_C_FLAG_${SUFFIX}) + if(HAS_C_FLAG_${SUFFIX}) + string(APPEND CMAKE_C_FLAGS_DEBUG " ${FLAG}") + endif() + + if(CMAKE_CXX_COMPILER) + check_cxx_compiler_flag(${FLAG} HAS_CXX_${SUFFIX}) + if(HAS_CXX_${SUFFIX}) + string(APPEND CMAKE_CXX_FLAGS_DEBUG " ${FLAG}") + endif() + endif() +endmacro() + +macro(asan_check_add_debug_flag ASAN_FLAG) + check_add_debug_flag("-fsanitize=${ASAN_FLAG}" "${ASAN_FLAG}") + if(HAS_C_${ASAN_FLAG} OR HAS_CXX_${ASAN_FLAG}) + set(HAVE_ASAN ON) + endif() +endmacro() + +macro(asan_check_add_debug_flag2 ASAN_FLAG) + # for some sanitize flags we have to manipulate the CMAKE_REQUIRED_LIBRARIES: + # http://cmake.3232098.n2.nabble.com/CHECK-CXX-COMPILER-FLAG-doesn-t-give-correct-result-for-fsanitize-address-tp7600216p7600217.html + + set(FLAG "-fsanitize=${ASAN_FLAG}") + + cmake_push_check_state() + list(APPEND CMAKE_REQUIRED_LIBRARIES ${FLAG} asan) + + check_c_compiler_flag (${FLAG} HAS_C_FLAG_${ASAN_FLAG}) + if (HAS_C_FLAG_${ASAN_FLAG}) + string(APPEND CMAKE_C_FLAGS_DEBUG " ${FLAG}") + endif() + + if(CMAKE_CXX_COMPILER) + check_cxx_compiler_flag (${FLAG} HAS_CXX_FLAG_${ASAN_FLAG}) + if (HAS_CXX_${ASAN_FLAG}) + string(APPEND CMAKE_CXX_FLAGS_DEBUG " ${FLAG}") + endif() + endif() + + cmake_pop_check_state() + if(HAS_C_${ASAN_FLAG} OR HAS_CXX_${ASAN_FLAG}) + set(HAVE_ASAN ON) + endif() +endmacro() + +# enable AddressSanitizer if supported +if(SDL_ASAN) + asan_check_add_debug_flag2("address") + asan_check_add_debug_flag("bool") + asan_check_add_debug_flag("bounds") + asan_check_add_debug_flag("enum") + asan_check_add_debug_flag("float-cast-overflow") + asan_check_add_debug_flag("float-divide-by-zero") + asan_check_add_debug_flag("nonnull-attribute") + asan_check_add_debug_flag("returns-nonnull-attribute") + asan_check_add_debug_flag("signed-integer-overflow") + asan_check_add_debug_flag("undefined") + asan_check_add_debug_flag("vla-bound") + asan_check_add_debug_flag("leak") + # The object size sanitizer has no effect on unoptimized builds on Clang, + # but causes warnings. + if(NOT USE_CLANG OR CMAKE_BUILD_TYPE STREQUAL "") + asan_check_add_debug_flag("object-size") + endif() +endif() + +if(SDL_CCACHE) + find_program(CCACHE_BINARY ccache) + if(CCACHE_BINARY) + set(CMAKE_C_COMPILER_LAUNCHER ${CCACHE_BINARY}) + set(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE_BINARY}) + set(CMAKE_OBJC_COMPILER_LAUNCHER ${CCACHE_BINARY}) + set(HAVE_CCACHE ON) + else() + set(HAVE_CCACHE OFF) + endif() +else() + set(HAVE_CCACHE OFF) +endif() + +if(SDL_CLANG_TIDY) + find_program(CLANG_TIDY_BINARY clang-tidy) + + if(CLANG_TIDY_BINARY) + set(HAVE_CLANG_TIDY ON) + get_clang_tidy_ignored_files(CLANG_TIDY_IGNORED_FILES) + set(CLANG_TIDY_COMMAND "${CLANG_TIDY_BINARY}" "-extra-arg=-Wno-unknown-warning-option" "--line-filter=[${CLANG_TIDY_IGNORED_FILES}]") + if(SDL_WERROR) + list(APPEND CLANG_TIDY_COMMAND "--warnings-as-errors=*") + endif() + set(CMAKE_C_CLANG_TIDY ${CLANG_TIDY_COMMAND}) + set(CMAKE_CXX_CLANG_TIDY ${CLANG_TIDY_COMMAND}) + set(CMAKE_OBJC_CLANG_TIDY ${CLANG_TIDY_COMMAND}) + get_property(shared_sources TARGET SDL3-collector PROPERTY INTERFACE_SOURCES) + set_source_files_properties(${shared_sources} PROPERTIES SKIP_PRECOMPILE_HEADERS TRUE) + file(GLOB STDLIB_SOURCES "${SDL3_SOURCE_DIR}/src/stdlib/*.c") + set_property(SOURCE ${STDLIB_SOURCES} APPEND PROPERTY COMPILE_DEFINITIONS "SDL_DISABLE_ANALYZE_MACROS") + else() + set(HAVE_CLANG_TIDY OFF) + endif() +endif() + +if(SDL_TESTS) + set(HAVE_TESTS ON) +endif() + +if(CMAKE_SIZEOF_VOID_P EQUAL 8) + set(ARCH_64 TRUE) +else() + set(ARCH_64 FALSE) +endif() + +if(ANDROID) + sdl_include_directories(PRIVATE SYSTEM "${CMAKE_ANDROID_NDK}/sources/android/cpufeatures") +endif() + +if(APPLE) + cmake_push_check_state(RESET) + check_c_compiler_flag(-fobjc-arc COMPILER_SUPPORTS_FOBJC_ARC) + cmake_pop_check_state() + if(NOT COMPILER_SUPPORTS_FOBJC_ARC) + message(FATAL_ERROR "Compiler does not support -fobjc-arc: this is required on Apple platforms") + endif() + sdl_compile_options(PRIVATE "-fobjc-arc") +endif() + +if(PS2) + sdl_compile_options(PRIVATE "-Wno-error=declaration-after-statement") +endif() + +if(NOT SDL_LIBC) + if(MSVC) + set(saved_CMAKE_TRY_COMPILE_TARGET_TYPE "${CMAKE_TRY_COMPILE_TARGET_TYPE}") + cmake_push_check_state(RESET) + set(CMAKE_TRY_COMPILE_TARGET_TYPE "STATIC_LIBRARY") + check_c_compiler_flag("/Zl" COMPILER_SUPPORTS_Zl) + cmake_pop_check_state() + set(CMAKE_TRY_COMPILE_TARGET_TYPE "${saved_CMAKE_TRY_COMPILE_TARGET_TYPE}") + if(COMPILER_SUPPORTS_Zl) + # /Zl omits the default C runtime library name from the .obj file. + sdl_compile_options(PRIVATE "$<$,$>:/Zl>") + if(TARGET SDL3_test) + target_compile_options(SDL3_test PRIVATE "/Zl") + endif() + endif() + endif() +endif() + +if(APPLE) + get_property(sources TARGET SDL3-collector PROPERTY INTERFACE_SOURCES) + foreach(SOURCE_FILE IN LISTS sources) + get_filename_component(FILE_EXTENSION ${SOURCE_FILE} EXT) + if(FILE_EXTENSION STREQUAL ".m") + set_property(SOURCE ${SOURCE_FILE} APPEND_STRING PROPERTY COMPILE_FLAGS " -x objective-c") + endif() + if(NOT FILE_EXTENSION STREQUAL ".c" AND NOT FILE_EXTENSION STREQUAL ".cpp") + set_property(SOURCE ${SOURCE_FILE} PROPERTY SKIP_PRECOMPILE_HEADERS 1) + endif() + endforeach() +endif() + +# Disable precompiled headers on SDL_dynapi.c to avoid applying dynapi overrides +set_source_files_properties(src/dynapi/SDL_dynapi.c PROPERTIES SKIP_PRECOMPILE_HEADERS 1) + +set(SDL_FRAMEWORK_RESOURCES + LICENSE.txt + README.md +) +if(SDL_FRAMEWORK) + sdl_sources(${SDL_FRAMEWORK_RESOURCES}) +endif() + +add_library(SDL3_Headers INTERFACE) +add_library(SDL3::Headers ALIAS SDL3_Headers) +set_property(TARGET SDL3_Headers PROPERTY EXPORT_NAME "Headers") +target_include_directories(SDL3_Headers + INTERFACE + "$" + "$" +) +if(SDL_FRAMEWORK) + target_include_directories(SDL3_Headers + INTERFACE + "$/SDL3.framework/Headers>" + ) + # Add `-F ` to make sure `#include "SDL3/..."` works. + target_compile_options(SDL3_Headers + INTERFACE + "$>" + ) +else() + target_include_directories(SDL3_Headers + INTERFACE + "$" + ) +endif() + +if(SDL_SHARED) + set_target_properties(SDL3-shared PROPERTIES + OUTPUT_NAME "SDL3" + POSITION_INDEPENDENT_CODE TRUE + LINK_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/dynapi/SDL_dynapi.sym" + INTERFACE_LINK_DEPENDS "$" + WINDOWS_EXPORT_ALL_SYMBOLS FALSE + DEFINE_SYMBOL "DLL_EXPORT" + ) + if(HAVE_GCC_FVISIBILITY) + set_target_properties(SDL3-shared PROPERTIES + C_VISIBILITY_PRESET "hidden" + CXX_VISIBILITY_PRESET "hidden" + OBJC_VISIBILITY_PRESET "hidden" + ) + endif() + if(NOT SDL_LIBC) + if(MSVC AND NOT MSVC_CLANG) + # Don't try to link with the default set of libraries. + # Note: The clang toolset for Visual Studio does not support /NODEFAULTLIB. + target_link_options(SDL3-shared PRIVATE "/NODEFAULTLIB") + if(SDL_CPU_ARM32) + # linking to msvcrt.lib avoid unresolved external symbols + # (__rt_sdiv, __rt_udiv, __rt_sdiv64, _rt_udiv64, __dtou64, __u64tod, __i64tos) + target_link_libraries(SDL3-shared PRIVATE msvcrt.lib) + endif() + find_library(HAVE_ONECORE_LIB NAMES "onecore.lib") + if(HAVE_ONECORE_LIB) + # SDL_malloc.c: __imp_MapViewOfFileNuma2 referenced in function MapViewOfFile2 + target_link_libraries(SDL3-shared PRIVATE onecore.lib) + endif() + find_library(HAVE_VOLATILEACCESSU_LIB NAMES "volatileaccessu.lib") + if(HAVE_VOLATILEACCESSU_LIB) + # SDL_malloc.c : RtlSetVolatileMemory referenced in function RtlFillVolatileMemory + # SDL_malloc.c : RtlFillDeviceMemory referenced in function RtlZeroDeviceMemory + target_link_libraries(SDL3-shared PRIVATE volatileaccessu.lib) + endif() + endif() + if(HAS_Q_NO_USE_LIBIRC) + target_compile_options(SDL3-shared PRIVATE /Q_no-use-libirc) + endif() + endif() + if(APPLE) + cmake_minimum_required(VERSION 3.17) + set_target_properties(SDL3-shared PROPERTIES + MACOSX_RPATH TRUE + FRAMEWORK "${SDL_FRAMEWORK}" + SOVERSION "${SDL_SO_VERSION_MAJOR}" + MACHO_COMPATIBILITY_VERSION "${SDL_DYLIB_COMPAT_VERSION}" + MACHO_CURRENT_VERSION "${SDL_DYLIB_CURRENT_VERSION}" + ) + if(SDL_FRAMEWORK) + set_target_properties(SDL3-shared PROPERTIES + PUBLIC_HEADER "${SDL3_INCLUDE_FILES}" + FRAMEWORK_VERSION "${SDL_FRAMEWORK_VERSION}" + MACOSX_FRAMEWORK_IDENTIFIER "org.libsdl.SDL3" + RESOURCE "${SDL_FRAMEWORK_RESOURCES}" + ) + endif() + elseif(UNIX AND NOT ANDROID) + set_target_properties(SDL3-shared PROPERTIES + VERSION "${SDL_SO_VERSION}" + SOVERSION "${SDL_SO_VERSION_MAJOR}" + ) + else() + if(WINDOWS OR CYGWIN) + set_target_properties(SDL3-shared PROPERTIES + PREFIX "" + ) + endif() + endif() + target_link_libraries(SDL3-shared PRIVATE ${SDL_CMAKE_DEPENDS}) + target_include_directories(SDL3-shared + PRIVATE + "$>>/build_config" + "$" + ) + target_link_libraries(SDL3-shared PUBLIC $) + if(MINGW OR CYGWIN) + target_link_options(SDL3-shared PRIVATE -static-libgcc) + endif() + # Use `Compatible Interface Properties` to: + # - allow consumers to enforce a shared/static library + # - block linking to SDL libraries of different major version + set_property(TARGET SDL3-shared APPEND PROPERTY COMPATIBLE_INTERFACE_BOOL SDL3_SHARED) + set_property(TARGET SDL3-shared PROPERTY INTERFACE_SDL3_SHARED TRUE) + set_property(TARGET SDL3-shared APPEND PROPERTY COMPATIBLE_INTERFACE_STRING "SDL_VERSION") + set_property(TARGET SDL3-shared PROPERTY INTERFACE_SDL_VERSION "SDL${SDL3_VERSION_MAJOR}") + if(NOT CMAKE_VERSION VERSION_LESS "3.16") + target_precompile_headers(SDL3-shared PRIVATE "$<$,$>:${PROJECT_SOURCE_DIR}/src/SDL_internal.h>") + endif() +endif() + +if(SDL_STATIC) + set_target_properties(SDL3-static PROPERTIES + OUTPUT_NAME "${sdl_static_libname}" + ) + target_compile_definitions(SDL3-static PRIVATE SDL_STATIC_LIB) + target_link_libraries(SDL3-static PRIVATE ${SDL_CMAKE_DEPENDS}) + target_include_directories(SDL3-static + PRIVATE + "$>>/build_config" + "$" + ) + target_link_libraries(SDL3-static PUBLIC $) + # Use `Compatible Interface Properties` to: + # - allow consumers to enforce a shared/static library + # - block linking to SDL libraries of different major version + set_property(TARGET SDL3-static APPEND PROPERTY COMPATIBLE_INTERFACE_BOOL SDL3_SHARED) + set_property(TARGET SDL3-static PROPERTY INTERFACE_SDL3_SHARED FALSE) + set_property(TARGET SDL3-static APPEND PROPERTY COMPATIBLE_INTERFACE_STRING "SDL_VERSION") + set_property(TARGET SDL3-static PROPERTY INTERFACE_SDL_VERSION "SDL${SDL3_VERSION_MAJOR}") + if(NOT CMAKE_VERSION VERSION_LESS "3.16") + target_precompile_headers(SDL3-static PRIVATE "$<$,$>:${PROJECT_SOURCE_DIR}/src/SDL_internal.h>") + endif() +endif() + +sdl_compile_definitions( + PRIVATE + "SDL_BUILD_MAJOR_VERSION=${PROJECT_VERSION_MAJOR}" + "SDL_BUILD_MINOR_VERSION=${PROJECT_VERSION_MINOR}" + "SDL_BUILD_MICRO_VERSION=${PROJECT_VERSION_PATCH}" +) + +##### Tests ##### + +if(SDL_TEST_LIBRARY) + file(GLOB TEST_SOURCES "${SDL3_SOURCE_DIR}/src/test/*.c") + target_sources(SDL3_test PRIVATE ${TEST_SOURCES}) + if(APPLE) + set_target_properties(SDL3_test PROPERTIES + FRAMEWORK "${SDL_FRAMEWORK}" + ) + if(SDL_FRAMEWORK) + set_target_properties(SDL3_test PROPERTIES + FRAMEWORK_VERSION "${SDL_FRAMEWORK_VERSION}" + MACOSX_FRAMEWORK_IDENTIFIER "org.libsdl.SDL3_test" + RESOURCE "${SDL_FRAMEWORK_RESOURCES}" + ) + endif() + endif() + target_link_libraries(SDL3_test PUBLIC $) + # FIXME: get rid of EXTRA_TEST_LIBS variable + target_link_libraries(SDL3_test PRIVATE ${EXTRA_TEST_LIBS}) + set_property(TARGET SDL3_test APPEND PROPERTY COMPATIBLE_INTERFACE_STRING "SDL_VERSION") + set_property(TARGET SDL3_test PROPERTY INTERFACE_SDL_VERSION "SDL${SDL3_VERSION_MAJOR}") +endif() + +##### Configure installation folders ##### + +if(WINDOWS AND NOT MINGW) + set(SDL_INSTALL_CMAKEDIR_ROOT_DEFAULT "cmake") +else() + set(SDL_INSTALL_CMAKEDIR_ROOT_DEFAULT "${CMAKE_INSTALL_LIBDIR}/cmake/SDL3") +endif() +set(SDL_INSTALL_CMAKEDIR_ROOT "${SDL_INSTALL_CMAKEDIR_ROOT_DEFAULT}" CACHE STRING "Root folder where to install SDL3Config.cmake related files (SDL3 subfolder for MSVC projects)") + +if(FREEBSD) + # FreeBSD uses ${PREFIX}/libdata/pkgconfig + set(SDL_PKGCONFIG_INSTALLDIR "libdata/pkgconfig") +else() + set(SDL_PKGCONFIG_INSTALLDIR "${CMAKE_INSTALL_LIBDIR}/pkgconfig") +endif() + +if(WINDOWS AND NOT MINGW) + set(SDL_INSTALL_CMAKEDIR "${SDL_INSTALL_CMAKEDIR_ROOT}") + set(SDL_INSTALL_LICENSEDIR "licenses/SDL3") + set(SDL_INSTALL_HEADERSDIR "${CMAKE_INSTALL_INCLUDEDIR}/SDL3") +elseif(SDL_FRAMEWORK) + set(SDL_INSTALL_CMAKEDIR "SDL3.framework/Versions/${SDL_FRAMEWORK_VERSION}/Resources/CMake") + set(SDL_INSTALL_LICENSEDIR "Resources") + set(SDL_INSTALL_HEADERSDIR "Headers") +else() + set(SDL_INSTALL_CMAKEDIR "${SDL_INSTALL_CMAKEDIR_ROOT}") + set(SDL_INSTALL_LICENSEDIR "${CMAKE_INSTALL_DATAROOTDIR}/licenses/${PROJECT_NAME}") + set(SDL_INSTALL_HEADERSDIR "${CMAKE_INSTALL_INCLUDEDIR}/SDL3") +endif() + +if(SDL_FRAMEWORK) + set(SDL_SDL_INSTALL_RESOURCEDIR "SDL3.framework/Resources") + set(SDL_SDL_INSTALL_CMAKEDIR "${SDL_SDL_INSTALL_RESOURCEDIR}/CMake") + set(SDL_SDL_INSTALL_REAL_RESOURCEDIR "SDL3.framework/Versions/${SDL_FRAMEWORK_VERSION}/Resources") + set(SDL_SDL_INSTALL_REAL_CMAKEDIR "${SDL_SDL_INSTALL_REAL_RESOURCEDIR}/CMake") + + set(SDL_SDLtest_INSTALL_RESOURCEDIR "SDL3_test.framework/Resources") + set(SDL_SDLtest_INSTALL_CMAKEDIR "${SDL_SDLtest_INSTALL_RESOURCEDIR}/CMake") + set(SDL_SDLtest_INSTALL_CMAKEFILENAME "SDL3_testConfig.cmake") +else() + set(SDL_SDL_INSTALL_RESOURCEDIR ".") + set(SDL_SDL_INSTALL_CMAKEDIR ${SDL_INSTALL_CMAKEDIR}) + set(SDL_SDL_INSTALL_REAL_CMAKEDIR ${SDL_INSTALL_CMAKEDIR}) + + # Install SDL3*Targets.cmake files in lib/cmake/SDL3 + set(SDL_SDLstatic_INSTALL_RESOURCEDIR ".") + set(SDL_SDLstatic_INSTALL_CMAKEDIR "${SDL_SDL_INSTALL_CMAKEDIR}") + set(SDL_SDLstatic_INSTALL_CMAKEFILENAME "SDL3staticTargets.cmake") + + set(SDL_SDLtest_INSTALL_RESOURCEDIR ".") + set(SDL_SDLtest_INSTALL_CMAKEDIR "${SDL_SDL_INSTALL_CMAKEDIR}") + set(SDL_SDLtest_INSTALL_CMAKEFILENAME "SDL3testTargets.cmake") +endif() + +export(TARGETS SDL3_Headers NAMESPACE "SDL3::" FILE "SDL3headersTargets.cmake") + +if(SDL_SHARED) + export(TARGETS SDL3-shared NAMESPACE "SDL3::" FILE "SDL3sharedTargets.cmake") +endif() + +if(SDL_STATIC) + export(TARGETS SDL3-static NAMESPACE "SDL3::" FILE "SDL3staticTargets.cmake") +endif() + +if(SDL_TEST_LIBRARY) + export(TARGETS SDL3_test NAMESPACE "SDL3::" FILE "SDL3testTargets.cmake") +endif() + +sdl_cmake_config_find_pkg_config_commands(SDL_FIND_PKG_CONFIG_COMMANDS + COLLECTOR SDL3-collector + CONFIG_COMPONENT_FOUND_NAME SDL3_SDL3-static_FOUND +) +sdl_cmake_config_find_pkg_config_commands(SDL_TEST_FIND_PKG_CONFIG_COMMANDS + COLLECTOR SDL3_test-collector + CONFIG_COMPONENT_FOUND_NAME SDL3_SDL3_test_FOUND +) + +include(CMakePackageConfigHelpers) +configure_package_config_file(cmake/SDL3Config.cmake.in SDL3Config.cmake + NO_SET_AND_CHECK_MACRO + PATH_VARS CMAKE_INSTALL_PREFIX + INSTALL_DESTINATION "${SDL_SDL_INSTALL_CMAKEDIR}" +) +write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/SDL3ConfigVersion.cmake" + COMPATIBILITY AnyNewerVersion +) + +sdl_cmake_config_required_modules(sdl_cmake_modules) +if(sdl_cmake_modules) + execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different ${sdl_cmake_modules} "${SDL3_BINARY_DIR}") +endif() + +if(SDL_INSTALL) + + ##### sdl3.pc ##### + configure_sdl3_pc() + if(NOT SDL_FRAMEWORK) + install(FILES ${SDL3_BINARY_DIR}/sdl3.pc DESTINATION "${SDL_PKGCONFIG_INSTALLDIR}") + endif() + + ##### Installation targets #####() + + install(TARGETS SDL3_Headers EXPORT SDL3headersTargets) + + if(SDL_SHARED) + install(TARGETS SDL3-shared EXPORT SDL3sharedTargets + PUBLIC_HEADER DESTINATION "${SDL_INSTALL_HEADERSDIR}" + ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" + LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" + RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" + FRAMEWORK DESTINATION "." + RESOURCE DESTINATION "${SDL_SDL_INSTALL_RESOURCEDIR}" + ) + if(MSVC) + SDL_install_pdb(SDL3-shared "${CMAKE_INSTALL_BINDIR}") + endif() + endif() + + if(SDL_STATIC) + install(TARGETS SDL3-static EXPORT SDL3staticTargets + ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" + FRAMEWORK DESTINATION "." + RESOURCE DESTINATION "${SDL_SDLstatic_INSTALL_RESOURCEDIR}" + ) + if(MSVC) + SDL_install_pdb(SDL3-static "${CMAKE_INSTALL_LIBDIR}") + endif() + endif() + + if(SDL_TEST_LIBRARY) + install(TARGETS SDL3_test EXPORT SDL3testTargets + ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" + FRAMEWORK DESTINATION "." + RESOURCE DESTINATION "${SDL_SDLtest_INSTALL_RESOURCEDIR}" + ) + if(MSVC) + SDL_install_pdb(SDL3_test "${CMAKE_INSTALL_LIBDIR}") + endif() + endif() + + ##### Install CMake Targets ##### + + install(EXPORT SDL3headersTargets + FILE "SDL3headersTargets.cmake" + NAMESPACE SDL3:: + DESTINATION "${SDL_SDL_INSTALL_CMAKEDIR}" + ) + + if(SDL_SHARED) + install(EXPORT SDL3sharedTargets + FILE "SDL3sharedTargets.cmake" + NAMESPACE SDL3:: + DESTINATION "${SDL_SDL_INSTALL_CMAKEDIR}" + ) + endif() + + if(SDL_STATIC) + install(EXPORT SDL3staticTargets + FILE "${SDL_SDLstatic_INSTALL_CMAKEFILENAME}" + NAMESPACE SDL3:: + DESTINATION "${SDL_SDLstatic_INSTALL_CMAKEDIR}" + ) + endif() + + if(SDL_TEST_LIBRARY) + install(EXPORT SDL3testTargets + FILE "${SDL_SDLtest_INSTALL_CMAKEFILENAME}" + NAMESPACE SDL3:: + DESTINATION "${SDL_SDLtest_INSTALL_CMAKEDIR}" + ) + endif() + + install(FILES + ${CMAKE_CURRENT_BINARY_DIR}/SDL3Config.cmake + ${CMAKE_CURRENT_BINARY_DIR}/SDL3ConfigVersion.cmake + ${sdl_cmake_modules} + DESTINATION "${SDL_SDL_INSTALL_REAL_CMAKEDIR}" + ) + + if(NOT SDL_FRAMEWORK) + install(FILES ${SDL3_INCLUDE_FILES} + DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/SDL3" + ) + if(SDL_TEST_LIBRARY) + install(FILES ${SDL3_TEST_INCLUDE_FILES} + DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/SDL3" + ) + endif() + + install(FILES "LICENSE.txt" DESTINATION "${SDL_INSTALL_LICENSEDIR}") + endif() + + if(SDL_INSTALL_CPACK) + if(SDL_FRAMEWORK) + set(CPACK_GENERATOR "DragNDrop") + elseif(MSVC) + set(CPACK_GENERATOR "ZIP") + else() + set(CPACK_GENERATOR "TGZ") + endif() + configure_file(cmake/CPackProjectConfig.cmake.in CPackProjectConfig.cmake @ONLY) + set(CPACK_PROJECT_CONFIG_FILE "${SDL3_BINARY_DIR}/CPackProjectConfig.cmake") + # CPACK_SOURCE_PACKAGE_FILE_NAME must end with "-src" (so we can block creating a source archive) + set(CPACK_SOURCE_PACKAGE_FILE_NAME "SDL${PROJECT_VERSION_MAJOR}-${PROJECT_VERSION}-src") + set(CPACK_PACKAGE_DIRECTORY "${CMAKE_BINARY_DIR}/dist") + include(CPack) + endif() + + if(ANDROID) + if(TARGET SDL3-jar) + set(SDL_INSTALL_JAVADIR "${CMAKE_INSTALL_DATAROOTDIR}/java" CACHE PATH "Path where to install java clases + java sources") + set(PROGUARD_RULES_PATH "${CMAKE_CURRENT_SOURCE_DIR}/android-project/app/proguard-rules.pro") + # install_jar or $ does not work on Windows: a SDL3.jar symlink is not generated + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/SDL3-${SDL3_VERSION}.jar" + DESTINATION "${SDL_INSTALL_JAVADIR}/SDL3") + install(FILES "${PROGUARD_RULES_PATH}" RENAME "proguard.txt" + DESTINATION "${SDL_INSTALL_JAVADIR}/SDL3") + configure_package_config_file(cmake/SDL3jarTargets.cmake.in SDL3jarTargets.cmake + INSTALL_DESTINATION "${SDL_SDL_INSTALL_CMAKEDIR}" + PATH_VARS SDL_INSTALL_JAVADIR + NO_CHECK_REQUIRED_COMPONENTS_MACRO + INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}" + ) + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/SDL3jarTargets.cmake" + DESTINATION "${SDL_SDL_INSTALL_CMAKEDIR}" + ) + endif() + if(TARGET SDL3-javasources) + install(FILES "${SDL3_BINARY_DIR}/SDL3-${SDL3_VERSION}-sources.jar" + DESTINATION "${SDL_INSTALL_JAVADIR}/SDL3") + endif() + endif() + + if(SDL_INSTALL_DOCS) + SDL_generate_manpages( + HEADERS_DIR "${PROJECT_SOURCE_DIR}/include/SDL3" + SYMBOL "SDL_Init" + WIKIHEADERS_PL_PATH "${CMAKE_CURRENT_SOURCE_DIR}/build-scripts/wikiheaders.pl" + REVISION "${SDL_REVISION}" + ) + if(TARGET SDL3-javadoc) + set(SDL_INSTALL_JAVADOCDIR "${CMAKE_INSTALL_DATAROOTDIR}/javadoc" CACHE PATH "Path where to install SDL3 javadoc") + install(FILES "${SDL3_BINARY_DIR}/SDL3-${SDL3_VERSION}-javadoc.jar" + DESTINATION "${SDL_INSTALL_JAVADOCDIR}/SDL3") + endif() + endif() +endif() + +##### Uninstall target ##### + +if(SDL_UNINSTALL) + if(NOT TARGET uninstall) + configure_file(cmake/cmake_uninstall.cmake.in cmake_uninstall.cmake IMMEDIATE @ONLY) + + add_custom_target(uninstall + COMMAND ${CMAKE_COMMAND} -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake") + endif() +endif() + +##### Tests subproject (must appear after the install/uninstall targets) ##### + +if(SDL_TESTS) + set(HAVE_TESTS ON) + enable_testing() + add_subdirectory(test) +endif() + +##### Examples subproject (must appear after the install/uninstall targets) ##### + +if(SDL_EXAMPLES) + set(HAVE_EXAMPLES ON) + add_subdirectory(examples) +endif() + +##### Fix Objective C builds ##### +string(APPEND CMAKE_OBJC_FLAGS " ${CMAKE_C_FLAGS}") + +SDL_PrintSummary() +debug_show_sdl_deps() -- cgit v1.2.3