2023-02-28 06:20:30 +03:00
cmake_minimum_required ( VERSION 3.16 )
2023-01-09 16:11:54 +03:00
if ( CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR )
2022-10-20 19:47:17 +03:00
message ( FATAL_ERROR "Prevented in-tree build. Please create a build directory outside of the SDL source code and run \" cmake -S ${ CMAKE_SOURCE_DIR } -B .\ " from there" )
2015-06-21 18:33:46 +03:00
endif ( )
2023-01-09 16:11:54 +03:00
# See docs/release_checklist.md
2024-05-01 19:34:25 +03:00
project ( SDL3 LANGUAGES C VERSION "3.1.2" )
2016-01-05 09:25:54 +03:00
2022-07-23 16:29:13 +03:00
if ( CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR )
2022-11-22 07:28:58 +03:00
set ( SDL3_SUBPROJECT OFF )
2022-07-23 16:29:13 +03:00
else ( )
2022-11-22 07:28:58 +03:00
set ( SDL3_SUBPROJECT ON )
2022-07-23 16:29:13 +03:00
endif ( )
2022-07-21 15:08:19 +03:00
# 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 ( )
2021-10-05 19:34:29 +03:00
2015-06-21 18:33:46 +03:00
include ( CheckLibraryExists )
include ( CheckIncludeFile )
2022-10-29 04:20:30 +03:00
include ( CheckLanguage )
2015-06-21 18:33:46 +03:00
include ( CheckSymbolExists )
2017-08-28 05:15:57 +03:00
include ( CheckCSourceCompiles )
2015-06-21 18:33:46 +03:00
include ( CheckCSourceRuns )
include ( CheckCCompilerFlag )
2021-02-02 07:25:24 +03:00
include ( CheckCXXCompilerFlag )
2015-06-21 18:33:46 +03:00
include ( CheckStructHasMember )
include ( CMakeDependentOption )
2023-01-23 05:04:35 +03:00
include ( CMakeParseArguments )
2022-09-27 02:08:04 +03:00
include ( CMakePushCheckState )
2016-10-02 01:11:18 +03:00
include ( GNUInstallDirs )
2022-06-17 03:58:45 +03:00
2023-02-28 06:20:30 +03:00
if ( NOT DEFINED OpenGL_GL_PREFERENCE )
set ( OpenGL_GL_PREFERENCE GLVND )
endif ( )
2022-11-01 15:06:39 +03:00
find_package ( PkgConfig )
2022-11-22 07:28:58 +03:00
list ( APPEND CMAKE_MODULE_PATH "${SDL3_SOURCE_DIR}/cmake" )
2023-02-28 06:20:30 +03:00
include ( "${SDL3_SOURCE_DIR}/cmake/macros.cmake" )
include ( "${SDL3_SOURCE_DIR}/cmake/sdlchecks.cmake" )
include ( "${SDL3_SOURCE_DIR}/cmake/sdlcompilers.cmake" )
2024-05-26 23:40:47 +03:00
include ( "${SDL3_SOURCE_DIR}/cmake/sdlcpu.cmake" )
2023-02-28 06:20:30 +03:00
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" )
2024-04-17 16:06:01 +03:00
include ( "${SDL3_SOURCE_DIR}/cmake/PreseedMSVCCache.cmake" )
2024-07-25 18:46:35 +03:00
include ( "${SDL3_SOURCE_DIR}/cmake/PreseedEmscriptenCache.cmake" )
2023-02-28 06:20:30 +03:00
SDL_DetectCompiler ( )
2024-05-26 23:40:47 +03:00
SDL_DetectTargetCPUArchitectures ( SDL_CPUS )
2024-07-25 18:46:35 +03:00
2022-05-04 18:40:11 +03:00
# Increment this if there is an incompatible change - but if that happens,
2022-11-22 07:28:58 +03:00
# we should rename the library from SDL3 to SDL4, at which point this would
2022-05-04 18:40:11 +03:00
# reset to 0 anyway.
2022-11-29 22:14:00 +03:00
set ( SDL_SO_VERSION_MAJOR "0" )
2023-01-09 16:11:54 +03:00
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}" )
2022-05-04 18:40:11 +03:00
2023-01-09 16:11:54 +03:00
if ( PROJECT_VERSION_MINOR MATCHES "[02468]$" )
math ( EXPR SDL_DYLIB_COMPAT_VERSION_MAJOR "100 * ${PROJECT_VERSION_MINOR} + 1" )
2022-11-29 22:57:19 +03:00
set ( SDL_DYLIB_COMPAT_VERSION_MINOR "0" )
math ( EXPR SDL_DYLIB_CURRENT_VERSION_MAJOR "${SDL_DYLIB_COMPAT_VERSION_MAJOR}" )
2023-01-09 16:11:54 +03:00
set ( SDL_DYLIB_CURRENT_VERSION_MINOR "${PROJECT_VERSION_PATCH}" )
2022-11-29 22:14:00 +03:00
else ( )
2023-01-09 16:11:54 +03:00
math ( EXPR SDL_DYLIB_COMPAT_VERSION_MAJOR "100 * ${PROJECT_VERSION_MINOR} + ${PROJECT_VERSION_PATCH} + 1" )
2022-11-29 22:14:00 +03:00
set ( SDL_DYLIB_COMPAT_VERSION_MINOR "0" )
2022-11-29 22:57:19 +03:00
math ( EXPR SDL_DYLIB_CURRENT_VERSION_MAJOR "${SDL_DYLIB_COMPAT_VERSION_MAJOR}" )
set ( SDL_DYLIB_CURRENT_VERSION_MINOR "0" )
2022-11-29 22:14:00 +03:00
endif ( )
2023-02-28 06:20:30 +03:00
set ( SDL_DYLIB_CURRENT_VERSION_PATCH "0" )
2023-01-09 16:11:54 +03:00
set ( SDL_DYLIB_COMPAT_VERSION_PATCH "0" )
2015-06-21 18:33:46 +03:00
2023-02-28 06:20:30 +03:00
set ( SDL_DYLIB_CURRENT_VERSION "${SDL_DYLIB_CURRENT_VERSION_MAJOR}.${SDL_DYLIB_CURRENT_VERSION_MINOR}.${SDL_DYLIB_CURRENT_VERSION_PATCH}" )
2023-01-09 16:11:54 +03:00
set ( SDL_DYLIB_COMPAT_VERSION "${SDL_DYLIB_COMPAT_VERSION_MAJOR}.${SDL_DYLIB_COMPAT_VERSION_MINOR}.${SDL_DYLIB_COMPAT_VERSION_PATCH}" )
2022-05-04 18:40:11 +03:00
2023-02-28 06:20:30 +03:00
message ( DEBUG "SDL_SO_VERSION=${SDL_SO_VERSION} SDL_DYLIB_CURRENT_VERSION=${SDL_DYLIB_CURRENT_VERSION} SDL_DYLIB_COMPAT_VERSION=${SDL_DYLIB_COMPAT_VERSION}" )
2015-06-21 18:33:46 +03:00
2023-01-29 08:12:40 +03:00
set ( SDL_FRAMEWORK_VERSION "A" )
2022-11-25 06:31:25 +03:00
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 )
2022-11-25 05:15:23 +03:00
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " -D_GNU_SOURCE=1" )
2022-11-25 05:15:23 +03:00
list ( APPEND CMAKE_REQUIRED_INCLUDES ${ SDL_CHECK_REQUIRED_INCLUDES } )
list ( APPEND CMAKE_REQUIRED_LINK_OPTIONS ${ SDL_CHECK_REQUIRED_LINK_OPTIONS } )
2022-11-25 00:38:29 +03:00
2023-01-08 20:45:59 +03:00
# Get the platform
SDL_DetectCMakePlatform ( )
2022-11-26 03:00:06 +03:00
# Don't mistake macOS for unix
cmake: disable UNIX_SYS by default for Android
This force disables SDL_OSS, SDL_ALSA, SDL_JACK, SDL_ESD,
SDL_PIPEWIRE, SDL_ARTS, SDL_NAS, SDL_SNDIO, SDL_LIBSAMPLERATE,
SDL_RPATH, SDL_CLOCK_GETTIME and SDL_X11.
2022-06-16 04:27:52 +03:00
if ( UNIX AND NOT ANDROID AND NOT APPLE AND NOT RISCOS )
2015-06-21 18:33:46 +03:00
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 ( )
2021-04-04 07:16:30 +03:00
# 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
2023-08-22 17:51:41 +03:00
# for the time being. This default will change to ON once this becomes
# commonly supported in browsers or the Emscripten team makes a single
2021-04-04 07:16:30 +03:00
# binary work everywhere.
if ( UNIX_OR_MAC_SYS AND NOT EMSCRIPTEN )
2023-02-28 06:20:30 +03:00
set ( SDL_PTHREADS_DEFAULT ON )
2015-06-21 18:33:46 +03:00
else ( )
2023-02-28 06:20:30 +03:00
set ( SDL_PTHREADS_DEFAULT OFF )
2015-06-21 18:33:46 +03:00
endif ( )
2022-06-24 15:41:06 +03:00
if ( UNIX_SYS OR ANDROID )
2023-02-28 06:20:30 +03:00
set ( SDL_CLOCK_GETTIME_DEFAULT ON )
2022-06-24 15:41:06 +03:00
else ( )
2023-02-28 06:20:30 +03:00
set ( SDL_CLOCK_GETTIME_DEFAULT OFF )
2022-06-24 15:41:06 +03:00
endif ( )
2019-07-08 23:46:52 +03:00
# The hidraw support doesn't catch Xbox, PS4 and Nintendo controllers,
2019-07-31 19:20:55 +03:00
# so we'll just use libusb when it's available. libusb does not support iOS,
# so we default to yes on iOS.
2024-04-08 20:18:28 +03:00
if ( IOS OR TVOS OR VISIONOS OR WATCHOS OR ANDROID )
2023-05-28 03:51:53 +03:00
set ( SDL_HIDAPI_LIBUSB_AVAILABLE FALSE )
2019-07-08 23:46:52 +03:00
else ( )
2023-05-28 03:51:53 +03:00
set ( SDL_HIDAPI_LIBUSB_AVAILABLE TRUE )
2019-07-08 23:46:52 +03:00
endif ( )
2023-02-28 06:20:30 +03:00
set ( SDL_ASSEMBLY_DEFAULT OFF )
if ( USE_CLANG OR USE_GCC OR USE_INTELCC OR MSVC_VERSION GREATER 1400 )
set ( SDL_ASSEMBLY_DEFAULT ON )
2015-06-21 18:33:46 +03:00
endif ( )
2023-02-28 06:20:30 +03:00
set ( SDL_GCC_ATOMICS_DEFAULT OFF )
2023-01-07 14:52:19 +03:00
if ( USE_GCC OR USE_CLANG OR USE_INTELCC OR USE_QCC )
2023-02-28 06:20:30 +03:00
set ( SDL_GCC_ATOMICS_DEFAULT ON )
2017-06-08 22:07:55 +03:00
endif ( )
2021-03-04 18:40:56 +03:00
# Default option knobs
2022-11-26 03:45:13 +03:00
set ( SDL_LIBC_DEFAULT ON )
2022-11-26 03:53:16 +03:00
set ( SDL_SYSTEM_ICONV_DEFAULT ON )
2024-05-03 02:50:04 +03:00
if ( WINDOWS OR MACOS OR IOS OR TVOS OR VISIONOS OR WATCHOS )
2022-11-26 03:53:16 +03:00
set ( SDL_SYSTEM_ICONV_DEFAULT OFF )
2021-03-04 18:40:56 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
if ( MSVC )
2021-11-04 09:02:48 +03:00
if ( NOT SDL_LIBC )
# Make sure /RTC1 is disabled, otherwise it will use functions from the CRT
foreach ( flag_var
C M A K E _ C _ F L A G S C M A K E _ C _ F L A G S _ D E B U G C M A K E _ C _ F L A G S _ R E L E A S E
C M A K E _ C _ F L A G S _ M I N S I Z E R E L C M A K E _ C _ F L A G S _ R E L W I T H D E B I N F O )
string ( REGEX REPLACE "/RTC(su|[1su])" "" ${ flag_var } "${${flag_var}}" )
endforeach ( flag_var )
endif ( )
2021-11-23 18:56:50 +03:00
if ( MSVC_CLANG )
2021-11-26 21:20:50 +03:00
# clang-cl treats /W4 as '-Wall -Wextra' -- we don't need -Wextra
2021-11-23 18:56:50 +03:00
foreach ( flag_var
C M A K E _ C _ F L A G S C M A K E _ C _ F L A G S _ D E B U G C M A K E _ C _ F L A G S _ R E L E A S E
C M A K E _ C _ F L A G S _ M I N S I Z E R E L C M A K E _ C _ F L A G S _ R E L W I T H D E B I N F O )
string ( REGEX REPLACE "/W4" "/W3" ${ flag_var } "${${flag_var}}" )
endforeach ( flag_var )
endif ( )
2015-06-21 18:33:46 +03:00
endif ( )
2023-02-28 06:20:30 +03:00
set ( SDL_SHARED_DEFAULT ON )
set ( SDL_STATIC_DEFAULT ON )
2015-06-21 18:33:46 +03:00
2023-02-28 06:20:30 +03:00
set ( SDL_SHARED_AVAILABLE ON )
2023-08-01 04:35:57 +03:00
set ( SDL_STATIC_AVAILABLE ON )
2023-02-28 04:15:39 +03:00
2023-02-28 06:20:30 +03:00
# All these *_DEFAULT vars will default to ON if not specified,
# so you only need to override them if they need to be disabled.
2015-06-21 18:33:46 +03:00
if ( EMSCRIPTEN )
# Set up default values for the currently supported set of subsystems:
2018-04-10 18:03:54 +03:00
# Emscripten/Javascript does not have assembly support, a dynamic library
2021-04-04 07:16:30 +03:00
# loading architecture, or low-level CPU inspection.
2023-02-28 06:20:30 +03:00
set ( SDL_ASSEMBLY_DEFAULT OFF )
set ( SDL_SHARED_AVAILABLE OFF )
2015-06-21 18:33:46 +03:00
endif ( )
2023-02-16 22:29:36 +03:00
if ( VITA OR PSP OR PS2 OR N3DS OR RISCOS )
2023-02-28 06:20:30 +03:00
set ( SDL_SHARED_AVAILABLE OFF )
2020-12-18 16:42:57 +03:00
endif ( )
2023-11-28 18:45:33 +03:00
if ( ( RISCOS OR UNIX_SYS ) AND NOT ( LINUX OR NETBSD OR OPENBSD ) )
2023-11-28 00:03:56 +03:00
set ( SDL_OSS_DEFAULT ON )
else ( )
set ( SDL_OSS_DEFAULT OFF )
endif ( )
2023-02-28 06:20:30 +03:00
if ( SDL_SHARED_DEFAULT AND SDL_STATIC_DEFAULT AND SDL_SHARED_AVAILABLE )
2023-02-28 04:15:39 +03:00
if ( DEFINED BUILD_SHARED_LIBS )
# When defined, use BUILD_SHARED_LIBS as default
if ( BUILD_SHARED_LIBS )
2023-02-28 06:20:30 +03:00
set ( SDL_STATIC_DEFAULT OFF )
2023-02-28 04:15:39 +03:00
else ( )
2023-02-28 06:20:30 +03:00
set ( SDL_SHARED_DEFAULT OFF )
2023-02-28 04:15:39 +03:00
endif ( )
else ( )
# Default to just building the shared library
2023-02-28 06:20:30 +03:00
set ( SDL_STATIC_DEFAULT OFF )
2023-02-28 04:15:39 +03:00
endif ( )
2022-05-27 02:40:11 +03:00
endif ( )
2024-02-22 09:53:54 +03:00
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 )
2015-06-21 18:33:46 +03:00
endif ( )
2024-02-22 09:53:54 +03:00
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 ( 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 )
2024-03-11 00:27:42 +03:00
define_sdl_subsystem ( Dialog )
2015-06-21 18:33:46 +03:00
2023-08-01 04:35:57 +03:00
cmake_dependent_option ( SDL_FRAMEWORK "Build SDL libraries as Apple Framework" OFF "APPLE" OFF )
if ( SDL_FRAMEWORK )
set ( SDL_STATIC_AVAILABLE FALSE )
endif ( )
2024-02-25 18:33:46 +03:00
if ( UNIX AND NOT ANDROID AND NOT RISCOS AND NOT SDL_FRAMEWORK )
set ( SDL_RPATH_DEFAULT ON )
else ( )
set ( SDL_RPATH_DEFAULT OFF )
endif ( )
2024-07-25 19:13:31 +03:00
set ( SDL_PRESEED_AVAILABLE OFF )
if ( COMMAND SDL_Preseed_CMakeCache )
set ( SDL_PRESEED_AVAILABLE ON )
endif ( )
2022-01-11 19:34:14 +03:00
# Allow some projects to be built conditionally.
2023-01-18 20:05:54 +03:00
set_option ( SDL_DISABLE_INSTALL "Disable installation of SDL3" ${ SDL3_SUBPROJECT } )
2023-03-18 02:27:27 +03:00
cmake_dependent_option ( SDL_DISABLE_INSTALL_CPACK "Create binary SDL3 archive using CPack" ${ SDL3_SUBPROJECT } "NOT SDL_DISABLE_INSTALL" ON )
2024-05-02 20:44:58 +03:00
cmake_dependent_option ( SDL_DISABLE_INSTALL_DOCS "Install docs for SDL3" ON "NOT SDL_DISABLE_INSTALL;NOT SDL_FRAMEWORK" ON )
2023-01-18 20:05:54 +03:00
set_option ( SDL_DISABLE_UNINSTALL "Disable uninstallation of SDL3" OFF )
2024-07-25 19:13:31 +03:00
cmake_dependent_option ( SDL_PRESEED "Preseed CMake cache to speed up configuration" ON "${SDL_PRESEED_AVAILABLE}" OFF )
2022-01-11 19:34:14 +03:00
2023-03-27 13:03:42 +03:00
cmake_dependent_option ( SDL_DISABLE_ANDROID_JAR "Disable creation of SDL3.jar" ${ SDL3_SUBPROJECT } "ANDROID" ON )
2021-10-05 17:43:35 +03:00
option_string ( SDL_ASSERTIONS "Enable internal sanity checks (auto/disabled/release/enabled/paranoid)" "auto" )
2022-11-26 01:06:38 +03:00
set_option ( SDL_ASSEMBLY "Enable assembly routines" ${ SDL_ASSEMBLY_DEFAULT } )
2023-02-25 02:21:15 +03:00
dep_option ( SDL_AVX "Use AVX assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF )
2023-03-21 14:55:32 +03:00
dep_option ( SDL_AVX2 "Use AVX2 assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF )
2023-03-25 02:18:50 +03:00
dep_option ( SDL_AVX512F "Use AVX512F assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF )
2022-11-25 03:27:44 +03:00
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 )
2023-03-21 18:57:09 +03:00
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 )
2022-11-25 03:27:44 +03:00
dep_option ( SDL_MMX "Use MMX assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF )
2023-02-26 02:22:23 +03:00
dep_option ( SDL_ALTIVEC "Use Altivec assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_POWERPC32 OR SDL_CPU_POWERPC64" OFF )
2022-11-25 03:27:44 +03:00
dep_option ( SDL_ARMSIMD "Use SIMD assembly blitters on ARM" OFF "SDL_ASSEMBLY;SDL_CPU_ARM32" OFF )
2023-04-04 22:47:00 +03:00
dep_option ( SDL_ARMNEON "Use NEON assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_ARM32 OR SDL_CPU_ARM64" OFF )
2022-11-25 04:18:16 +03:00
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 )
2022-11-25 03:27:44 +03:00
2022-11-26 03:45:13 +03:00
set_option ( SDL_LIBC "Use the system C library" ${ SDL_LIBC_DEFAULT } )
2022-11-26 03:53:16 +03:00
set_option ( SDL_SYSTEM_ICONV "Use iconv() from system-installed libraries" ${ SDL_SYSTEM_ICONV_DEFAULT } )
2023-11-23 04:30:56 +03:00
set_option ( SDL_LIBICONV "Prefer iconv() from libiconv, if available, over libc version" OFF )
2023-02-28 06:20:30 +03:00
set_option ( SDL_GCC_ATOMICS "Use gcc builtin atomics" ${ SDL_GCC_ATOMICS_DEFAULT } )
2024-02-22 10:00:08 +03:00
dep_option ( SDL_DBUS "Enable D-Bus 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 )
2024-04-08 20:18:28 +03:00
dep_option ( SDL_OPENGL "Include OpenGL support" ON "SDL_VIDEO;NOT IOS;NOT VISIONOS;NOT TVOS;NOT WATCHOS" OFF )
2024-07-18 19:27:16 +03:00
dep_option ( SDL_OPENGLES "Include OpenGL ES support" ON "SDL_VIDEO;NOT VISIONOS;NOT TVOS;NOT WATCHOS" OFF )
2023-02-28 06:20:30 +03:00
set_option ( SDL_PTHREADS "Use POSIX threads for multi-threading" ${ SDL_PTHREADS_DEFAULT } )
2021-10-05 17:43:35 +03:00
dep_option ( SDL_PTHREADS_SEM "Use pthread semaphores" ON "SDL_PTHREADS" OFF )
2024-02-22 10:00:08 +03:00
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 )
2021-10-05 17:43:35 +03:00
dep_option ( SDL_ALSA_SHARED "Dynamically load ALSA audio support" ON "SDL_ALSA" OFF )
2024-02-22 10:00:08 +03:00
dep_option ( SDL_JACK "Support the JACK audio API" ${ UNIX_SYS } "SDL_AUDIO" OFF )
2022-11-23 06:50:20 +03:00
dep_option ( SDL_JACK_SHARED "Dynamically load JACK audio support" ON "SDL_JACK" OFF )
2021-10-05 17:43:35 +03:00
set_option ( SDL_PIPEWIRE "Use Pipewire audio" ${ UNIX_SYS } )
dep_option ( SDL_PIPEWIRE_SHARED "Dynamically load Pipewire support" ON "SDL_PIPEWIRE" OFF )
2024-02-22 10:00:08 +03:00
dep_option ( SDL_PULSEAUDIO "Use PulseAudio" ${ UNIX_SYS } "SDL_AUDIO" OFF )
2021-10-05 17:43:35 +03:00
dep_option ( SDL_PULSEAUDIO_SHARED "Dynamically load PulseAudio support" ON "SDL_PULSEAUDIO" OFF )
2024-02-22 10:00:08 +03:00
dep_option ( SDL_SNDIO "Support the sndio audio API" ${ UNIX_SYS } "SDL_AUDIO" OFF )
2022-11-22 22:04:10 +03:00
dep_option ( SDL_SNDIO_SHARED "Dynamically load the sndio audio API" ON "SDL_SNDIO" OFF )
2024-02-25 18:33:46 +03:00
set_option ( SDL_RPATH "Use an rpath when linking SDL" ${ SDL_RPATH_DEFAULT } )
2023-02-28 06:20:30 +03:00
set_option ( SDL_CLOCK_GETTIME "Use clock_gettime() instead of gettimeofday()" ${ SDL_CLOCK_GETTIME_DEFAULT } )
2024-02-24 19:31:48 +03:00
dep_option ( SDL_X11 "Use X11 video driver" ${ UNIX_SYS } "SDL_VIDEO" OFF )
2021-10-05 17:43:35 +03:00
dep_option ( SDL_X11_SHARED "Dynamically load X11 support" ON "SDL_X11" OFF )
2022-04-26 23:41:28 +03:00
set ( SDL_X11_OPTIONS Xcursor Xdbe XInput Xfixes Xrandr Xscrnsaver XShape )
2015-06-21 18:33:46 +03:00
foreach ( _SUB ${ SDL_X11_OPTIONS } )
2021-10-05 17:43:35 +03:00
string ( TOUPPER "SDL_X11_${_SUB}" _OPT )
dep_option ( ${ _OPT } "Enable ${_SUB} support" ON "SDL_X11" OFF )
2015-06-21 18:33:46 +03:00
endforeach ( )
2024-02-22 10:00:08 +03:00
dep_option ( SDL_WAYLAND "Use Wayland video driver" ${ UNIX_SYS } "SDL_VIDEO" OFF )
2021-10-05 17:43:35 +03:00
dep_option ( SDL_WAYLAND_SHARED "Dynamically load Wayland support" ON "SDL_WAYLAND" OFF )
2022-01-12 15:05:12 +03:00
dep_option ( SDL_WAYLAND_LIBDECOR "Use client-side window decorations on Wayland" ON "SDL_WAYLAND" OFF )
2022-08-26 02:56:20 +03:00
dep_option ( SDL_WAYLAND_LIBDECOR_SHARED "Dynamically load libdecor support" ON "SDL_WAYLAND_LIBDECOR;SDL_WAYLAND_SHARED" OFF )
2024-02-22 10:00:08 +03:00
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 )
2024-08-01 16:49:02 +03:00
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 )
2024-02-22 10:00:08 +03:00
dep_option ( SDL_RENDER_METAL "Enable the Metal render driver" ON "SDL_RENDER;${APPLE}" OFF )
2023-02-28 06:20:30 +03:00
dep_option ( SDL_VIVANTE "Use Vivante EGL video driver" ON "${UNIX_SYS};SDL_CPU_ARM32" OFF )
2024-07-25 19:31:40 +03:00
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 )
2024-02-22 10:00:08 +03:00
dep_option ( SDL_METAL "Enable Metal support" ON "APPLE" OFF )
2024-02-22 17:25:33 +03:00
dep_option ( SDL_KMSDRM "Use KMS DRM video driver" ${ UNIX_SYS } "SDL_VIDEO" OFF )
2021-10-05 17:43:35 +03:00
dep_option ( SDL_KMSDRM_SHARED "Dynamically load KMS DRM support" ON "SDL_KMSDRM" OFF )
2022-09-15 20:39:35 +03:00
set_option ( SDL_OFFSCREEN "Use offscreen video driver" ON )
2024-02-22 10:00:08 +03:00
dep_option ( SDL_DUMMYCAMERA "Support the dummy camera driver" ON SDL_CAMERA OFF )
2021-11-11 20:16:44 +03:00
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 )
2023-07-24 09:11:09 +03:00
dep_option ( SDL_HIDAPI "Enable the HIDAPI subsystem" ON "NOT VISIONOS" OFF )
2023-08-09 20:55:36 +03:00
dep_option ( SDL_HIDAPI_LIBUSB "Use libusb for low level joystick drivers" ON SDL_HIDAPI_LIBUSB_AVAILABLE OFF )
2023-08-14 16:48:14 +03:00
dep_option ( SDL_HIDAPI_LIBUSB_SHARED "Dynamically load libusb support" ON SDL_HIDAPI_LIBUSB OFF )
2022-07-26 03:41:43 +03:00
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 )
2022-11-25 04:57:00 +03:00
set_option ( SDL_LIBUDEV "Enable libudev support" ON )
2021-10-05 17:43:35 +03:00
set_option ( SDL_ASAN "Use AddressSanitizer to detect memory errors" OFF )
2023-03-09 17:45:07 +03:00
set_option ( SDL_CCACHE "Use Ccache to speed up build" OFF )
2022-10-26 06:26:42 +03:00
set_option ( SDL_CLANG_TIDY "Run clang-tidy static analysis" OFF )
2015-06-21 18:33:46 +03:00
2023-02-28 06:20:30 +03:00
set ( SDL_VENDOR_INFO "" CACHE STRING "Vendor name and/or version to add to SDL_REVISION" )
2022-10-05 16:14:08 +03:00
2023-02-28 06:20:30 +03:00
cmake_dependent_option ( SDL_SHARED "Build a shared version of the library" ${ SDL_SHARED_DEFAULT } ${ SDL_SHARED_AVAILABLE } OFF )
2023-08-01 04:35:57 +03:00
cmake_dependent_option ( SDL_STATIC "Build a static version of the library" ${ SDL_STATIC_DEFAULT } ${ SDL_STATIC_AVAILABLE } OFF )
2023-07-28 02:51:01 +03:00
option ( SDL_TEST_LIBRARY "Build the SDL3_test library" ON )
2015-06-21 18:33:46 +03:00
2023-07-28 02:51:01 +03:00
dep_option ( SDL_TESTS "Build the test directory" OFF SDL_TEST_LIBRARY OFF )
2023-04-19 17:28:39 +03:00
dep_option ( SDL_INSTALL_TESTS "Install test-cases" OFF "NOT SDL_DISABLE_INSTALL;NOT SDL_FRAMEWORK;NOT WINDOWS_STORE" OFF )
2023-07-16 20:38:17 +03:00
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" )
2016-01-05 09:26:32 +03:00
2024-07-23 07:56:57 +03:00
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}" )
2023-02-28 06:20:30 +03:00
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 ( )
2023-07-16 20:38:17 +03:00
if ( NOT ( SDL_SHARED OR SDL_STATIC ) )
message ( FATAL_ERROR "SDL_SHARED and SDL_STATIC cannot both be disabled" )
endif ( )
2024-07-25 19:13:31 +03:00
if ( SDL_PRESEED )
SDL_Preseed_CMakeCache ( )
endif ( )
2023-02-28 06:20:30 +03:00
if ( SDL_SHARED )
add_library ( SDL3-shared SHARED )
add_library ( SDL3::SDL3-shared ALIAS SDL3-shared )
SDL_AddCommonCompilerFlags ( SDL3-shared )
2024-02-21 02:51:40 +03:00
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 ( )
2023-02-28 06:20:30 +03:00
endif ( )
if ( SDL_STATIC )
add_library ( SDL3-static STATIC )
add_library ( SDL3::SDL3-static ALIAS SDL3-static )
SDL_AddCommonCompilerFlags ( SDL3-static )
2024-02-21 02:51:40 +03:00
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 ( )
2023-02-28 06:20:30 +03:00
endif ( )
2023-07-28 02:51:01 +03:00
if ( SDL_TEST_LIBRARY )
2023-02-28 06:20:30 +03:00
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 ( )
if ( WINDOWS_STORE )
2024-07-18 23:32:49 +03:00
sdl_compile_definitions ( PRIVATE "SDL_BUILDING_WINRT=1" "WINAPI_FAMILY=WINAPI_FAMILY_APP" )
sdl_compile_options ( PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:/ZW>" "$<$<COMPILE_LANGUAGE:CXX>:-EHsc>" )
2023-02-28 06:20:30 +03:00
endif ( )
2023-09-20 05:24:08 +03:00
check_linker_supports_version_file ( HAVE_WL_VERSION_SCRIPT )
2023-02-28 06:20:30 +03:00
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; }"
H A V E _ G C C _ N O _ C Y G W I N )
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 (
P R I V A T E
2024-08-22 19:52:00 +03:00
" $ { S D L 3 _ B I N A R Y _ D I R } / i n c l u d e - c o n f i g - $ < L O W E R _ C A S E : $ < C O N F I G > > / b u i l d _ c o n f i g "
2023-02-28 06:20:30 +03:00
" $ { S D L 3 _ B I N A R Y _ D I R } / i n c l u d e "
" $ { S D L 3 _ S O U R C E _ D I R } / i n c l u d e "
)
# 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 ) )
2024-05-07 17:53:23 +03:00
sdl_compile_options ( NO_EXPORT PRIVATE "$<BUILD_INTERFACE:-idirafter${SDL3_SOURCE_DIR}/src/video/khronos>" )
2023-02-28 06:20:30 +03:00
else ( )
2024-05-07 17:53:23 +03:00
sdl_include_directories ( NO_EXPORT SYSTEM PRIVATE "$<BUILD_INTERFACE:${SDL3_SOURCE_DIR}/src/video/khronos>" )
2021-06-10 13:20:39 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
# General source files
2023-02-28 06:20:30 +03:00
sdl_glob_sources (
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / a t o m i c / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / a u d i o / * . c "
2023-11-28 03:27:58 +03:00
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / c a m e r a / * . c "
2023-02-28 06:20:30 +03:00
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / c o r e / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / c p u i n f o / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / d y n a p i / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / e v e n t s / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / f i l e / * . c "
2024-03-16 18:15:13 +03:00
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / f i l e s y s t e m / * . c "
2023-02-28 06:20:30 +03:00
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / j o y s t i c k / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / h a p t i c / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / h i d a p i / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / l o c a l e / * . c "
main: Added _optional_ callback entry points.
This lets apps optionally have a handful of callbacks for their entry points instead of a single main function. If used, the actual main/SDL_main/whatever entry point will be implemented in the single-header library SDL_main.h and the app will implement four separate functions:
First:
int SDL_AppInit(int argc, char **argv);
This will be called once before anything else. argc/argv work like they always do. If this returns 0, the app runs. If it returns < 0, the app calls SDL_AppQuit and terminates with an exit code that reports an error to the platform. If it returns > 0, the app calls SDL_AppQuit and terminates with an exit code that reports success to the platform. This function should not go into an infinite mainloop; it should do any one-time startup it requires and then return.
Then:
int SDL_AppIterate(void);
This is called over and over, possibly at the refresh rate of the display or some other metric that the platform dictates. This is where the heart of your app runs. It should return as quickly as reasonably possible, but it's not a "run one memcpy and that's all the time you have" sort of thing. The app should do any game updates, and render a frame of video. If it returns < 0, SDL will call SDL_AppQuit and terminate the process with an exit code that reports an error to the platform. If it returns > 0, the app calls SDL_AppQuit and terminates with an exit code that reports success to the platform. If it returns 0, then SDL_AppIterate will be called again at some regular frequency. The platform may choose to run this more or less (perhaps less in the background, etc), or it might just call this function in a loop as fast as possible. You do not check the event queue in this function (SDL_AppEvent exists for that).
Next:
int SDL_AppEvent(const SDL_Event *event);
This will be called once for each event pushed into the SDL queue. This may be called from any thread, and possibly in parallel to SDL_AppIterate. The fields in event do not need to be free'd (as you would normally need to do for SDL_EVENT_DROP_FILE, etc), and your app should not call SDL_PollEvent, SDL_PumpEvent, etc, as SDL will manage this for you. Return values are the same as from SDL_AppIterate(), so you can terminate in response to SDL_EVENT_QUIT, etc.
Finally:
void SDL_AppQuit(void);
This is called once before terminating the app--assuming the app isn't being forcibly killed or crashed--as a last chance to clean up. After this returns, SDL will call SDL_Quit so the app doesn't have to (but it's safe for the app to call it, too). Process termination proceeds as if the app returned normally from main(), so atexit handles will run, if your platform supports that.
The app does not implement SDL_main if using this. To turn this on, define SDL_MAIN_USE_CALLBACKS before including SDL_main.h. Defines like SDL_MAIN_HANDLED and SDL_MAIN_NOIMPL are also respected for callbacks, if the app wants to do some sort of magic main implementation thing.
In theory, on most platforms these can be implemented in the app itself, but this saves some #ifdefs in the app and lets everyone struggle less against some platforms, and might be more efficient in the long run, too.
On some platforms, it's possible this is the only reasonable way to go, but we haven't actually hit one that 100% requires it yet (but we will, if we want to write a RetroArch backend, for example).
Using the callback entry points works on every platform, because on platforms that don't require them, we can fake them with a simple loop in an internal implementation of the usual SDL_main.
The primary way we expect people to write SDL apps is with SDL_main, and this is not intended to replace it. If the app chooses to use this, it just removes some platform-specific details they might have to otherwise manage, and maybe removes a barrier to entry on some future platform.
Fixes #6785.
Reference PR #8247.
2023-11-02 01:40:41 +03:00
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / m a i n / * . c "
2023-02-28 06:20:30 +03:00
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / m i s c / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / p o w e r / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / r e n d e r / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / r e n d e r / * / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / s e n s o r / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / s t d l i b / * . c "
2024-03-08 22:38:46 +03:00
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / s t o r a g e / * . c "
2023-02-28 06:20:30 +03:00
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / * . c "
Add time and realtime clock functions
Adds functions to query the system's realtime clock, convert time intervals to/from a calendar date and time in either UTC or the local time, and perform time related calculations.
An SDL_Time type (a time interval represented in nanoseconds), and SDL_DateTime struct (broken down calendar date and time) were added to facilitate this functionality.
Querying the system time results in a value expressed in nanoseconds since the Unix epoch (Jan 1, 1970) in UTC +0000. Conversions to and from the various platform epochs and units are performed when required.
Any direct handling of timezones and DST were intentionally avoided. The offset from UTC is provided when converting from UTC to a local time by calculating the difference between the original UTC and the resulting local time, but no other timezone or DST information is used.
The preferred date formatting and 12/24 hour time for the system locale can be retrieved via global preferences.
Helper functions for obtaining the day of week or day or year for calendar date, and getting the number of days in a month in a given year are provided for convenience. These are simple, but useful for performing various time related calculations.
An automated test for time conversion is included, as is a simple standalone test to display the current system date and time onscreen along with a calendar, the rendering of which demonstrates the use of the utility functions (press up/down to increment or decrement the current month, and keys 1-5 to change the date and time formats).
2024-02-29 21:06:26 +03:00
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t i m e / * . c "
2023-02-28 06:20:30 +03:00
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t i m e r / * . c "
2023-09-07 01:08:19 +03:00
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / v i d e o / * . c "
2023-02-28 06:20:30 +03:00
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / v i d e o / y u v 2 r g b / * . c "
)
2024-08-23 03:16:08 +03:00
if ( NOT SDL_LIBC )
sdl_glob_sources (
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / l i b m / * . c "
)
endif ( )
2023-10-02 12:00:06 +03:00
if ( MSVC AND TARGET SDL3-shared )
if ( SDL_CPU_X64 )
enable_language ( ASM_MASM )
2024-01-04 19:46:00 +03:00
set ( asm_src "${SDL3_SOURCE_DIR}/src/stdlib/SDL_mslibc_x64.masm" )
2023-10-02 12:00:06 +03:00
target_compile_options ( SDL3-shared PRIVATE "$<$<COMPILE_LANGUAGE:ASM_MASM>:/nologo>" )
set_property ( SOURCE "${asm_src}" PROPERTY LANGUAGE "ASM_MASM" )
target_sources ( SDL3-shared PRIVATE "${asm_src}" )
2023-11-02 20:33:44 +03:00
elseif ( SDL_CPU_ARM32 OR SDL_CPU_ARM64 )
2023-10-02 12:00:06 +03:00
# FIXME: ARM assembler (armasm.exe/armasm64.exe) is NOT ASM_MASM, and does currently not work with CMake
# (https://gitlab.kitware.com/cmake/cmake/-/issues/18912)
endif ( )
endif ( )
2015-06-21 18:33:46 +03:00
2023-03-21 23:56:03 +03:00
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
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / l i b m / e _ e x p . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / l i b m / e _ l o g . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / l i b m / e _ l o g 1 0 . c "
P R O P E R T Y S K I P _ P R E C O M P I L E _ H E A D E R S 1 )
endif ( )
2015-06-21 18:33:46 +03:00
2022-06-15 07:17:59 +03:00
set ( SDL_DEFAULT_ASSERT_LEVEL_CONFIGURED 1 )
if ( SDL_ASSERTIONS MATCHES "^(auto|)$" )
2015-06-21 18:33:46 +03:00
# Do nada - use optimization settings to determine the assertion level
2022-06-15 07:17:59 +03:00
set ( SDL_DEFAULT_ASSERT_LEVEL )
set ( SDL_DEFAULT_ASSERT_LEVEL_CONFIGURED 0 )
elseif ( SDL_ASSERTIONS MATCHES "^(disabled|0)$" )
2015-06-21 18:33:46 +03:00
set ( SDL_DEFAULT_ASSERT_LEVEL 0 )
2022-06-15 07:17:59 +03:00
elseif ( SDL_ASSERTIONS MATCHES "^(release|1)$" )
2015-06-21 18:33:46 +03:00
set ( SDL_DEFAULT_ASSERT_LEVEL 1 )
2022-06-15 07:17:59 +03:00
elseif ( SDL_ASSERTIONS MATCHES "^(enabled|2)$" )
2015-06-21 18:33:46 +03:00
set ( SDL_DEFAULT_ASSERT_LEVEL 2 )
2022-06-15 07:17:59 +03:00
elseif ( SDL_ASSERTIONS MATCHES "^(paranoid|3)$" )
2015-06-21 18:33:46 +03:00
set ( SDL_DEFAULT_ASSERT_LEVEL 3 )
else ( )
2023-02-28 06:20:30 +03:00
message ( FATAL_ERROR "unknown assertion level" )
2015-06-21 18:33:46 +03:00
endif ( )
2021-10-05 17:43:35 +03:00
set ( HAVE_ASSERTIONS ${ SDL_ASSERTIONS } )
2015-06-21 18:33:46 +03:00
2021-10-05 17:43:35 +03:00
if ( NOT SDL_BACKGROUNDING_SIGNAL STREQUAL "OFF" )
2023-02-28 06:20:30 +03:00
sdl_compile_definitions ( PRIVATE "SDL_BACKGROUNDING_SIGNAL=${SDL_BACKGROUNDING_SIGNAL}" )
2019-03-15 22:51:05 +03:00
endif ( )
2021-10-05 17:43:35 +03:00
if ( NOT SDL_FOREGROUNDING_SIGNAL STREQUAL "OFF" )
2023-02-28 06:20:30 +03:00
sdl_compile_definitions ( PRIVATE "SDL_FOREGROUNDING_SIGNAL=${SDL_FOREGROUNDING_SIGNAL}" )
2019-03-15 22:51:05 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
# Compiler option evaluation
2023-01-07 14:52:19 +03:00
if ( USE_GCC OR USE_CLANG OR USE_INTELCC OR USE_QCC )
2021-10-05 17:43:35 +03:00
if ( SDL_GCC_ATOMICS )
2015-06-21 18:33:46 +03:00
check_c_source_compiles ( " int main(int argc, char **argv ) {
i n t a ;
v o i d * 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 ) ;
2022-03-13 19:10:52 +03:00
__sync_bool_compare_and_swap ( &x, y, z ) ;
2023-03-30 00:49:01 +03:00
r e t u r n 0 ; } " C O M P I L E R _ S U P P O R T S _ G C C _ A T O M I C S )
set ( HAVE_GCC_ATOMICS ${ COMPILER_SUPPORTS_GCC_ATOMICS } )
2015-06-21 18:33:46 +03:00
if ( NOT HAVE_GCC_ATOMICS )
check_c_source_compiles ( " int main(int argc, char **argv ) {
i n t a ;
__sync_lock_test_and_set ( &a, 1 ) ;
2022-03-13 19:10:52 +03:00
__sync_lock_release ( &a ) ;
2023-03-30 00:49:01 +03:00
r e t u r n 0 ; } " C O M P I L E R _ S U P P O R T S _ S Y N C _ L O C K _ T E S T _ A N D _ S E T )
set ( HAVE_GCC_SYNC_LOCK_TEST_AND_SET ${ COMPILER_SUPPORTS_SYNC_LOCK_TEST_AND_SET } )
2015-06-21 18:33:46 +03:00
endif ( )
endif ( )
2023-01-26 00:27:47 +03:00
cmake_push_check_state ( )
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " -fvisibility=hidden -Werror" )
2023-01-26 00:27:47 +03:00
check_c_source_compiles ( "
#if !defined(__GNUC__) || __GNUC__ < 4
#error SDL only uses visibility attributes in GCC 4 or newer
#endif
2023-01-26 01:32:32 +03:00
__attribute__ ( ( visibility(\ "default\" ) ) ) i n t foo ( void ) ;
__attribute__ ( ( visibility(\ "hidden\" ) ) ) i n t bar ( void ) ;
i n t foo ( void ) { r e t u r n 0 ; }
i n t bar ( void ) { r e t u r n 1 ; }
i n t main ( void ) { r e t u r n 0 ; } " H A V E _ G C C _ F V I S I B I L I T Y )
2023-01-26 00:27:47 +03:00
cmake_pop_check_state ( )
2017-08-19 01:52:25 +03:00
if ( APPLE )
2023-02-28 06:20:30 +03:00
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" )
2022-10-06 01:39:47 +03:00
endif ( )
2023-02-28 06:20:30 +03:00
endif ( )
2022-10-06 01:39:47 +03:00
2023-02-28 06:20:30 +03:00
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" )
2023-01-07 20:08:46 +03:00
endif ( )
2020-12-27 05:20:10 +03:00
elseif ( NOT OPENBSD )
2022-12-18 23:48:24 +03:00
cmake_push_check_state ( )
2023-02-28 06:20:30 +03:00
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" )
2021-08-22 09:40:54 +03:00
endif ( )
endif ( )
2015-06-21 18:33:46 +03:00
endif ( )
2023-02-28 06:20:30 +03:00
2022-05-06 17:59:36 +03:00
if ( MSVC )
2023-02-28 06:20:30 +03:00
sdl_compile_definitions (
P R I V A T E
" _ C R T _ S E C U R E _ N O _ D E P R E C A T E "
" _ C R T _ N O N S T D C _ N O _ D E P R E C A T E "
" _ C R T _ S E C U R E _ N O _ W A R N I N G S "
)
2022-08-21 22:15:06 +03:00
2023-02-28 06:20:30 +03:00
# CET support was added in VS 2019 16.7
2022-09-05 18:58:49 +03:00
if ( MSVC_VERSION GREATER 1926 AND CMAKE_GENERATOR_PLATFORM MATCHES "Win32|x64" )
2023-02-28 06:20:30 +03:00
# Mark SDL3.dll as compatible with Control-flow Enforcement Technology (CET)
sdl_shared_link_options ( "-CETCOMPAT" )
2022-08-21 22:15:06 +03:00
endif ( )
2022-05-06 17:59:36 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
2022-10-06 03:16:07 +03:00
if ( CMAKE_C_COMPILER_ID STREQUAL "MSVC" )
2022-06-15 21:48:54 +03:00
# Due to a limitation of Microsoft's LTO implementation, LTO must be disabled for memcpy and memset.
2022-07-26 22:47:52 +03:00
# The same applies to various functions normally belonging in the C library (for x86 architecture).
2023-02-28 06:20:30 +03:00
set_property ( SOURCE "${SDL3_SOURCE_DIR}/src/stdlib/SDL_mslibc.c" APPEND_STRING PROPERTY COMPILE_FLAGS " /GL-" )
2022-06-15 21:48:54 +03:00
endif ( )
2021-10-05 17:43:35 +03:00
if ( SDL_ASSEMBLY )
2023-03-20 01:11:16 +03:00
set ( HAVE_ASSEMBLY TRUE )
2023-02-25 02:21:15 +03:00
2023-03-20 01:11:16 +03:00
if ( SDL_MMX )
cmake_push_check_state ( )
2023-03-21 22:38:36 +03:00
if ( USE_GCC OR USE_CLANG OR USE_INTELCC )
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " -mmmx" )
2015-06-21 18:33:46 +03:00
endif ( )
2023-03-20 01:11:16 +03:00
check_c_source_compiles ( "
#include <mmintrin.h>
v o i d ints_add ( int *dest, int *a, int *b, unsigned size ) {
for ( ; size >= 2; size -= 2, dest += 2, a += 2, b += 2 ) {
* ( _ _ m 6 4 * ) d e s t = _mm_add_pi32 ( *(__m64* ) a , * ( _ _ m 6 4 * ) b ) ;
}
}
i n t main ( int argc, char *argv[] ) {
ints_add ( ( int* ) 0, ( int* ) 0, ( int* ) 0, 0 ) ;
r e t u r n 0 ;
} " C O M P I L E R _ S U P P O R T S _ M M X )
cmake_pop_check_state ( )
if ( COMPILER_SUPPORTS_MMX )
set ( HAVE_MMX TRUE )
endif ( )
endif ( )
if ( SDL_SSE )
cmake_push_check_state ( )
2023-03-21 22:38:36 +03:00
if ( USE_GCC OR USE_CLANG OR USE_INTELCC )
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " -msse" )
2015-06-21 18:33:46 +03:00
endif ( )
2023-03-20 01:11:16 +03:00
check_c_source_compiles ( "
#include <xmmintrin.h>
v o i d 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 ) ) ) ;
}
}
i n t main ( int argc, char **argv ) {
floats_add ( ( float* ) 0, ( float* ) 0, ( float* ) 0, 0 ) ;
r e t u r n 0 ;
} " C O M P I L E R _ S U P P O R T S _ S S E )
cmake_pop_check_state ( )
if ( COMPILER_SUPPORTS_SSE )
set ( HAVE_SSE TRUE )
endif ( )
endif ( )
if ( SDL_SSE2 )
cmake_push_check_state ( )
2023-03-21 22:38:36 +03:00
if ( USE_GCC OR USE_CLANG OR USE_INTELCC )
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " -msse2" )
2015-06-21 18:33:46 +03:00
endif ( )
2023-03-20 01:11:16 +03:00
check_c_source_compiles ( "
#include <emmintrin.h>
v o i d 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 ) ) ) ;
}
}
i n t main ( int argc, char **argv ) {
doubles_add ( ( double* ) 0, ( double* ) 0, ( double* ) 0, 0 ) ;
r e t u r n 0 ;
} " C O M P I L E R _ S U P P O R T S _ S S E 2 )
cmake_pop_check_state ( )
if ( COMPILER_SUPPORTS_SSE2 )
set ( HAVE_SSE2 TRUE )
endif ( )
endif ( )
2023-03-21 14:55:32 +03:00
if ( SDL_SSE3 )
cmake_push_check_state ( )
2023-03-21 22:38:36 +03:00
if ( USE_GCC OR USE_CLANG OR USE_INTELCC )
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " -msse3" )
2023-03-21 14:55:32 +03:00
endif ( )
check_c_source_compiles ( "
#include <pmmintrin.h>
v o i d 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 ) ) ) ;
}
}
i n t main ( int argc, char **argv ) {
ints_add ( ( int* ) 0, ( int* ) 0, ( int* ) 0, 0 ) ;
r e t u r n 0 ;
} " C O M P I L E R _ S U P P O R T S _ S S E 3 )
cmake_pop_check_state ( )
if ( COMPILER_SUPPORTS_SSE3 )
set ( HAVE_SSE3 TRUE )
endif ( )
endif ( )
2023-03-21 18:57:09 +03:00
if ( SDL_SSE4_1 )
2023-03-21 14:55:32 +03:00
cmake_push_check_state ( )
2023-03-21 22:38:36 +03:00
if ( USE_GCC OR USE_CLANG OR USE_INTELCC )
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " -msse4.1" )
2023-03-21 14:55:32 +03:00
endif ( )
check_c_source_compiles ( "
#include <smmintrin.h>
v o i d 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 ) ) ) ;
}
}
i n t main ( int argc, char **argv ) {
ints_mul ( ( int* ) 0, ( int* ) 0, ( int* ) 0, 0 ) ;
r e t u r n 0 ;
2023-03-21 18:57:09 +03:00
} " C O M P I L E R _ S U P P O R T S _ S S E 4 _ 1 )
2023-03-21 14:55:32 +03:00
cmake_pop_check_state ( )
2023-03-21 18:57:09 +03:00
if ( COMPILER_SUPPORTS_SSE4_1 )
set ( HAVE_SSE4_1 TRUE )
2023-03-21 14:55:32 +03:00
endif ( )
endif ( )
2023-03-21 18:57:09 +03:00
if ( SDL_SSE4_2 )
2023-03-21 14:55:32 +03:00
cmake_push_check_state ( )
2023-03-21 22:38:36 +03:00
if ( USE_GCC OR USE_CLANG OR USE_INTELCC )
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " -msse4.2" )
2023-03-21 14:55:32 +03:00
endif ( )
check_c_source_compiles ( "
#include <nmmintrin.h>
u n s i g n e d calc_crc32c ( const char *text, unsigned len ) {
u n s i g n e d c r c 3 2 c = ~ 0 ;
for ( ; len >= 4; len -= 4, text += 4 ) {
c r c 3 2 c = ( u n s i g n e d ) _mm_crc32_u32 ( crc32c, *(unsigned* ) t e x t ) ;
}
r e t u r n c r c 3 2 c ;
}
i n t main ( int argc, char **argv ) {
calc_crc32c ( \"SDL_SSE4\",8);
r e t u r n 0 ;
2023-03-21 18:57:09 +03:00
} " C O M P I L E R _ S U P P O R T S _ S S E 4 _ 2 )
2023-03-21 14:55:32 +03:00
cmake_pop_check_state ( )
2023-03-21 18:57:09 +03:00
if ( COMPILER_SUPPORTS_SSE4_2 )
set ( HAVE_SSE4_2 TRUE )
2023-03-21 14:55:32 +03:00
endif ( )
endif ( )
2023-03-20 01:11:16 +03:00
if ( SDL_AVX )
cmake_push_check_state ( )
2023-03-21 22:38:36 +03:00
if ( USE_GCC OR USE_CLANG OR USE_INTELCC )
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " -mavx" )
2023-03-20 01:11:16 +03:00
endif ( )
check_c_source_compiles ( "
#include <immintrin.h>
v o i d 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 ) ) ) ;
}
}
i n t main ( int argc, char **argv ) {
floats_add ( ( float* ) 0, ( float* ) 0, ( float* ) 0, 0 ) ;
r e t u r n 0 ;
} " C O M P I L E R _ S U P P O R T S _ A V X )
cmake_pop_check_state ( )
if ( COMPILER_SUPPORTS_AVX )
set ( HAVE_AVX TRUE )
endif ( )
endif ( )
2023-03-21 14:55:32 +03:00
if ( SDL_AVX2 )
cmake_push_check_state ( )
2023-03-21 22:38:36 +03:00
if ( USE_GCC OR USE_CLANG OR USE_INTELCC )
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " -mavx2" )
2023-03-21 14:55:32 +03:00
endif ( )
check_c_source_compiles ( "
#include <immintrin.h>
v o i d 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 ) ) ) ;
}
}
i n t main ( int argc, char **argv ) {
ints_add ( ( int* ) 0, ( int* ) 0, ( int* ) 0, 0 ) ;
r e t u r n 0 ;
} " C O M P I L E R _ S U P P O R T S _ A V X 2 )
cmake_pop_check_state ( )
if ( COMPILER_SUPPORTS_AVX2 )
set ( HAVE_AVX2 TRUE )
endif ( )
endif ( )
2023-03-25 02:18:50 +03:00
if ( SDL_AVX512F )
2023-03-21 14:55:32 +03:00
cmake_push_check_state ( )
2023-03-21 22:38:36 +03:00
if ( USE_GCC OR USE_CLANG OR USE_INTELCC )
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " -mavx512f" )
2023-03-21 14:55:32 +03:00
endif ( )
check_c_source_compiles ( "
#include <immintrin.h>
v o i d 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 ) ) ) ;
}
}
i n t main ( int argc, char **argv ) {
floats_add ( ( float* ) 0, ( float* ) 0, ( float* ) 0, 0 ) ;
r e t u r n 0 ;
} " C O M P I L E R _ S U P P O R T S _ A V X 5 1 2 F )
cmake_pop_check_state ( )
if ( COMPILER_SUPPORTS_AVX512F )
set ( HAVE_AVX512F TRUE )
endif ( )
endif ( )
2023-03-20 01:11:16 +03:00
if ( USE_GCC OR USE_CLANG )
# TODO: Those all seem to be quite GCC specific - needs to be
# reworked for better compiler support
2015-06-21 18:33:46 +03:00
2021-10-05 17:43:35 +03:00
if ( SDL_ALTIVEC )
2022-12-18 23:48:24 +03:00
cmake_push_check_state ( )
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " -maltivec" )
2015-06-21 18:33:46 +03:00
check_c_source_compiles ( "
#include <altivec.h>
v e c t o r u n s i g n e d i n t vzero ( ) {
r e t u r n vec_splat_u32 ( 0 ) ;
}
2023-03-20 01:11:16 +03:00
i n t main ( int argc, char **argv ) { r e t u r n 0 ; } " C O M P I L E R _ S U P P O R T S _ A L T I V E C )
2022-12-18 23:48:24 +03:00
cmake_pop_check_state ( )
2023-03-20 01:11:16 +03:00
if ( COMPILER_SUPPORTS_ALTIVEC )
2023-03-15 06:56:55 +03:00
set ( HAVE_ALTIVEC TRUE )
2015-06-21 18:33:46 +03:00
set ( SDL_ALTIVEC_BLITTERS 1 )
2023-02-28 06:20:30 +03:00
sdl_compile_options ( PRIVATE "-maltivec" )
2023-03-15 06:56:55 +03:00
set_property ( SOURCE "${SDL3_SOURCE_DIR}/src/video/SDL_blit_N.c" APPEND PROPERTY COMPILE_DEFINITIONS "SDL_ENABLE_ALTIVEC" )
2023-03-21 23:56:03 +03:00
set_property ( SOURCE "${SDL3_SOURCE_DIR}/src/video/SDL_blit_N.c" PROPERTY SKIP_PRECOMPILE_HEADERS 1 )
2015-06-21 18:33:46 +03:00
endif ( )
endif ( )
2019-10-25 06:17:19 +03:00
2022-11-25 04:18:16 +03:00
if ( SDL_LSX )
cmake_push_check_state ( )
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " -mlsx" )
2023-01-09 10:52:07 +03:00
check_c_source_compiles ( "
2022-11-25 04:18:16 +03:00
#ifndef __loongarch_sx
#error Assembler CPP flag not enabled
#endif
2023-03-20 01:11:16 +03:00
i n t main ( int argc, char **argv ) { r e t u r n 0 ; } " C O M P I L E R _ S U P P O R T S _ L S X )
2022-11-25 04:18:16 +03:00
check_include_file ( "lsxintrin.h" HAVE_LSXINTRIN_H )
cmake_pop_check_state ( )
2023-03-20 01:11:16 +03:00
if ( COMPILER_SUPPORTS_LSX AND HAVE_LSXINTRIN_H )
2024-01-18 15:26:09 +03:00
set_property ( SOURCE "${SDL3_SOURCE_DIR}/src/video/yuv2rgb/yuv_rgb_lsx.c" APPEND PROPERTY COMPILE_OPTIONS "-mlsx" )
2023-01-09 10:52:07 +03:00
set ( HAVE_LSX TRUE )
2022-11-25 04:18:16 +03:00
endif ( )
endif ( )
if ( SDL_LASX )
cmake_push_check_state ( )
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " -mlasx" )
2023-01-09 10:52:07 +03:00
check_c_source_compiles ( "
2022-11-25 04:18:16 +03:00
#ifndef __loongarch_asx
#error Assembler CPP flag not enabled
#endif
2023-03-20 01:11:16 +03:00
i n t main ( int argc, char **argv ) { r e t u r n 0 ; } " C O M P I L E R _ S U P P O R T S _ L A S X )
2022-11-25 04:18:16 +03:00
check_include_file ( "lasxintrin.h" HAVE_LASXINTRIN_H )
cmake_pop_check_state ( )
2023-03-20 01:11:16 +03:00
if ( COMPILER_SUPPORTS_LASX AND HAVE_LASXINTRIN_H )
2023-01-09 10:52:07 +03:00
set ( HAVE_LASX TRUE )
2022-11-25 04:18:16 +03:00
endif ( )
endif ( )
2023-04-04 22:47:00 +03:00
if ( SDL_ARMNEON )
check_c_source_compiles ( "
#include <arm_neon.h>
v o i d 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 ) ) ) ;
}
}
i n t main ( int argc, char *argv[] ) {
floats_add ( ( float* ) 0, ( float* ) 0, ( float* ) 0, 0 ) ;
r e t u r n 0 ;
} " C O M P I L E R _ S U P P O R T S _ A R M N E O N )
if ( COMPILER_SUPPORTS_ARMNEON )
set ( HAVE_ARMNEON TRUE )
endif ( )
endif ( )
2015-06-21 18:33:46 +03:00
endif ( )
endif ( )
2023-02-25 02:21:15 +03:00
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 ( )
2023-03-21 18:57:09 +03:00
if ( NOT HAVE_SSE4_1 )
set ( SDL_DISABLE_SSE4_1 1 )
2023-03-21 14:55:32 +03:00
endif ( )
2023-03-21 18:57:09 +03:00
if ( NOT HAVE_SSE4_2 )
set ( SDL_DISABLE_SSE4_2 1 )
2023-03-21 14:55:32 +03:00
endif ( )
2023-03-20 01:11:16 +03:00
if ( NOT HAVE_AVX )
set ( SDL_DISABLE_AVX 1 )
endif ( )
2023-03-21 14:55:32 +03:00
if ( NOT HAVE_AVX2 )
set ( SDL_DISABLE_AVX2 1 )
endif ( )
if ( NOT HAVE_AVX512F )
set ( SDL_DISABLE_AVX512F 1 )
endif ( )
2023-02-26 02:35:57 +03:00
if ( NOT HAVE_LSX )
set ( SDL_DISABLE_LSX 1 )
endif ( )
if ( NOT HAVE_LASX )
set ( SDL_DISABLE_LASX 1 )
endif ( )
2023-02-26 03:51:19 +03:00
if ( NOT HAVE_ARMNEON )
set ( SDL_DISABLE_NEON 1 )
endif ( )
2023-10-02 12:00:06 +03:00
set ( SDL_DISABLE_ALLOCA 0 )
check_include_file ( "alloca.h" "HAVE_ALLOCA_H" )
if ( MSVC )
check_include_file ( "malloc.h" "HAVE_MALLOC" )
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 ( )
2023-02-28 06:20:30 +03:00
# TODO: Can't deactivate on FreeBSD? w/o LIBC, SDL_stdinc.h can't define anything.
2021-10-05 17:43:35 +03:00
if ( SDL_LIBC )
2023-02-28 06:20:30 +03:00
set ( available_headers )
set ( HAVE_LIBC TRUE )
set ( headers_to_check
f l o a t . h
i c o n v . h
i n t t y p e s . h
l i m i t s . h
m a l l o c . h
m a t h . h
m e m o r y . h
s i g n a l . h
s t d a r g . h
2024-08-22 19:21:26 +03:00
s t d b o o l . h
2023-02-28 06:20:30 +03:00
s t d d e f . h
s t d i n t . h
s t d i o . h
s t d l i b . h
s t r i n g . h
s t r i n g s . h
s y s / t y p e s . h
Add time and realtime clock functions
Adds functions to query the system's realtime clock, convert time intervals to/from a calendar date and time in either UTC or the local time, and perform time related calculations.
An SDL_Time type (a time interval represented in nanoseconds), and SDL_DateTime struct (broken down calendar date and time) were added to facilitate this functionality.
Querying the system time results in a value expressed in nanoseconds since the Unix epoch (Jan 1, 1970) in UTC +0000. Conversions to and from the various platform epochs and units are performed when required.
Any direct handling of timezones and DST were intentionally avoided. The offset from UTC is provided when converting from UTC to a local time by calculating the difference between the original UTC and the resulting local time, but no other timezone or DST information is used.
The preferred date formatting and 12/24 hour time for the system locale can be retrieved via global preferences.
Helper functions for obtaining the day of week or day or year for calendar date, and getting the number of days in a month in a given year are provided for convenience. These are simple, but useful for performing various time related calculations.
An automated test for time conversion is included, as is a simple standalone test to display the current system date and time onscreen along with a calendar, the rendering of which demonstrates the use of the utility functions (press up/down to increment or decrement the current month, and keys 1-5 to change the date and time formats).
2024-02-29 21:06:26 +03:00
t i m e . h
2023-02-28 06:20:30 +03:00
w c h a r . 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
2023-10-02 12:00:06 +03:00
a b s a c o s a c o s f a s i n a s i n f a t a n a t a n 2 a t a n 2 f a t a n f a t o f a t o i
2024-02-29 04:51:48 +03:00
b c o p y
2023-02-28 06:20:30 +03:00
c a l l o c c e i l c e i l f c o p y s i g n c o p y s i g n f c o s c o s f
_ E x i t e x p e x p f
f a b s f a b s f f l o o r f l o o r f f m o d f m o d f f o p e n 6 4 f r e e f s e e k o f s e e k o 6 4
g e t e n v
2024-06-24 20:37:20 +03:00
_ i 6 4 t o a i n d e x i t o a
2023-02-28 06:20:30 +03:00
l o g l o g 1 0 l o g 1 0 f l o g f l r o u n d l r o u n d f _ l t o a
m a l l o c m e m c m p m e m c p y m e m m o v e m e m s e t m o d f m o d f f
p o w p o w f p u t e n v
r e a l l o c r i n d e x r o u n d r o u n d f
s c a l b n s c a l b n f s e t e n v s i n s i n f s q r s q r t s q r t f s s c a n f s t r c h r
s t r c m p s t r l c a t s t r l c p y s t r l e n s t r n c m p s t r n l e n
2023-12-04 01:42:28 +03:00
s t r r c h r s t r s t r s t r n s t r s t r t o d s t r t o k _ r s t r t o l s t r t o l l s t r t o u l s t r t o u l l
2023-02-28 06:20:30 +03:00
t a n t a n f t r u n c t r u n c f
u n s e t e n v
v s n p r i n t f v s s c a n f
w c s n l e n w c s c m p w c s d u p w c s l c a t w c s l c p y w c s l e n w c s n c m p w c s s t r w c s t o l
)
if ( WINDOWS )
list ( APPEND symbols_to_check
stdlib: Improve Unicode support and consistency in string comparison functions.
SDL_strcasecmp (even when calling into a C runtime) does not work with
Unicode chars, and depending on the user's locale, might not work with
even basic ASCII strings.
This implements the function from scratch, using "case-folding,"
which is a more robust method that deals with various languages. It
involves a hashtable of a few hundred codepoints that are "uppercase" and
how to map them to lowercase equivalents (possibly increasing the size of
the string in the process). The vast majority of human languages (and
Unicode) do not have letters with different cases, but still, this static
table takes about 10 kilobytes on a 64-bit machine.
Even this will fail in one known case: the Turkish 'i' folds differently
if you're writing in Turkish vs other languages. Generally this is seen as
unfortunate collateral damage in cases where you can't specify the language
in use.
In addition to case-folding the codepoints, the new functions also know how
to decode the various formats to turn them into codepoints in the first
place, instead of blindly stepping by one byte (or one wchar_t) per
character.
Also included is casefolding.txt from the Unicode Consortium and a perl
script to generate the hashtable from that text file, so we can trivially
update this if new languages are added in the future.
A simple test using the new function:
```c
#include <SDL3/SDL.h>
int main(void)
{
const char *a = "α ε η";
const char *b = "Α Ε Η";
SDL_Log(" strcasecmp(\"%s\", \"%s\") == %d\n", a, b, strcasecmp(a, b));
SDL_Log("SDL_strcasecmp(\"%s\", \"%s\") == %d\n", a, b, SDL_strcasecmp(a, b));
return 0;
}
```
Produces:
```
INFO: strcasecmp("α ε η", "Α Ε Η") == 32
INFO: SDL_strcasecmp("α ε η", "Α Ε Η") == 0
```
glibc strcasecmp() fails to compare a Greek lowercase string to its uppercase
equivalent, even with a UTF-8 locale, but SDL_strcasecmp() works.
Other SDL_stdinc.h functions are changed to be more consistent, which is to
say they now ignore any C runtime and often dictate that only English-based
low-ASCII works with them.
Fixes Issue #9313.
2024-03-26 20:22:38 +03:00
_ s t r r e v _ u i 6 4 t o a _ u i t o a _ u l t o a _ w c s d u p
2023-02-28 06:20:30 +03:00
)
2015-06-21 18:33:46 +03:00
else ( )
2023-02-28 06:20:30 +03:00
list ( APPEND symbols_to_check
stdlib: Improve Unicode support and consistency in string comparison functions.
SDL_strcasecmp (even when calling into a C runtime) does not work with
Unicode chars, and depending on the user's locale, might not work with
even basic ASCII strings.
This implements the function from scratch, using "case-folding,"
which is a more robust method that deals with various languages. It
involves a hashtable of a few hundred codepoints that are "uppercase" and
how to map them to lowercase equivalents (possibly increasing the size of
the string in the process). The vast majority of human languages (and
Unicode) do not have letters with different cases, but still, this static
table takes about 10 kilobytes on a 64-bit machine.
Even this will fail in one known case: the Turkish 'i' folds differently
if you're writing in Turkish vs other languages. Generally this is seen as
unfortunate collateral damage in cases where you can't specify the language
in use.
In addition to case-folding the codepoints, the new functions also know how
to decode the various formats to turn them into codepoints in the first
place, instead of blindly stepping by one byte (or one wchar_t) per
character.
Also included is casefolding.txt from the Unicode Consortium and a perl
script to generate the hashtable from that text file, so we can trivially
update this if new languages are added in the future.
A simple test using the new function:
```c
#include <SDL3/SDL.h>
int main(void)
{
const char *a = "α ε η";
const char *b = "Α Ε Η";
SDL_Log(" strcasecmp(\"%s\", \"%s\") == %d\n", a, b, strcasecmp(a, b));
SDL_Log("SDL_strcasecmp(\"%s\", \"%s\") == %d\n", a, b, SDL_strcasecmp(a, b));
return 0;
}
```
Produces:
```
INFO: strcasecmp("α ε η", "Α Ε Η") == 32
INFO: SDL_strcasecmp("α ε η", "Α Ε Η") == 0
```
glibc strcasecmp() fails to compare a Greek lowercase string to its uppercase
equivalent, even with a UTF-8 locale, but SDL_strcasecmp() works.
Other SDL_stdinc.h functions are changed to be more consistent, which is to
say they now ignore any C runtime and often dictate that only English-based
low-ASCII works with them.
Fixes Issue #9313.
2024-03-26 20:22:38 +03:00
s t r c a s e s t r
2022-11-01 15:08:38 +03:00
)
2023-02-28 06:20:30 +03:00
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 ( )
2015-06-21 18:33:46 +03:00
2024-06-24 22:47:19 +03:00
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 <math.h>
i n t main ( ) {
d o u b l e d = 3 . 1 4 1 5 9 ;
r e t u r n $ { m a t h _ f n } ( d ) ;
}
" L I B C _ H A S _ $ { M A T H _ F N } )
set ( HAVE_ ${ MATH_FN } ${ LIBC_HAS_${MATH_FN } } )
2024-08-23 03:16:08 +03:00
if ( NOT HAVE_ ${ MATH_FN } )
sdl_sources ( "${SDL3_SOURCE_DIR}/src/libm/s_${math_fn}.c" )
endif ( )
2024-06-24 22:47:19 +03:00
check_c_source_compiles ( "
#include <math.h>
i n t main ( ) {
f l o a t f = 3 . 1 4 1 5 9 f ;
r e t u r n $ { m a t h _ f n } ( f ) ;
}
" L I B C _ $ { M A T H _ F N } _ H A N D L E S _ F L O A T )
set ( HAVE_ ${ MATH_FN } _FLOAT_MACRO ${ LIBC_${MATH_FN } _HANDLES_FLOAT} )
check_c_source_compiles ( "
#include <math.h>
i n t main ( ) {
f l o a t f = 3 . 1 4 1 5 9 f ;
r e t u r n $ { m a t h _ f n } f ( f ) ;
}
" L I B C _ H A S _ $ { M A T H _ F N } F )
2024-08-23 03:16:08 +03:00
set ( HAVE_ ${ MATH_FN } F "${LIBC_HAS_${MATH_FN}F}" )
if ( NOT HAVE_ ${ MATH_FN } F )
sdl_sources ( "${SDL3_SOURCE_DIR}/src/libm/s_${math_fn}f.c" )
endif ( )
2024-06-24 22:47:19 +03:00
endforeach ( )
cmake_pop_check_state ( )
2023-02-28 06:20:30 +03:00
if ( NOT WINDOWS )
check_symbol_exists ( getpagesize "unistd.h" HAVE_GETPAGESIZE )
2020-04-13 22:22:09 +03:00
check_symbol_exists ( sigaction "signal.h" HAVE_SIGACTION )
check_symbol_exists ( setjmp "setjmp.h" HAVE_SETJMP )
2023-02-28 06:20:30 +03:00
check_symbol_exists ( nanosleep "time.h" HAVE_NANOSLEEP )
Add time and realtime clock functions
Adds functions to query the system's realtime clock, convert time intervals to/from a calendar date and time in either UTC or the local time, and perform time related calculations.
An SDL_Time type (a time interval represented in nanoseconds), and SDL_DateTime struct (broken down calendar date and time) were added to facilitate this functionality.
Querying the system time results in a value expressed in nanoseconds since the Unix epoch (Jan 1, 1970) in UTC +0000. Conversions to and from the various platform epochs and units are performed when required.
Any direct handling of timezones and DST were intentionally avoided. The offset from UTC is provided when converting from UTC to a local time by calculating the difference between the original UTC and the resulting local time, but no other timezone or DST information is used.
The preferred date formatting and 12/24 hour time for the system locale can be retrieved via global preferences.
Helper functions for obtaining the day of week or day or year for calendar date, and getting the number of days in a month in a given year are provided for convenience. These are simple, but useful for performing various time related calculations.
An automated test for time conversion is included, as is a simple standalone test to display the current system date and time onscreen along with a calendar, the rendering of which demonstrates the use of the utility functions (press up/down to increment or decrement the current month, and keys 1-5 to change the date and time formats).
2024-02-29 21:06:26 +03:00
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 )
2020-04-13 22:22:09 +03:00
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 )
2020-12-18 08:41:23 +03:00
check_symbol_exists ( elf_aux_info "sys/auxv.h" HAVE_ELF_AUX_INFO )
2020-04-13 22:22:09 +03:00
check_symbol_exists ( poll "poll.h" HAVE_POLL )
2024-03-13 00:39:32 +03:00
check_symbol_exists ( memfd_create "sys/mman.h" HAVE_MEMFD_CREATE )
check_symbol_exists ( posix_fallocate "fcntl.h" HAVE_POSIX_FALLOCATE )
2020-04-13 22:22:09 +03:00
2022-10-06 03:37:50 +03:00
if ( SDL_SYSTEM_ICONV )
2023-11-23 04:30:56 +03:00
check_c_source_compiles ( "
#define LIBICONV_PLUG 1 /* in case libiconv header is in include path */
#include <stddef.h>
#include <iconv.h>
i n t main ( int argc, char **argv ) {
2023-11-26 01:55:28 +03:00
r e t u r n ! iconv_open ( NULL,NULL ) ;
2023-11-23 04:30:56 +03:00
} " I C O N V _ I N _ L I B C )
cmake_push_check_state ( )
list ( APPEND CMAKE_REQUIRED_LIBRARIES iconv )
check_c_source_compiles ( "
#include <stddef.h>
#include <iconv.h>
i n t main ( int argc, char **argv ) {
2023-11-26 01:55:28 +03:00
r e t u r n ! iconv_open ( NULL,NULL ) ;
2023-11-23 04:30:56 +03:00
} " I C O N V _ I N _ L I B I C O N V )
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 )
2022-10-05 18:12:08 +03:00
endif ( )
2021-12-03 01:57:00 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
endif ( )
check_struct_has_member ( "struct sigaction" "sa_sigaction" "signal.h" HAVE_SA_SIGACTION )
2024-03-20 17:42:07 +03:00
check_struct_has_member ( "struct stat" "st_mtim" "sys/stat.h" HAVE_ST_MTIM )
2015-06-21 18:33:46 +03:00
endif ( )
else ( )
2022-11-26 04:05:22 +03:00
set ( headers
s t d a r g . h
s t d d e f . h
s t d i n t . 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 ( )
2023-03-23 09:30:23 +03:00
if ( MSVC AND USE_CLANG )
2023-02-28 06:20:30 +03:00
check_c_compiler_flag ( "/Q_no-use-libirc" HAS_Q_NO_USE_LIBIRC )
2023-03-23 09:30:23 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
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.
2023-02-28 06:20:30 +03:00
message ( FATAL_ERROR "SDL_HAPTIC requires SDL_JOYSTICK, which is not enabled" )
2015-06-21 18:33:46 +03:00
endif ( )
endif ( )
2020-05-04 09:27:29 +03:00
2015-06-21 18:33:46 +03:00
# General SDL subsystem options, valid for all platforms
if ( SDL_AUDIO )
# CheckDummyAudio/CheckDiskAudio - valid for all platforms
2021-10-05 17:43:35 +03:00
if ( SDL_DUMMYAUDIO )
2015-06-21 18:33:46 +03:00
set ( SDL_AUDIO_DRIVER_DUMMY 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/audio/dummy/*.c" )
2015-06-21 18:33:46 +03:00
set ( HAVE_DUMMYAUDIO TRUE )
2022-01-12 19:17:48 +03:00
set ( HAVE_SDL_AUDIO TRUE )
2015-06-21 18:33:46 +03:00
endif ( )
2021-10-05 17:43:35 +03:00
if ( SDL_DISKAUDIO )
2015-06-21 18:33:46 +03:00
set ( SDL_AUDIO_DRIVER_DISK 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/audio/disk/*.c" )
2015-06-21 18:33:46 +03:00
set ( HAVE_DISKAUDIO TRUE )
2022-01-12 19:17:48 +03:00
set ( HAVE_SDL_AUDIO TRUE )
2015-06-21 18:33:46 +03:00
endif ( )
endif ( )
2023-12-01 18:59:13 +03:00
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 ( )
2021-08-10 20:55:50 +03:00
if ( UNIX OR APPLE )
2015-06-21 18:33:46 +03:00
# Relevant for Unix/Darwin only
2021-08-10 20:55:50 +03:00
set ( DYNAPI_NEEDS_DLOPEN 1 )
CheckDLOPEN ( )
2024-01-17 08:32:35 +03:00
if ( HAVE_DLOPEN )
2021-08-10 20:55:50 +03:00
set ( SDL_LOADSO_DLOPEN 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/loadso/dlopen/*.c" )
2021-08-10 20:55:50 +03:00
set ( HAVE_SDL_LOADSO TRUE )
2015-06-21 18:33:46 +03:00
endif ( )
endif ( )
2021-11-27 19:10:10 +03:00
if ( UNIX OR APPLE OR HAIKU OR RISCOS )
CheckO_CLOEXEC ( )
endif ( )
Fixed bug 5028 - Virtual Joysticks (new joystick backend)
David Ludwig
I have created a new driver for SDL's Joystick and Game-Controller subsystem: a Virtual driver. This driver allows one to create a software-based joystick, which to SDL applications will look and react like a real joystick, but whose state can be set programmatically. A primary use case for this is to help enable developers to add touch-screen joysticks to their apps.
The driver comes with a set of new, public APIs, with functions to attach and detach joysticks, set virtual-joystick state, and to determine if a joystick is a virtual-one.
Use of virtual joysticks goes as such:
1. Attach one or more virtual joysticks by calling SDL_JoystickAttachVirtual. If successful, this returns the virtual-device's joystick-index.
2. Open the virtual joysticks (using indicies returned by SDL_JoystickAttachVirtual).
3. Call any of the SDL_JoystickSetVirtual* functions when joystick-state changes. Please note that virtual-joystick state will only get applied on the next call to SDL_JoystickUpdate, or when pumping or polling for SDL events (via SDL_PumpEvents or SDL_PollEvent).
Here is a listing of the new, public APIs, at present and subject to change:
------------------------------------------------------------
/**
* Attaches a new virtual joystick.
* Returns the joystick's device index, or -1 if an error occurred.
*/
extern DECLSPEC int SDLCALL SDL_JoystickAttachVirtual(SDL_JoystickType type, int naxes, int nballs, int nbuttons, int nhats);
/**
* Detaches a virtual joystick
* Returns 0 on success, or -1 if an error occurred.
*/
extern DECLSPEC int SDLCALL SDL_JoystickDetachVirtual(int device_index);
/**
* Indicates whether or not a virtual-joystick is at a given device index.
*/
extern DECLSPEC SDL_bool SDLCALL SDL_JoystickIsVirtual(int device_index);
/**
* Set values on an opened, virtual-joystick's controls.
* Returns 0 on success, -1 on error.
*/
extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualAxis(SDL_Joystick * joystick, int axis, Sint16 value);
extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualBall(SDL_Joystick * joystick, int ball, Sint16 xrel, Sint16 yrel);
extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualButton(SDL_Joystick * joystick, int button, Uint8 value);
extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualHat(SDL_Joystick * joystick, int hat, Uint8 value);
------------------------------------------------------------
Miscellaneous notes on the initial patch, which are also subject to change:
1. no test code is present in SDL, yet. This should, perhaps, change. Initial development was done with an ImGui-based app, which potentially is too thick for use in SDL-official. If tests are to be added, what kind of tests? Automated? Graphical?
2. virtual game controllers can be created by calling SDL_JoystickAttachVirtual with a joystick-type of SDL_JOYSTICK_TYPE_GAME_CONTROLLER, with naxes (num axes) set to SDL_CONTROLLER_AXIS_MAX, and with nbuttons (num buttons) set to SDL_CONTROLLER_BUTTON_MAX. When updating their state, values of type SDL_GameControllerAxis or SDL_GameControllerButton can be casted to an int and used for the control-index (in calls to SDL_JoystickSetVirtual* functions).
3. virtual joysticks' guids are mostly all-zeros with the exception of the last two bytes, the first of which is a 'v', to indicate that the guid is a virtual one, and the second of which is a SDL_JoystickType that has been converted into a Uint8.
4. virtual joysticks are ONLY turned into virtual game-controllers if and when their joystick-type is set to SDL_JOYSTICK_TYPE_GAMECONTROLLER. This is controlled by having SDL's default list of game-controllers have a single entry for a virtual game controller (of guid, "00000000000000000000000000007601", which is subject to the guid-encoding described above).
5. regarding having to call SDL_JoystickUpdate, either directly or indirectly via SDL_PumpEvents or SDL_PollEvents, before new virtual-joystick state becomes active (as specified via SDL_JoystickSetVirtual* function-calls), this was done to match behavior found in SDL's other joystick drivers, almost all of which will only update SDL-state during SDL_JoystickUpdate.
6. the initial patch is based off of SDL 2.0.12
7. the virtual joystick subsystem is disabled by default. It should be possible to enable it by building with SDL_JOYSTICK_VIRTUAL=1
Questions, comments, suggestions, or bug reports very welcome!
2020-03-14 05:08:45 +03:00
if ( SDL_JOYSTICK )
2021-10-05 17:43:35 +03:00
if ( SDL_VIRTUAL_JOYSTICK )
set ( HAVE_VIRTUAL_JOYSTICK TRUE )
Fixed bug 5028 - Virtual Joysticks (new joystick backend)
David Ludwig
I have created a new driver for SDL's Joystick and Game-Controller subsystem: a Virtual driver. This driver allows one to create a software-based joystick, which to SDL applications will look and react like a real joystick, but whose state can be set programmatically. A primary use case for this is to help enable developers to add touch-screen joysticks to their apps.
The driver comes with a set of new, public APIs, with functions to attach and detach joysticks, set virtual-joystick state, and to determine if a joystick is a virtual-one.
Use of virtual joysticks goes as such:
1. Attach one or more virtual joysticks by calling SDL_JoystickAttachVirtual. If successful, this returns the virtual-device's joystick-index.
2. Open the virtual joysticks (using indicies returned by SDL_JoystickAttachVirtual).
3. Call any of the SDL_JoystickSetVirtual* functions when joystick-state changes. Please note that virtual-joystick state will only get applied on the next call to SDL_JoystickUpdate, or when pumping or polling for SDL events (via SDL_PumpEvents or SDL_PollEvent).
Here is a listing of the new, public APIs, at present and subject to change:
------------------------------------------------------------
/**
* Attaches a new virtual joystick.
* Returns the joystick's device index, or -1 if an error occurred.
*/
extern DECLSPEC int SDLCALL SDL_JoystickAttachVirtual(SDL_JoystickType type, int naxes, int nballs, int nbuttons, int nhats);
/**
* Detaches a virtual joystick
* Returns 0 on success, or -1 if an error occurred.
*/
extern DECLSPEC int SDLCALL SDL_JoystickDetachVirtual(int device_index);
/**
* Indicates whether or not a virtual-joystick is at a given device index.
*/
extern DECLSPEC SDL_bool SDLCALL SDL_JoystickIsVirtual(int device_index);
/**
* Set values on an opened, virtual-joystick's controls.
* Returns 0 on success, -1 on error.
*/
extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualAxis(SDL_Joystick * joystick, int axis, Sint16 value);
extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualBall(SDL_Joystick * joystick, int ball, Sint16 xrel, Sint16 yrel);
extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualButton(SDL_Joystick * joystick, int button, Uint8 value);
extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualHat(SDL_Joystick * joystick, int hat, Uint8 value);
------------------------------------------------------------
Miscellaneous notes on the initial patch, which are also subject to change:
1. no test code is present in SDL, yet. This should, perhaps, change. Initial development was done with an ImGui-based app, which potentially is too thick for use in SDL-official. If tests are to be added, what kind of tests? Automated? Graphical?
2. virtual game controllers can be created by calling SDL_JoystickAttachVirtual with a joystick-type of SDL_JOYSTICK_TYPE_GAME_CONTROLLER, with naxes (num axes) set to SDL_CONTROLLER_AXIS_MAX, and with nbuttons (num buttons) set to SDL_CONTROLLER_BUTTON_MAX. When updating their state, values of type SDL_GameControllerAxis or SDL_GameControllerButton can be casted to an int and used for the control-index (in calls to SDL_JoystickSetVirtual* functions).
3. virtual joysticks' guids are mostly all-zeros with the exception of the last two bytes, the first of which is a 'v', to indicate that the guid is a virtual one, and the second of which is a SDL_JoystickType that has been converted into a Uint8.
4. virtual joysticks are ONLY turned into virtual game-controllers if and when their joystick-type is set to SDL_JOYSTICK_TYPE_GAMECONTROLLER. This is controlled by having SDL's default list of game-controllers have a single entry for a virtual game controller (of guid, "00000000000000000000000000007601", which is subject to the guid-encoding described above).
5. regarding having to call SDL_JoystickUpdate, either directly or indirectly via SDL_PumpEvents or SDL_PollEvents, before new virtual-joystick state becomes active (as specified via SDL_JoystickSetVirtual* function-calls), this was done to match behavior found in SDL's other joystick drivers, almost all of which will only update SDL-state during SDL_JoystickUpdate.
6. the initial patch is based off of SDL 2.0.12
7. the virtual joystick subsystem is disabled by default. It should be possible to enable it by building with SDL_JOYSTICK_VIRTUAL=1
Questions, comments, suggestions, or bug reports very welcome!
2020-03-14 05:08:45 +03:00
set ( SDL_JOYSTICK_VIRTUAL 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/joystick/virtual/*.c" )
Fixed bug 5028 - Virtual Joysticks (new joystick backend)
David Ludwig
I have created a new driver for SDL's Joystick and Game-Controller subsystem: a Virtual driver. This driver allows one to create a software-based joystick, which to SDL applications will look and react like a real joystick, but whose state can be set programmatically. A primary use case for this is to help enable developers to add touch-screen joysticks to their apps.
The driver comes with a set of new, public APIs, with functions to attach and detach joysticks, set virtual-joystick state, and to determine if a joystick is a virtual-one.
Use of virtual joysticks goes as such:
1. Attach one or more virtual joysticks by calling SDL_JoystickAttachVirtual. If successful, this returns the virtual-device's joystick-index.
2. Open the virtual joysticks (using indicies returned by SDL_JoystickAttachVirtual).
3. Call any of the SDL_JoystickSetVirtual* functions when joystick-state changes. Please note that virtual-joystick state will only get applied on the next call to SDL_JoystickUpdate, or when pumping or polling for SDL events (via SDL_PumpEvents or SDL_PollEvent).
Here is a listing of the new, public APIs, at present and subject to change:
------------------------------------------------------------
/**
* Attaches a new virtual joystick.
* Returns the joystick's device index, or -1 if an error occurred.
*/
extern DECLSPEC int SDLCALL SDL_JoystickAttachVirtual(SDL_JoystickType type, int naxes, int nballs, int nbuttons, int nhats);
/**
* Detaches a virtual joystick
* Returns 0 on success, or -1 if an error occurred.
*/
extern DECLSPEC int SDLCALL SDL_JoystickDetachVirtual(int device_index);
/**
* Indicates whether or not a virtual-joystick is at a given device index.
*/
extern DECLSPEC SDL_bool SDLCALL SDL_JoystickIsVirtual(int device_index);
/**
* Set values on an opened, virtual-joystick's controls.
* Returns 0 on success, -1 on error.
*/
extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualAxis(SDL_Joystick * joystick, int axis, Sint16 value);
extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualBall(SDL_Joystick * joystick, int ball, Sint16 xrel, Sint16 yrel);
extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualButton(SDL_Joystick * joystick, int button, Uint8 value);
extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualHat(SDL_Joystick * joystick, int hat, Uint8 value);
------------------------------------------------------------
Miscellaneous notes on the initial patch, which are also subject to change:
1. no test code is present in SDL, yet. This should, perhaps, change. Initial development was done with an ImGui-based app, which potentially is too thick for use in SDL-official. If tests are to be added, what kind of tests? Automated? Graphical?
2. virtual game controllers can be created by calling SDL_JoystickAttachVirtual with a joystick-type of SDL_JOYSTICK_TYPE_GAME_CONTROLLER, with naxes (num axes) set to SDL_CONTROLLER_AXIS_MAX, and with nbuttons (num buttons) set to SDL_CONTROLLER_BUTTON_MAX. When updating their state, values of type SDL_GameControllerAxis or SDL_GameControllerButton can be casted to an int and used for the control-index (in calls to SDL_JoystickSetVirtual* functions).
3. virtual joysticks' guids are mostly all-zeros with the exception of the last two bytes, the first of which is a 'v', to indicate that the guid is a virtual one, and the second of which is a SDL_JoystickType that has been converted into a Uint8.
4. virtual joysticks are ONLY turned into virtual game-controllers if and when their joystick-type is set to SDL_JOYSTICK_TYPE_GAMECONTROLLER. This is controlled by having SDL's default list of game-controllers have a single entry for a virtual game controller (of guid, "00000000000000000000000000007601", which is subject to the guid-encoding described above).
5. regarding having to call SDL_JoystickUpdate, either directly or indirectly via SDL_PumpEvents or SDL_PollEvents, before new virtual-joystick state becomes active (as specified via SDL_JoystickSetVirtual* function-calls), this was done to match behavior found in SDL's other joystick drivers, almost all of which will only update SDL-state during SDL_JoystickUpdate.
6. the initial patch is based off of SDL 2.0.12
7. the virtual joystick subsystem is disabled by default. It should be possible to enable it by building with SDL_JOYSTICK_VIRTUAL=1
Questions, comments, suggestions, or bug reports very welcome!
2020-03-14 05:08:45 +03:00
endif ( )
endif ( )
2015-06-21 18:33:46 +03:00
if ( SDL_VIDEO )
2021-10-05 17:43:35 +03:00
if ( SDL_DUMMYVIDEO )
2015-06-21 18:33:46 +03:00
set ( SDL_VIDEO_DRIVER_DUMMY 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/video/dummy/*.c" )
2021-11-22 14:10:02 +03:00
set ( HAVE_DUMMYVIDEO TRUE )
2015-06-21 18:33:46 +03:00
set ( HAVE_SDL_VIDEO TRUE )
endif ( )
endif ( )
2019-07-08 23:46:52 +03:00
# Platform-specific options and settings
2015-12-29 08:57:24 +03:00
if ( ANDROID )
2023-03-27 13:03:42 +03:00
list ( APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake/android" )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/core/android/*.c" )
sdl_sources ( "${ANDROID_NDK}/sources/android/cpufeatures/cpu-features.c" )
2022-09-27 18:33:49 +03:00
set_property ( SOURCE "${ANDROID_NDK}/sources/android/cpufeatures/cpu-features.c" APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-declaration-after-statement" )
2017-06-04 21:25:57 +03:00
2024-01-17 19:57:27 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/misc/android/*.c" )
set ( HAVE_SDL_MISC TRUE )
2020-10-05 18:30:33 +03:00
2017-06-04 21:25:57 +03:00
# 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
2022-11-25 00:38:13 +03:00
cmake_push_check_state ( )
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " -Werror=unused-command-line-argument" )
2017-06-04 21:25:57 +03:00
check_c_compiler_flag ( -marm HAVE_ARM_MODE )
2022-12-18 23:48:24 +03:00
cmake_pop_check_state ( )
2017-06-04 21:25:57 +03:00
if ( HAVE_ARM_MODE )
2022-11-22 07:28:58 +03:00
set_property ( SOURCE "${SDL3_SOURCE_DIR}/src/atomic/SDL_spinlock.c" APPEND_STRING PROPERTY COMPILE_FLAGS " -marm" )
2022-12-21 12:20:59 +03:00
set_source_files_properties ( src/atomic/SDL_spinlock.c PROPERTIES SKIP_PRECOMPILE_HEADERS 1 )
2017-06-04 21:25:57 +03:00
endif ( )
2015-12-29 08:57:24 +03:00
if ( SDL_AUDIO )
2021-04-15 22:13:17 +03:00
set ( SDL_AUDIO_DRIVER_OPENSLES 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/audio/openslES/*.c" )
2021-04-15 22:13:17 +03:00
2023-02-28 06:20:30 +03:00
sdl_link_dependency ( opensles LIBS ${ ANDROID_DL_LIBRARY } OpenSLES )
2021-04-16 10:44:07 +03:00
2021-08-11 00:50:43 +03:00
set ( SDL_AUDIO_DRIVER_AAUDIO 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/audio/aaudio/*.c" )
2021-04-15 22:13:17 +03:00
2015-12-29 08:57:24 +03:00
set ( HAVE_SDL_AUDIO TRUE )
endif ( )
2024-01-17 19:36:52 +03:00
2024-01-17 19:50:48 +03:00
set ( SDL_FILESYSTEM_ANDROID 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/android/*.c" )
set ( HAVE_SDL_FILESYSTEM TRUE )
2024-01-17 19:36:52 +03:00
2024-03-16 18:15:13 +03:00
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 )
2017-08-27 07:17:12 +03:00
if ( SDL_HAPTIC )
set ( SDL_HAPTIC_ANDROID 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/haptic/android/*.c" )
2017-08-27 07:17:12 +03:00
set ( HAVE_SDL_HAPTIC TRUE )
endif ( )
2024-01-17 19:36:52 +03:00
2021-11-11 20:16:44 +03:00
if ( SDL_HIDAPI )
2019-07-08 23:46:52 +03:00
CheckHIDAPI ( )
2021-11-11 20:16:44 +03:00
endif ( )
2024-01-17 19:36:52 +03:00
2021-11-11 20:16:44 +03:00
if ( SDL_JOYSTICK )
2015-12-29 08:57:24 +03:00
set ( SDL_JOYSTICK_ANDROID 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources (
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / j o y s t i c k / a n d r o i d / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / j o y s t i c k / s t e a m / * . c "
)
2015-12-29 08:57:24 +03:00
set ( HAVE_SDL_JOYSTICK TRUE )
endif ( )
2024-01-17 19:36:52 +03:00
2024-01-17 08:32:35 +03:00
set ( SDL_LOADSO_DLOPEN 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/loadso/dlopen/*.c" )
set ( HAVE_SDL_LOADSO TRUE )
2024-01-17 19:36:52 +03:00
2015-12-29 08:57:24 +03:00
if ( SDL_POWER )
set ( SDL_POWER_ANDROID 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/power/android/*.c" )
2015-12-29 08:57:24 +03:00
set ( HAVE_SDL_POWER TRUE )
endif ( )
2024-01-17 19:36:52 +03:00
2024-01-17 19:54:27 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/locale/android/*.c" )
set ( HAVE_SDL_LOCALE TRUE )
2024-01-17 19:36:52 +03:00
Add time and realtime clock functions
Adds functions to query the system's realtime clock, convert time intervals to/from a calendar date and time in either UTC or the local time, and perform time related calculations.
An SDL_Time type (a time interval represented in nanoseconds), and SDL_DateTime struct (broken down calendar date and time) were added to facilitate this functionality.
Querying the system time results in a value expressed in nanoseconds since the Unix epoch (Jan 1, 1970) in UTC +0000. Conversions to and from the various platform epochs and units are performed when required.
Any direct handling of timezones and DST were intentionally avoided. The offset from UTC is provided when converting from UTC to a local time by calculating the difference between the original UTC and the resulting local time, but no other timezone or DST information is used.
The preferred date formatting and 12/24 hour time for the system locale can be retrieved via global preferences.
Helper functions for obtaining the day of week or day or year for calendar date, and getting the number of days in a month in a given year are provided for convenience. These are simple, but useful for performing various time related calculations.
An automated test for time conversion is included, as is a simple standalone test to display the current system date and time onscreen along with a calendar, the rendering of which demonstrates the use of the utility functions (press up/down to increment or decrement the current month, and keys 1-5 to change the date and time formats).
2024-02-29 21:06:26 +03:00
set ( SDL_TIME_UNIX 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/time/unix/*.c" )
set ( HAVE_SDL_TIME TRUE )
2024-01-17 19:36:52 +03:00
set ( SDL_TIMER_UNIX 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/timer/unix/*.c" )
set ( HAVE_SDL_TIMERS TRUE )
2018-08-23 21:32:30 +03:00
if ( SDL_SENSOR )
set ( SDL_SENSOR_ANDROID 1 )
set ( HAVE_SDL_SENSORS TRUE )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/sensor/android/*.c" )
2018-08-23 21:32:30 +03:00
endif ( )
2024-01-17 19:36:52 +03:00
2023-11-28 07:05:54 +03:00
if ( SDL_CAMERA )
2023-12-01 18:59:13 +03:00
set ( SDL_CAMERA_DRIVER_ANDROID 1 )
2023-11-28 07:05:54 +03:00
set ( HAVE_CAMERA TRUE )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/camera/android/*.c" )
endif ( )
2015-12-29 08:57:24 +03:00
if ( SDL_VIDEO )
set ( SDL_VIDEO_DRIVER_ANDROID 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/video/android/*.c" )
2015-12-29 08:57:24 +03:00
set ( HAVE_SDL_VIDEO TRUE )
2017-06-04 21:25:57 +03:00
# Core stuff
2019-08-11 16:23:37 +03:00
# find_library(ANDROID_DL_LIBRARY dl)
# FIXME failing dlopen https://github.com/android-ndk/ndk/issues/929
2023-02-28 06:20:30 +03:00
sdl_link_dependency ( android_video LIBS dl log android )
sdl_compile_definitions ( PRIVATE "GL_GLEXT_PROTOTYPES" )
2017-06-04 21:25:57 +03:00
2015-12-29 08:57:24 +03:00
#enable gles
2021-10-05 17:43:35 +03:00
if ( SDL_OPENGLES )
2015-12-29 08:57:24 +03:00
set ( SDL_VIDEO_OPENGL_EGL 1 )
2021-10-05 17:43:35 +03:00
set ( HAVE_OPENGLES TRUE )
2022-11-23 18:50:02 +03:00
set ( SDL_VIDEO_OPENGL_ES 1 )
2015-12-29 08:57:24 +03:00
set ( SDL_VIDEO_OPENGL_ES2 1 )
set ( SDL_VIDEO_RENDER_OGL_ES2 1 )
2017-06-04 21:25:57 +03:00
2023-02-28 06:20:30 +03:00
sdl_link_dependency ( opengles LIBS GLESv1_CM GLESv2 )
2015-12-29 08:57:24 +03:00
endif ( )
2017-08-28 05:15:57 +03:00
2022-01-10 17:39:42 +03:00
if ( SDL_VULKAN )
2023-02-28 06:20:30 +03:00
check_c_source_compiles ( "
2022-01-10 17:39:42 +03:00
#if defined(__ARM_ARCH) && __ARM_ARCH < 7
#error Vulkan doesn't work on this configuration
#endif
2022-03-13 19:10:52 +03:00
i n t main ( int argc, char **argv ) { r e t u r n 0 ; }
2022-01-10 17:39:42 +03:00
" V U L K A N _ P A S S E D _ A N D R O I D _ C H E C K S )
if ( VULKAN_PASSED_ANDROID_CHECKS )
set ( SDL_VIDEO_VULKAN 1 )
set ( HAVE_VULKAN TRUE )
2024-07-13 14:53:53 +03:00
if ( SDL_RENDER_VULKAN )
set ( SDL_VIDEO_RENDER_VULKAN 1 )
set ( HAVE_RENDER_VULKAN TRUE )
endif ( )
2022-01-10 17:39:42 +03:00
endif ( )
2017-08-28 05:15:57 +03:00
endif ( )
2015-12-29 08:57:24 +03:00
endif ( )
2017-06-08 22:07:55 +03:00
CheckPTHREAD ( )
2022-06-24 15:41:06 +03:00
if ( SDL_CLOCK_GETTIME )
set ( HAVE_CLOCK_GETTIME 1 )
endif ( )
2017-06-08 22:07:55 +03:00
2023-03-27 13:03:42 +03:00
if ( NOT SDL_DISABLE_ANDROID_JAR )
find_package ( Java )
find_package ( SdlAndroidPlatform MODULE )
2024-05-15 19:31:37 +03:00
if ( Java_FOUND AND SdlAndroidPlatform_FOUND AND NOT CMAKE_VERSION VERSION_LESS "3.19" )
2023-03-27 13:03:42 +03:00
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
S O U R C E S $ { S D L _ J A V A _ S O U R C E S }
I N C L U D E _ J A R S " $ { p a t h _ a n d r o i d _ j a r } "
O U T P U T _ N A M E " S D L 3 "
V E R S I O N " $ { S D L 3 _ V E R S I O N } "
)
set_property ( TARGET SDL3-jar PROPERTY OUTPUT "${SDL3_BINARY_DIR}/SDL3-${SDL3_VERSION}.jar" )
2023-11-23 01:28:39 +03:00
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}" )
2023-03-27 13:03:42 +03:00
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 (
O U T P U T " $ { j a v a s o u r c e s j a r } "
C O M M A N D $ { J a v a _ J A R _ E X E C U T A B L E } c f " $ { j a v a s o u r c e s j a r } " $ { s d l _ r e l a t i v e _ j a v a _ s o u r c e s }
W O R K I N G _ D I R E C T O R Y " $ { a n d r o i d _ j a v a _ s o u r c e s _ r o o t } "
D E P E N D S $ { S D L _ J A V A _ S O U R C E S }
)
add_custom_target ( SDL3-javasources ALL DEPENDS "${javasourcesjar}" )
if ( NOT SDL_DISABLE_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 (
O U T P U T " $ { j a v a d o c _ i n d e x _ h t m l } "
C O M M A N D $ { C M A K E _ C O M M A N D } - E r m - r f " $ { j a v a d o c d i r } "
C O M M A N D $ { J a v a _ J A V A D O C _ E X E C U T A B L E } - e n c o d i n g u t f 8 - d " $ { j a v a d o c d i r } "
- c l a s s p a t h " $ { p a t h _ a n d r o i d _ j a r } "
- a u t h o r - u s e - v e r s i o n $ { S D L _ J A V A _ S O U R C E S }
D E P E N D S $ { S D L _ J A V A _ S O U R C E S } " $ { p a t h _ a n d r o i d _ j a r } "
)
add_custom_target ( SDL3-javadoc ALL DEPENDS "${javadoc_index_html}" )
set_property ( TARGET SDL3-javadoc PROPERTY OUTPUT_DIR "${javadocdir}" )
endif ( )
endif ( )
endif ( )
2019-07-08 23:46:52 +03:00
elseif ( EMSCRIPTEN )
2015-06-21 18:33:46 +03:00
# 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.
2023-02-28 06:20:30 +03:00
sdl_compile_options ( PRIVATE "-Wno-warn-absolute-paths" )
2022-01-22 16:31:11 +03:00
main: Added _optional_ callback entry points.
This lets apps optionally have a handful of callbacks for their entry points instead of a single main function. If used, the actual main/SDL_main/whatever entry point will be implemented in the single-header library SDL_main.h and the app will implement four separate functions:
First:
int SDL_AppInit(int argc, char **argv);
This will be called once before anything else. argc/argv work like they always do. If this returns 0, the app runs. If it returns < 0, the app calls SDL_AppQuit and terminates with an exit code that reports an error to the platform. If it returns > 0, the app calls SDL_AppQuit and terminates with an exit code that reports success to the platform. This function should not go into an infinite mainloop; it should do any one-time startup it requires and then return.
Then:
int SDL_AppIterate(void);
This is called over and over, possibly at the refresh rate of the display or some other metric that the platform dictates. This is where the heart of your app runs. It should return as quickly as reasonably possible, but it's not a "run one memcpy and that's all the time you have" sort of thing. The app should do any game updates, and render a frame of video. If it returns < 0, SDL will call SDL_AppQuit and terminate the process with an exit code that reports an error to the platform. If it returns > 0, the app calls SDL_AppQuit and terminates with an exit code that reports success to the platform. If it returns 0, then SDL_AppIterate will be called again at some regular frequency. The platform may choose to run this more or less (perhaps less in the background, etc), or it might just call this function in a loop as fast as possible. You do not check the event queue in this function (SDL_AppEvent exists for that).
Next:
int SDL_AppEvent(const SDL_Event *event);
This will be called once for each event pushed into the SDL queue. This may be called from any thread, and possibly in parallel to SDL_AppIterate. The fields in event do not need to be free'd (as you would normally need to do for SDL_EVENT_DROP_FILE, etc), and your app should not call SDL_PollEvent, SDL_PumpEvent, etc, as SDL will manage this for you. Return values are the same as from SDL_AppIterate(), so you can terminate in response to SDL_EVENT_QUIT, etc.
Finally:
void SDL_AppQuit(void);
This is called once before terminating the app--assuming the app isn't being forcibly killed or crashed--as a last chance to clean up. After this returns, SDL will call SDL_Quit so the app doesn't have to (but it's safe for the app to call it, too). Process termination proceeds as if the app returned normally from main(), so atexit handles will run, if your platform supports that.
The app does not implement SDL_main if using this. To turn this on, define SDL_MAIN_USE_CALLBACKS before including SDL_main.h. Defines like SDL_MAIN_HANDLED and SDL_MAIN_NOIMPL are also respected for callbacks, if the app wants to do some sort of magic main implementation thing.
In theory, on most platforms these can be implemented in the app itself, but this saves some #ifdefs in the app and lets everyone struggle less against some platforms, and might be more efficient in the long run, too.
On some platforms, it's possible this is the only reasonable way to go, but we haven't actually hit one that 100% requires it yet (but we will, if we want to write a RetroArch backend, for example).
Using the callback entry points works on every platform, because on platforms that don't require them, we can fake them with a simple loop in an internal implementation of the usual SDL_main.
The primary way we expect people to write SDL apps is with SDL_main, and this is not intended to replace it. If the app chooses to use this, it just removes some platform-specific details they might have to otherwise manage, and maybe removes a barrier to entry on some future platform.
Fixes #6785.
Reference PR #8247.
2023-11-02 01:40:41 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/main/emscripten/*.c" )
set ( HAVE_SDL_MAIN_CALLBACKS TRUE )
2024-01-17 19:57:27 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/misc/emscripten/*.c" )
set ( HAVE_SDL_MISC TRUE )
2024-01-17 19:36:52 +03:00
2015-06-21 18:33:46 +03:00
if ( SDL_AUDIO )
set ( SDL_AUDIO_DRIVER_EMSCRIPTEN 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/audio/emscripten/*.c" )
2015-06-21 18:33:46 +03:00
set ( HAVE_SDL_AUDIO TRUE )
endif ( )
2024-01-17 19:36:52 +03:00
2024-01-17 19:50:48 +03:00
set ( SDL_FILESYSTEM_EMSCRIPTEN 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/emscripten/*.c" )
set ( HAVE_SDL_FILESYSTEM TRUE )
2024-01-17 19:36:52 +03:00
2024-03-16 18:15:13 +03:00
set ( SDL_FSOPS_POSIX 1 )
sdl_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/posix/SDL_sysfsops.c" )
set ( HAVE_SDL_FSOPS TRUE )
2023-12-22 09:23:49 +03:00
if ( SDL_CAMERA )
set ( SDL_CAMERA_DRIVER_EMSCRIPTEN 1 )
set ( HAVE_CAMERA TRUE )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/camera/emscripten/*.c" )
endif ( )
2015-06-21 18:33:46 +03:00
if ( SDL_JOYSTICK )
set ( SDL_JOYSTICK_EMSCRIPTEN 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/joystick/emscripten/*.c" )
2015-06-21 18:33:46 +03:00
set ( HAVE_SDL_JOYSTICK TRUE )
endif ( )
2024-01-17 19:36:52 +03:00
2015-06-21 18:33:46 +03:00
if ( SDL_POWER )
set ( SDL_POWER_EMSCRIPTEN 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/power/emscripten/*.c" )
2015-06-21 18:33:46 +03:00
set ( HAVE_SDL_POWER TRUE )
endif ( )
2024-01-17 19:36:52 +03:00
2024-01-17 19:54:27 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/locale/emscripten/*.c" )
set ( HAVE_SDL_LOCALE TRUE )
2016-09-13 10:03:40 +03:00
Add time and realtime clock functions
Adds functions to query the system's realtime clock, convert time intervals to/from a calendar date and time in either UTC or the local time, and perform time related calculations.
An SDL_Time type (a time interval represented in nanoseconds), and SDL_DateTime struct (broken down calendar date and time) were added to facilitate this functionality.
Querying the system time results in a value expressed in nanoseconds since the Unix epoch (Jan 1, 1970) in UTC +0000. Conversions to and from the various platform epochs and units are performed when required.
Any direct handling of timezones and DST were intentionally avoided. The offset from UTC is provided when converting from UTC to a local time by calculating the difference between the original UTC and the resulting local time, but no other timezone or DST information is used.
The preferred date formatting and 12/24 hour time for the system locale can be retrieved via global preferences.
Helper functions for obtaining the day of week or day or year for calendar date, and getting the number of days in a month in a given year are provided for convenience. These are simple, but useful for performing various time related calculations.
An automated test for time conversion is included, as is a simple standalone test to display the current system date and time onscreen along with a calendar, the rendering of which demonstrates the use of the utility functions (press up/down to increment or decrement the current month, and keys 1-5 to change the date and time formats).
2024-02-29 21:06:26 +03:00
set ( SDL_TIME_UNIX 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/time/unix/*.c" )
set ( HAVE_SDL_TIME TRUE )
2024-01-17 19:36:52 +03:00
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 )
2016-09-13 10:03:40 +03:00
endif ( )
2024-01-17 19:36:52 +03:00
2015-06-21 18:33:46 +03:00
if ( SDL_VIDEO )
set ( SDL_VIDEO_DRIVER_EMSCRIPTEN 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/video/emscripten/*.c" )
2015-06-21 18:33:46 +03:00
set ( HAVE_SDL_VIDEO TRUE )
#enable gles
2021-10-05 17:43:35 +03:00
if ( SDL_OPENGLES )
2015-06-21 18:33:46 +03:00
set ( SDL_VIDEO_OPENGL_EGL 1 )
2021-10-05 17:43:35 +03:00
set ( HAVE_OPENGLES TRUE )
2015-06-21 18:33:46 +03:00
set ( SDL_VIDEO_OPENGL_ES2 1 )
set ( SDL_VIDEO_RENDER_OGL_ES2 1 )
endif ( )
endif ( )
2019-07-08 23:46:52 +03:00
2021-04-04 07:16:30 +03:00
CheckPTHREAD ( )
2023-02-28 06:20:30 +03:00
CheckLibUnwind ( )
2022-11-01 15:09:29 +03:00
2022-06-24 15:41:06 +03:00
elseif ( UNIX AND NOT APPLE AND NOT RISCOS AND NOT HAIKU )
2015-06-21 18:33:46 +03:00
if ( SDL_AUDIO )
2022-11-22 19:51:56 +03:00
if ( NETBSD )
2017-05-25 02:56:59 +03:00
set ( SDL_AUDIO_DRIVER_NETBSD 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/audio/netbsd/*.c" )
2015-06-21 18:33:46 +03:00
set ( HAVE_SDL_AUDIO TRUE )
2023-01-07 14:29:03 +03:00
elseif ( QNX )
set ( SDL_AUDIO_DRIVER_QNX 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/audio/qnx/*.c" )
sdl_link_dependency ( asound LIBS asound )
2023-01-07 14:29:03 +03:00
set ( HAVE_SDL_AUDIO TRUE )
2015-06-21 18:33:46 +03:00
endif ( )
CheckOSS ( )
CheckALSA ( )
2022-11-23 06:50:20 +03:00
CheckJACK ( )
2021-02-13 19:56:05 +03:00
CheckPipewire ( )
2015-06-21 18:33:46 +03:00
CheckPulseAudio ( )
2022-11-22 22:04:10 +03:00
CheckSNDIO ( )
2015-06-21 18:33:46 +03:00
endif ( )
if ( SDL_VIDEO )
# Need to check for Raspberry PI first and add platform specific compiler flags, otherwise the test for GLES fails!
CheckRPI ( )
2022-12-26 03:44:40 +03:00
# Need to check for ROCKCHIP platform and get rid of "Can't window GBM/EGL surfaces on window creation."
CheckROCKCHIP ( )
2015-06-21 18:33:46 +03:00
CheckX11 ( )
2023-02-28 06:20:30 +03:00
# Need to check for EGL first because KMSDRM and Wayland depend on it.
2021-05-06 16:43:16 +03:00
CheckEGL ( )
CheckKMSDRM ( )
CheckGLX ( )
CheckOpenGL ( )
CheckOpenGLES ( )
2015-06-21 18:33:46 +03:00
CheckWayland ( )
CheckVivante ( )
2023-02-28 06:20:30 +03:00
CheckVulkan ( )
2023-01-07 14:29:03 +03:00
CheckQNXScreen ( )
2015-06-21 18:33:46 +03:00
endif ( )
2017-08-17 22:44:47 +03:00
if ( UNIX )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/core/unix/*.c" )
2017-08-17 22:44:47 +03:00
2023-11-08 10:44:58 +03:00
check_c_source_compiles ( "
#include <linux/input.h>
#ifndef EVIOCGNAME
#error EVIOCGNAME() ioctl not available
#endif
i n t main ( int argc, char** argv ) { r e t u r n 0 ; } " H A V E _ L I N U X _ I N P U T _ H )
2015-06-21 18:33:46 +03:00
2021-05-16 14:16:54 +03:00
if ( LINUX )
check_c_source_compiles ( "
#include <linux/kd.h>
#include <linux/keyboard.h>
2022-09-12 20:28:00 +03:00
#include <sys/ioctl.h>
2022-03-15 23:10:02 +03:00
i n t main ( int argc, char **argv ) {
2021-05-16 14:16:54 +03:00
s t r u c t k b e n t r y k b e ;
k b e . k b _ t a b l e = K G _ C T R L ;
ioctl ( 0, KDGKBENT, &kbe ) ;
2022-03-13 19:10:52 +03:00
r e t u r n 0 ;
2021-05-16 14:16:54 +03:00
} " H A V E _ I N P U T _ K D )
2023-11-28 07:05:54 +03:00
check_c_source_compiles ( "
#include <linux/videodev2.h>
i n t main ( int argc, char** argv ) { r e t u r n 0 ; } " H A V E _ L I N U X _ V I D E O D E V 2 _ H )
2021-05-16 14:16:54 +03:00
elseif ( FREEBSD )
check_c_source_compiles ( "
#include <sys/kbio.h>
#include <sys/ioctl.h>
2022-03-15 23:10:02 +03:00
i n t main ( int argc, char **argv ) {
2021-05-16 14:16:54 +03:00
a c c e n t m a p _ t a c c T a b l e ;
ioctl ( 0, KDENABIO, 1 ) ;
2022-03-13 19:10:52 +03:00
r e t u r n 0 ;
2021-05-16 14:16:54 +03:00
} " H A V E _ I N P U T _ K B I O )
2022-11-25 04:39:50 +03:00
elseif ( OPENBSD OR NETBSD )
check_c_source_compiles ( "
#include <sys/time.h>
#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wsksymdef.h>
#include <dev/wscons/wsksymvar.h>
#include <sys/ioctl.h>
i n t main ( int argc, char **argv ) {
s t r u c t w s k b d _ m a p _ d a t a d a t a ;
ioctl ( 0, WSKBDIO_GETMAP, &data ) ;
r e t u r n 0 ;
} " H A V E _ I N P U T _ W S C O N S )
2021-05-16 14:16:54 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
2023-11-28 07:05:54 +03:00
if ( SDL_CAMERA AND HAVE_LINUX_VIDEODEV2_H )
2023-12-01 18:59:13 +03:00
set ( SDL_CAMERA_DRIVER_V4L2 1 )
2023-11-28 07:05:54 +03:00
set ( HAVE_CAMERA TRUE )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/camera/v4l2/*.c" )
endif ( )
2023-11-02 23:31:32 +03:00
if ( HAVE_LINUX_INPUT_H )
2015-06-21 18:33:46 +03:00
set ( SDL_INPUT_LINUXEV 1 )
endif ( )
2023-11-02 23:31:32 +03:00
if ( SDL_HAPTIC AND HAVE_LINUX_INPUT_H )
2015-06-21 18:33:46 +03:00
set ( SDL_HAPTIC_LINUX 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/haptic/linux/*.c" )
2015-06-21 18:33:46 +03:00
set ( HAVE_SDL_HAPTIC TRUE )
endif ( )
if ( HAVE_INPUT_KD )
set ( SDL_INPUT_LINUXKD 1 )
endif ( )
2021-10-31 03:54:20 +03:00
2021-05-16 14:16:54 +03:00
if ( HAVE_INPUT_KBIO )
set ( SDL_INPUT_FBSDKBIO 1 )
endif ( )
2015-06-21 18:33:46 +03:00
2022-11-25 04:39:50 +03:00
if ( HAVE_INPUT_WSCONS )
set ( SDL_INPUT_WSCONS 1 )
endif ( )
2022-11-25 04:57:00 +03:00
CheckLibUDev ( )
2020-12-13 15:32:24 +03:00
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 )
2021-10-31 03:54:20 +03:00
2020-12-13 15:32:24 +03:00
if ( HAVE_SYS_INOTIFY_H AND HAVE_INOTIFY_INIT )
set ( HAVE_INOTIFY 1 )
endif ( )
2015-06-21 18:33:46 +03:00
2016-10-01 22:48:08 +03:00
if ( PKG_CONFIG_FOUND )
2022-08-26 03:37:57 +03:00
if ( SDL_DBUS )
pkg_search_module ( DBUS dbus-1 dbus )
if ( DBUS_FOUND )
set ( HAVE_DBUS_DBUS_H TRUE )
2023-02-28 06:20:30 +03:00
sdl_include_directories ( PRIVATE SYSTEM ${ DBUS_INCLUDE_DIRS } )
2022-08-26 03:37:57 +03:00
# Fcitx need only dbus.
set ( HAVE_FCITX TRUE )
set ( HAVE_DBUS TRUE )
endif ( )
2016-10-01 22:48:08 +03:00
endif ( )
2022-08-26 03:38:54 +03:00
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 )
2023-02-28 06:20:30 +03:00
sdl_include_directories ( PRIVATE SYSTEM ${ IBUS_INCLUDE_DIRS } )
2022-08-26 03:38:54 +03:00
set ( HAVE_IBUS TRUE )
endif ( )
2020-05-12 00:31:04 +03:00
endif ( )
if ( HAVE_IBUS_IBUS_H OR HAVE_FCITX )
2021-11-17 02:59:38 +03:00
set ( SDL_USE_IME 1 )
2016-10-01 22:48:08 +03:00
endif ( )
2021-10-31 03:54:20 +03:00
2023-11-11 23:52:07 +03:00
if ( ( FREEBSD OR NETBSD ) AND NOT HAVE_INOTIFY )
2023-02-28 06:20:30 +03:00
set ( LibInotify_PKG_CONFIG_SPEC libinotify )
pkg_check_modules ( PC_LIBINOTIFY IMPORTED_TARGET ${ LibInotify_PKG_CONFIG_SPEC } )
if ( PC_LIBINOTIFY_FOUND )
2021-05-16 14:16:54 +03:00
set ( HAVE_INOTIFY 1 )
2023-02-28 06:20:30 +03:00
sdl_link_dependency ( libinotify LIBS PkgConfig::PC_LIBINOTIFY PKG_CONFIG_PREFIX PC_LIBINOTIFY PKG_CONFIG_SPECS ${ LibInotify_PKG_CONFIG_SPEC } )
2021-05-16 14:16:54 +03:00
endif ( )
endif ( )
2023-02-28 06:20:30 +03:00
CheckLibUnwind ( )
2016-10-01 22:48:08 +03:00
endif ( )
2020-06-27 00:42:30 +03:00
if ( HAVE_DBUS_DBUS_H )
2023-02-28 06:20:30 +03:00
sdl_sources (
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / c o r e / l i n u x / S D L _ d b u s . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / c o r e / l i n u x / S D L _ s y s t e m _ t h e m e . c "
)
2020-06-27 00:42:30 +03:00
endif ( )
if ( SDL_USE_IME )
2023-02-28 06:20:30 +03:00
sdl_sources ( "${SDL3_SOURCE_DIR}/src/core/linux/SDL_ime.c" )
2020-06-27 00:42:30 +03:00
endif ( )
if ( HAVE_IBUS_IBUS_H )
2023-02-28 06:20:30 +03:00
sdl_sources ( "${SDL3_SOURCE_DIR}/src/core/linux/SDL_ibus.c" )
2020-06-27 00:42:30 +03:00
endif ( )
if ( HAVE_FCITX )
2023-02-28 06:20:30 +03:00
sdl_sources ( "${SDL3_SOURCE_DIR}/src/core/linux/SDL_fcitx.c" )
2020-06-27 00:42:30 +03:00
endif ( )
if ( HAVE_LIBUDEV_H )
2023-02-28 06:20:30 +03:00
sdl_sources ( "${SDL3_SOURCE_DIR}/src/core/linux/SDL_udev.c" )
2020-06-27 00:42:30 +03:00
endif ( )
2023-11-02 23:31:32 +03:00
if ( HAVE_LINUX_INPUT_H )
2023-02-28 06:20:30 +03:00
sdl_sources (
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / c o r e / l i n u x / S D L _ e v d e v . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / c o r e / l i n u x / S D L _ e v d e v _ k b d . c "
)
2020-06-27 00:42:30 +03:00
endif ( )
2021-10-31 03:54:20 +03:00
2021-05-16 14:16:54 +03:00
if ( HAVE_INPUT_KBIO )
2023-02-28 06:20:30 +03:00
sdl_sources ( "${SDL3_SOURCE_DIR}/src/core/freebsd/SDL_evdev_kbd_freebsd.c" )
2021-05-16 14:16:54 +03:00
endif ( )
2020-06-27 00:42:30 +03:00
2023-11-22 01:56:10 +03:00
if ( HAVE_INPUT_WSCONS )
sdl_sources (
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / c o r e / o p e n b s d / S D L _ w s c o n s _ k b d . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / c o r e / o p e n b s d / S D L _ w s c o n s _ m o u s e . c "
)
endif ( )
2020-06-27 00:42:30 +03:00
# Always compiled for Linux, unconditionally:
2023-02-28 06:20:30 +03:00
sdl_sources (
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / c o r e / l i n u x / S D L _ e v d e v _ c a p a b i l i t i e s . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / c o r e / l i n u x / S D L _ t h r e a d p r i o . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / c o r e / l i n u x / S D L _ s a n d b o x . c "
)
2020-06-27 00:42:30 +03:00
# src/core/unix/*.c is included in a generic if(UNIX) section, elsewhere.
2015-06-21 18:33:46 +03:00
endif ( )
2021-11-11 20:16:44 +03:00
if ( SDL_HIDAPI )
CheckHIDAPI ( )
endif ( )
2015-06-21 18:33:46 +03:00
if ( SDL_JOYSTICK )
2019-07-31 19:34:00 +03:00
if ( FREEBSD OR NETBSD OR OPENBSD OR BSDI )
CheckUSBHID ( )
endif ( )
2024-06-22 16:55:17 +03:00
if ( ( LINUX OR FREEBSD ) AND HAVE_LINUX_INPUT_H AND NOT ANDROID )
2015-06-21 18:33:46 +03:00
set ( SDL_JOYSTICK_LINUX 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources (
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / j o y s t i c k / l i n u x / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / j o y s t i c k / s t e a m / * . c "
)
2015-06-21 18:33:46 +03:00
set ( HAVE_SDL_JOYSTICK TRUE )
endif ( )
endif ( )
CheckPTHREAD ( )
2021-10-05 17:43:35 +03:00
if ( SDL_CLOCK_GETTIME )
2023-02-13 21:47:14 +03:00
check_library_exists ( c clock_gettime "" FOUND_CLOCK_GETTIME_LIBC )
if ( FOUND_CLOCK_GETTIME_LIBC )
2015-06-21 18:33:46 +03:00
set ( HAVE_CLOCK_GETTIME 1 )
else ( )
2023-02-13 21:47:14 +03:00
check_library_exists ( rt clock_gettime "" FOUND_CLOCK_GETTIME_LIBRT )
if ( FOUND_CLOCK_GETTIME_LIBRT )
2015-06-21 18:33:46 +03:00
set ( HAVE_CLOCK_GETTIME 1 )
2023-02-28 06:20:30 +03:00
sdl_link_dependency ( clock LIBS rt )
2015-06-21 18:33:46 +03:00
endif ( )
endif ( )
endif ( )
2024-01-17 19:57:27 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/misc/unix/*.c" )
set ( HAVE_SDL_MISC TRUE )
2020-10-05 18:30:33 +03:00
2015-06-21 18:33:46 +03:00
if ( SDL_POWER )
if ( LINUX )
set ( SDL_POWER_LINUX 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/power/linux/*.c" )
2015-06-21 18:33:46 +03:00
set ( HAVE_SDL_POWER TRUE )
endif ( )
endif ( )
2024-01-17 19:54:27 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/locale/unix/*.c" )
set ( HAVE_SDL_LOCALE TRUE )
2020-05-04 09:27:29 +03:00
2024-01-17 19:50:48 +03:00
set ( SDL_FILESYSTEM_UNIX 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/unix/*.c" )
set ( HAVE_SDL_FILESYSTEM TRUE )
2015-06-21 18:33:46 +03:00
2024-03-08 22:38:46 +03:00
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 )
2024-03-16 18:15:13 +03:00
set ( SDL_FSOPS_POSIX 1 )
sdl_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/posix/SDL_sysfsops.c" )
set ( HAVE_SDL_FSOPS TRUE )
Add time and realtime clock functions
Adds functions to query the system's realtime clock, convert time intervals to/from a calendar date and time in either UTC or the local time, and perform time related calculations.
An SDL_Time type (a time interval represented in nanoseconds), and SDL_DateTime struct (broken down calendar date and time) were added to facilitate this functionality.
Querying the system time results in a value expressed in nanoseconds since the Unix epoch (Jan 1, 1970) in UTC +0000. Conversions to and from the various platform epochs and units are performed when required.
Any direct handling of timezones and DST were intentionally avoided. The offset from UTC is provided when converting from UTC to a local time by calculating the difference between the original UTC and the resulting local time, but no other timezone or DST information is used.
The preferred date formatting and 12/24 hour time for the system locale can be retrieved via global preferences.
Helper functions for obtaining the day of week or day or year for calendar date, and getting the number of days in a month in a given year are provided for convenience. These are simple, but useful for performing various time related calculations.
An automated test for time conversion is included, as is a simple standalone test to display the current system date and time onscreen along with a calendar, the rendering of which demonstrates the use of the utility functions (press up/down to increment or decrement the current month, and keys 1-5 to change the date and time formats).
2024-02-29 21:06:26 +03:00
set ( SDL_TIME_UNIX 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/time/unix/*.c" )
set ( HAVE_SDL_TIME TRUE )
2024-01-17 19:36:52 +03:00
set ( SDL_TIMER_UNIX 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/timer/unix/*.c" )
set ( HAVE_SDL_TIMERS TRUE )
2015-06-21 18:33:46 +03:00
2020-04-12 01:38:34 +03:00
set ( SDL_RLD_FLAGS "" )
2021-10-05 17:43:35 +03:00
if ( SDL_RPATH AND SDL_SHARED )
2015-06-21 18:33:46 +03:00
if ( BSDI OR FREEBSD OR LINUX OR NETBSD )
2022-12-18 23:48:24 +03:00
cmake_push_check_state ( )
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " -Wl,--enable-new-dtags" )
2016-01-08 03:42:30 +03:00
check_c_compiler_flag ( "" HAVE_ENABLE_NEW_DTAGS )
2022-12-18 23:48:24 +03:00
cmake_pop_check_state ( )
2016-01-08 03:42:30 +03:00
if ( HAVE_ENABLE_NEW_DTAGS )
2016-01-08 04:21:50 +03:00
set ( SDL_RLD_FLAGS "-Wl,-rpath,\${libdir} -Wl,--enable-new-dtags" )
else ( )
set ( SDL_RLD_FLAGS "-Wl,-rpath,\${libdir}" )
2016-01-08 03:42:30 +03:00
endif ( )
2024-02-25 18:33:46 +03:00
set ( HAVE_RPATH TRUE )
2015-06-21 18:33:46 +03:00
elseif ( SOLARIS )
set ( SDL_RLD_FLAGS "-R\${libdir}" )
2024-02-25 18:33:46 +03:00
set ( HAVE_RPATH TRUE )
2015-06-21 18:33:46 +03:00
endif ( )
endif ( )
2023-01-10 14:11:39 +03:00
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 )
2023-01-10 15:08:51 +03:00
set ( USE_POSIX_SPAWN 1 )
2023-01-10 14:11:39 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
elseif ( WINDOWS )
check_c_source_compiles ( "
#include <windows.h>
2022-03-13 19:10:52 +03:00
i n t main ( int argc, char **argv ) { r e t u r n 0 ; } " H A V E _ W I N 3 2 _ C C )
2015-06-21 18:33:46 +03:00
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/core/windows/*.c" )
2024-07-05 03:32:19 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/main/windows/*.c" )
2015-06-21 18:33:46 +03:00
2022-11-23 21:41:43 +03:00
if ( WINDOWS_STORE )
2024-03-11 01:57:24 +03:00
enable_language ( CXX )
2023-02-28 06:20:30 +03:00
sdl_glob_sources (
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / c o r e / w i n r t / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / c o r e / w i n r t / * . c p p "
2024-07-05 03:32:19 +03:00
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / m a i n / w i n r t / * . c p p "
2023-02-28 06:20:30 +03:00
)
2022-11-23 21:41:43 +03:00
endif ( )
2023-02-28 06:20:30 +03:00
if ( TARGET SDL3-shared AND MSVC AND NOT SDL_LIBC )
2015-12-31 22:26:40 +03:00
# Prevent codegen that would use the VC runtime libraries.
2023-10-02 12:00:06 +03:00
target_compile_options ( SDL3-shared PRIVATE $< $<COMPILE_LANGUAGE:C,CXX > :/GS-> $< $<COMPILE_LANGUAGE:C,CXX > :/Gs1048576> )
2022-11-26 04:11:32 +03:00
if ( SDL_CPU_X86 )
2023-02-28 06:20:30 +03:00
target_compile_options ( SDL3-shared PRIVATE "/arch:SSE" )
2015-12-31 22:26:40 +03:00
endif ( )
endif ( )
2024-01-17 19:57:27 +03:00
if ( WINDOWS_STORE )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/misc/winrt/*.cpp" )
else ( )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/misc/windows/*.c" )
2021-01-15 01:53:34 +03:00
endif ( )
2024-01-17 19:57:27 +03:00
set ( HAVE_SDL_MISC TRUE )
2020-10-05 18:30:33 +03:00
2015-06-21 18:33:46 +03:00
# Check for DirectX
2021-10-05 17:43:35 +03:00
if ( SDL_DIRECTX )
2022-12-18 23:48:24 +03:00
cmake_push_check_state ( )
2015-12-29 08:02:43 +03:00
if ( DEFINED MSVC_VERSION AND NOT ${ MSVC_VERSION } LESS 1700 )
set ( USE_WINSDK_DIRECTX TRUE )
endif ( )
2021-11-24 18:10:00 +03:00
if ( NOT MINGW AND NOT USE_WINSDK_DIRECTX )
2015-06-21 18:33:46 +03:00
if ( "$ENV{DXSDK_DIR}" STREQUAL "" )
2023-02-28 06:20:30 +03:00
message ( FATAL_ERROR "DIRECTX requires the \$DXSDK_DIR environment variable to be set" )
2015-06-21 18:33:46 +03:00
endif ( )
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " /I\" $ENV{ DXSDK_DIR } \\Include\"")
2015-06-21 18:33:46 +03:00
endif ( )
2015-08-29 01:05:24 +03:00
2024-08-01 16:49:02 +03:00
check_include_file ( d3d9.h HAVE_D3D9_H )
2015-06-21 18:33:46 +03:00
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 )
2023-07-01 23:30:31 +03:00
if ( WINDOWS_STORE OR SDL_CPU_ARM32 )
2020-12-08 20:13:08 +03:00
set ( HAVE_DINPUT_H 0 )
endif ( )
2015-06-21 18:33:46 +03:00
check_include_file ( dxgi.h HAVE_DXGI_H )
2022-12-18 23:48:24 +03:00
cmake_pop_check_state ( )
2024-08-01 16:49:02 +03:00
if ( HAVE_D3D9_H OR HAVE_D3D11_H OR HAVE_DDRAW_H OR HAVE_DSOUND_H OR HAVE_DINPUT_H )
2015-06-21 18:33:46 +03:00
set ( HAVE_DIRECTX TRUE )
2021-11-24 18:10:00 +03:00
if ( NOT MINGW AND NOT USE_WINSDK_DIRECTX )
2023-02-28 06:20:30 +03:00
if ( CMAKE_SIZEOF_VOID_P EQUAL 8 )
set ( PROCESSOR_ARCH "x64" )
else ( )
set ( PROCESSOR_ARCH "x86" )
endif ( )
sdl_link_directories ( "$<BUILD_INTERFACE:$$ENV{DXSDK_DIR}\\lib\\${PROCESSOR_ARCH}>" )
sdl_include_directories ( PRIVATE SYSTEM "$<BUILD_INTERFACE:$ENV{DXSDK_DIR}\\Include>" )
2015-06-21 18:33:46 +03:00
endif ( )
endif ( )
endif ( )
2021-10-05 17:43:35 +03:00
if ( SDL_XINPUT )
2021-01-17 05:00:50 +03:00
# xinput.h may need windows.h, but does not include it itself.
check_c_source_compiles ( "
#include <windows.h>
#include <xinput.h>
2022-03-13 19:10:52 +03:00
i n t main ( int argc, char **argv ) { r e t u r n 0 ; } " H A V E _ X I N P U T _ H )
2021-01-17 05:00:50 +03:00
endif ( )
2019-10-01 14:00:02 +03:00
# headers needed elsewhere
2024-08-08 02:57:53 +03:00
check_c_source_compiles ( "
#define COBJMACROS
#include <windows.gaming.input.h>
s t a t i c _ _ x _ A B I _ C W i n d o w s _ C G a m i n g _ C I n p u t _ C I G a m e p a d S t a t i c s 2 * s 2 ;
i n t main ( int argc, char **argv ) { r e t u r n 0 ; } " H A V E _ W I N D O W S _ G A M I N G _ I N P U T _ H
)
check_c_source_compiles ( "
#include <stdbool.h>
#define COBJMACROS
2024-08-08 03:52:05 +03:00
#include <gameinput.h>
2024-08-08 02:57:53 +03:00
i n t main ( int argc, char **argv ) { r e t u r n 0 ; } " H A V E _ G A M E I N P U T _ H
)
2024-05-28 22:11:56 +03:00
check_include_file ( dxgi1_6.h HAVE_DXGI1_6_H )
2022-01-06 22:24:00 +03:00
check_include_file ( tpcshrd.h HAVE_TPCSHRD_H )
2022-04-02 02:50:02 +03:00
check_include_file ( roapi.h HAVE_ROAPI_H )
2018-09-28 13:41:04 +03:00
check_include_file ( mmdeviceapi.h HAVE_MMDEVICEAPI_H )
check_include_file ( audioclient.h HAVE_AUDIOCLIENT_H )
2020-10-12 01:02:28 +03:00
check_include_file ( sensorsapi.h HAVE_SENSORSAPI_H )
2022-06-18 21:51:32 +03:00
check_include_file ( shellscalingapi.h HAVE_SHELLSCALINGAPI_H )
2024-05-28 22:11:50 +03:00
check_c_source_compiles ( "
#include <windows.h>
#include <mfapi.h>
#include <mfidl.h>
#include <mfreadwrite.h>
i n t main ( int argc, char **argv ) { r e t u r n 0 ; }
" H A V E _ M F A P I _ H
)
2018-09-28 13:41:04 +03:00
2015-06-21 18:33:46 +03:00
if ( SDL_AUDIO )
2022-11-23 21:41:43 +03:00
if ( HAVE_DSOUND_H AND NOT WINDOWS_STORE )
2015-06-21 18:33:46 +03:00
set ( SDL_AUDIO_DRIVER_DSOUND 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/audio/directsound/*.c" )
2022-01-12 18:31:00 +03:00
set ( HAVE_SDL_AUDIO TRUE )
2015-06-21 18:33:46 +03:00
endif ( )
2021-10-05 17:43:35 +03:00
if ( SDL_WASAPI AND HAVE_AUDIOCLIENT_H AND HAVE_MMDEVICEAPI_H )
2017-02-24 06:38:04 +03:00
set ( SDL_AUDIO_DRIVER_WASAPI 1 )
2021-11-22 14:10:02 +03:00
set ( HAVE_WASAPI TRUE )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/audio/wasapi/*.c" )
2022-11-23 21:41:43 +03:00
if ( WINDOWS_STORE )
2023-02-28 06:20:30 +03:00
sdl_sources ( "${SDL3_SOURCE_DIR}/src/audio/wasapi/SDL_wasapi_winrt.cpp" )
2022-11-23 21:41:43 +03:00
endif ( )
2022-01-12 18:31:00 +03:00
set ( HAVE_SDL_AUDIO TRUE )
2017-02-24 06:38:04 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
endif ( )
if ( SDL_VIDEO )
2022-11-23 21:41:43 +03:00
if ( WINDOWS_STORE )
set ( SDL_VIDEO_DRIVER_WINRT 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources (
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / v i d e o / w i n r t / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / v i d e o / w i n r t / * . c p p "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / r e n d e r / d i r e c t 3 d 1 1 / * . c p p "
)
2022-11-23 21:41:43 +03:00
else ( )
set ( SDL_VIDEO_DRIVER_WINDOWS 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/video/windows/*.c" )
2022-11-23 21:41:43 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
2024-08-01 16:49:02 +03:00
if ( SDL_RENDER_D3D AND HAVE_D3D9_H AND NOT WINDOWS_STORE )
2015-06-21 18:33:46 +03:00
set ( SDL_VIDEO_RENDER_D3D 1 )
set ( HAVE_RENDER_D3D TRUE )
endif ( )
2024-08-01 16:49:02 +03:00
if ( SDL_RENDER_D3D11 AND HAVE_D3D11_H )
2015-06-21 18:33:46 +03:00
set ( SDL_VIDEO_RENDER_D3D11 1 )
2024-08-01 16:49:02 +03:00
set ( HAVE_RENDER_D3D11 TRUE )
2015-06-21 18:33:46 +03:00
endif ( )
2024-08-01 16:49:02 +03:00
if ( SDL_RENDER_D3D12 AND NOT WINDOWS_STORE )
2022-06-07 03:42:30 +03:00
set ( SDL_VIDEO_RENDER_D3D12 1 )
2024-08-01 16:49:02 +03:00
set ( HAVE_RENDER_D3D12 TRUE )
2022-06-07 03:42:30 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
set ( HAVE_SDL_VIDEO TRUE )
endif ( )
2024-01-17 19:36:52 +03:00
set ( SDL_THREAD_GENERIC_COND_SUFFIX 1 )
set ( SDL_THREAD_GENERIC_RWLOCK_SUFFIX 1 )
set ( SDL_THREAD_WINDOWS 1 )
2024-07-18 23:32:49 +03:00
if ( WINDOWS_STORE )
sdl_sources (
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / s t d c p p / S D L _ s y s c o n d . c p p "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / s t d c p p / S D L _ s y s m u t e x . c p p "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / s t d c p p / S D L _ s y s r w l o c k . c p p "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / s t d c p p / S D L _ s y s t h r e a d . c p p "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / g e n e r i c / S D L _ s y s s e m . c "
)
else ( )
sdl_sources (
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / g e n e r i c / S D L _ s y s c o n d . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / g e n e r i c / S D L _ s y s r w l o c k . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / w i n d o w s / S D L _ s y s c o n d _ c v . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / w i n d o w s / S D L _ s y s m u t e x . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / w i n d o w s / S D L _ s y s r w l o c k _ s r w . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / w i n d o w s / S D L _ s y s s e m . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / w i n d o w s / S D L _ s y s t h r e a d . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / w i n d o w s / S D L _ s y s t l s . c "
)
endif ( )
2024-01-17 19:36:52 +03:00
set ( HAVE_SDL_THREADS TRUE )
2015-06-21 18:33:46 +03:00
2022-11-23 21:41:43 +03:00
if ( SDL_SENSOR AND HAVE_SENSORSAPI_H AND NOT WINDOWS_STORE )
2020-04-08 18:34:27 +03:00
set ( SDL_SENSOR_WINDOWS 1 )
set ( HAVE_SDL_SENSORS TRUE )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/sensor/windows/*.c" )
2020-04-08 18:34:27 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
if ( SDL_POWER )
2022-11-23 21:41:43 +03:00
if ( WINDOWS_STORE )
set ( SDL_POWER_WINRT 1 )
2023-02-28 06:20:30 +03:00
sdl_sources ( "${SDL3_SOURCE_DIR}/src/power/winrt/SDL_syspower.cpp" )
2022-11-23 21:41:43 +03:00
else ( )
set ( SDL_POWER_WINDOWS 1 )
2023-02-28 06:20:30 +03:00
sdl_sources ( "${SDL3_SOURCE_DIR}/src/power/windows/SDL_syspower.c" )
2022-11-23 21:41:43 +03:00
set ( HAVE_SDL_POWER TRUE )
endif ( )
2015-06-21 18:33:46 +03:00
endif ( )
2024-01-17 19:54:27 +03:00
if ( WINDOWS_STORE )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/locale/winrt/*.c" )
else ( )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/locale/windows/*.c" )
2020-05-04 09:27:29 +03:00
endif ( )
2024-01-17 19:54:27 +03:00
set ( HAVE_SDL_LOCALE TRUE )
2020-05-04 09:27:29 +03:00
2024-01-17 19:50:48 +03:00
set ( SDL_FILESYSTEM_WINDOWS 1 )
if ( WINDOWS_STORE )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/winrt/*.cpp" )
2024-03-16 18:15:13 +03:00
sdl_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/windows/SDL_sysfsops.c" )
2024-01-17 19:50:48 +03:00
else ( )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/windows/*.c" )
2015-06-21 18:33:46 +03:00
endif ( )
2024-01-17 19:50:48 +03:00
set ( HAVE_SDL_FILESYSTEM TRUE )
2015-06-21 18:33:46 +03:00
2024-03-16 18:15:13 +03:00
set ( SDL_FSOPS_WINDOWS 1 )
set ( HAVE_SDL_FSOPS TRUE )
2024-03-08 22:38:46 +03:00
set ( SDL_STORAGE_GENERIC 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/storage/generic/*.c" )
if ( NOT WINDOWS_STORE )
set ( SDL_STORAGE_STEAM 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/storage/steam/*.c" )
endif ( )
set ( HAVE_SDL_STORAGE 1 )
2015-06-21 18:33:46 +03:00
# Libraries for Win32 native and MinGW
2022-11-23 21:41:43 +03:00
if ( NOT WINDOWS_STORE )
2023-02-28 06:20:30 +03:00
sdl_link_dependency ( base LIBS kernel32 user32 gdi32 winmm imm32 ole32 oleaut32 version uuid advapi32 setupapi shell32 )
2022-11-23 21:41:43 +03:00
endif ( )
if ( WINDOWS_STORE )
2023-02-28 06:20:30 +03:00
sdl_link_dependency ( windows
L I B S
v c c o r l i b $ < $ < C O N F I G : D e b u g > : d > . l i b
m s v c r t $ < $ < C O N F I G : D e b u g > : d > . l i b
L I N K _ O P T I O N S
2023-11-09 02:20:34 +03:00
/ n o d e f a u l t l i b : v c c o r l i b $ < $ < C O N F I G : D e b u g > : d >
/ n o d e f a u l t l i b : m s v c r t $ < $ < C O N F I G : D e b u g > : d >
2022-11-23 21:41:43 +03:00
)
endif ( )
2021-04-08 15:28:45 +03:00
Add time and realtime clock functions
Adds functions to query the system's realtime clock, convert time intervals to/from a calendar date and time in either UTC or the local time, and perform time related calculations.
An SDL_Time type (a time interval represented in nanoseconds), and SDL_DateTime struct (broken down calendar date and time) were added to facilitate this functionality.
Querying the system time results in a value expressed in nanoseconds since the Unix epoch (Jan 1, 1970) in UTC +0000. Conversions to and from the various platform epochs and units are performed when required.
Any direct handling of timezones and DST were intentionally avoided. The offset from UTC is provided when converting from UTC to a local time by calculating the difference between the original UTC and the resulting local time, but no other timezone or DST information is used.
The preferred date formatting and 12/24 hour time for the system locale can be retrieved via global preferences.
Helper functions for obtaining the day of week or day or year for calendar date, and getting the number of days in a month in a given year are provided for convenience. These are simple, but useful for performing various time related calculations.
An automated test for time conversion is included, as is a simple standalone test to display the current system date and time onscreen along with a calendar, the rendering of which demonstrates the use of the utility functions (press up/down to increment or decrement the current month, and keys 1-5 to change the date and time formats).
2024-02-29 21:06:26 +03:00
set ( SDL_TIME_WINDOWS 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/time/windows/*.c" )
set ( HAVE_SDL_TIME TRUE )
2024-01-17 19:36:52 +03:00
set ( SDL_TIMER_WINDOWS 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/timer/windows/*.c" )
set ( HAVE_SDL_TIMERS TRUE )
2015-06-21 18:33:46 +03:00
2024-01-17 08:32:35 +03:00
set ( SDL_LOADSO_WINDOWS 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/loadso/windows/*.c" )
set ( HAVE_SDL_LOADSO TRUE )
2015-06-21 18:33:46 +03:00
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/core/windows/*.c" )
2015-06-21 18:33:46 +03:00
if ( SDL_VIDEO )
2022-11-23 21:41:43 +03:00
if ( SDL_OPENGL AND NOT WINDOWS_STORE )
2015-06-21 18:33:46 +03:00
set ( SDL_VIDEO_OPENGL 1 )
set ( SDL_VIDEO_OPENGL_WGL 1 )
set ( SDL_VIDEO_RENDER_OGL 1 )
2021-10-05 17:43:35 +03:00
set ( HAVE_OPENGL TRUE )
2015-06-21 18:33:46 +03:00
endif ( )
2015-08-29 01:10:46 +03:00
2021-10-05 17:43:35 +03:00
if ( SDL_OPENGLES )
2015-08-29 01:10:46 +03:00
set ( SDL_VIDEO_OPENGL_EGL 1 )
set ( SDL_VIDEO_OPENGL_ES2 1 )
set ( SDL_VIDEO_RENDER_OGL_ES2 1 )
2021-10-05 17:43:35 +03:00
set ( HAVE_OPENGLES TRUE )
2015-08-29 01:10:46 +03:00
endif ( )
2022-01-10 17:39:42 +03:00
if ( SDL_VULKAN )
set ( SDL_VIDEO_VULKAN 1 )
set ( HAVE_VULKAN TRUE )
Vulkan Renderer (#9114)
This pull request adds an implementation of a Vulkan Render backend to SDL. I have so far tested this primarily on Windows, but also smoke tested on Linux and macOS (MoltenVK). I have not tried it yet on Android, but it should be usable there as well (sans any bugs I missed). This began as a port of the SDL Direct3D12 Renderer, which is the closest thing to Vulkan as existed in the SDL codebase. The shaders are more or less identical (with the only differences being in descriptor bindings vs root descriptors). The shaders are built using the HLSL frontend of glslang.
Everything in the code is pure Vulkan 1.0 (no extensions), with the exception of HDR support which requires the Vulkan instance extension `VK_EXT_swapchain_colorspace`. The code could have been simplified considerably if I used dynamic rendering, push descriptors, extended dynamic state, and other modern Vulkan-isms, but I felt it was more important to make the code as vanilla Vulkan as possible so that it would run on any Vulkan implementation.
The main differences with the Direct3D12 renderer are:
* Having to manage renderpasses for performing clears. There is likely some optimization that would still remain for more efficient use of TBDR hardware where there might be some unnecessary load/stores, but it does attempt to do clears using renderpasses.
* Constant buffer data couldn't be directly updated in the command buffer since I didn't want to rely on push descriptors, so there is a persistently mapped buffer with increasing offset per swapchain image where CB data gets written.
* Many more resources are dependent on the swapchain resizing due to i.e. Vulkan requiring the VkFramebuffer to reference the VkImageView of the swapchain, so there is a bit more code around handling that than was necessary in D3D12.
* For NV12/NV21 textures, rather than there being plane data in the texture itself, the UV data is placed in a separate `VkImage`/`VkImageView`.
I've verified that `testcolorspace` works with both sRGB and HDR linear. I've tested `testoverlay` works with the various YUV/NV12/NV21 formats. I've tested `testsprite`. I've checked that window resizing and swapchain out-of-date handling when minimizing are working. I've run through `testautomation` with the render tests. I also have run several of the tests with Vulkan validation and synchronization validation. Surely I will have missed some things, but I think it's in a good state to be merged and build out from here.
2024-02-23 01:58:11 +03:00
if ( SDL_RENDER_VULKAN )
set ( SDL_VIDEO_RENDER_VULKAN 1 )
2024-02-26 22:37:07 +03:00
set ( HAVE_RENDER_VULKAN TRUE )
Vulkan Renderer (#9114)
This pull request adds an implementation of a Vulkan Render backend to SDL. I have so far tested this primarily on Windows, but also smoke tested on Linux and macOS (MoltenVK). I have not tried it yet on Android, but it should be usable there as well (sans any bugs I missed). This began as a port of the SDL Direct3D12 Renderer, which is the closest thing to Vulkan as existed in the SDL codebase. The shaders are more or less identical (with the only differences being in descriptor bindings vs root descriptors). The shaders are built using the HLSL frontend of glslang.
Everything in the code is pure Vulkan 1.0 (no extensions), with the exception of HDR support which requires the Vulkan instance extension `VK_EXT_swapchain_colorspace`. The code could have been simplified considerably if I used dynamic rendering, push descriptors, extended dynamic state, and other modern Vulkan-isms, but I felt it was more important to make the code as vanilla Vulkan as possible so that it would run on any Vulkan implementation.
The main differences with the Direct3D12 renderer are:
* Having to manage renderpasses for performing clears. There is likely some optimization that would still remain for more efficient use of TBDR hardware where there might be some unnecessary load/stores, but it does attempt to do clears using renderpasses.
* Constant buffer data couldn't be directly updated in the command buffer since I didn't want to rely on push descriptors, so there is a persistently mapped buffer with increasing offset per swapchain image where CB data gets written.
* Many more resources are dependent on the swapchain resizing due to i.e. Vulkan requiring the VkFramebuffer to reference the VkImageView of the swapchain, so there is a bit more code around handling that than was necessary in D3D12.
* For NV12/NV21 textures, rather than there being plane data in the texture itself, the UV data is placed in a separate `VkImage`/`VkImageView`.
I've verified that `testcolorspace` works with both sRGB and HDR linear. I've tested `testoverlay` works with the various YUV/NV12/NV21 formats. I've tested `testsprite`. I've checked that window resizing and swapchain out-of-date handling when minimizing are working. I've run through `testautomation` with the render tests. I also have run several of the tests with Vulkan validation and synchronization validation. Surely I will have missed some things, but I think it's in a good state to be merged and build out from here.
2024-02-23 01:58:11 +03:00
endif ( )
2022-01-10 17:39:42 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
endif ( )
2021-11-11 20:16:44 +03:00
if ( SDL_HIDAPI )
2019-07-08 23:46:52 +03:00
CheckHIDAPI ( )
2021-11-11 20:16:44 +03:00
endif ( )
if ( SDL_JOYSTICK )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/joystick/windows/*.c" )
2021-11-23 17:04:40 +03:00
2022-11-23 21:41:43 +03:00
if ( NOT WINDOWS_STORE )
set ( SDL_JOYSTICK_RAWINPUT 1 )
endif ( )
2015-06-21 18:33:46 +03:00
if ( HAVE_DINPUT_H )
set ( SDL_JOYSTICK_DINPUT 1 )
2023-02-28 06:20:30 +03:00
sdl_link_dependency ( joystick LIBS dinput8 )
2015-06-21 18:33:46 +03:00
endif ( )
if ( HAVE_XINPUT_H )
2022-11-23 21:41:43 +03:00
if ( NOT WINDOWS_STORE )
set ( SDL_JOYSTICK_XINPUT 1 )
set ( HAVE_XINPUT TRUE )
endif ( )
2024-08-08 02:57:53 +03:00
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 )
2015-06-21 18:33:46 +03:00
endif ( )
set ( HAVE_SDL_JOYSTICK TRUE )
if ( SDL_HAPTIC )
2024-01-18 02:22:35 +03:00
if ( HAVE_DINPUT_H AND NOT WINDOWS_STORE )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/haptic/windows/*.c" )
2024-01-18 02:22:35 +03:00
set ( SDL_HAPTIC_DINPUT 1 )
set ( HAVE_SDL_HAPTIC TRUE )
2015-06-21 18:33:46 +03:00
endif ( )
endif ( )
endif ( )
2024-02-22 09:51:41 +03:00
if ( SDL_CAMERA )
2024-05-28 22:11:50 +03:00
if ( HAVE_MFAPI_H AND NOT WINDOWS_STORE )
2024-02-22 09:51:41 +03:00
set ( HAVE_CAMERA TRUE )
set ( SDL_CAMERA_DRIVER_MEDIAFOUNDATION 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/camera/mediafoundation/*.c" )
endif ( )
endif ( )
2024-07-18 22:56:35 +03:00
enable_language ( RC )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( SHARED "${SDL3_SOURCE_DIR}/src/core/windows/*.rc" )
2015-06-21 18:33:46 +03:00
if ( MINGW OR CYGWIN )
2023-02-28 06:20:30 +03:00
sdl_pc_link_options ( "-mwindows" )
2015-06-21 18:33:46 +03:00
endif ( )
2019-07-08 23:46:52 +03:00
2015-06-21 18:33:46 +03:00
elseif ( APPLE )
2022-11-26 03:00:06 +03:00
# TODO: rework this all for proper macOS, iOS and Darwin support
2017-08-19 03:25:14 +03:00
main: Added _optional_ callback entry points.
This lets apps optionally have a handful of callbacks for their entry points instead of a single main function. If used, the actual main/SDL_main/whatever entry point will be implemented in the single-header library SDL_main.h and the app will implement four separate functions:
First:
int SDL_AppInit(int argc, char **argv);
This will be called once before anything else. argc/argv work like they always do. If this returns 0, the app runs. If it returns < 0, the app calls SDL_AppQuit and terminates with an exit code that reports an error to the platform. If it returns > 0, the app calls SDL_AppQuit and terminates with an exit code that reports success to the platform. This function should not go into an infinite mainloop; it should do any one-time startup it requires and then return.
Then:
int SDL_AppIterate(void);
This is called over and over, possibly at the refresh rate of the display or some other metric that the platform dictates. This is where the heart of your app runs. It should return as quickly as reasonably possible, but it's not a "run one memcpy and that's all the time you have" sort of thing. The app should do any game updates, and render a frame of video. If it returns < 0, SDL will call SDL_AppQuit and terminate the process with an exit code that reports an error to the platform. If it returns > 0, the app calls SDL_AppQuit and terminates with an exit code that reports success to the platform. If it returns 0, then SDL_AppIterate will be called again at some regular frequency. The platform may choose to run this more or less (perhaps less in the background, etc), or it might just call this function in a loop as fast as possible. You do not check the event queue in this function (SDL_AppEvent exists for that).
Next:
int SDL_AppEvent(const SDL_Event *event);
This will be called once for each event pushed into the SDL queue. This may be called from any thread, and possibly in parallel to SDL_AppIterate. The fields in event do not need to be free'd (as you would normally need to do for SDL_EVENT_DROP_FILE, etc), and your app should not call SDL_PollEvent, SDL_PumpEvent, etc, as SDL will manage this for you. Return values are the same as from SDL_AppIterate(), so you can terminate in response to SDL_EVENT_QUIT, etc.
Finally:
void SDL_AppQuit(void);
This is called once before terminating the app--assuming the app isn't being forcibly killed or crashed--as a last chance to clean up. After this returns, SDL will call SDL_Quit so the app doesn't have to (but it's safe for the app to call it, too). Process termination proceeds as if the app returned normally from main(), so atexit handles will run, if your platform supports that.
The app does not implement SDL_main if using this. To turn this on, define SDL_MAIN_USE_CALLBACKS before including SDL_main.h. Defines like SDL_MAIN_HANDLED and SDL_MAIN_NOIMPL are also respected for callbacks, if the app wants to do some sort of magic main implementation thing.
In theory, on most platforms these can be implemented in the app itself, but this saves some #ifdefs in the app and lets everyone struggle less against some platforms, and might be more efficient in the long run, too.
On some platforms, it's possible this is the only reasonable way to go, but we haven't actually hit one that 100% requires it yet (but we will, if we want to write a RetroArch backend, for example).
Using the callback entry points works on every platform, because on platforms that don't require them, we can fake them with a simple loop in an internal implementation of the usual SDL_main.
The primary way we expect people to write SDL apps is with SDL_main, and this is not intended to replace it. If the app chooses to use this, it just removes some platform-specific details they might have to otherwise manage, and maybe removes a barrier to entry on some future platform.
Fixes #6785.
Reference PR #8247.
2023-11-02 01:40:41 +03:00
# !!! 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).
2017-08-19 03:25:14 +03:00
# 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.
2024-04-08 20:18:28 +03:00
if ( MACOS )
2017-08-19 03:25:14 +03:00
set ( SDL_FRAMEWORK_COCOA 1 )
set ( SDL_FRAMEWORK_CARBON 1 )
2024-04-01 05:07:06 +03:00
set ( SDL_FRAMEWORK_UTTYPES 1 )
2017-08-19 03:25:14 +03:00
endif ( )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
set ( SDL_FRAMEWORK_FOUNDATION 1 )
2021-11-22 14:10:02 +03:00
set ( SDL_FRAMEWORK_COREVIDEO 1 )
2015-06-21 18:33:46 +03:00
main: Added _optional_ callback entry points.
This lets apps optionally have a handful of callbacks for their entry points instead of a single main function. If used, the actual main/SDL_main/whatever entry point will be implemented in the single-header library SDL_main.h and the app will implement four separate functions:
First:
int SDL_AppInit(int argc, char **argv);
This will be called once before anything else. argc/argv work like they always do. If this returns 0, the app runs. If it returns < 0, the app calls SDL_AppQuit and terminates with an exit code that reports an error to the platform. If it returns > 0, the app calls SDL_AppQuit and terminates with an exit code that reports success to the platform. This function should not go into an infinite mainloop; it should do any one-time startup it requires and then return.
Then:
int SDL_AppIterate(void);
This is called over and over, possibly at the refresh rate of the display or some other metric that the platform dictates. This is where the heart of your app runs. It should return as quickly as reasonably possible, but it's not a "run one memcpy and that's all the time you have" sort of thing. The app should do any game updates, and render a frame of video. If it returns < 0, SDL will call SDL_AppQuit and terminate the process with an exit code that reports an error to the platform. If it returns > 0, the app calls SDL_AppQuit and terminates with an exit code that reports success to the platform. If it returns 0, then SDL_AppIterate will be called again at some regular frequency. The platform may choose to run this more or less (perhaps less in the background, etc), or it might just call this function in a loop as fast as possible. You do not check the event queue in this function (SDL_AppEvent exists for that).
Next:
int SDL_AppEvent(const SDL_Event *event);
This will be called once for each event pushed into the SDL queue. This may be called from any thread, and possibly in parallel to SDL_AppIterate. The fields in event do not need to be free'd (as you would normally need to do for SDL_EVENT_DROP_FILE, etc), and your app should not call SDL_PollEvent, SDL_PumpEvent, etc, as SDL will manage this for you. Return values are the same as from SDL_AppIterate(), so you can terminate in response to SDL_EVENT_QUIT, etc.
Finally:
void SDL_AppQuit(void);
This is called once before terminating the app--assuming the app isn't being forcibly killed or crashed--as a last chance to clean up. After this returns, SDL will call SDL_Quit so the app doesn't have to (but it's safe for the app to call it, too). Process termination proceeds as if the app returned normally from main(), so atexit handles will run, if your platform supports that.
The app does not implement SDL_main if using this. To turn this on, define SDL_MAIN_USE_CALLBACKS before including SDL_main.h. Defines like SDL_MAIN_HANDLED and SDL_MAIN_NOIMPL are also respected for callbacks, if the app wants to do some sort of magic main implementation thing.
In theory, on most platforms these can be implemented in the app itself, but this saves some #ifdefs in the app and lets everyone struggle less against some platforms, and might be more efficient in the long run, too.
On some platforms, it's possible this is the only reasonable way to go, but we haven't actually hit one that 100% requires it yet (but we will, if we want to write a RetroArch backend, for example).
Using the callback entry points works on every platform, because on platforms that don't require them, we can fake them with a simple loop in an internal implementation of the usual SDL_main.
The primary way we expect people to write SDL apps is with SDL_main, and this is not intended to replace it. If the app chooses to use this, it just removes some platform-specific details they might have to otherwise manage, and maybe removes a barrier to entry on some future platform.
Fixes #6785.
Reference PR #8247.
2023-11-02 01:40:41 +03:00
# iOS can use a CADisplayLink for main callbacks. macOS just uses the generic one atm.
2024-04-08 20:18:28 +03:00
if ( IOS OR TVOS OR VISIONOS OR WATCHOS )
main: Added _optional_ callback entry points.
This lets apps optionally have a handful of callbacks for their entry points instead of a single main function. If used, the actual main/SDL_main/whatever entry point will be implemented in the single-header library SDL_main.h and the app will implement four separate functions:
First:
int SDL_AppInit(int argc, char **argv);
This will be called once before anything else. argc/argv work like they always do. If this returns 0, the app runs. If it returns < 0, the app calls SDL_AppQuit and terminates with an exit code that reports an error to the platform. If it returns > 0, the app calls SDL_AppQuit and terminates with an exit code that reports success to the platform. This function should not go into an infinite mainloop; it should do any one-time startup it requires and then return.
Then:
int SDL_AppIterate(void);
This is called over and over, possibly at the refresh rate of the display or some other metric that the platform dictates. This is where the heart of your app runs. It should return as quickly as reasonably possible, but it's not a "run one memcpy and that's all the time you have" sort of thing. The app should do any game updates, and render a frame of video. If it returns < 0, SDL will call SDL_AppQuit and terminate the process with an exit code that reports an error to the platform. If it returns > 0, the app calls SDL_AppQuit and terminates with an exit code that reports success to the platform. If it returns 0, then SDL_AppIterate will be called again at some regular frequency. The platform may choose to run this more or less (perhaps less in the background, etc), or it might just call this function in a loop as fast as possible. You do not check the event queue in this function (SDL_AppEvent exists for that).
Next:
int SDL_AppEvent(const SDL_Event *event);
This will be called once for each event pushed into the SDL queue. This may be called from any thread, and possibly in parallel to SDL_AppIterate. The fields in event do not need to be free'd (as you would normally need to do for SDL_EVENT_DROP_FILE, etc), and your app should not call SDL_PollEvent, SDL_PumpEvent, etc, as SDL will manage this for you. Return values are the same as from SDL_AppIterate(), so you can terminate in response to SDL_EVENT_QUIT, etc.
Finally:
void SDL_AppQuit(void);
This is called once before terminating the app--assuming the app isn't being forcibly killed or crashed--as a last chance to clean up. After this returns, SDL will call SDL_Quit so the app doesn't have to (but it's safe for the app to call it, too). Process termination proceeds as if the app returned normally from main(), so atexit handles will run, if your platform supports that.
The app does not implement SDL_main if using this. To turn this on, define SDL_MAIN_USE_CALLBACKS before including SDL_main.h. Defines like SDL_MAIN_HANDLED and SDL_MAIN_NOIMPL are also respected for callbacks, if the app wants to do some sort of magic main implementation thing.
In theory, on most platforms these can be implemented in the app itself, but this saves some #ifdefs in the app and lets everyone struggle less against some platforms, and might be more efficient in the long run, too.
On some platforms, it's possible this is the only reasonable way to go, but we haven't actually hit one that 100% requires it yet (but we will, if we want to write a RetroArch backend, for example).
Using the callback entry points works on every platform, because on platforms that don't require them, we can fake them with a simple loop in an internal implementation of the usual SDL_main.
The primary way we expect people to write SDL apps is with SDL_main, and this is not intended to replace it. If the app chooses to use this, it just removes some platform-specific details they might have to otherwise manage, and maybe removes a barrier to entry on some future platform.
Fixes #6785.
Reference PR #8247.
2023-11-02 01:40:41 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/main/ios/*.m" )
set ( HAVE_SDL_MAIN_CALLBACKS TRUE )
endif ( )
2024-01-17 19:43:11 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/file/cocoa/*.m" )
2015-06-21 18:33:46 +03:00
2024-02-22 10:26:52 +03:00
if ( SDL_CAMERA )
2024-04-08 20:18:28 +03:00
if ( MACOS OR IOS )
2024-02-22 10:26:52 +03:00
set ( SDL_CAMERA_DRIVER_COREMEDIA 1 )
set ( HAVE_CAMERA TRUE )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/camera/coremedia/*.m" )
endif ( )
2023-11-09 13:11:07 +03:00
endif ( )
2024-04-08 20:18:28 +03:00
if ( IOS OR TVOS OR VISIONOS OR WATCHOS )
2024-01-17 19:57:27 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/misc/ios/*.m" )
else ( )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/misc/macos/*.m" )
2020-12-27 14:00:30 +03:00
endif ( )
2024-01-17 19:57:27 +03:00
set ( HAVE_SDL_MISC TRUE )
2020-10-05 18:30:33 +03:00
2015-06-21 18:33:46 +03:00
if ( SDL_AUDIO )
set ( SDL_AUDIO_DRIVER_COREAUDIO 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/audio/coreaudio/*.m" )
2015-06-21 18:33:46 +03:00
set ( HAVE_SDL_AUDIO TRUE )
2016-09-15 18:57:56 +03:00
set ( SDL_FRAMEWORK_COREAUDIO 1 )
set ( SDL_FRAMEWORK_AUDIOTOOLBOX 1 )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
set ( SDL_FRAMEWORK_AVFOUNDATION 1 )
2015-06-21 18:33:46 +03:00
endif ( )
2021-11-11 20:16:44 +03:00
if ( SDL_HIDAPI )
2019-07-08 23:46:52 +03:00
CheckHIDAPI ( )
2021-11-11 20:16:44 +03:00
endif ( )
if ( SDL_JOYSTICK )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/joystick/apple/*.m" )
2024-04-08 20:18:28 +03:00
if ( IOS OR TVOS OR VISIONOS OR WATCHOS )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/joystick/steam/*.c" )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
set ( SDL_JOYSTICK_MFI 1 )
2024-04-08 20:18:28 +03:00
if ( IOS OR VISIONOS OR WATCHOS )
2019-08-27 19:30:20 +03:00
set ( SDL_FRAMEWORK_COREMOTION 1 )
endif ( )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
set ( SDL_FRAMEWORK_GAMECONTROLLER 1 )
2021-04-11 13:29:01 +03:00
set ( SDL_FRAMEWORK_COREHAPTICS 1 )
2016-10-01 22:54:48 +03:00
else ( )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/joystick/darwin/*.c" )
2022-10-06 06:04:51 +03:00
set_property ( SOURCE ${ MFI_JOYSTICK_SOURCES } APPEND_STRING PROPERTY COMPILE_FLAGS " -fobjc-weak" )
2021-11-21 02:05:28 +03:00
check_objc_source_compiles ( "
#include <AvailabilityMacros.h>
#include <TargetConditionals.h>
#import <Foundation/Foundation.h>
#import <GameController/GameController.h>
#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
2022-03-13 19:10:52 +03:00
i n t main ( ) { r e t u r n 0 ; } " H A V E _ F R A M E W O R K _ G A M E C O N T R O L L E R )
2021-11-21 02:05:28 +03:00
check_objc_source_compiles ( "
#include <AvailabilityMacros.h>
#include <TargetConditionals.h>
#import <Foundation/Foundation.h>
#import <CoreHaptics/CoreHaptics.h>
2022-03-13 19:10:52 +03:00
i n t main ( ) { r e t u r n 0 ; } " H A V E _ F R A M E W O R K _ C O R E H A P T I C S )
2021-11-21 02:05:28 +03:00
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 ( )
2023-07-24 09:11:09 +03:00
if ( NOT VISIONOS )
set ( SDL_JOYSTICK_IOKIT 1 )
set ( SDL_FRAMEWORK_IOKIT 1 )
endif ( )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
set ( SDL_FRAMEWORK_FF 1 )
2016-10-01 22:54:48 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
set ( HAVE_SDL_JOYSTICK TRUE )
endif ( )
if ( SDL_HAPTIC )
2024-04-08 20:18:28 +03:00
if ( IOS OR TVOS OR VISIONOS OR WATCHOS )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/haptic/dummy/*.c" )
2016-10-01 22:54:48 +03:00
set ( SDL_HAPTIC_DUMMY 1 )
else ( )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/haptic/darwin/*.c" )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
set ( SDL_HAPTIC_IOKIT 1 )
set ( SDL_FRAMEWORK_IOKIT 1 )
set ( SDL_FRAMEWORK_FF 1 )
2016-10-01 22:54:48 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
set ( HAVE_SDL_HAPTIC TRUE )
endif ( )
if ( SDL_POWER )
2024-04-08 20:18:28 +03:00
if ( IOS OR TVOS OR VISIONOS OR WATCHOS )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/power/uikit/*.m" )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
set ( SDL_POWER_UIKIT 1 )
2016-10-01 22:54:48 +03:00
else ( )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/power/macos/*.c" )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
set ( SDL_POWER_MACOSX 1 )
2019-09-24 01:24:03 +03:00
set ( SDL_FRAMEWORK_IOKIT 1 )
2016-10-01 22:54:48 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
set ( HAVE_SDL_POWER TRUE )
endif ( )
2024-01-17 19:54:27 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/locale/macos/*.m" )
set ( HAVE_SDL_LOCALE TRUE )
2020-05-04 09:27:29 +03:00
Add time and realtime clock functions
Adds functions to query the system's realtime clock, convert time intervals to/from a calendar date and time in either UTC or the local time, and perform time related calculations.
An SDL_Time type (a time interval represented in nanoseconds), and SDL_DateTime struct (broken down calendar date and time) were added to facilitate this functionality.
Querying the system time results in a value expressed in nanoseconds since the Unix epoch (Jan 1, 1970) in UTC +0000. Conversions to and from the various platform epochs and units are performed when required.
Any direct handling of timezones and DST were intentionally avoided. The offset from UTC is provided when converting from UTC to a local time by calculating the difference between the original UTC and the resulting local time, but no other timezone or DST information is used.
The preferred date formatting and 12/24 hour time for the system locale can be retrieved via global preferences.
Helper functions for obtaining the day of week or day or year for calendar date, and getting the number of days in a month in a given year are provided for convenience. These are simple, but useful for performing various time related calculations.
An automated test for time conversion is included, as is a simple standalone test to display the current system date and time onscreen along with a calendar, the rendering of which demonstrates the use of the utility functions (press up/down to increment or decrement the current month, and keys 1-5 to change the date and time formats).
2024-02-29 21:06:26 +03:00
set ( SDL_TIME_UNIX 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/time/unix/*.c" )
set ( HAVE_SDL_TIME TRUE )
2024-01-17 19:36:52 +03:00
set ( SDL_TIMER_UNIX 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/timer/unix/*.c" )
set ( HAVE_SDL_TIMERS TRUE )
2015-06-21 18:33:46 +03:00
2024-01-17 19:50:48 +03:00
set ( SDL_FILESYSTEM_COCOA 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/cocoa/*.m" )
set ( HAVE_SDL_FILESYSTEM TRUE )
2015-06-21 18:33:46 +03:00
2024-03-08 22:38:46 +03:00
# TODO: SDL_STORAGE_ICLOUD
set ( SDL_STORAGE_GENERIC 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/storage/generic/*.c" )
2024-04-08 20:18:28 +03:00
if ( MACOS )
2024-03-08 22:38:46 +03:00
set ( SDL_STORAGE_STEAM 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/storage/steam/*.c" )
endif ( )
set ( HAVE_SDL_STORAGE 1 )
2024-03-16 18:15:13 +03:00
set ( SDL_FSOPS_POSIX 1 )
sdl_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/posix/SDL_sysfsops.c" )
set ( HAVE_SDL_FSOPS TRUE )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
if ( SDL_SENSOR )
2024-04-08 20:18:28 +03:00
if ( IOS OR VISIONOS OR WATCHOS )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
set ( SDL_SENSOR_COREMOTION 1 )
set ( HAVE_SDL_SENSORS TRUE )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/sensor/coremotion/*.m" )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
endif ( )
endif ( )
2019-08-05 18:35:32 +03:00
# iOS hack needed - http://code.google.com/p/ios-cmake/ ?
if ( SDL_VIDEO )
2024-04-08 20:18:28 +03:00
if ( IOS OR TVOS OR VISIONOS OR WATCHOS )
2019-08-05 18:35:32 +03:00
set ( SDL_VIDEO_DRIVER_UIKIT 1 )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
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 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/video/uikit/*.m" )
2022-01-12 19:18:37 +03:00
set ( HAVE_SDL_VIDEO TRUE )
2019-08-05 18:35:32 +03:00
else ( )
CheckCOCOA ( )
2021-10-05 17:43:35 +03:00
if ( SDL_OPENGL )
2019-08-05 18:35:32 +03:00
set ( SDL_VIDEO_OPENGL 1 )
set ( SDL_VIDEO_OPENGL_CGL 1 )
set ( SDL_VIDEO_RENDER_OGL 1 )
2021-10-05 17:43:35 +03:00
set ( HAVE_OPENGL TRUE )
2019-08-05 18:35:32 +03:00
endif ( )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
endif ( )
2019-08-05 18:35:32 +03:00
2021-10-05 17:43:35 +03:00
if ( SDL_OPENGLES )
2024-04-08 20:18:28 +03:00
if ( IOS OR TVOS OR VISIONOS OR WATCHOS )
2022-11-23 18:50:02 +03:00
set ( SDL_FRAMEWORK_OPENGLES 1 )
set ( SDL_VIDEO_OPENGL_ES 1 )
else ( )
2019-08-05 18:35:32 +03:00
set ( SDL_VIDEO_OPENGL_EGL 1 )
endif ( )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
set ( SDL_VIDEO_OPENGL_ES2 1 )
set ( SDL_VIDEO_RENDER_OGL_ES2 1 )
2021-10-05 17:43:35 +03:00
set ( HAVE_OPENGLES TRUE )
2019-08-05 18:35:32 +03:00
endif ( )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
2021-10-05 17:43:35 +03:00
if ( SDL_VULKAN OR SDL_METAL OR SDL_RENDER_METAL )
2021-11-27 04:27:34 +03:00
check_objc_source_compiles ( "
2019-08-05 18:35:32 +03:00
#include <AvailabilityMacros.h>
#import <Metal/Metal.h>
#import <QuartzCore/CAMetalLayer.h>
2021-07-08 21:20:02 +03:00
#if (!TARGET_CPU_X86_64 && !TARGET_CPU_ARM64)
2019-08-05 18:35:32 +03:00
#error Metal doesn't work on this configuration
#endif
2022-03-13 19:10:52 +03:00
i n t main ( int argc, char **argv ) { r e t u r n 0 ; } " H A V E _ F R A M E W O R K _ M E T A L )
2019-08-05 18:35:32 +03:00
if ( HAVE_FRAMEWORK_METAL )
set ( SDL_FRAMEWORK_METAL 1 )
set ( SDL_FRAMEWORK_QUARTZCORE 1 )
2022-01-10 17:39:42 +03:00
if ( SDL_VULKAN )
set ( SDL_VIDEO_VULKAN 1 )
set ( HAVE_VULKAN TRUE )
Vulkan Renderer (#9114)
This pull request adds an implementation of a Vulkan Render backend to SDL. I have so far tested this primarily on Windows, but also smoke tested on Linux and macOS (MoltenVK). I have not tried it yet on Android, but it should be usable there as well (sans any bugs I missed). This began as a port of the SDL Direct3D12 Renderer, which is the closest thing to Vulkan as existed in the SDL codebase. The shaders are more or less identical (with the only differences being in descriptor bindings vs root descriptors). The shaders are built using the HLSL frontend of glslang.
Everything in the code is pure Vulkan 1.0 (no extensions), with the exception of HDR support which requires the Vulkan instance extension `VK_EXT_swapchain_colorspace`. The code could have been simplified considerably if I used dynamic rendering, push descriptors, extended dynamic state, and other modern Vulkan-isms, but I felt it was more important to make the code as vanilla Vulkan as possible so that it would run on any Vulkan implementation.
The main differences with the Direct3D12 renderer are:
* Having to manage renderpasses for performing clears. There is likely some optimization that would still remain for more efficient use of TBDR hardware where there might be some unnecessary load/stores, but it does attempt to do clears using renderpasses.
* Constant buffer data couldn't be directly updated in the command buffer since I didn't want to rely on push descriptors, so there is a persistently mapped buffer with increasing offset per swapchain image where CB data gets written.
* Many more resources are dependent on the swapchain resizing due to i.e. Vulkan requiring the VkFramebuffer to reference the VkImageView of the swapchain, so there is a bit more code around handling that than was necessary in D3D12.
* For NV12/NV21 textures, rather than there being plane data in the texture itself, the UV data is placed in a separate `VkImage`/`VkImageView`.
I've verified that `testcolorspace` works with both sRGB and HDR linear. I've tested `testoverlay` works with the various YUV/NV12/NV21 formats. I've tested `testsprite`. I've checked that window resizing and swapchain out-of-date handling when minimizing are working. I've run through `testautomation` with the render tests. I also have run several of the tests with Vulkan validation and synchronization validation. Surely I will have missed some things, but I think it's in a good state to be merged and build out from here.
2024-02-23 01:58:11 +03:00
if ( SDL_RENDER_VULKAN )
set ( SDL_VIDEO_RENDER_VULKAN 1 )
2024-02-26 22:37:07 +03:00
set ( HAVE_RENDER_VULKAN TRUE )
Vulkan Renderer (#9114)
This pull request adds an implementation of a Vulkan Render backend to SDL. I have so far tested this primarily on Windows, but also smoke tested on Linux and macOS (MoltenVK). I have not tried it yet on Android, but it should be usable there as well (sans any bugs I missed). This began as a port of the SDL Direct3D12 Renderer, which is the closest thing to Vulkan as existed in the SDL codebase. The shaders are more or less identical (with the only differences being in descriptor bindings vs root descriptors). The shaders are built using the HLSL frontend of glslang.
Everything in the code is pure Vulkan 1.0 (no extensions), with the exception of HDR support which requires the Vulkan instance extension `VK_EXT_swapchain_colorspace`. The code could have been simplified considerably if I used dynamic rendering, push descriptors, extended dynamic state, and other modern Vulkan-isms, but I felt it was more important to make the code as vanilla Vulkan as possible so that it would run on any Vulkan implementation.
The main differences with the Direct3D12 renderer are:
* Having to manage renderpasses for performing clears. There is likely some optimization that would still remain for more efficient use of TBDR hardware where there might be some unnecessary load/stores, but it does attempt to do clears using renderpasses.
* Constant buffer data couldn't be directly updated in the command buffer since I didn't want to rely on push descriptors, so there is a persistently mapped buffer with increasing offset per swapchain image where CB data gets written.
* Many more resources are dependent on the swapchain resizing due to i.e. Vulkan requiring the VkFramebuffer to reference the VkImageView of the swapchain, so there is a bit more code around handling that than was necessary in D3D12.
* For NV12/NV21 textures, rather than there being plane data in the texture itself, the UV data is placed in a separate `VkImage`/`VkImageView`.
I've verified that `testcolorspace` works with both sRGB and HDR linear. I've tested `testoverlay` works with the various YUV/NV12/NV21 formats. I've tested `testsprite`. I've checked that window resizing and swapchain out-of-date handling when minimizing are working. I've run through `testautomation` with the render tests. I also have run several of the tests with Vulkan validation and synchronization validation. Surely I will have missed some things, but I think it's in a good state to be merged and build out from here.
2024-02-23 01:58:11 +03:00
endif ( )
2022-01-10 17:39:42 +03:00
endif ( )
if ( SDL_METAL )
set ( SDL_VIDEO_METAL 1 )
set ( HAVE_METAL TRUE )
endif ( )
if ( SDL_RENDER_METAL )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/render/metal/*.m" )
2022-01-10 17:39:42 +03:00
set ( SDL_VIDEO_RENDER_METAL 1 )
set ( HAVE_RENDER_METAL TRUE )
endif ( )
2019-08-05 18:35:32 +03:00
endif ( )
endif ( )
endif ( )
2024-07-26 19:16:58 +03:00
# Minimum version for $<LINK_LIBRARY:feature,library-list>
cmake_minimum_required ( VERSION 3.24 )
2015-06-21 18:33:46 +03:00
# Actually load the frameworks at the end so we don't duplicate include.
if ( SDL_FRAMEWORK_COREVIDEO )
2023-11-09 13:11:07 +03:00
find_library ( COREMEDIA CoreMedia )
if ( COREMEDIA )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( corevideo LIBS "$<LINK_LIBRARY:FRAMEWORK,CoreMedia>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,CoreMedia" )
2023-11-09 13:11:07 +03:00
endif ( )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( corevideo LIBS "$<LINK_LIBRARY:FRAMEWORK,CoreVideo>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,CoreVideo" )
2015-06-21 18:33:46 +03:00
endif ( )
if ( SDL_FRAMEWORK_COCOA )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( cocoa LIBS "$<LINK_LIBRARY:FRAMEWORK,Cocoa>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,Cocoa" )
2015-06-21 18:33:46 +03:00
endif ( )
if ( SDL_FRAMEWORK_IOKIT )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( iokit LIBS "$<LINK_LIBRARY:FRAMEWORK,IOKit>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,IOKit" )
2015-06-21 18:33:46 +03:00
endif ( )
if ( SDL_FRAMEWORK_FF )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( ff LIBS "$<LINK_LIBRARY:FRAMEWORK,ForceFeedback>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,ForceFeedback" )
2015-06-21 18:33:46 +03:00
endif ( )
if ( SDL_FRAMEWORK_CARBON )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( carbon LIBS "$<LINK_LIBRARY:FRAMEWORK,Carbon>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,Carbon" )
2015-06-21 18:33:46 +03:00
endif ( )
2016-09-15 18:57:56 +03:00
if ( SDL_FRAMEWORK_COREAUDIO )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( core_audio LIBS "$<LINK_LIBRARY:FRAMEWORK,CoreAudio>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,CoreAudio" )
2016-09-15 18:57:56 +03:00
endif ( )
if ( SDL_FRAMEWORK_AUDIOTOOLBOX )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( audio_toolbox LIBS "$<LINK_LIBRARY:FRAMEWORK,AudioToolbox>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,AudioToolbox" )
2016-09-04 08:42:46 +03:00
endif ( )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
if ( SDL_FRAMEWORK_AVFOUNDATION )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( av_foundation LIBS "$<LINK_LIBRARY:FRAMEWORK,AVFoundation>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,AVFoundation" )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
endif ( )
if ( SDL_FRAMEWORK_COREBLUETOOTH )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( core_bluetooth LIBS "$<LINK_LIBRARY:FRAMEWORK,CoreBluetooth>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,CoreBluetooth" )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
endif ( )
if ( SDL_FRAMEWORK_COREGRAPHICS )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( core_graphics LIBS "$<LINK_LIBRARY:FRAMEWORK,CoreGraphics>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,CoreGraphics" )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
endif ( )
if ( SDL_FRAMEWORK_COREMOTION )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( core_motion LIBS "$<LINK_LIBRARY:FRAMEWORK,CoreMotion>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,CoreMotion" )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
endif ( )
if ( SDL_FRAMEWORK_FOUNDATION )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( foundation LIBS "$<LINK_LIBRARY:FRAMEWORK,Foundation>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,Foundation" )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
endif ( )
if ( SDL_FRAMEWORK_GAMECONTROLLER )
find_library ( GAMECONTROLLER GameController )
2021-11-24 23:34:45 +03:00
if ( GAMECONTROLLER )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( game_controller LIBS "$<LINK_LIBRARY:WEAK_FRAMEWORK,GameController>" PKG_CONFIG_LINK_OPTIONS "-Wl,-weak_framework,GameController" )
2021-11-24 23:34:45 +03:00
endif ( )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
endif ( )
2019-08-05 18:35:32 +03:00
if ( SDL_FRAMEWORK_METAL )
2024-04-08 20:18:28 +03:00
if ( IOS OR TVOS OR VISIONOS OR WATCHOS )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( metal LIBS "$<LINK_LIBRARY:FRAMEWORK,Metal>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,Metal" )
2016-10-01 22:54:48 +03:00
else ( )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( metal LIBS "$<LINK_LIBRARY:WEAK_FRAMEWORK,Metal>" PKG_CONFIG_LINK_OPTIONS "-Wl,-weak_framework,Metal" )
2019-08-05 18:35:32 +03:00
endif ( )
endif ( )
2022-11-23 18:50:02 +03:00
if ( SDL_FRAMEWORK_OPENGLES )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( opengles LIBS "$<LINK_LIBRARY:FRAMEWORK,OpenGLES>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,OpenGLES" )
2022-11-23 18:50:02 +03:00
endif ( )
2019-08-05 18:35:32 +03:00
if ( SDL_FRAMEWORK_QUARTZCORE )
2024-04-08 20:18:28 +03:00
if ( IOS OR TVOS OR VISIONOS OR WATCHOS )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( quartz_core LIBS "$<LINK_LIBRARY:FRAMEWORK,QuartzCore>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,QuartzCore" )
2019-08-05 18:35:32 +03:00
else ( )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( metal LIBS "$<LINK_LIBRARY:WEAK_FRAMEWORK,QuartzCore>" PKG_CONFIG_LINK_OPTIONS "-Wl,-weak_framework,QuartzCore" )
2015-06-21 18:33:46 +03:00
endif ( )
endif ( )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
if ( SDL_FRAMEWORK_UIKIT )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( ui_kit LIBS "$<LINK_LIBRARY:FRAMEWORK,UIKit>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,UIKit" )
CMake: iOS support added
When using a recent version of CMake (3.14+), this should make it possible to:
- build SDL for iOS, both static and dynamic
- build SDL test apps (as iOS .app bundles)
- generate a working SDL_config.h for iOS (using SDL_config.h.cmake as a basis)
To use, set the following CMake variables when running CMake's configuration stage:
- CMAKE_SYSTEM_NAME=iOS
- CMAKE_OSX_SYSROOT=<SDK> (examples: iphoneos, iphonesimulator, iphoneos12.4, /full/path/to/iPhoneOS.sdk, etc.)
- CMAKE_OSX_ARCHITECTURES=<semicolon-separated list of CPU architectures> (example: "arm64;armv7s")
Examples:
- for Simulator, using the latest, installed SDK:
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
- for Device, using the latest, installed SDK, 64-bit only
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64
- for Device, using the latest, installed SDK, mixed 32/64 bit
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES="arm64;armv7s"
- for Device, using a specific SDK revision (iOS 12.4, in this example):
cmake path/to/SDL -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos12.4 -DCMAKE_OSX_ARCHITECTURES=arm64
- for Simulator, using the latest, installed SDK, and building SDL test apps (as .app bundles):
cmake path/to/SDL -DSDL_TEST=1 -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=x86_64
2019-08-27 18:07:43 +03:00
endif ( )
2021-04-11 13:29:01 +03:00
if ( SDL_FRAMEWORK_COREHAPTICS )
find_library ( COREHAPTICS CoreHaptics )
if ( COREHAPTICS )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( core_haptics LIBS "$<LINK_LIBRARY:FRAMEWORK,CoreHaptics>" PKG_CONFIG_LINK_OPTIONS "-Wl,-framework,CoreHaptics" )
2021-04-11 13:29:01 +03:00
endif ( )
endif ( )
2015-06-21 18:33:46 +03:00
CheckPTHREAD ( )
2019-07-08 23:46:52 +03:00
2024-02-25 18:33:46 +03:00
if ( SDL_RPATH AND SDL_SHARED )
set ( SDL_RLD_FLAGS "-Wl,-rpath,\${libdir}" )
set ( HAVE_RPATH TRUE )
endif ( )
2015-06-21 18:33:46 +03:00
elseif ( HAIKU )
2024-03-11 01:57:24 +03:00
enable_language ( CXX )
2021-07-24 18:02:27 +03:00
if ( SDL_AUDIO )
set ( SDL_AUDIO_DRIVER_HAIKU 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/audio/haiku/*.cc" )
2021-07-24 18:02:27 +03:00
set ( HAVE_SDL_AUDIO TRUE )
endif ( )
if ( SDL_JOYSTICK )
set ( SDL_JOYSTICK_HAIKU 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/joystick/haiku/*.cc" )
2021-07-24 18:02:27 +03:00
set ( HAVE_SDL_JOYSTICK TRUE )
endif ( )
2024-01-17 19:57:27 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/misc/haiku/*.cc" )
set ( HAVE_SDL_MISC TRUE )
2020-10-05 18:30:33 +03:00
2015-06-21 18:33:46 +03:00
if ( SDL_VIDEO )
set ( SDL_VIDEO_DRIVER_HAIKU 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/video/haiku/*.cc" )
2015-06-21 18:33:46 +03:00
set ( HAVE_SDL_VIDEO TRUE )
2021-10-05 17:43:35 +03:00
if ( SDL_OPENGL )
2015-06-21 18:33:46 +03:00
# TODO: Use FIND_PACKAGE(OpenGL) instead
set ( SDL_VIDEO_OPENGL 1 )
2021-07-24 18:02:27 +03:00
set ( SDL_VIDEO_OPENGL_HAIKU 1 )
2015-06-21 18:33:46 +03:00
set ( SDL_VIDEO_RENDER_OGL 1 )
2023-02-28 06:20:30 +03:00
sdl_link_dependency ( opengl LIBS GL )
2021-10-05 17:43:35 +03:00
set ( HAVE_OPENGL TRUE )
2015-06-21 18:33:46 +03:00
endif ( )
endif ( )
2024-01-17 19:50:48 +03:00
set ( SDL_FILESYSTEM_HAIKU 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/haiku/*.cc" )
set ( HAVE_SDL_FILESYSTEM TRUE )
2020-04-24 09:06:53 +03:00
2024-03-16 18:15:13 +03:00
set ( SDL_FSOPS_POSIX 1 )
sdl_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/posix/SDL_sysfsops.c" )
set ( HAVE_SDL_FSOPS TRUE )
Add time and realtime clock functions
Adds functions to query the system's realtime clock, convert time intervals to/from a calendar date and time in either UTC or the local time, and perform time related calculations.
An SDL_Time type (a time interval represented in nanoseconds), and SDL_DateTime struct (broken down calendar date and time) were added to facilitate this functionality.
Querying the system time results in a value expressed in nanoseconds since the Unix epoch (Jan 1, 1970) in UTC +0000. Conversions to and from the various platform epochs and units are performed when required.
Any direct handling of timezones and DST were intentionally avoided. The offset from UTC is provided when converting from UTC to a local time by calculating the difference between the original UTC and the resulting local time, but no other timezone or DST information is used.
The preferred date formatting and 12/24 hour time for the system locale can be retrieved via global preferences.
Helper functions for obtaining the day of week or day or year for calendar date, and getting the number of days in a month in a given year are provided for convenience. These are simple, but useful for performing various time related calculations.
An automated test for time conversion is included, as is a simple standalone test to display the current system date and time onscreen along with a calendar, the rendering of which demonstrates the use of the utility functions (press up/down to increment or decrement the current month, and keys 1-5 to change the date and time formats).
2024-02-29 21:06:26 +03:00
set ( SDL_TIME_UNIX 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/time/unix/*.c" )
set ( HAVE_SDL_TIME TRUE )
2024-01-17 19:36:52 +03:00
set ( SDL_TIMER_HAIKU 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/timer/haiku/*.c" )
set ( HAVE_SDL_TIMERS TRUE )
2020-04-24 09:06:53 +03:00
2021-07-24 18:02:27 +03:00
if ( SDL_POWER )
set ( SDL_POWER_HAIKU 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/power/haiku/*.c" )
2021-07-24 18:02:27 +03:00
set ( HAVE_SDL_POWER TRUE )
endif ( )
2024-01-17 19:54:27 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/locale/haiku/*.cc" )
set ( HAVE_SDL_LOCALE TRUE )
2020-05-04 09:27:29 +03:00
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/core/haiku/*.cc" )
2021-07-24 18:02:27 +03:00
2015-06-21 18:33:46 +03:00
CheckPTHREAD ( )
2024-03-11 00:27:42 +03:00
sdl_link_dependency ( base LIBS root be media game device textencoding tracker )
2020-02-13 23:50:47 +03:00
elseif ( RISCOS )
2024-01-17 19:57:27 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/misc/riscos/*.c" )
set ( HAVE_SDL_MISC TRUE )
2020-10-11 19:32:32 +03:00
2020-02-14 00:55:08 +03:00
if ( SDL_VIDEO )
set ( SDL_VIDEO_DRIVER_RISCOS 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/video/riscos/*.c" )
2020-02-14 00:55:08 +03:00
set ( HAVE_SDL_VIDEO TRUE )
endif ( )
2024-01-17 19:50:48 +03:00
set ( SDL_FILESYSTEM_RISCOS 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/riscos/*.c" )
set ( HAVE_SDL_FILESYSTEM TRUE )
2020-02-14 01:32:35 +03:00
2024-03-16 18:15:13 +03:00
set ( SDL_FSOPS_POSIX 1 )
sdl_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/posix/SDL_sysfsops.c" )
set ( HAVE_SDL_FSOPS TRUE )
Add time and realtime clock functions
Adds functions to query the system's realtime clock, convert time intervals to/from a calendar date and time in either UTC or the local time, and perform time related calculations.
An SDL_Time type (a time interval represented in nanoseconds), and SDL_DateTime struct (broken down calendar date and time) were added to facilitate this functionality.
Querying the system time results in a value expressed in nanoseconds since the Unix epoch (Jan 1, 1970) in UTC +0000. Conversions to and from the various platform epochs and units are performed when required.
Any direct handling of timezones and DST were intentionally avoided. The offset from UTC is provided when converting from UTC to a local time by calculating the difference between the original UTC and the resulting local time, but no other timezone or DST information is used.
The preferred date formatting and 12/24 hour time for the system locale can be retrieved via global preferences.
Helper functions for obtaining the day of week or day or year for calendar date, and getting the number of days in a month in a given year are provided for convenience. These are simple, but useful for performing various time related calculations.
An automated test for time conversion is included, as is a simple standalone test to display the current system date and time onscreen along with a calendar, the rendering of which demonstrates the use of the utility functions (press up/down to increment or decrement the current month, and keys 1-5 to change the date and time formats).
2024-02-29 21:06:26 +03:00
set ( SDL_TIME_UNIX 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/time/unix/*.c" )
set ( HAVE_SDL_TIME TRUE )
2024-01-17 19:36:52 +03:00
set ( SDL_TIMER_UNIX 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/timer/unix/*.c" )
set ( HAVE_SDL_TIMERS TRUE )
2020-02-13 23:50:47 +03:00
2024-01-17 19:36:52 +03:00
if ( SDL_CLOCK_GETTIME )
set ( HAVE_CLOCK_GETTIME 1 )
2020-02-13 23:50:47 +03:00
endif ( )
CheckPTHREAD ( )
if ( SDL_AUDIO )
CheckOSS ( )
endif ( )
2021-12-07 14:24:32 +03:00
2020-12-18 16:42:57 +03:00
elseif ( VITA )
# SDL_spinlock.c Needs to be compiled in ARM mode.
2022-11-25 00:38:13 +03:00
cmake_push_check_state ( )
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_REQUIRED_FLAGS " -Werror=unused-command-line-argument" )
2020-12-18 16:42:57 +03:00
check_c_compiler_flag ( -marm HAVE_ARM_MODE )
2022-12-18 23:48:24 +03:00
cmake_pop_check_state ( )
2020-12-18 16:42:57 +03:00
if ( HAVE_ARM_MODE )
2022-11-22 07:28:58 +03:00
set_property ( SOURCE "${SDL3_SOURCE_DIR}/src/atomic/SDL_spinlock.c" APPEND_STRING PROPERTY COMPILE_FLAGS " -marm" )
2020-12-18 16:42:57 +03:00
endif ( )
2024-01-17 19:57:27 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/misc/vita/*.c" )
set ( HAVE_SDL_MISC TRUE )
2021-01-29 10:26:13 +03:00
2020-12-18 16:42:57 +03:00
if ( SDL_AUDIO )
set ( SDL_AUDIO_DRIVER_VITA 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/audio/vita/*.c" )
2020-12-18 16:42:57 +03:00
set ( HAVE_SDL_AUDIO TRUE )
endif ( )
2024-01-17 19:36:52 +03:00
2024-01-17 19:50:48 +03:00
set ( SDL_FILESYSTEM_VITA 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/vita/*.c" )
set ( HAVE_SDL_FILESYSTEM TRUE )
2024-01-17 19:36:52 +03:00
2024-03-16 18:15:13 +03:00
# !!! FIXME: do we need a FSops implementation for this?
2020-12-18 16:42:57 +03:00
if ( SDL_JOYSTICK )
set ( SDL_JOYSTICK_VITA 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/joystick/vita/*.c" )
2020-12-18 16:42:57 +03:00
set ( HAVE_SDL_JOYSTICK TRUE )
endif ( )
2024-01-17 19:36:52 +03:00
2020-12-18 16:42:57 +03:00
if ( SDL_POWER )
set ( SDL_POWER_VITA 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/power/vita/*.c" )
2020-12-18 16:42:57 +03:00
set ( HAVE_SDL_POWER TRUE )
endif ( )
2024-01-17 19:36:52 +03:00
set ( SDL_THREAD_VITA 1 )
sdl_sources (
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / v i t a / S D L _ s y s m u t e x . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / v i t a / S D L _ s y s s e m . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / v i t a / S D L _ s y s t h r e a d . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / g e n e r i c / S D L _ s y s c o n d . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / g e n e r i c / S D L _ s y s r w l o c k . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / g e n e r i c / S D L _ s y s t l s . c "
)
set ( HAVE_SDL_THREADS TRUE )
2024-01-17 19:54:27 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/locale/vita/*.c" )
set ( HAVE_SDL_LOCALE TRUE )
2024-01-17 19:36:52 +03:00
Add time and realtime clock functions
Adds functions to query the system's realtime clock, convert time intervals to/from a calendar date and time in either UTC or the local time, and perform time related calculations.
An SDL_Time type (a time interval represented in nanoseconds), and SDL_DateTime struct (broken down calendar date and time) were added to facilitate this functionality.
Querying the system time results in a value expressed in nanoseconds since the Unix epoch (Jan 1, 1970) in UTC +0000. Conversions to and from the various platform epochs and units are performed when required.
Any direct handling of timezones and DST were intentionally avoided. The offset from UTC is provided when converting from UTC to a local time by calculating the difference between the original UTC and the resulting local time, but no other timezone or DST information is used.
The preferred date formatting and 12/24 hour time for the system locale can be retrieved via global preferences.
Helper functions for obtaining the day of week or day or year for calendar date, and getting the number of days in a month in a given year are provided for convenience. These are simple, but useful for performing various time related calculations.
An automated test for time conversion is included, as is a simple standalone test to display the current system date and time onscreen along with a calendar, the rendering of which demonstrates the use of the utility functions (press up/down to increment or decrement the current month, and keys 1-5 to change the date and time formats).
2024-02-29 21:06:26 +03:00
set ( SDL_TIME_VITA 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/time/vita/*.c" )
set ( HAVE_SDL_TIME TRUE )
2024-01-17 19:36:52 +03:00
set ( SDL_TIMER_VITA 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/timer/vita/*.c" )
set ( HAVE_SDL_TIMERS TRUE )
2020-12-18 16:42:57 +03:00
if ( SDL_SENSOR )
set ( SDL_SENSOR_VITA 1 )
set ( HAVE_SDL_SENSORS TRUE )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/sensor/vita/*.c" )
2020-12-18 16:42:57 +03:00
endif ( )
2024-01-17 19:36:52 +03:00
2020-12-18 16:42:57 +03:00
if ( SDL_VIDEO )
set ( SDL_VIDEO_DRIVER_VITA 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/video/vita/*.c" )
2020-12-18 16:42:57 +03:00
set ( HAVE_SDL_VIDEO TRUE )
2021-06-10 13:20:39 +03:00
if ( VIDEO_VITA_PIB )
check_include_file ( pib.h HAVE_PIGS_IN_BLANKET_H )
2021-03-08 18:39:00 +03:00
2021-06-10 13:20:39 +03:00
if ( HAVE_PIGS_IN_BLANKET_H )
set ( SDL_VIDEO_OPENGL_ES2 1 )
2023-02-28 06:20:30 +03:00
sdl_link_dependency ( pib
L I B S
p i b
l i b S c e P i g l e t _ s t u b _ w e a k
t a i h e n _ s t u b _ w e a k
S c e S h a c c C g _ s t u b _ w e a k
2021-06-10 13:20:39 +03:00
)
2022-04-11 23:31:09 +03:00
set ( HAVE_VIDEO_VITA_PIB ON )
2021-06-10 13:20:39 +03:00
set ( SDL_VIDEO_VITA_PIB 1 )
else ( )
2022-04-11 23:31:09 +03:00
set ( HAVE_VIDEO_VITA_PIB OFF )
2021-06-10 13:20:39 +03:00
endif ( )
2020-12-18 16:42:57 +03:00
endif ( )
2021-06-10 13:20:39 +03:00
2021-08-16 19:08:12 +03:00
if ( VIDEO_VITA_PVR )
check_include_file ( gpu_es4/psp2_pvr_hint.h HAVE_PVR_H )
if ( HAVE_PVR_H )
2023-02-28 06:20:30 +03:00
sdl_compile_definitions ( PRIVATE "__psp2__" )
2021-08-16 19:08:12 +03:00
set ( SDL_VIDEO_OPENGL_EGL 1 )
2021-10-05 17:43:35 +03:00
set ( HAVE_OPENGLES TRUE )
2022-11-23 18:50:02 +03:00
set ( SDL_VIDEO_OPENGL_ES 1 )
2021-08-16 19:08:12 +03:00
set ( SDL_VIDEO_OPENGL_ES2 1 )
set ( SDL_VIDEO_RENDER_OGL_ES2 1 )
2023-02-28 06:20:30 +03:00
sdl_link_dependency ( pvr
L I B S
l i b g p u _ e s 4 _ e x t _ s t u b _ w e a k
l i b I M G E G L _ s t u b _ w e a k
S c e I m e _ s t u b
2021-08-16 19:08:12 +03:00
)
2022-03-30 03:08:56 +03:00
2022-04-11 23:31:09 +03:00
set ( HAVE_VIDEO_VITA_PVR ON )
2021-08-16 19:08:12 +03:00
set ( SDL_VIDEO_VITA_PVR 1 )
2022-03-30 03:08:56 +03:00
2023-01-25 01:52:48 +03:00
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 )
2023-02-28 06:20:30 +03:00
sdl_link_dependency ( opengl LIBS libGL_stub )
2023-01-25 01:52:48 +03:00
set ( SDL_VIDEO_VITA_PVR_OGL 1 )
endif ( )
2022-03-30 03:08:56 +03:00
endif ( )
2021-08-16 19:08:12 +03:00
else ( )
2022-04-11 23:31:09 +03:00
set ( HAVE_VIDEO_VITA_PVR OFF )
2021-08-16 19:08:12 +03:00
endif ( )
endif ( )
2021-03-08 18:39:00 +03:00
set ( SDL_VIDEO_RENDER_VITA_GXM 1 )
2023-02-28 06:20:30 +03:00
sdl_link_dependency ( base
L I B S
S c e G x m _ s t u b
S c e D i s p l a y _ s t u b
S c e C t r l _ s t u b
S c e A p p M g r _ s t u b
S c e A p p U t i l _ s t u b
S c e A u d i o _ s t u b
S c e A u d i o I n _ s t u b
S c e S y s m o d u l e _ s t u b
S c e D i s p l a y _ s t u b
S c e C t r l _ s t u b
S c e I o f i l e m g r _ s t u b
S c e C o m m o n D i a l o g _ s t u b
S c e T o u c h _ s t u b
S c e H i d _ s t u b
S c e M o t i o n _ s t u b
S c e P o w e r _ s t u b
S c e P r o c e s s m g r _ s t u b
2021-03-08 18:39:00 +03:00
)
2020-12-18 16:42:57 +03:00
endif ( )
2023-02-28 06:20:30 +03:00
sdl_compile_definitions ( PRIVATE "__VITA__" )
2020-12-18 16:42:57 +03:00
2021-11-29 20:42:13 +03:00
elseif ( PSP )
2024-07-05 03:32:19 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/main/psp/*.c" )
2022-12-12 21:22:17 +03:00
2021-11-29 20:42:13 +03:00
if ( SDL_AUDIO )
set ( SDL_AUDIO_DRIVER_PSP 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/audio/psp/*.c" )
2021-11-29 20:42:13 +03:00
set ( HAVE_SDL_AUDIO TRUE )
endif ( )
2024-01-17 19:36:52 +03:00
2024-01-17 19:50:48 +03:00
set ( SDL_FILESYSTEM_PSP 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/psp/*.c" )
set ( HAVE_SDL_FILESYSTEM TRUE )
2024-01-17 19:36:52 +03:00
2024-03-16 18:15:13 +03:00
# !!! FIXME: do we need a FSops implementation for this?
2021-11-29 20:42:13 +03:00
if ( SDL_JOYSTICK )
set ( SDL_JOYSTICK_PSP 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/joystick/psp/*.c" )
2021-11-29 20:42:13 +03:00
set ( HAVE_SDL_JOYSTICK TRUE )
endif ( )
2024-01-17 19:36:52 +03:00
2021-11-29 20:42:13 +03:00
if ( SDL_POWER )
set ( SDL_POWER_PSP 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/power/psp/*.c" )
2021-11-29 20:42:13 +03:00
set ( HAVE_SDL_POWER TRUE )
endif ( )
2024-01-17 19:36:52 +03:00
set ( SDL_THREAD_PSP 1 )
sdl_glob_sources (
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / g e n e r i c / S D L _ s y s c o n d . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / g e n e r i c / S D L _ s y s t l s . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / g e n e r i c / S D L _ s y s r w l o c k . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / p s p / * . c "
)
set ( HAVE_SDL_THREADS TRUE )
Add time and realtime clock functions
Adds functions to query the system's realtime clock, convert time intervals to/from a calendar date and time in either UTC or the local time, and perform time related calculations.
An SDL_Time type (a time interval represented in nanoseconds), and SDL_DateTime struct (broken down calendar date and time) were added to facilitate this functionality.
Querying the system time results in a value expressed in nanoseconds since the Unix epoch (Jan 1, 1970) in UTC +0000. Conversions to and from the various platform epochs and units are performed when required.
Any direct handling of timezones and DST were intentionally avoided. The offset from UTC is provided when converting from UTC to a local time by calculating the difference between the original UTC and the resulting local time, but no other timezone or DST information is used.
The preferred date formatting and 12/24 hour time for the system locale can be retrieved via global preferences.
Helper functions for obtaining the day of week or day or year for calendar date, and getting the number of days in a month in a given year are provided for convenience. These are simple, but useful for performing various time related calculations.
An automated test for time conversion is included, as is a simple standalone test to display the current system date and time onscreen along with a calendar, the rendering of which demonstrates the use of the utility functions (press up/down to increment or decrement the current month, and keys 1-5 to change the date and time formats).
2024-02-29 21:06:26 +03:00
set ( SDL_TIME_PSP 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/time/psp/*.c" )
set ( HAVE_SDL_TIME TRUE )
2024-01-17 19:36:52 +03:00
set ( SDL_TIMER_PSP 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/timer/psp/*.c" )
set ( HAVE_SDL_TIMERS TRUE )
2021-11-29 20:42:13 +03:00
if ( SDL_VIDEO )
set ( SDL_VIDEO_DRIVER_PSP 1 )
2021-12-07 12:24:46 +03:00
set ( SDL_VIDEO_RENDER_PSP 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/video/psp/*.c" )
2021-11-29 20:42:13 +03:00
set ( SDL_VIDEO_OPENGL 1 )
2021-12-07 12:24:46 +03:00
set ( HAVE_SDL_VIDEO TRUE )
2021-11-29 20:42:13 +03:00
endif ( )
2024-01-17 19:36:52 +03:00
2023-02-28 06:20:30 +03:00
sdl_link_dependency ( base
L I B S
2021-11-29 20:42:13 +03:00
G L
2022-10-18 11:34:51 +03:00
p s p v r a m
p s p a u d i o
p s p v f p u
p s p d i s p l a y
p s p g u
p s p g e
p s p h p r m
p s p c t r l
p s p p o w e r
2022-06-16 17:38:58 +03:00
)
2022-01-11 11:33:02 +03:00
2022-06-06 01:02:08 +03:00
elseif ( PS2 )
2023-02-28 06:20:30 +03:00
sdl_compile_definitions ( PRIVATE "PS2" "__PS2__" )
sdl_include_directories ( PRIVATE SYSTEM "$ENV{PS2SDK}/ports/include" "$ENV{PS2DEV}/gsKit/include" )
2022-03-20 21:42:06 +03:00
2024-07-05 03:32:19 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/main/ps2/*.c" )
2022-12-12 21:15:09 +03:00
2022-06-24 17:43:20 +03:00
if ( SDL_AUDIO )
set ( SDL_AUDIO_DRIVER_PS2 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/audio/ps2/*.c" )
2022-06-24 17:43:20 +03:00
set ( HAVE_SDL_AUDIO TRUE )
endif ( )
2024-01-17 19:36:52 +03:00
2024-01-17 19:50:48 +03:00
set ( SDL_FILESYSTEM_PS2 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/ps2/*.c" )
set ( HAVE_SDL_FILESYSTEM TRUE )
2024-01-17 19:36:52 +03:00
2024-03-16 18:15:13 +03:00
# !!! FIXME: do we need a FSops implementation for this?
2022-06-18 18:40:53 +03:00
if ( SDL_JOYSTICK )
set ( SDL_JOYSTICK_PS2 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/joystick/ps2/*.c" )
2022-06-18 18:40:53 +03:00
set ( HAVE_SDL_JOYSTICK TRUE )
endif ( )
2024-01-17 19:36:52 +03:00
set ( SDL_THREAD_PS2 1 )
sdl_glob_sources (
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / g e n e r i c / S D L _ s y s c o n d . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / g e n e r i c / S D L _ s y s m u t e x . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / g e n e r i c / S D L _ s y s r w l o c k . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / g e n e r i c / S D L _ s y s t l s . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / p s 2 / * . c "
)
set ( HAVE_SDL_THREADS TRUE )
Add time and realtime clock functions
Adds functions to query the system's realtime clock, convert time intervals to/from a calendar date and time in either UTC or the local time, and perform time related calculations.
An SDL_Time type (a time interval represented in nanoseconds), and SDL_DateTime struct (broken down calendar date and time) were added to facilitate this functionality.
Querying the system time results in a value expressed in nanoseconds since the Unix epoch (Jan 1, 1970) in UTC +0000. Conversions to and from the various platform epochs and units are performed when required.
Any direct handling of timezones and DST were intentionally avoided. The offset from UTC is provided when converting from UTC to a local time by calculating the difference between the original UTC and the resulting local time, but no other timezone or DST information is used.
The preferred date formatting and 12/24 hour time for the system locale can be retrieved via global preferences.
Helper functions for obtaining the day of week or day or year for calendar date, and getting the number of days in a month in a given year are provided for convenience. These are simple, but useful for performing various time related calculations.
An automated test for time conversion is included, as is a simple standalone test to display the current system date and time onscreen along with a calendar, the rendering of which demonstrates the use of the utility functions (press up/down to increment or decrement the current month, and keys 1-5 to change the date and time formats).
2024-02-29 21:06:26 +03:00
set ( SDL_TIME_PS2 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/time/ps2/*.c" )
set ( HAVE_SDL_TIME TRUE )
2024-01-17 19:36:52 +03:00
set ( SDL_TIMER_PS2 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/timer/ps2/*.c" )
set ( HAVE_SDL_TIMERS TRUE )
2022-06-24 01:20:11 +03:00
if ( SDL_VIDEO )
set ( SDL_VIDEO_DRIVER_PS2 1 )
set ( SDL_VIDEO_RENDER_PS2 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources (
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / v i d e o / p s 2 / * . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / r e n d e r / p s 2 / * . c "
)
2022-06-24 01:20:11 +03:00
set ( SDL_VIDEO_OPENGL 0 )
set ( HAVE_SDL_VIDEO TRUE )
endif ( )
2022-03-20 21:42:06 +03:00
2023-02-28 06:20:30 +03:00
sdl_link_dependency ( base
L I B S
p a t c h e s
g s k i t
d m a k i t
p s 2 _ d r i v e r s
2022-03-20 21:42:06 +03:00
)
2021-03-30 11:32:39 +03:00
elseif ( N3DS )
2024-07-05 03:32:19 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/main/n3ds/*.c" )
2022-12-12 06:38:06 +03:00
2021-03-30 11:32:39 +03:00
if ( SDL_AUDIO )
set ( SDL_AUDIO_DRIVER_N3DS 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/audio/n3ds/*.c" )
2021-03-30 11:32:39 +03:00
set ( HAVE_SDL_AUDIO TRUE )
endif ( )
2024-01-17 19:50:48 +03:00
set ( SDL_FILESYSTEM_N3DS 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/n3ds/*.c" )
set ( HAVE_SDL_FILESYSTEM TRUE )
2021-03-30 11:32:39 +03:00
2024-03-16 18:15:13 +03:00
# !!! FIXME: do we need a FSops implementation for this?
2021-03-30 11:32:39 +03:00
if ( SDL_JOYSTICK )
set ( SDL_JOYSTICK_N3DS 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/joystick/n3ds/*.c" )
2021-03-30 11:32:39 +03:00
set ( HAVE_SDL_JOYSTICK TRUE )
endif ( )
if ( SDL_POWER )
set ( SDL_POWER_N3DS 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/power/n3ds/*.c" )
2021-03-30 11:32:39 +03:00
set ( HAVE_SDL_POWER TRUE )
endif ( )
2024-01-17 19:36:52 +03:00
set ( SDL_THREAD_N3DS 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/thread/n3ds/*.c" )
sdl_sources (
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / g e n e r i c / S D L _ s y s t l s . c "
" $ { S D L 3 _ S O U R C E _ D I R } / s r c / t h r e a d / g e n e r i c / S D L _ s y s r w l o c k . c "
)
set ( HAVE_SDL_THREADS TRUE )
2021-03-30 11:32:39 +03:00
Add time and realtime clock functions
Adds functions to query the system's realtime clock, convert time intervals to/from a calendar date and time in either UTC or the local time, and perform time related calculations.
An SDL_Time type (a time interval represented in nanoseconds), and SDL_DateTime struct (broken down calendar date and time) were added to facilitate this functionality.
Querying the system time results in a value expressed in nanoseconds since the Unix epoch (Jan 1, 1970) in UTC +0000. Conversions to and from the various platform epochs and units are performed when required.
Any direct handling of timezones and DST were intentionally avoided. The offset from UTC is provided when converting from UTC to a local time by calculating the difference between the original UTC and the resulting local time, but no other timezone or DST information is used.
The preferred date formatting and 12/24 hour time for the system locale can be retrieved via global preferences.
Helper functions for obtaining the day of week or day or year for calendar date, and getting the number of days in a month in a given year are provided for convenience. These are simple, but useful for performing various time related calculations.
An automated test for time conversion is included, as is a simple standalone test to display the current system date and time onscreen along with a calendar, the rendering of which demonstrates the use of the utility functions (press up/down to increment or decrement the current month, and keys 1-5 to change the date and time formats).
2024-02-29 21:06:26 +03:00
set ( SDL_TIME_N3DS 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/time/n3ds/*.c" )
set ( HAVE_SDL_TIME TRUE )
2024-01-17 19:36:52 +03:00
set ( SDL_TIMER_N3DS 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/timer/n3ds/*.c" )
set ( HAVE_SDL_TIMERS TRUE )
2021-03-30 11:32:39 +03:00
2024-03-16 18:15:13 +03:00
set ( SDL_FSOPS_POSIX 1 )
sdl_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/posix/SDL_sysfsops.c" )
set ( HAVE_SDL_FSOPS TRUE )
2022-09-21 05:45:24 +03:00
if ( SDL_SENSOR )
set ( SDL_SENSOR_N3DS 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/sensor/n3ds/*.c" )
2022-09-21 05:45:24 +03:00
set ( HAVE_SDL_SENSORS TRUE )
endif ( )
2021-03-30 11:32:39 +03:00
if ( SDL_VIDEO )
set ( SDL_VIDEO_DRIVER_N3DS 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/video/n3ds/*.c" )
2021-03-30 11:32:39 +03:00
set ( HAVE_SDL_VIDEO TRUE )
endif ( )
2024-01-17 19:54:27 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/locale/n3ds/*.c" )
set ( HAVE_SDL_LOCALE TRUE )
2021-03-30 11:32:39 +03:00
2024-01-17 19:43:11 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/file/n3ds/*.c" )
2015-06-21 18:33:46 +03:00
endif ( )
2024-03-11 00:27:42 +03:00
if ( SDL_DIALOG )
2024-04-02 23:03:58 +03:00
sdl_sources ( ${ SDL3_SOURCE_DIR } /src/dialog/SDL_dialog_utils.c )
2024-05-06 07:14:20 +03:00
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 )
2024-03-11 00:27:42 +03:00
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 AND NOT WINDOWS_STORE )
sdl_sources ( ${ SDL3_SOURCE_DIR } /src/dialog/windows/SDL_windowsdialog.c )
set ( HAVE_SDL_DIALOG TRUE )
2024-04-08 20:18:28 +03:00
elseif ( MACOS )
2024-03-11 00:27:42 +03:00
sdl_sources ( ${ SDL3_SOURCE_DIR } /src/dialog/cocoa/SDL_cocoadialog.m )
2024-07-26 19:16:58 +03:00
sdl_link_dependency ( uniformtypeidentifiers LIBS "$<LINK_LIBRARY:WEAK_FRAMEWORK,UniformTypeIdentifiers>" PKG_CONFIG_LINK_OPTIONS "-Wl,-weak_framework,UniformTypeIdentifiers" )
2024-03-11 00:27:42 +03:00
set ( HAVE_SDL_DIALOG TRUE )
endif ( )
endif ( )
2022-06-16 20:59:57 +03:00
# Platform-independent options
2022-11-23 21:55:34 +03:00
if ( SDL_VIDEO )
2024-05-29 06:02:55 +03:00
if ( SDL_OFFSCREEN )
2022-11-23 21:55:34 +03:00
set ( SDL_VIDEO_DRIVER_OFFSCREEN 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/video/offscreen/*.c" )
2022-11-23 21:55:34 +03:00
set ( HAVE_OFFSCREEN TRUE )
set ( HAVE_SDL_VIDEO TRUE )
endif ( )
endif ( )
2015-06-21 18:33:46 +03:00
# Dummies
2019-03-25 15:01:32 +03:00
# configure.ac does it differently:
2015-06-21 18:33:46 +03:00
# 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.
2022-01-12 19:21:06 +03:00
if ( NOT HAVE_SDL_AUDIO )
set ( SDL_AUDIO_DRIVER_DUMMY 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/audio/dummy/*.c" )
2022-01-12 19:21:06 +03:00
endif ( )
if ( NOT HAVE_SDL_VIDEO )
set ( SDL_VIDEO_DRIVER_DUMMY 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/video/dummy/*.c" )
2022-01-12 19:21:06 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
if ( NOT HAVE_SDL_JOYSTICK )
2018-09-29 07:19:27 +03:00
set ( SDL_JOYSTICK_DUMMY 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/joystick/dummy/*.c" )
2015-06-21 18:33:46 +03:00
endif ( )
if ( NOT HAVE_SDL_HAPTIC )
2018-09-29 07:19:27 +03:00
set ( SDL_HAPTIC_DUMMY 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/haptic/dummy/*.c" )
2015-06-21 18:33:46 +03:00
endif ( )
2018-09-29 07:19:27 +03:00
if ( NOT HAVE_SDL_SENSORS )
set ( SDL_SENSOR_DUMMY 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/sensor/dummy/*.c" )
2018-09-29 07:19:27 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
if ( NOT HAVE_SDL_LOADSO )
2022-01-11 12:45:41 +03:00
set ( SDL_LOADSO_DUMMY 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/loadso/dummy/*.c" )
2015-06-21 18:33:46 +03:00
endif ( )
if ( NOT HAVE_SDL_FILESYSTEM )
2022-01-10 19:00:32 +03:00
set ( SDL_FILESYSTEM_DUMMY 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/dummy/*.c" )
2015-06-21 18:33:46 +03:00
endif ( )
2024-03-08 22:38:46 +03:00
if ( NOT HAVE_SDL_STORAGE )
set ( SDL_STORAGE_GENERIC 1 )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/storage/generic/*.c" )
endif ( )
2024-03-16 18:15:13 +03:00
if ( NOT HAVE_SDL_FSOPS )
set ( SDL_FSOPS_DUMMY 1 )
sdl_sources ( "${SDL3_SOURCE_DIR}/src/filesystem/dummy/SDL_sysfsops.c" )
endif ( )
2020-05-04 09:27:29 +03:00
if ( NOT HAVE_SDL_LOCALE )
2022-01-10 19:00:32 +03:00
set ( SDL_LOCALE_DUMMY 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/locale/dummy/*.c" )
2020-05-04 09:27:29 +03:00
endif ( )
2020-10-05 18:30:33 +03:00
if ( NOT HAVE_SDL_MISC )
2022-01-10 19:00:32 +03:00
set ( SDL_MISC_DUMMY 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/misc/dummy/*.c" )
2020-10-05 18:30:33 +03:00
endif ( )
2024-03-11 00:27:42 +03:00
if ( NOT HAVE_SDL_DIALOG )
set ( SDL_DIALOG_DUMMY 1 )
sdl_sources ( ${ SDL3_SOURCE_DIR } /src/dialog/dummy/SDL_dummydialog.c )
endif ( )
2023-11-28 07:05:54 +03:00
if ( NOT HAVE_CAMERA )
2023-12-01 18:59:13 +03:00
set ( SDL_CAMERA_DRIVER_DUMMY 1 )
2023-11-28 07:05:54 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/camera/dummy/*.c" )
endif ( )
2015-06-21 18:33:46 +03:00
# We always need to have threads and timers around
if ( NOT HAVE_SDL_THREADS )
2022-08-01 19:51:21 +03:00
# The emscripten platform has been carefully vetted to work without threads
2023-02-28 06:20:30 +03:00
if ( EMSCRIPTEN )
2022-08-01 19:51:21 +03:00
set ( SDL_THREADS_DISABLED 1 )
2023-02-28 06:20:30 +03:00
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/thread/generic/*.c" )
2022-08-01 19:51:21 +03:00
else ( )
2023-02-28 06:20:30 +03:00
message ( FATAL_ERROR "Threads are needed by many SDL subsystems and may not be disabled" )
2022-08-01 19:51:21 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
endif ( )
if ( NOT HAVE_SDL_TIMERS )
2024-01-17 07:09:37 +03:00
message ( FATAL_ERROR "Timers are needed by many SDL subsystems and may not be disabled" )
2023-01-07 14:25:04 +03:00
endif ( )
main: Added _optional_ callback entry points.
This lets apps optionally have a handful of callbacks for their entry points instead of a single main function. If used, the actual main/SDL_main/whatever entry point will be implemented in the single-header library SDL_main.h and the app will implement four separate functions:
First:
int SDL_AppInit(int argc, char **argv);
This will be called once before anything else. argc/argv work like they always do. If this returns 0, the app runs. If it returns < 0, the app calls SDL_AppQuit and terminates with an exit code that reports an error to the platform. If it returns > 0, the app calls SDL_AppQuit and terminates with an exit code that reports success to the platform. This function should not go into an infinite mainloop; it should do any one-time startup it requires and then return.
Then:
int SDL_AppIterate(void);
This is called over and over, possibly at the refresh rate of the display or some other metric that the platform dictates. This is where the heart of your app runs. It should return as quickly as reasonably possible, but it's not a "run one memcpy and that's all the time you have" sort of thing. The app should do any game updates, and render a frame of video. If it returns < 0, SDL will call SDL_AppQuit and terminate the process with an exit code that reports an error to the platform. If it returns > 0, the app calls SDL_AppQuit and terminates with an exit code that reports success to the platform. If it returns 0, then SDL_AppIterate will be called again at some regular frequency. The platform may choose to run this more or less (perhaps less in the background, etc), or it might just call this function in a loop as fast as possible. You do not check the event queue in this function (SDL_AppEvent exists for that).
Next:
int SDL_AppEvent(const SDL_Event *event);
This will be called once for each event pushed into the SDL queue. This may be called from any thread, and possibly in parallel to SDL_AppIterate. The fields in event do not need to be free'd (as you would normally need to do for SDL_EVENT_DROP_FILE, etc), and your app should not call SDL_PollEvent, SDL_PumpEvent, etc, as SDL will manage this for you. Return values are the same as from SDL_AppIterate(), so you can terminate in response to SDL_EVENT_QUIT, etc.
Finally:
void SDL_AppQuit(void);
This is called once before terminating the app--assuming the app isn't being forcibly killed or crashed--as a last chance to clean up. After this returns, SDL will call SDL_Quit so the app doesn't have to (but it's safe for the app to call it, too). Process termination proceeds as if the app returned normally from main(), so atexit handles will run, if your platform supports that.
The app does not implement SDL_main if using this. To turn this on, define SDL_MAIN_USE_CALLBACKS before including SDL_main.h. Defines like SDL_MAIN_HANDLED and SDL_MAIN_NOIMPL are also respected for callbacks, if the app wants to do some sort of magic main implementation thing.
In theory, on most platforms these can be implemented in the app itself, but this saves some #ifdefs in the app and lets everyone struggle less against some platforms, and might be more efficient in the long run, too.
On some platforms, it's possible this is the only reasonable way to go, but we haven't actually hit one that 100% requires it yet (but we will, if we want to write a RetroArch backend, for example).
Using the callback entry points works on every platform, because on platforms that don't require them, we can fake them with a simple loop in an internal implementation of the usual SDL_main.
The primary way we expect people to write SDL apps is with SDL_main, and this is not intended to replace it. If the app chooses to use this, it just removes some platform-specific details they might have to otherwise manage, and maybe removes a barrier to entry on some future platform.
Fixes #6785.
Reference PR #8247.
2023-11-02 01:40:41 +03:00
# Most platforms use this.
if ( NOT HAVE_SDL_MAIN_CALLBACKS )
sdl_glob_sources ( "${SDL3_SOURCE_DIR}/src/main/generic/*.c" )
endif ( )
2022-11-26 12:41:46 +03:00
# config variables may contain generator expression, so we need to generate SDL_build_config.h in 2 steps:
2022-06-16 20:59:57 +03:00
# 1. replace all `#cmakedefine`'s and `@abc@`
2022-11-26 12:41:46 +03:00
configure_file ( "${SDL3_SOURCE_DIR}/include/build_config/SDL_build_config.h.cmake"
" $ { S D L 3 _ B I N A R Y _ D I R } / S D L _ b u i l d _ c o n f i g . h . i n t e r m e d i a t e " )
2023-02-28 06:20:30 +03:00
# 2. generate SDL_build_config.h in an build_type-dependent folder (which should be first in the include search path)
2022-06-16 20:59:57 +03:00
file ( GENERATE
2023-02-28 06:20:30 +03:00
O U T P U T " $ { S D L 3 _ B I N A R Y _ D I R } / i n c l u d e - c o n f i g - $ < L O W E R _ C A S E : $ < C O N F I G > > / b u i l d _ c o n f i g / S D L _ b u i l d _ c o n f i g . h "
I N P U T " $ { S D L 3 _ B I N A R Y _ D I R } / S D L _ b u i l d _ c o n f i g . h . i n t e r m e d i a t e "
)
2015-06-21 18:33:46 +03:00
2023-02-28 06:20:30 +03:00
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" )
2022-11-26 23:25:31 +03:00
foreach ( _hdr IN LISTS SDL3_INCLUDE_FILES )
2022-12-18 05:35:13 +03:00
if ( _hdr MATCHES ".*SDL_revision\\.h" OR _hdr MATCHES ".*SDL_test.*\\.h" )
2022-11-26 23:25:31 +03:00
list ( REMOVE_ITEM SDL3_INCLUDE_FILES "${_hdr}" )
endif ( )
endforeach ( )
2023-07-30 00:16:32 +03:00
set ( SDL_REVISION "" CACHE STRING "Custom SDL revision (overrides SDL_REVISION_SUFFIX)" )
if ( NOT SDL_REVISION )
set ( SDL_REVISION_SUFFIX "" CACHE STRING "Suffix for the SDL revision" )
if ( EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/VERSION.txt" )
2023-09-29 04:42:33 +03:00
# If VERSION.txt exists, it contains the SDL version
2023-07-30 00:16:32 +03:00
file ( READ "${CMAKE_CURRENT_SOURCE_DIR}/VERSION.txt" SDL_REVISION_CENTER )
string ( STRIP "${SDL_REVISION_CENTER}" SDL_REVISION_CENTER )
else ( )
# If VERSION does not exist, use git to calculate a version
git_describe ( SDL_REVISION_CENTER )
if ( NOT SDL_REVISION_CENTER )
set ( SDL_REVISION_CENTER "${SDL3_VERSION}-no-vcs" )
endif ( )
2021-09-09 19:59:47 +03:00
endif ( )
2023-07-30 00:16:32 +03:00
set ( SDL_REVISION "SDL-${SDL_REVISION_CENTER}${SDL_REVISION_SUFFIX}" )
2020-10-13 14:45:10 +03:00
endif ( )
2021-09-09 19:59:47 +03:00
2022-11-27 07:43:38 +03:00
execute_process ( COMMAND "${CMAKE_COMMAND}" -E make_directory "${SDL3_BINARY_DIR}/include/SDL3" )
2023-01-21 03:08:32 +03:00
configure_file ( include/build_config/SDL_revision.h.cmake include/SDL3/SDL_revision.h @ONLY )
list ( APPEND SDL3_INCLUDE_FILES "${SDL3_BINARY_DIR}/include/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 } )
2023-02-28 06:20:30 +03:00
sdl_sources ( ${ SDL3_INCLUDE_FILES } )
2023-01-21 03:08:32 +03:00
endif ( )
2021-09-09 19:59:47 +03:00
2023-01-21 03:08:32 +03:00
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
2022-11-22 07:28:58 +03:00
set ( sdl_static_libname "SDL3-static" )
2022-10-04 22:17:10 +03:00
else ( )
2022-11-22 07:28:58 +03:00
set ( sdl_static_libname "SDL3" )
2022-10-04 22:17:10 +03:00
endif ( )
2020-12-18 16:42:57 +03:00
2021-04-12 01:05:58 +03:00
macro ( check_add_debug_flag FLAG SUFFIX )
2023-02-28 06:20:30 +03:00
check_c_compiler_flag ( ${ FLAG } HAS_C_FLAG_ ${ SUFFIX } )
if ( HAS_C_FLAG_ ${ SUFFIX } )
string ( APPEND CMAKE_C_FLAGS_DEBUG " ${FLAG}" )
endif ( )
2021-04-12 01:05:58 +03:00
2024-06-01 11:18:15 +03:00
if ( CMAKE_CXX_COMPILER )
check_cxx_compiler_flag ( ${ FLAG } HAS_CXX_ ${ SUFFIX } )
if ( HAS_CXX_ ${ SUFFIX } )
string ( APPEND CMAKE_CXX_FLAGS_DEBUG " ${FLAG}" )
endif ( )
2023-02-28 06:20:30 +03:00
endif ( )
2021-04-12 01:05:58 +03:00
endmacro ( )
macro ( asan_check_add_debug_flag ASAN_FLAG )
2023-02-28 06:20:30 +03:00
check_add_debug_flag ( "-fsanitize=${ASAN_FLAG}" "${ASAN_FLAG}" )
if ( HAS_C_ ${ ASAN_FLAG } OR HAS_CXX_ ${ ASAN_FLAG } )
set ( HAVE_ASAN ON )
endif ( )
2021-04-12 01:05:58 +03:00
endmacro ( )
macro ( asan_check_add_debug_flag2 ASAN_FLAG )
2023-02-28 06:20:30 +03:00
# 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
2021-04-12 01:05:58 +03:00
2023-02-28 06:20:30 +03:00
set ( FLAG "-fsanitize=${ASAN_FLAG}" )
2021-04-12 01:05:58 +03:00
2023-02-28 06:20:30 +03:00
cmake_push_check_state ( )
list ( APPEND CMAKE_REQUIRED_LIBRARIES ${ FLAG } asan )
2021-04-12 01:05:58 +03:00
2024-06-01 11:18:15 +03:00
check_c_compiler_flag ( ${ FLAG } HAS_C_FLAG_ ${ ASAN_FLAG } )
2023-02-28 06:20:30 +03:00
if ( HAS_C_FLAG_ ${ ASAN_FLAG } )
string ( APPEND CMAKE_C_FLAGS_DEBUG " ${FLAG}" )
endif ( )
2021-04-12 01:05:58 +03:00
2024-06-01 11:18:15 +03:00
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 ( )
2023-02-28 06:20:30 +03:00
endif ( )
2021-04-12 01:10:28 +03:00
2024-06-01 11:18:15 +03:00
cmake_pop_check_state ( )
2023-02-28 06:20:30 +03:00
if ( HAS_C_ ${ ASAN_FLAG } OR HAS_CXX_ ${ ASAN_FLAG } )
set ( HAVE_ASAN ON )
endif ( )
2021-04-12 01:05:58 +03:00
endmacro ( )
# enable AddressSanitizer if supported
2023-01-07 19:45:58 +03:00
if ( SDL_ASAN )
2021-04-12 01:05:58 +03:00
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.
2023-02-28 06:20:30 +03:00
if ( NOT USE_CLANG OR CMAKE_BUILD_TYPE STREQUAL "" )
2021-04-12 01:05:58 +03:00
asan_check_add_debug_flag ( "object-size" )
endif ( )
endif ( )
2023-02-28 06:20:30 +03:00
if ( SDL_CCACHE )
2022-11-15 21:04:22 +03:00
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 ( )
2022-12-12 02:18:06 +03:00
else ( )
set ( HAVE_CCACHE OFF )
2022-11-15 21:04:22 +03:00
endif ( )
2022-10-26 06:26:42 +03:00
if ( SDL_CLANG_TIDY )
cmake_minimum_required ( VERSION 3.6 )
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 } )
2023-02-28 06:20:30 +03:00
get_property ( shared_sources TARGET SDL3-collector PROPERTY INTERFACE_SOURCES )
set_source_files_properties ( ${ shared_sources } PROPERTIES SKIP_PRECOMPILE_HEADERS TRUE )
2022-10-26 06:26:42 +03:00
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 ( )
2022-10-21 16:32:05 +03:00
if ( SDL_TESTS )
set ( HAVE_TESTS ON )
endif ( )
2023-02-28 06:20:30 +03:00
if ( CMAKE_SIZEOF_VOID_P EQUAL 8 )
set ( ARCH_64 TRUE )
else ( )
set ( ARCH_64 FALSE )
2019-10-25 06:17:19 +03:00
endif ( )
2021-10-05 19:34:29 +03:00
if ( ANDROID )
2023-02-28 06:20:30 +03:00
sdl_include_directories ( PRIVATE SYSTEM "${ANDROID_NDK}/sources/android/cpufeatures" )
2021-10-05 19:34:29 +03:00
endif ( )
2022-05-08 03:57:23 +03:00
if ( APPLE )
2023-10-30 22:43:22 +03:00
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 )
2023-10-30 21:59:28 +03:00
message ( FATAL_ERROR "Compiler does not support -fobjc-arc: this is required on Apple platforms" )
endif ( )
2023-02-28 06:20:30 +03:00
sdl_compile_options ( PRIVATE "-fobjc-arc" )
2021-10-05 19:34:29 +03:00
endif ( )
2022-06-24 21:48:50 +03:00
if ( PS2 )
2023-02-28 06:20:30 +03:00
sdl_compile_options ( PRIVATE "-Wno-error=declaration-after-statement" )
2022-06-24 21:48:50 +03:00
endif ( )
2023-11-09 02:20:34 +03:00
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 "$<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:/Zl>" )
if ( TARGET SDL3_test )
target_compile_options ( SDL3_test PRIVATE "/Zl" )
endif ( )
endif ( )
endif ( )
endif ( )
2022-09-07 13:21:56 +03:00
if ( APPLE )
2023-02-28 06:20:30 +03:00
get_property ( sources TARGET SDL3-collector PROPERTY INTERFACE_SOURCES )
foreach ( SOURCE_FILE IN LISTS sources )
2022-09-07 13:21:56 +03:00
get_filename_component ( FILE_EXTENSION ${ SOURCE_FILE } EXT )
2023-03-15 02:15:32 +03:00
if ( FILE_EXTENSION STREQUAL ".m" )
2022-09-07 13:21:56 +03:00
set_property ( SOURCE ${ SOURCE_FILE } APPEND_STRING PROPERTY COMPILE_FLAGS " -x objective-c" )
endif ( )
2023-03-15 02:32:14 +03:00
if ( NOT FILE_EXTENSION STREQUAL ".c" AND NOT FILE_EXTENSION STREQUAL ".cpp" )
set_property ( SOURCE ${ SOURCE_FILE } PROPERTY SKIP_PRECOMPILE_HEADERS 1 )
endif ( )
2022-09-07 13:21:56 +03:00
endforeach ( )
endif ( )
2022-07-25 23:21:11 +03:00
# 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 )
2023-01-21 03:08:32 +03:00
set ( SDL_FRAMEWORK_RESOURCES
X c o d e / S D L / p k g - s u p p o r t / r e s o u r c e s / R e a d M e . t x t
L I C E N S E . t x t
)
if ( SDL_FRAMEWORK )
2023-02-28 06:20:30 +03:00
sdl_sources ( ${ SDL_FRAMEWORK_RESOURCES } )
2023-01-21 03:08:32 +03:00
endif ( )
2023-01-22 02:01:52 +03:00
add_library ( SDL3_Headers INTERFACE )
add_library ( SDL3::Headers ALIAS SDL3_Headers )
2024-03-29 21:38:46 +03:00
set_property ( TARGET SDL3_Headers PROPERTY EXPORT_NAME "Headers" )
2023-01-22 02:01:52 +03:00
target_include_directories ( SDL3_Headers
2023-01-21 02:55:44 +03:00
I N T E R F A C E
" $ < B U I L D _ I N T E R F A C E : $ { S D L 3 _ B I N A R Y _ D I R } / i n c l u d e > "
" $ < B U I L D _ I N T E R F A C E : $ { S D L 3 _ S O U R C E _ D I R } / i n c l u d e > "
)
if ( SDL_FRAMEWORK )
2023-01-22 02:01:52 +03:00
target_include_directories ( SDL3_Headers
2023-01-21 02:55:44 +03:00
I N T E R F A C E
2023-02-13 07:14:40 +03:00
" $ < I N S T A L L _ I N T E R F A C E : $ < I N S T A L L _ P R E F I X > / S D L 3 . f r a m e w o r k / H e a d e r s > "
)
# Add `-F <parent folder of SDL3.framework>` to make sure `#include "SDL3/..."` works.
target_compile_options ( SDL3_Headers
I N T E R F A C E
" $ < I N S T A L L _ I N T E R F A C E : S H E L L : - F $ < I N S T A L L _ P R E F I X > > "
2023-01-21 02:55:44 +03:00
)
else ( )
2023-01-22 02:01:52 +03:00
target_include_directories ( SDL3_Headers
2023-01-21 02:55:44 +03:00
I N T E R F A C E
" $ < I N S T A L L _ I N T E R F A C E : $ { C M A K E _ I N S T A L L _ I N C L U D E D I R } > "
)
endif ( )
2015-06-21 18:33:46 +03:00
if ( SDL_SHARED )
2023-02-17 01:30:20 +03:00
set_target_properties ( SDL3-shared PROPERTIES
O U T P U T _ N A M E " S D L 3 "
2023-01-07 17:06:21 +03:00
P O S I T I O N _ I N D E P E N D E N T _ C O D E T R U E
L I N K _ D E P E N D S " $ { C M A K E _ C U R R E N T _ S O U R C E _ D I R } / s r c / d y n a p i / S D L _ d y n a p i . s y m "
I N T E R F A C E _ L I N K _ D E P E N D S " $ < B U I L D _ I N T E R F A C E : $ { C M A K E _ C U R R E N T _ S O U R C E _ D I R } / s r c / d y n a p i / S D L _ d y n a p i . s y m > "
2023-07-05 01:12:10 +03:00
W I N D O W S _ E X P O R T _ A L L _ S Y M B O L S F A L S E
2023-02-28 06:20:30 +03:00
D E F I N E _ S Y M B O L " D L L _ E X P O R T "
2023-01-07 17:06:21 +03:00
)
2023-01-26 00:27:47 +03:00
if ( HAVE_GCC_FVISIBILITY )
2023-02-17 01:30:20 +03:00
set_target_properties ( SDL3-shared PROPERTIES
2023-01-26 00:27:47 +03:00
C _ V I S I B I L I T Y _ P R E S E T " h i d d e n "
C X X _ V I S I B I L I T Y _ P R E S E T " h i d d e n "
O B J C _ V I S I B I L I T Y _ P R E S E T " h i d d e n "
)
endif ( )
2022-10-21 19:32:53 +03:00
if ( NOT SDL_LIBC )
2023-11-09 02:20:34 +03:00
if ( MSVC AND ( NOT MSVC_CLANG AND NOT WINDOWS_STORE ) )
# 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 ( )
2022-10-21 19:32:53 +03:00
endif ( )
2023-03-23 09:30:23 +03:00
if ( HAS_Q_NO_USE_LIBIRC )
target_compile_options ( SDL3-shared PRIVATE /Q_no-use-libirc )
endif ( )
2022-10-21 19:32:53 +03:00
endif ( )
2017-08-10 05:43:16 +03:00
if ( APPLE )
2024-04-15 21:36:27 +03:00
cmake_minimum_required ( VERSION 3.17 )
2023-02-17 01:30:20 +03:00
set_target_properties ( SDL3-shared PROPERTIES
2023-01-09 15:41:54 +03:00
M A C O S X _ R P A T H T R U E
2023-01-21 03:08:32 +03:00
F R A M E W O R K " $ { S D L _ F R A M E W O R K } "
2024-04-15 21:36:27 +03:00
S O V E R S I O N " $ { S D L _ S O _ V E R S I O N _ M A J O R } "
M A C H O _ C O M P A T I B I L I T Y _ V E R S I O N " $ { S D L _ D Y L I B _ C O M P A T _ V E R S I O N } "
M A C H O _ C U R R E N T _ V E R S I O N " $ { S D L _ D Y L I B _ C U R R E N T _ V E R S I O N } "
2023-01-07 20:08:46 +03:00
)
2023-01-21 03:08:32 +03:00
if ( SDL_FRAMEWORK )
2023-02-17 01:30:20 +03:00
set_target_properties ( SDL3-shared PROPERTIES
2023-01-21 03:08:32 +03:00
P U B L I C _ H E A D E R " $ { S D L 3 _ I N C L U D E _ F I L E S } "
2023-01-29 08:12:40 +03:00
F R A M E W O R K _ V E R S I O N " $ { S D L _ F R A M E W O R K _ V E R S I O N } "
2023-01-21 03:08:32 +03:00
M A C O S X _ F R A M E W O R K _ I D E N T I F I E R " o r g . l i b s d l . S D L 3 "
R E S O U R C E " $ { S D L _ F R A M E W O R K _ R E S O U R C E S } "
)
endif ( )
2017-08-10 05:43:16 +03:00
elseif ( UNIX AND NOT ANDROID )
2023-02-17 01:30:20 +03:00
set_target_properties ( SDL3-shared PROPERTIES
2022-11-29 22:36:46 +03:00
V E R S I O N " $ { S D L _ S O _ V E R S I O N } "
2023-02-28 06:20:30 +03:00
S O V E R S I O N " $ { S D L _ S O _ V E R S I O N _ M A J O R } "
)
2015-06-21 18:33:46 +03:00
else ( )
2020-12-09 12:01:10 +03:00
if ( WINDOWS OR CYGWIN )
2023-02-17 01:30:20 +03:00
set_target_properties ( SDL3-shared PROPERTIES
2023-02-28 06:20:30 +03:00
P R E F I X " "
)
2020-12-09 12:01:10 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
endif ( )
2023-02-28 06:20:30 +03:00
target_link_libraries ( SDL3-shared PRIVATE ${ SDL_CMAKE_DEPENDS } )
2023-02-17 01:30:20 +03:00
target_include_directories ( SDL3-shared
2022-11-26 23:25:31 +03:00
P R I V A T E
2024-08-22 19:52:00 +03:00
" $ < B U I L D _ I N T E R F A C E : $ { S D L 3 _ B I N A R Y _ D I R } / i n c l u d e - c o n f i g - $ < L O W E R _ C A S E : $ < C O N F I G > > > / b u i l d _ c o n f i g "
2022-11-30 05:34:15 +03:00
" $ < B U I L D _ I N T E R F A C E : $ { S D L 3 _ S O U R C E _ D I R } / s r c > "
2022-11-26 23:25:31 +03:00
)
2023-02-17 01:30:20 +03:00
target_link_libraries ( SDL3-shared PUBLIC $< TARGET_NAME:SDL3::Headers > )
2022-06-03 21:12:52 +03:00
if ( MINGW OR CYGWIN )
2023-02-28 06:20:30 +03:00
target_link_options ( SDL3-shared PRIVATE -static-libgcc )
2022-06-03 21:12:52 +03:00
endif ( )
2023-03-01 06:33:30 +03:00
# Use `Compatible Interface Properties` to:
# - allow consumers to enforce a shared/static library
# - block linking to SDL libraries of different major version
2023-02-17 01:30:20 +03:00
set_property ( TARGET SDL3-shared APPEND PROPERTY COMPATIBLE_INTERFACE_BOOL SDL3_SHARED )
2023-03-01 06:33:30 +03:00
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}" )
2022-07-25 23:21:11 +03:00
if ( NOT CMAKE_VERSION VERSION_LESS "3.16" )
2023-03-15 02:32:14 +03:00
target_precompile_headers ( SDL3-shared PRIVATE "$<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:${PROJECT_SOURCE_DIR}/src/SDL_internal.h>" )
2022-07-25 23:21:11 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
endif ( )
if ( SDL_STATIC )
2022-11-22 07:28:58 +03:00
set_target_properties ( SDL3-static PROPERTIES
2022-10-04 22:17:10 +03:00
O U T P U T _ N A M E " $ { s d l _ s t a t i c _ l i b n a m e } "
2023-01-07 18:15:28 +03:00
)
2022-11-22 07:28:58 +03:00
target_compile_definitions ( SDL3-static PRIVATE SDL_STATIC_LIB )
2023-02-28 06:20:30 +03:00
target_link_libraries ( SDL3-static PRIVATE ${ SDL_CMAKE_DEPENDS } )
2022-11-26 23:25:31 +03:00
target_include_directories ( SDL3-static
P R I V A T E
2024-08-22 19:52:00 +03:00
" $ < B U I L D _ I N T E R F A C E : $ { S D L 3 _ B I N A R Y _ D I R } / i n c l u d e - c o n f i g - $ < L O W E R _ C A S E : $ < C O N F I G > > > / b u i l d _ c o n f i g "
2022-11-30 05:34:15 +03:00
" $ < B U I L D _ I N T E R F A C E : $ { S D L 3 _ S O U R C E _ D I R } / s r c > "
2022-11-26 23:25:31 +03:00
)
2023-01-22 02:01:52 +03:00
target_link_libraries ( SDL3-static PUBLIC $< TARGET_NAME:SDL3::Headers > )
2023-03-01 06:33:30 +03:00
# Use `Compatible Interface Properties` to:
# - allow consumers to enforce a shared/static library
# - block linking to SDL libraries of different major version
2022-11-22 07:28:58 +03:00
set_property ( TARGET SDL3-static APPEND PROPERTY COMPATIBLE_INTERFACE_BOOL SDL3_SHARED )
2023-03-01 06:33:30 +03:00
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}" )
2022-07-25 23:21:11 +03:00
if ( NOT CMAKE_VERSION VERSION_LESS "3.16" )
2023-03-15 02:32:14 +03:00
target_precompile_headers ( SDL3-static PRIVATE "$<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:${PROJECT_SOURCE_DIR}/src/SDL_internal.h>" )
2022-07-25 23:21:11 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
endif ( )
2023-02-28 06:20:30 +03:00
sdl_compile_definitions (
P R I V A T E
" S D L _ B U I L D _ M A J O R _ V E R S I O N = $ { P R O J E C T _ V E R S I O N _ M A J O R } "
" S D L _ B U I L D _ M I N O R _ V E R S I O N = $ { P R O J E C T _ V E R S I O N _ M I N O R } "
" S D L _ B U I L D _ M I C R O _ V E R S I O N = $ { P R O J E C T _ V E R S I O N _ P A T C H } "
2023-01-07 18:15:28 +03:00
)
2022-05-03 16:39:00 +03:00
2018-02-24 19:59:58 +03:00
##### Tests #####
2023-07-28 02:51:01 +03:00
if ( SDL_TEST_LIBRARY )
2023-02-28 06:20:30 +03:00
file ( GLOB TEST_SOURCES "${SDL3_SOURCE_DIR}/src/test/*.c" )
target_sources ( SDL3_test PRIVATE ${ TEST_SOURCES } )
2023-01-21 03:08:32 +03:00
if ( APPLE )
set_target_properties ( SDL3_test PROPERTIES
F R A M E W O R K " $ { S D L _ F R A M E W O R K } "
)
if ( SDL_FRAMEWORK )
set_target_properties ( SDL3_test PROPERTIES
2023-01-29 08:12:40 +03:00
F R A M E W O R K _ V E R S I O N " $ { S D L _ F R A M E W O R K _ V E R S I O N } "
2023-01-21 03:08:32 +03:00
M A C O S X _ F R A M E W O R K _ I D E N T I F I E R " o r g . l i b s d l . S D L 3 _ t e s t "
R E S O U R C E " $ { S D L _ F R A M E W O R K _ R E S O U R C E S } "
)
endif ( )
endif ( )
2023-01-22 02:01:52 +03:00
target_link_libraries ( SDL3_test PUBLIC $< TARGET_NAME:SDL3::Headers > )
2023-02-28 06:20:30 +03:00
# FIXME: get rid of EXTRA_TEST_LIBS variable
2022-11-22 07:28:58 +03:00
target_link_libraries ( SDL3_test PRIVATE ${ EXTRA_TEST_LIBS } )
2023-03-01 06:33:30 +03:00
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}" )
2018-02-24 19:59:58 +03:00
endif ( )
2023-02-05 01:20:03 +03:00
##### Configure installation folders #####
2022-12-17 01:51:39 +03:00
2023-02-05 01:20:03 +03:00
if ( WINDOWS AND NOT MINGW )
set ( SDL_INSTALL_CMAKEDIR_ROOT_DEFAULT "cmake" )
else ( )
set ( SDL_INSTALL_CMAKEDIR_ROOT_DEFAULT "${CMAKE_INSTALL_LIBDIR}/cmake" )
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)" )
2022-12-17 01:51:39 +03:00
2023-02-05 01:20:03 +03:00
if ( FREEBSD )
# FreeBSD uses ${PREFIX}/libdata/pkgconfig
set ( SDL_PKGCONFIG_INSTALLDIR "libdata/pkgconfig" )
else ( )
set ( SDL_PKGCONFIG_INSTALLDIR "${CMAKE_INSTALL_LIBDIR}/pkgconfig" )
endif ( )
2022-12-17 01:51:39 +03:00
2023-02-05 01:20:03 +03:00
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}/SDL3" )
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" )
2023-02-28 06:20:30 +03:00
endif ( )
2023-01-15 22:01:58 +03:00
2023-02-28 06:20:30 +03:00
export ( TARGETS SDL3_Headers NAMESPACE "SDL3::" FILE "SDL3headersTargets.cmake" )
2023-02-05 01:20:03 +03:00
2023-02-28 06:20:30 +03:00
if ( SDL_SHARED )
export ( TARGETS SDL3-shared NAMESPACE "SDL3::" FILE "SDL3sharedTargets.cmake" )
endif ( )
2022-01-07 22:30:26 +03:00
2023-02-28 06:20:30 +03:00
if ( SDL_STATIC )
export ( TARGETS SDL3-static NAMESPACE "SDL3::" FILE "SDL3staticTargets.cmake" )
endif ( )
2022-04-16 03:50:55 +03:00
2023-07-28 02:51:01 +03:00
if ( SDL_TEST_LIBRARY )
2023-02-28 06:20:30 +03:00
export ( TARGETS SDL3_test NAMESPACE "SDL3::" FILE "SDL3testTargets.cmake" )
2023-02-05 01:20:03 +03:00
endif ( )
2023-02-28 06:20:30 +03:00
sdl_cmake_config_find_pkg_config_commands ( SDL_FIND_PKG_CONFIG_COMMANDS
C O L L E C T O R S D L 3 - c o l l e c t o r
C O N F I G _ C O M P O N E N T _ F O U N D _ N A M E S D L 3 _ S D L 3 - s t a t i c _ F O U N D
)
sdl_cmake_config_find_pkg_config_commands ( SDL_TEST_FIND_PKG_CONFIG_COMMANDS
C O L L E C T O R S D L 3 _ t e s t - c o l l e c t o r
C O N F I G _ C O M P O N E N T _ F O U N D _ N A M E S D L 3 _ S D L 3 _ t e s t _ F O U N D
)
2023-02-05 01:20:03 +03:00
include ( CMakePackageConfigHelpers )
configure_package_config_file ( cmake/SDL3Config.cmake.in SDL3Config.cmake
2023-11-23 01:28:39 +03:00
N O _ S E T _ A N D _ C H E C K _ M A C R O
2023-02-05 01:20:03 +03:00
P A T H _ V A R S C M A K E _ I N S T A L L _ P R E F I X
I N S T A L L _ D E S T I N A T I O N " $ { S D L _ S D L _ I N S T A L L _ C M A K E D I R } "
)
write_basic_package_version_file ( "${CMAKE_CURRENT_BINARY_DIR}/SDL3ConfigVersion.cmake"
C O M P A T I B I L I T Y A n y N e w e r V e r s i o n
)
2023-02-28 06:20:30 +03:00
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 ( )
2023-02-05 01:20:03 +03:00
if ( NOT SDL_DISABLE_INSTALL )
2022-05-27 02:40:11 +03:00
2023-01-15 22:01:58 +03:00
##### sdl3.pc #####
2023-02-28 06:20:30 +03:00
configure_sdl3_pc ( )
2023-01-21 03:08:32 +03:00
if ( NOT SDL_FRAMEWORK )
install ( FILES ${ SDL3_BINARY_DIR } /sdl3.pc DESTINATION "${SDL_PKGCONFIG_INSTALLDIR}" )
endif ( )
2023-01-15 22:01:58 +03:00
2023-01-29 08:12:40 +03:00
##### Installation targets #####()
install ( TARGETS SDL3_Headers EXPORT SDL3headersTargets )
if ( SDL_SHARED )
2023-02-17 01:30:20 +03:00
install ( TARGETS SDL3-shared EXPORT SDL3sharedTargets
2023-01-29 08:12:40 +03:00
P U B L I C _ H E A D E R D E S T I N A T I O N " $ { S D L _ I N S T A L L _ H E A D E R S D I R } "
A R C H I V E D E S T I N A T I O N " $ { C M A K E _ I N S T A L L _ L I B D I R } "
L I B R A R Y D E S T I N A T I O N " $ { C M A K E _ I N S T A L L _ L I B D I R } "
R U N T I M E D E S T I N A T I O N " $ { C M A K E _ I N S T A L L _ B I N D I R } "
F R A M E W O R K D E S T I N A T I O N " . "
R E S O U R C E D E S T I N A T I O N " $ { S D L _ S D L _ I N S T A L L _ R E S O U R C E D I R } "
)
2023-10-12 01:49:43 +03:00
if ( MSVC )
2023-11-09 02:24:10 +03:00
SDL_install_pdb ( SDL3-shared "${CMAKE_INSTALL_BINDIR}" )
2023-10-12 01:49:43 +03:00
endif ( )
2023-01-29 08:12:40 +03:00
endif ( )
if ( SDL_STATIC )
install ( TARGETS SDL3-static EXPORT SDL3staticTargets
A R C H I V E D E S T I N A T I O N " $ { C M A K E _ I N S T A L L _ L I B D I R } "
F R A M E W O R K D E S T I N A T I O N " . "
R E S O U R C E D E S T I N A T I O N " $ { S D L _ S D L s t a t i c _ I N S T A L L _ R E S O U R C E D I R } "
)
2023-11-09 02:24:10 +03:00
if ( MSVC )
SDL_install_pdb ( SDL3-static "${CMAKE_INSTALL_LIBDIR}" )
endif ( )
2023-01-29 08:12:40 +03:00
endif ( )
2023-07-28 02:51:01 +03:00
if ( SDL_TEST_LIBRARY )
2023-01-29 08:12:40 +03:00
install ( TARGETS SDL3_test EXPORT SDL3testTargets
A R C H I V E D E S T I N A T I O N " $ { C M A K E _ I N S T A L L _ L I B D I R } "
F R A M E W O R K D E S T I N A T I O N " . "
R E S O U R C E D E S T I N A T I O N " $ { S D L _ S D L t e s t _ I N S T A L L _ R E S O U R C E D I R } "
)
2023-11-09 02:24:10 +03:00
if ( MSVC )
SDL_install_pdb ( SDL3_test "${CMAKE_INSTALL_LIBDIR}" )
endif ( )
2023-01-29 08:12:40 +03:00
endif ( )
2023-02-05 01:20:03 +03:00
##### Install CMake Targets #####
2017-08-10 05:03:10 +03:00
2023-01-21 02:55:44 +03:00
install ( EXPORT SDL3headersTargets
2023-01-21 03:08:32 +03:00
F I L E " S D L 3 h e a d e r s T a r g e t s . c m a k e "
2023-01-21 02:55:44 +03:00
N A M E S P A C E S D L 3 : :
2023-01-21 03:08:32 +03:00
D E S T I N A T I O N " $ { S D L _ S D L _ I N S T A L L _ C M A K E D I R } "
2023-01-21 02:55:44 +03:00
)
2022-04-16 03:50:55 +03:00
if ( SDL_SHARED )
2023-02-17 01:30:20 +03:00
install ( EXPORT SDL3sharedTargets
F I L E " S D L 3 s h a r e d T a r g e t s . c m a k e "
2022-11-22 07:28:58 +03:00
N A M E S P A C E S D L 3 : :
2023-01-21 03:08:32 +03:00
D E S T I N A T I O N " $ { S D L _ S D L _ I N S T A L L _ C M A K E D I R } "
2022-04-16 03:50:55 +03:00
)
endif ( )
2017-08-10 05:03:10 +03:00
2022-04-16 03:50:55 +03:00
if ( SDL_STATIC )
2022-11-22 07:28:58 +03:00
install ( EXPORT SDL3staticTargets
2023-01-29 08:12:40 +03:00
F I L E " $ { S D L _ S D L s t a t i c _ I N S T A L L _ C M A K E F I L E N A M E } "
2022-11-22 07:28:58 +03:00
N A M E S P A C E S D L 3 : :
2023-01-21 03:08:32 +03:00
D E S T I N A T I O N " $ { S D L _ S D L s t a t i c _ I N S T A L L _ C M A K E D I R } "
2022-04-16 03:50:55 +03:00
)
endif ( )
2022-01-07 22:30:26 +03:00
2023-07-28 02:51:01 +03:00
if ( SDL_TEST_LIBRARY )
2022-11-22 07:28:58 +03:00
install ( EXPORT SDL3testTargets
2023-01-29 08:12:40 +03:00
F I L E " $ { S D L _ S D L t e s t _ I N S T A L L _ C M A K E F I L E N A M E } "
2022-11-22 07:28:58 +03:00
N A M E S P A C E S D L 3 : :
2023-01-21 03:08:32 +03:00
D E S T I N A T I O N " $ { S D L _ S D L t e s t _ I N S T A L L _ C M A K E D I R } "
2022-05-27 02:40:11 +03:00
)
endif ( )
2023-01-29 08:12:40 +03:00
install ( FILES
2022-11-22 07:28:58 +03:00
$ { C M A K E _ C U R R E N T _ B I N A R Y _ D I R } / S D L 3 C o n f i g . c m a k e
$ { C M A K E _ C U R R E N T _ B I N A R Y _ D I R } / S D L 3 C o n f i g V e r s i o n . c m a k e
2023-02-28 06:20:30 +03:00
$ { s d l _ c m a k e _ m o d u l e s }
2023-01-29 08:12:40 +03:00
D E S T I N A T I O N " $ { S D L _ S D L _ I N S T A L L _ R E A L _ C M A K E D I R } "
2022-01-07 22:30:26 +03:00
)
2015-06-21 18:33:46 +03:00
2023-01-21 03:08:32 +03:00
if ( NOT SDL_FRAMEWORK )
2023-01-29 08:12:40 +03:00
install ( FILES ${ SDL3_INCLUDE_FILES }
D E S T I N A T I O N " $ { C M A K E _ I N S T A L L _ I N C L U D E D I R } / S D L 3 "
2022-12-18 05:35:13 +03:00
)
2023-07-28 02:51:01 +03:00
if ( SDL_TEST_LIBRARY )
2023-01-29 08:12:40 +03:00
install ( FILES ${ SDL3_TEST_INCLUDE_FILES }
D E S T I N A T I O N " $ { C M A K E _ I N S T A L L _ I N C L U D E D I R } / S D L 3 "
2023-01-21 03:08:32 +03:00
)
endif ( )
2022-04-16 03:50:55 +03:00
2023-01-29 08:12:40 +03:00
install ( FILES "LICENSE.txt" DESTINATION "${SDL_INSTALL_LICENSEDIR}" )
endif ( )
if ( NOT SDL_DISABLE_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 )
2023-01-21 03:08:32 +03:00
endif ( )
2023-03-18 02:27:27 +03:00
2023-03-27 13:03:42 +03:00
if ( ANDROID )
if ( TARGET SDL3-jar )
2023-11-23 01:28:39 +03:00
set ( SDL_INSTALL_JAVADIR "${CMAKE_INSTALL_DATAROOTDIR}/java" CACHE PATH "Path where to install java clases + java sources" )
2024-07-31 01:05:54 +03:00
set ( PROGUARD_RULES_PATH "${CMAKE_CURRENT_SOURCE_DIR}/android-project/app/proguard-rules.pro" )
2024-08-23 04:20:39 +03:00
# install_jar or $<TARGET_PROPERTY:SDL3-jar,INSTALL_FILES> does not work on Windows: a SDL3.jar symlink is not generated
install ( FILES "${CMAKE_CURRENT_BINARY_DIR}/SDL3-${SDL3_VERSION}.jar"
2023-03-27 13:03:42 +03:00
D E S T I N A T I O N " $ { S D L _ I N S T A L L _ J A V A D I R } / S D L 3 " )
2024-07-31 01:05:54 +03:00
install ( FILES "${PROGUARD_RULES_PATH}" RENAME "proguard.txt"
D E S T I N A T I O N " $ { S D L _ I N S T A L L _ J A V A D I R } / S D L 3 " )
2023-11-23 01:28:39 +03:00
configure_package_config_file ( cmake/SDL3jarTargets.cmake.in SDL3jarTargets.cmake
I N S T A L L _ D E S T I N A T I O N " $ { S D L _ S D L _ I N S T A L L _ C M A K E D I R } "
P A T H _ V A R S S D L _ I N S T A L L _ J A V A D I R
N O _ C H E C K _ R E Q U I R E D _ C O M P O N E N T S _ M A C R O
I N S T A L L _ P R E F I X " $ { C M A K E _ I N S T A L L _ P R E F I X } "
)
install ( FILES "${CMAKE_CURRENT_BINARY_DIR}/SDL3jarTargets.cmake"
D E S T I N A T I O N " $ { S D L _ S D L _ I N S T A L L _ C M A K E D I R } "
)
2023-03-27 13:03:42 +03:00
endif ( )
if ( TARGET SDL3-javasources )
install ( FILES "${SDL3_BINARY_DIR}/SDL3-${SDL3_VERSION}-sources.jar"
D E S T I N A T I O N " $ { S D L _ I N S T A L L _ J A V A D I R } / S D L 3 " )
endif ( )
endif ( )
if ( NOT SDL_DISABLE_INSTALL_DOCS )
2023-06-27 03:49:05 +03:00
SDL_generate_manpages (
2023-09-29 04:42:33 +03:00
H E A D E R S _ D I R " $ { P R O J E C T _ S O U R C E _ D I R } / i n c l u d e / S D L 3 "
2023-06-27 03:49:05 +03:00
S Y M B O L " S D L _ I n i t "
2023-06-27 20:02:33 +03:00
W I K I H E A D E R S _ P L _ P A T H " $ { C M A K E _ C U R R E N T _ S O U R C E _ D I R } / b u i l d - s c r i p t s / w i k i h e a d e r s . p l "
2023-09-04 19:56:00 +03:00
R E V I S I O N " $ { S D L _ R E V I S I O N } "
2023-06-27 03:49:05 +03:00
)
2023-03-27 13:03:42 +03:00
if ( TARGET SDL3-javadoc )
set ( SDL_INSTALL_JAVADOCDIR "${CMAKE_INSTALL_DATAROOTDIR}/javadoc" CACHE PATH "Path where to install SDL3 javadoc" )
install ( DIRECTORY "${SDL3_BINARY_DIR}/docs/javadoc/"
D E S T I N A T I O N " $ { S D L _ I N S T A L L _ J A V A D O C D I R } / S D L 3 " )
endif ( )
2023-03-18 02:27:27 +03:00
endif ( )
2015-06-21 18:33:46 +03:00
endif ( )
##### Uninstall target #####
2023-01-18 20:05:54 +03:00
if ( NOT SDL_DISABLE_UNINSTALL )
2022-04-16 03:50:55 +03:00
if ( NOT TARGET uninstall )
2022-12-18 04:24:42 +03:00
configure_file ( cmake/cmake_uninstall.cmake.in cmake_uninstall.cmake IMMEDIATE @ONLY )
2017-10-12 18:47:02 +03:00
2022-04-16 03:50:55 +03:00
add_custom_target ( uninstall
2022-12-18 04:24:42 +03:00
C O M M A N D $ { C M A K E _ C O M M A N D } - P " $ { C M A K E _ C U R R E N T _ B I N A R Y _ D I R } / c m a k e _ u n i n s t a l l . c m a k e " )
2022-04-16 03:50:55 +03:00
endif ( )
2017-10-12 18:47:02 +03:00
endif ( )
2022-04-16 03:50:55 +03:00
2022-05-03 22:37:03 +03:00
##### Tests subproject (must appear after the install/uninstall targets) #####
2022-05-27 02:40:11 +03:00
if ( SDL_TESTS )
2022-10-21 16:32:05 +03:00
set ( HAVE_TESTS ON )
2022-05-27 02:40:11 +03:00
enable_testing ( )
2022-05-03 22:37:03 +03:00
add_subdirectory ( test )
endif ( )
2022-05-21 23:51:21 +03:00
2024-07-23 07:56:57 +03:00
##### Examples subproject (must appear after the install/uninstall targets) #####
if ( SDL_EXAMPLES )
set ( HAVE_EXAMPLES ON )
add_subdirectory ( examples )
endif ( )
2022-05-21 23:51:21 +03:00
##### Fix Objective C builds #####
2023-02-28 06:20:30 +03:00
string ( APPEND CMAKE_OBJC_FLAGS " ${CMAKE_C_FLAGS}" )
2022-06-15 05:29:14 +03:00
2023-02-28 06:20:30 +03:00
SDL_PrintSummary ( )
debug_show_sdl_deps ( )