if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})

  message(FATAL_ERROR "Prevented in-tree built. Please create a build directory outside of the SDL source code and call cmake from there")

endif()

cmake_minimum_required(VERSION 2.8.11)

project(SDL2 C)

# !!! FIXME: this should probably do "MACOSX_RPATH ON" as a target property

# !!! FIXME:  for the SDL2 shared library (so you get an

# !!! FIXME:  install_name ("soname") of "@rpath/libSDL-whatever.dylib"

# !!! FIXME:  instead of "/usr/local/lib/libSDL-whatever.dylib"), but I'm

# !!! FIXME:  punting for now and leaving the existing behavior. Until this

# !!! FIXME:  properly resolved, this line silences a warning in CMake 3.0+.

# !!! FIXME:  remove it and this comment entirely once the problem is

# !!! FIXME:  properly resolved.

#cmake_policy(SET CMP0042 OLD)

include(CheckFunctionExists)

include(CheckLibraryExists)

include(CheckIncludeFiles)

include(CheckIncludeFile)

include(CheckSymbolExists)

include(CheckCSourceCompiles)

include(CheckCSourceRuns)

include(CheckCCompilerFlag)

include(CheckTypeSize)

include(CheckStructHasMember)

include(CMakeDependentOption)

include(FindPkgConfig)

include(GNUInstallDirs)

set(CMAKE_MODULE_PATH "${SDL2_SOURCE_DIR}/cmake")

include(${SDL2_SOURCE_DIR}/cmake/macros.cmake)

include(${SDL2_SOURCE_DIR}/cmake/sdlchecks.cmake)

# General settings

# Edit include/SDL_version.h and change the version, then:

#   SDL_MICRO_VERSION += 1;

#   SDL_INTERFACE_AGE += 1;

#   SDL_BINARY_AGE += 1;

# if any functions have been added, set SDL_INTERFACE_AGE to 0.

# if backwards compatibility has been broken,

# set SDL_BINARY_AGE and SDL_INTERFACE_AGE to 0.

set(SDL_MAJOR_VERSION 2)

set(SDL_MINOR_VERSION 0)

set(SDL_MICRO_VERSION 6)

set(SDL_INTERFACE_AGE 0)

set(SDL_BINARY_AGE 6)

set(SDL_VERSION "${SDL_MAJOR_VERSION}.${SDL_MINOR_VERSION}.${SDL_MICRO_VERSION}")

# Set defaults preventing destination file conflicts

set(CMAKE_DEBUG_POSTFIX "d"

    CACHE STRING "Name suffix for debug builds")

mark_as_advanced(CMAKE_IMPORT_LIBRARY_SUFFIX CMAKE_DEBUG_POSTFIX)

# Calculate a libtool-like version number

math(EXPR LT_CURRENT "${SDL_MICRO_VERSION} - ${SDL_INTERFACE_AGE}")

math(EXPR LT_AGE "${SDL_BINARY_AGE} - ${SDL_INTERFACE_AGE}")

math(EXPR LT_MAJOR "${LT_CURRENT}- ${LT_AGE}")

set(LT_REVISION "${SDL_INTERFACE_AGE}")

set(LT_RELEASE "${SDL_MAJOR_VERSION}.${SDL_MINOR_VERSION}")

set(LT_VERSION "${LT_MAJOR}.${LT_AGE}.${LT_REVISION}")

message(STATUS "${LT_VERSION} :: ${LT_AGE} :: ${LT_REVISION} :: ${LT_CURRENT} :: ${LT_RELEASE}")

# General settings & flags

set(LIBRARY_OUTPUT_DIRECTORY "build")

# Check for 64 or 32 bit

set(SIZEOF_VOIDP ${CMAKE_SIZEOF_VOID_P})

if(CMAKE_SIZEOF_VOID_P EQUAL 8)

  set(ARCH_64 TRUE)

  set(PROCESSOR_ARCH "x64")

else()

  set(ARCH_64 FALSE)

  set(PROCESSOR_ARCH "x86")

endif()

set(LIBNAME SDL2)

if(NOT LIBTYPE)

  set(LIBTYPE SHARED)

endif()

# Get the platform

if(WIN32)

  if(NOT WINDOWS)

    set(WINDOWS TRUE)

  endif()

elseif(UNIX AND NOT APPLE)

  if(CMAKE_SYSTEM_NAME MATCHES ".*Linux")

    set(LINUX TRUE)

  elseif(CMAKE_SYSTEM_NAME MATCHES "kFreeBSD.*")

    set(FREEBSD TRUE)

  elseif(CMAKE_SYSTEM_NAME MATCHES "kNetBSD.*|NetBSD.*")

    set(NETBSD TRUE)

  elseif(CMAKE_SYSTEM_NAME MATCHES "kOpenBSD.*|OpenBSD.*")

    set(OPENBSD TRUE)

  elseif(CMAKE_SYSTEM_NAME MATCHES ".*GNU.*")

    set(GNU TRUE)

  elseif(CMAKE_SYSTEM_NAME MATCHES ".*BSDI.*")

    set(BSDI TRUE)

  elseif(CMAKE_SYSTEM_NAME MATCHES "DragonFly.*|FreeBSD")

    set(FREEBSD TRUE)

  elseif(CMAKE_SYSTEM_NAME MATCHES "SYSV5.*")

    set(SYSV5 TRUE)

  elseif(CMAKE_SYSTEM_NAME MATCHES "Solaris.*")

    set(SOLARIS TRUE)

  elseif(CMAKE_SYSTEM_NAME MATCHES "HP-UX.*")

    set(HPUX TRUE)

  elseif(CMAKE_SYSTEM_NAME MATCHES "AIX.*")

    set(AIX TRUE)

  elseif(CMAKE_SYSTEM_NAME MATCHES "Minix.*")

    set(MINIX TRUE)

  endif()

elseif(APPLE)

  if(CMAKE_SYSTEM_NAME MATCHES ".*Darwin.*")

    set(DARWIN TRUE)

  elseif(CMAKE_SYSTEM_NAME MATCHES ".*MacOS.*")

    set(MACOSX TRUE)

  endif()

  # TODO: iOS?

elseif(CMAKE_SYSTEM_NAME MATCHES "BeOS.*")

  message_error("BeOS support has been removed as of SDL 2.0.2.")

elseif(CMAKE_SYSTEM_NAME MATCHES "Haiku.*")

  set(HAIKU TRUE)

endif()

# Don't mistake osx for unix

if(UNIX AND NOT APPLE)

  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()

if (UNIX_OR_MAC_SYS AND NOT EMSCRIPTEN) # JavaScript does not yet have threading support, so disable pthreads when building for Emscripten.

  set(SDL_PTHREADS_ENABLED_BY_DEFAULT ON)

else()

  set(SDL_PTHREADS_ENABLED_BY_DEFAULT OFF)

endif()

# Default option knobs

if(APPLE OR ARCH_64)

  if(NOT "${CMAKE_OSX_ARCHITECTURES}" MATCHES "arm")

    set(OPT_DEF_SSEMATH ON)

  endif()

endif()

if(UNIX OR MINGW OR MSYS)

  set(OPT_DEF_LIBC ON)

endif()

# Compiler info

if(CMAKE_COMPILER_IS_GNUCC)

  set(USE_GCC TRUE)

  set(OPT_DEF_ASM TRUE)

elseif(CMAKE_C_COMPILER_ID MATCHES "Clang")

  set(USE_CLANG TRUE)

  set(OPT_DEF_ASM TRUE)

elseif(MSVC_VERSION GREATER 1400) # VisualStudio 8.0+

  set(OPT_DEF_ASM TRUE)

  #set(CMAKE_C_FLAGS "/ZI /WX- /

else()

  set(OPT_DEF_ASM FALSE)

endif()

if(USE_GCC OR USE_CLANG)

  set(OPT_DEF_GCC_ATOMICS ON)

endif()

# Default flags, if not set otherwise

if("$ENV{CFLAGS}" STREQUAL "")

  if(CMAKE_BUILD_TYPE STREQUAL "")

    if(USE_GCC OR USE_CLANG)

      set(CMAKE_C_FLAGS "-g -O3")

    endif()

  endif()

else()

  set(CMAKE_C_FLAGS "$ENV{CFLAGS}")

  list(APPEND EXTRA_CFLAGS "$ENV{CFLAGS}")

endif()

if(NOT ("$ENV{CFLAGS}" STREQUAL "")) # Hackish, but does the trick on Win32

  list(APPEND EXTRA_LDFLAGS "$ENV{LDFLAGS}")

endif()

if(MSVC)

  option(FORCE_STATIC_VCRT "Force /MT for static VC runtimes" OFF)

  if(FORCE_STATIC_VCRT)

    foreach(flag_var

        CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE

        CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO)

      if(${flag_var} MATCHES "/MD")

        string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")

      endif()

    endforeach()

  endif()

  # Make sure /RTC1 is disabled, otherwise it will use functions from the CRT

  foreach(flag_var

      CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE

      CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO)

    string(REGEX REPLACE "/RTC(su|[1su])" "" ${flag_var} "${${flag_var}}")

  endforeach(flag_var)

endif()

# Those are used for pkg-config and friends, so that the SDL2.pc, sdl2-config,

# etc. are created correctly.

set(SDL_LIBS "-lSDL2")

set(SDL_CFLAGS "")

# Emscripten toolchain has a nonempty default value for this, and the checks 

# in this file need to change that, so remember the original value, and 

# restore back to that afterwards. For check_function_exists() to work in

# Emscripten, this value must be at its default value.

set(ORIG_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})

if(CYGWIN)

  # We build SDL on cygwin without the UNIX emulation layer

  include_directories("-I/usr/include/mingw")

  set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -mno-cygwin")

  check_c_source_compiles("int main(int argc, char **argv) {}"

    HAVE_GCC_NO_CYGWIN)

  set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})

  if(HAVE_GCC_NO_CYGWIN)

    list(APPEND EXTRA_LDFLAGS "-mno-cygwin")

    list(APPEND SDL_LIBS "-mno-cygwin")

  endif()

  set(SDL_CFLAGS "${SDL_CFLAGS} -I/usr/include/mingw")

endif()

add_definitions(-DUSING_GENERATED_CONFIG_H)

# General includes

include_directories(${SDL2_BINARY_DIR}/include ${SDL2_SOURCE_DIR}/include)

if(USE_GCC OR USE_CLANG)

  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -idirafter ${SDL2_SOURCE_DIR}/src/video/khronos")

else()

  include_directories(${SDL2_SOURCE_DIR}/src/video/khronos)

endif()

# All these ENABLED_BY_DEFAULT vars will default to ON if not specified, so

#  you only need to have a platform override them if they are disabling.

set(OPT_DEF_ASM TRUE)

if(EMSCRIPTEN)

  # Set up default values for the currently supported set of subsystems:

  # Emscripten/Javascript does not have assembly support, a dynamic library 

  # loading architecture, low-level CPU inspection or multithreading.

  set(OPT_DEF_ASM FALSE)

  set(SDL_SHARED_ENABLED_BY_DEFAULT OFF)

  set(SDL_ATOMIC_ENABLED_BY_DEFAULT OFF)

  set(SDL_THREADS_ENABLED_BY_DEFAULT OFF)

  set(SDL_LOADSO_ENABLED_BY_DEFAULT OFF)

  set(SDL_CPUINFO_ENABLED_BY_DEFAULT OFF)

  set(SDL_DLOPEN_ENABLED_BY_DEFAULT OFF)

endif()

if (NOT DEFINED SDL_SHARED_ENABLED_BY_DEFAULT)

    set(SDL_SHARED_ENABLED_BY_DEFAULT ON)

endif()

set(SDL_SUBSYSTEMS

    Atomic Audio Video Render Events Joystick Haptic Power Threads Timers

    File Loadso CPUinfo Filesystem Dlopen)

foreach(_SUB ${SDL_SUBSYSTEMS})

  string(TOUPPER ${_SUB} _OPT)

  if (NOT DEFINED SDL_${_OPT}_ENABLED_BY_DEFAULT)

    set(SDL_${_OPT}_ENABLED_BY_DEFAULT ON)

  endif()

  option(SDL_${_OPT} "Enable the ${_SUB} subsystem" ${SDL_${_OPT}_ENABLED_BY_DEFAULT})

endforeach()

option_string(ASSERTIONS "Enable internal sanity checks (auto/disabled/release/enabled/paranoid)" "auto")

#set_option(DEPENDENCY_TRACKING "Use gcc -MMD -MT dependency tracking" ON)

set_option(LIBC                "Use the system C library" ${OPT_DEF_LIBC})

set_option(GCC_ATOMICS         "Use gcc builtin atomics" ${OPT_DEF_GCC_ATOMICS})

set_option(ASSEMBLY            "Enable assembly routines" ${OPT_DEF_ASM})

set_option(SSEMATH             "Allow GCC to use SSE floating point math" ${OPT_DEF_SSEMATH})

set_option(MMX                 "Use MMX assembly routines" ${OPT_DEF_ASM})

set_option(3DNOW               "Use 3Dnow! MMX assembly routines" ${OPT_DEF_ASM})

set_option(SSE                 "Use SSE assembly routines" ${OPT_DEF_ASM})

set_option(SSE2                "Use SSE2 assembly routines" ${OPT_DEF_SSEMATH})

set_option(SSE3                "Use SSE3 assembly routines" ${OPT_DEF_SSEMATH})

set_option(ALTIVEC             "Use Altivec assembly routines" ${OPT_DEF_ASM})

set_option(DISKAUDIO           "Support the disk writer audio driver" ON)

set_option(DUMMYAUDIO          "Support the dummy audio driver" ON)

set_option(VIDEO_DIRECTFB      "Use DirectFB video driver" OFF)

dep_option(DIRECTFB_SHARED     "Dynamically load directfb support" ON "VIDEO_DIRECTFB" OFF)

set_option(VIDEO_DUMMY         "Use dummy video driver" ON)

set_option(VIDEO_OPENGL        "Include OpenGL support" ON)

set_option(VIDEO_OPENGLES      "Include OpenGL ES support" ON)

set_option(PTHREADS            "Use POSIX threads for multi-threading" ${SDL_PTHREADS_ENABLED_BY_DEFAULT})

dep_option(PTHREADS_SEM        "Use pthread semaphores" ON "PTHREADS" OFF)

set_option(SDL_DLOPEN          "Use dlopen for shared object loading" ${SDL_DLOPEN_ENABLED_BY_DEFAULT})

set_option(OSS                 "Support the OSS audio API" ${UNIX_SYS})

set_option(ALSA                "Support the ALSA audio API" ${UNIX_SYS})

dep_option(ALSA_SHARED         "Dynamically load ALSA audio support" ON "ALSA" OFF)

set_option(JACK                "Support the JACK audio API" ${UNIX_SYS})

dep_option(JACK_SHARED         "Dynamically load JACK audio support" ON "JACK" OFF)

set_option(ESD                 "Support the Enlightened Sound Daemon" ${UNIX_SYS})

dep_option(ESD_SHARED          "Dynamically load ESD audio support" ON "ESD" OFF)

set_option(PULSEAUDIO          "Use PulseAudio" ${UNIX_SYS})

dep_option(PULSEAUDIO_SHARED   "Dynamically load PulseAudio support" ON "PULSEAUDIO" OFF)

set_option(ARTS                "Support the Analog Real Time Synthesizer" ${UNIX_SYS})

dep_option(ARTS_SHARED         "Dynamically load aRts audio support" ON "ARTS" OFF)

set_option(NAS                 "Support the NAS audio API" ${UNIX_SYS})

set_option(NAS_SHARED          "Dynamically load NAS audio API" ${UNIX_SYS})

set_option(SNDIO               "Support the sndio audio API" ${UNIX_SYS})

set_option(FUSIONSOUND         "Use FusionSound audio driver" OFF)

dep_option(FUSIONSOUND_SHARED  "Dynamically load fusionsound audio support" ON "FUSIONSOUND" OFF)

set_option(LIBSAMPLERATE       "Use libsamplerate for audio rate conversion" ${UNIX_SYS})

dep_option(LIBSAMPLERATE_SHARED "Dynamically load libsamplerate" ON "LIBSAMPLERATE" OFF)

set_option(RPATH               "Use an rpath when linking SDL" ${UNIX_SYS})

set_option(CLOCK_GETTIME       "Use clock_gettime() instead of gettimeofday()" OFF)

set_option(INPUT_TSLIB         "Use the Touchscreen library for input" ${UNIX_SYS})

set_option(VIDEO_X11           "Use X11 video driver" ${UNIX_SYS})

set_option(VIDEO_WAYLAND       "Use Wayland video driver" ${UNIX_SYS})

dep_option(WAYLAND_SHARED      "Dynamically load Wayland support" ON "VIDEO_WAYLAND" OFF)

dep_option(VIDEO_WAYLAND_QT_TOUCH  "QtWayland server support for Wayland video driver" ON "VIDEO_WAYLAND" OFF)

set_option(VIDEO_MIR           "Use Mir video driver" ${UNIX_SYS})

dep_option(MIR_SHARED          "Dynamically load Mir support" ON "VIDEO_MIR" OFF)

set_option(VIDEO_RPI           "Use Raspberry Pi video driver" ${UNIX_SYS})

dep_option(X11_SHARED          "Dynamically load X11 support" ON "VIDEO_X11" OFF)

set(SDL_X11_OPTIONS Xcursor Xinerama XInput Xrandr Xscrnsaver XShape Xvm)

foreach(_SUB ${SDL_X11_OPTIONS})

  string(TOUPPER "VIDEO_X11_${_SUB}" _OPT)

  dep_option(${_OPT}           "Enable ${_SUB} support" ON "VIDEO_X11" OFF)

endforeach()

set_option(VIDEO_COCOA         "Use Cocoa video driver" ${APPLE})

set_option(DIRECTX             "Use DirectX for Windows audio/video" ${WINDOWS})

set_option(RENDER_D3D          "Enable the Direct3D render driver" ${WINDOWS})

set_option(VIDEO_VIVANTE       "Use Vivante EGL video driver" ${UNIX_SYS})

dep_option(VIDEO_VULKAN        "Enable Vulkan support" ON "ANDROID OR APPLE OR LINUX OR WINDOWS" OFF)

set_option(VIDEO_KMSDRM        "Use KMS DRM video driver" ${UNIX_SYS})

dep_option(KMSDRM_SHARED       "Dynamically load KMS DRM support" ON "VIDEO_KMSDRM" OFF)

# TODO: We should (should we?) respect cmake's ${BUILD_SHARED_LIBS} flag here

# The options below are for compatibility to configure's default behaviour.

set(SDL_SHARED ${SDL_SHARED_ENABLED_BY_DEFAULT} CACHE BOOL "Build a shared version of the library")

set(SDL_STATIC ON CACHE BOOL "Build a static version of the library")

dep_option(SDL_STATIC_PIC      "Static version of the library should be built with Position Independent Code" OFF "SDL_STATIC" OFF)

# General source files

file(GLOB SOURCE_FILES

  ${SDL2_SOURCE_DIR}/src/*.c

  ${SDL2_SOURCE_DIR}/src/atomic/*.c

  ${SDL2_SOURCE_DIR}/src/audio/*.c

  ${SDL2_SOURCE_DIR}/src/cpuinfo/*.c

  ${SDL2_SOURCE_DIR}/src/dynapi/*.c

  ${SDL2_SOURCE_DIR}/src/events/*.c

  ${SDL2_SOURCE_DIR}/src/file/*.c

  ${SDL2_SOURCE_DIR}/src/libm/*.c

  ${SDL2_SOURCE_DIR}/src/render/*.c

  ${SDL2_SOURCE_DIR}/src/render/*/*.c

  ${SDL2_SOURCE_DIR}/src/stdlib/*.c

  ${SDL2_SOURCE_DIR}/src/thread/*.c

  ${SDL2_SOURCE_DIR}/src/timer/*.c

  ${SDL2_SOURCE_DIR}/src/video/*.c)

if(ASSERTIONS STREQUAL "auto")

  # Do nada - use optimization settings to determine the assertion level

elseif(ASSERTIONS STREQUAL "disabled")

  set(SDL_DEFAULT_ASSERT_LEVEL 0)

elseif(ASSERTIONS STREQUAL "release")

  set(SDL_DEFAULT_ASSERT_LEVEL 1)

elseif(ASSERTIONS STREQUAL "enabled")

  set(SDL_DEFAULT_ASSERT_LEVEL 2)

elseif(ASSERTIONS STREQUAL "paranoid")

  set(SDL_DEFAULT_ASSERT_LEVEL 3)

else()

  message_error("unknown assertion level")

endif()

set(HAVE_ASSERTIONS ${ASSERTIONS})

# Compiler option evaluation

if(USE_GCC OR USE_CLANG)

  # Check for -Wall first, so later things can override pieces of it.

  check_c_compiler_flag(-Wall HAVE_GCC_WALL)

  if(HAVE_GCC_WALL)

    list(APPEND EXTRA_CFLAGS "-Wall")

    if(HAIKU)

      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-multichar")

    endif()

  endif()

  check_c_compiler_flag(-Wdeclaration-after-statement HAVE_GCC_WDECLARATION_AFTER_STATEMENT)

  if(HAVE_GCC_WDECLARATION_AFTER_STATEMENT)

    check_c_compiler_flag(-Werror=declaration-after-statement HAVE_GCC_WERROR_DECLARATION_AFTER_STATEMENT)

    if(HAVE_GCC_WERROR_DECLARATION_AFTER_STATEMENT)

      list(APPEND EXTRA_CFLAGS "-Werror=declaration-after-statement")

    endif()

    list(APPEND EXTRA_CFLAGS "-Wdeclaration-after-statement")

  endif()

  if(DEPENDENCY_TRACKING)

    check_c_source_compiles("

        #if !defined(__GNUC__) || __GNUC__ < 3

        #error Dependency tracking requires GCC 3.0 or newer

        #endif

        int main(int argc, char **argv) { }" HAVE_DEPENDENCY_TRACKING)

  endif()

  if(GCC_ATOMICS)

    check_c_source_compiles("int main(int argc, char **argv) {

        int a;

        void *x, *y, *z;

        __sync_lock_test_and_set(&a, 4);

        __sync_lock_test_and_set(&x, y);

        __sync_fetch_and_add(&a, 1);

        __sync_bool_compare_and_swap(&a, 5, 10);

        __sync_bool_compare_and_swap(&x, y, z); }" HAVE_GCC_ATOMICS)

    if(NOT HAVE_GCC_ATOMICS)

      check_c_source_compiles("int main(int argc, char **argv) {

          int a;

          __sync_lock_test_and_set(&a, 1);

          __sync_lock_release(&a); }" HAVE_GCC_SYNC_LOCK_TEST_AND_SET)

    endif()

  endif()

  set(CMAKE_REQUIRED_FLAGS "-mpreferred-stack-boundary=2")

  check_c_source_compiles("int x = 0; int main(int argc, char **argv) {}"

    HAVE_GCC_PREFERRED_STACK_BOUNDARY)

  set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})

  set(CMAKE_REQUIRED_FLAGS "-fvisibility=hidden -Werror")

  check_c_source_compiles("

      #if !defined(__GNUC__) || __GNUC__ < 4

      #error SDL only uses visibility attributes in GCC 4 or newer

      #endif

      int main(int argc, char **argv) {}" HAVE_GCC_FVISIBILITY)

  if(HAVE_GCC_FVISIBILITY)

    list(APPEND EXTRA_CFLAGS "-fvisibility=hidden")

  endif()

  set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})

  check_c_compiler_flag(-Wshadow HAVE_GCC_WSHADOW)

  if(HAVE_GCC_WSHADOW)

    list(APPEND EXTRA_CFLAGS "-Wshadow")

  endif()

  if(APPLE)

    list(APPEND EXTRA_LDFLAGS "-Wl,-undefined,error")

  else()

    set(CMAKE_REQUIRED_FLAGS "-Wl,--no-undefined")

    check_c_compiler_flag("" HAVE_NO_UNDEFINED)

    set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})

    if(HAVE_NO_UNDEFINED)

      list(APPEND EXTRA_LDFLAGS "-Wl,--no-undefined")

    endif()

  endif()

endif()

if(ASSEMBLY)

  if(USE_GCC OR USE_CLANG)

    set(SDL_ASSEMBLY_ROUTINES 1)

    # TODO: Those all seem to be quite GCC specific - needs to be

    # reworked for better compiler support

    set(HAVE_ASSEMBLY TRUE)

    if(MMX)

      set(CMAKE_REQUIRED_FLAGS "-mmmx")

      check_c_source_compiles("

          #ifdef __MINGW32__

          #include <_mingw.h>

          #ifdef __MINGW64_VERSION_MAJOR

          #include <intrin.h>

          #else

          #include <mmintrin.h>

          #endif

          #else

          #include <mmintrin.h>

          #endif

          #ifndef __MMX__

          #error Assembler CPP flag not enabled

          #endif

          int main(int argc, char **argv) { }" HAVE_MMX)

      if(HAVE_MMX)

        list(APPEND EXTRA_CFLAGS "-mmmx")

      endif()

      set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})

    endif()

    if(3DNOW)

      set(CMAKE_REQUIRED_FLAGS "-m3dnow")

      check_c_source_compiles("

          #include <mm3dnow.h>

          #ifndef __3dNOW__

          #error Assembler CPP flag not enabled

          #endif

          int main(int argc, char **argv) {

            void *p = 0;

            _m_prefetch(p);

          }" HAVE_3DNOW)

      if(HAVE_3DNOW)

        list(APPEND EXTRA_CFLAGS "-m3dnow")

      endif()

      set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})

    endif()

    if(SSE)

      set(CMAKE_REQUIRED_FLAGS "-msse")

      check_c_source_compiles("

          #ifdef __MINGW32__

          #include <_mingw.h>

          #ifdef __MINGW64_VERSION_MAJOR

          #include <intrin.h>

          #else

          #include <xmmintrin.h>

          #endif

          #else

          #include <xmmintrin.h>

          #endif

          #ifndef __SSE__

          #error Assembler CPP flag not enabled

          #endif

          int main(int argc, char **argv) { }" HAVE_SSE)

      if(HAVE_SSE)

        list(APPEND EXTRA_CFLAGS "-msse")

      endif()

      set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})

    endif()

    if(SSE2)

      set(CMAKE_REQUIRED_FLAGS "-msse2")

      check_c_source_compiles("

          #ifdef __MINGW32__

          #include <_mingw.h>

          #ifdef __MINGW64_VERSION_MAJOR

          #include <intrin.h>

          #else

          #include <emmintrin.h>

          #endif

          #else

          #include <emmintrin.h>

          #endif

          #ifndef __SSE2__

          #error Assembler CPP flag not enabled

          #endif

          int main(int argc, char **argv) { }" HAVE_SSE2)

      if(HAVE_SSE2)

        list(APPEND EXTRA_CFLAGS "-msse2")

      endif()

      set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})

    endif()

    if(SSE3)

      set(CMAKE_REQUIRED_FLAGS "-msse3")

      check_c_source_compiles("

          #ifdef __MINGW32__

          #include <_mingw.h>

          #ifdef __MINGW64_VERSION_MAJOR

          #include <intrin.h>

          #else

          #include <pmmintrin.h>

          #endif

          #else

          #include <pmmintrin.h>

          #endif

          #ifndef __SSE3__

          #error Assembler CPP flag not enabled

          #endif

          int main(int argc, char **argv) { }" HAVE_SSE3)

      if(HAVE_SSE3)

        list(APPEND EXTRA_CFLAGS "-msse3")

      endif()

      set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})

    endif()

    if(NOT SSEMATH)

      if(SSE OR SSE2 OR SSE3)

        if(USE_GCC)

          check_c_compiler_flag(-mfpmath=387 HAVE_FP_387)

          if(HAVE_FP_387)

            list(APPEND EXTRA_CFLAGS "-mfpmath=387")

          endif()

        endif()

        set(HAVE_SSEMATH TRUE)

      endif()

    endif()

    if(ALTIVEC)

      set(CMAKE_REQUIRED_FLAGS "-maltivec")

      check_c_source_compiles("

          #include <altivec.h>

          vector unsigned int vzero() {

              return vec_splat_u32(0);

          }

          int main(int argc, char **argv) { }" HAVE_ALTIVEC_H_HDR)

      check_c_source_compiles("

          vector unsigned int vzero() {

              return vec_splat_u32(0);

          }

          int main(int argc, char **argv) { }" HAVE_ALTIVEC)

      set(CMAKE_REQUIRED_FLAGS ${ORIG_CMAKE_REQUIRED_FLAGS})

      if(HAVE_ALTIVEC OR HAVE_ALTIVEC_H_HDR)

        set(HAVE_ALTIVEC TRUE) # if only HAVE_ALTIVEC_H_HDR is set

        list(APPEND EXTRA_CFLAGS "-maltivec")

        set(SDL_ALTIVEC_BLITTERS 1)

        if(HAVE_ALTIVEC_H_HDR)

          set(HAVE_ALTIVEC_H 1)

        endif()

      endif()

    endif()

  elseif(MSVC_VERSION GREATER 1500)

    # TODO: SDL_cpuinfo.h needs to support the user's configuration wish

    # for MSVC - right now it is always activated

    if(NOT ARCH_64)

      set(HAVE_MMX TRUE)

      set(HAVE_3DNOW TRUE)

    endif()

    set(HAVE_SSE TRUE)

    set(HAVE_SSE2 TRUE)

    set(HAVE_SSE3 TRUE)

    set(SDL_ASSEMBLY_ROUTINES 1)

  endif()

# TODO:

#else()

#  if(USE_GCC OR USE_CLANG)

#    list(APPEND EXTRA_CFLAGS "-mno-sse" "-mno-sse2" "-mno-sse3" "-mno-mmx")

#  endif()

endif()

# TODO: Can't deactivate on FreeBSD? w/o LIBC, SDL_stdinc.h can't define

# anything.

if(LIBC)

  if(WINDOWS AND NOT MINGW)

    set(HAVE_LIBC TRUE)

    foreach(_HEADER stdio.h string.h wchar.h ctype.h math.h limits.h)

      string(TOUPPER "HAVE_${_HEADER}" _UPPER)

      string(REPLACE "." "_" _HAVE_H ${_UPPER})

      set(${_HAVE_H} 1)

    endforeach()

    set(HAVE_SIGNAL_H 1)

    foreach(_FN

            malloc calloc realloc free qsort abs memset memcpy memmove memcmp

            wcslen wcscmp

            strlen _strrev _strupr _strlwr strchr strrchr strstr itoa _ltoa

            _ultoa strtol strtoul strtoll strtod atoi atof strcmp strncmp

            _stricmp _strnicmp sscanf atan atan2 acos asin ceil copysign cos

            cosf fabs floor log pow scalbn sin sinf sqrt sqrtf tan tanf)

      string(TOUPPER ${_FN} _UPPER)

      set(HAVE_${_UPPER} 1)

    endforeach()

    if(NOT CYGWIN AND NOT MINGW)

      set(HAVE_ALLOCA 1)

    endif()

    set(HAVE_M_PI 1)

    add_definitions(-D_USE_MATH_DEFINES) # needed for M_PI

    set(STDC_HEADERS 1)

  else()

    set(HAVE_LIBC TRUE)

    check_include_file(sys/types.h HAVE_SYS_TYPES_H)

    foreach(_HEADER

            stdio.h stdlib.h stddef.h stdarg.h malloc.h memory.h string.h limits.h

            strings.h wchar.h inttypes.h stdint.h ctype.h math.h iconv.h signal.h)

      string(TOUPPER "HAVE_${_HEADER}" _UPPER)

      string(REPLACE "." "_" _HAVE_H ${_UPPER})

      check_include_file("${_HEADER}" ${_HAVE_H})

    endforeach()

    check_include_files("dlfcn.h;stdint.h;stddef.h;inttypes.h;stdlib.h;strings.h;string.h;float.h" STDC_HEADERS)

    check_type_size("size_t" SIZEOF_SIZE_T)

    check_symbol_exists(M_PI math.h HAVE_M_PI)

    # TODO: refine the mprotect check

    check_c_source_compiles("#include <sys/types.h>

                             #include <sys/mman.h>

                             int main() { }" HAVE_MPROTECT)

    foreach(_FN

            strtod malloc calloc realloc free getenv setenv putenv unsetenv

            qsort abs bcopy memset memcpy memmove memcmp strlen strlcpy strlcat

            strdup _strrev _strupr _strlwr strchr strrchr strstr itoa _ltoa

            _uitoa _ultoa strtol strtoul _i64toa _ui64toa strtoll strtoull

            atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp strncasecmp

            vsscanf vsnprintf fopen64 fseeko fseeko64 sigaction setjmp

            nanosleep sysconf sysctlbyname getauxval poll

            )

      string(TOUPPER ${_FN} _UPPER)

      set(_HAVEVAR "HAVE_${_UPPER}")

      check_function_exists("${_FN}" ${_HAVEVAR})

    endforeach()

    check_library_exists(m pow "" HAVE_LIBM)

    if(HAVE_LIBM)

      set(CMAKE_REQUIRED_LIBRARIES m)

      foreach(_FN

              atan atan2 ceil copysign cos cosf fabs floor log pow scalbn sin

              sinf sqrt sqrtf tan tanf acos asin)

        string(TOUPPER ${_FN} _UPPER)

        set(_HAVEVAR "HAVE_${_UPPER}")

        check_function_exists("${_FN}" ${_HAVEVAR})

      endforeach()

      set(CMAKE_REQUIRED_LIBRARIES)

      list(APPEND EXTRA_LIBS m)

    endif()

    check_library_exists(iconv iconv_open "" HAVE_LIBICONV)

    if(HAVE_LIBICONV)

      list(APPEND EXTRA_LIBS iconv)

      set(HAVE_ICONV 1)

    endif()

    if(NOT APPLE)

      check_include_file(alloca.h HAVE_ALLOCA_H)

      check_function_exists(alloca HAVE_ALLOCA)

    else()

      set(HAVE_ALLOCA_H 1)

      set(HAVE_ALLOCA 1)

    endif()

    check_struct_has_member("struct sigaction" "sa_sigaction" "signal.h" HAVE_SA_SIGACTION)

  endif()

else()

  if(WINDOWS)

    set(HAVE_STDARG_H 1)

    set(HAVE_STDDEF_H 1)

  endif()

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_JOYSTICK)

  file(GLOB JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/*.c)

  set(SOURCE_FILES ${SOURCE_FILES} ${JOYSTICK_SOURCES})

endif()

if(SDL_HAPTIC)

  if(NOT SDL_JOYSTICK)

    # Haptic requires some private functions from the joystick subsystem.

    message_error("SDL_HAPTIC requires SDL_JOYSTICK, which is not enabled")

  endif()

  file(GLOB HAPTIC_SOURCES ${SDL2_SOURCE_DIR}/src/haptic/*.c)

  set(SOURCE_FILES ${SOURCE_FILES} ${HAPTIC_SOURCES})

endif()

if(SDL_POWER)

  file(GLOB POWER_SOURCES ${SDL2_SOURCE_DIR}/src/power/*.c)

  set(SOURCE_FILES ${SOURCE_FILES} ${POWER_SOURCES})

endif()

# TODO: in configure.in, the test for LOADSO and SDL_DLOPEN is a bit weird:

# if LOADSO is not wanted, SDL_LOADSO_DISABLED is set

# If however on Unix or APPLE dlopen() is detected via CheckDLOPEN(),

# SDL_LOADSO_DISABLED will not be set, regardless of the LOADSO settings

# General SDL subsystem options, valid for all platforms

if(SDL_AUDIO)

  # CheckDummyAudio/CheckDiskAudio - valid for all platforms

  if(DUMMYAUDIO)

    set(SDL_AUDIO_DRIVER_DUMMY 1)

    file(GLOB DUMMYAUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/dummy/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${DUMMYAUDIO_SOURCES})

    set(HAVE_DUMMYAUDIO TRUE)

  endif()

  if(DISKAUDIO)

    set(SDL_AUDIO_DRIVER_DISK 1)

    file(GLOB DISKAUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/disk/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${DISKAUDIO_SOURCES})

    set(HAVE_DISKAUDIO TRUE)

  endif()

endif()

if(SDL_DLOPEN)

  # Relevant for Unix/Darwin only

  if(UNIX OR APPLE)

    CheckDLOPEN()

  endif()

endif()

if(SDL_VIDEO)

  if(VIDEO_DUMMY)

    set(SDL_VIDEO_DRIVER_DUMMY 1)

    file(GLOB VIDEO_DUMMY_SOURCES ${SDL2_SOURCE_DIR}/src/video/dummy/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${VIDEO_DUMMY_SOURCES})

    set(HAVE_VIDEO_DUMMY TRUE)

    set(HAVE_SDL_VIDEO TRUE)

  endif()

endif()

if(ANDROID)

  file(GLOB ANDROID_CORE_SOURCES ${SDL2_SOURCE_DIR}/src/core/android/*.c)

  set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_CORE_SOURCES})

  # 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

  check_c_compiler_flag(-marm HAVE_ARM_MODE)

  if(HAVE_ARM_MODE)

    set_source_files_properties(${SDL2_SOURCE_DIR}/src/atomic/SDL_spinlock.c PROPERTIES COMPILE_FLAGS -marm)

  endif()

  file(GLOB ANDROID_MAIN_SOURCES ${SDL2_SOURCE_DIR}/src/main/android/*.c)

  set(SDLMAIN_SOURCES ${SDLMAIN_SOURCES} ${ANDROID_MAIN_SOURCES})

  if(SDL_AUDIO)

    set(SDL_AUDIO_DRIVER_ANDROID 1)

    file(GLOB ANDROID_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/android/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_AUDIO_SOURCES})

    set(HAVE_SDL_AUDIO TRUE)

  endif()

  if(SDL_FILESYSTEM)

    set(SDL_FILESYSTEM_ANDROID 1)

    file(GLOB ANDROID_FILESYSTEM_SOURCES ${SDL2_SOURCE_DIR}/src/filesystem/android/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_FILESYSTEM_SOURCES})

    set(HAVE_SDL_FILESYSTEM TRUE)

  endif()

  if(SDL_HAPTIC)

    set(SDL_HAPTIC_ANDROID 1)

    file(GLOB ANDROID_HAPTIC_SOURCES ${SDL2_SOURCE_DIR}/src/haptic/android/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_HAPTIC_SOURCES})

    set(HAVE_SDL_HAPTIC TRUE)

  endif()

  if(SDL_JOYSTICK)

    set(SDL_JOYSTICK_ANDROID 1)

    file(GLOB ANDROID_JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/android/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_JOYSTICK_SOURCES})

    set(HAVE_SDL_JOYSTICK TRUE)

  endif()

  if(SDL_LOADSO)

    set(SDL_LOADSO_DLOPEN 1)

    file(GLOB LOADSO_SOURCES ${SDL2_SOURCE_DIR}/src/loadso/dlopen/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${LOADSO_SOURCES})

    set(HAVE_SDL_LOADSO TRUE)

  endif()

  if(SDL_POWER)

    set(SDL_POWER_ANDROID 1)

    file(GLOB ANDROID_POWER_SOURCES ${SDL2_SOURCE_DIR}/src/power/android/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_POWER_SOURCES})

    set(HAVE_SDL_POWER TRUE)

  endif()

  if(SDL_TIMERS)

    set(SDL_TIMER_UNIX 1)

    file(GLOB TIMER_SOURCES ${SDL2_SOURCE_DIR}/src/timer/unix/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${TIMER_SOURCES})

    set(HAVE_SDL_TIMERS TRUE)

  endif()

  if(SDL_VIDEO)

    set(SDL_VIDEO_DRIVER_ANDROID 1)

    file(GLOB ANDROID_VIDEO_SOURCES ${SDL2_SOURCE_DIR}/src/video/android/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${ANDROID_VIDEO_SOURCES})

    set(HAVE_SDL_VIDEO TRUE)

    # Core stuff

    find_library(ANDROID_DL_LIBRARY dl)

    find_library(ANDROID_LOG_LIBRARY log)

    find_library(ANDROID_LIBRARY_LIBRARY android)

    list(APPEND EXTRA_LIBS ${ANDROID_DL_LIBRARY} ${ANDROID_LOG_LIBRARY} ${ANDROID_LIBRARY_LIBRARY})

    add_definitions(-DGL_GLEXT_PROTOTYPES)

    #enable gles

    if(VIDEO_OPENGLES)

      set(SDL_VIDEO_OPENGL_EGL 1)

      set(HAVE_VIDEO_OPENGLES TRUE)

      set(SDL_VIDEO_OPENGL_ES2 1)

      set(SDL_VIDEO_RENDER_OGL_ES2 1)

      find_library(OpenGLES1_LIBRARY GLESv1_CM)

      find_library(OpenGLES2_LIBRARY GLESv2)

      list(APPEND EXTRA_LIBS ${OpenGLES1_LIBRARY} ${OpenGLES2_LIBRARY})

    endif()

    CHECK_C_SOURCE_COMPILES("

    #if defined(__ARM_ARCH) && __ARM_ARCH < 7

    #error Vulkan doesn't work on this configuration

    #endif

    int main()

    {

        return 0;

    }

    " VULKAN_PASSED_ANDROID_CHECKS)

    if(NOT VULKAN_PASSED_ANDROID_CHECKS)

      set(VIDEO_VULKAN OFF)

      message(STATUS "Vulkan doesn't work on this configuration")

    endif()

  endif()

  CheckPTHREAD()

endif()

# Platform-specific options and settings

if(EMSCRIPTEN)

  # Hide noisy warnings that intend to aid mostly during initial stages of porting a new

  # project. Uncomment at will for verbose cross-compiling -I/../ path info.

  add_definitions(-Wno-warn-absolute-paths)

  if(SDL_AUDIO)

    set(SDL_AUDIO_DRIVER_EMSCRIPTEN 1)

    file(GLOB EM_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/emscripten/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${EM_AUDIO_SOURCES})

    set(HAVE_SDL_AUDIO TRUE)

  endif()

  if(SDL_FILESYSTEM)

    set(SDL_FILESYSTEM_EMSCRIPTEN 1)

    file(GLOB EM_FILESYSTEM_SOURCES ${SDL2_SOURCE_DIR}/src/filesystem/emscripten/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${EM_FILESYSTEM_SOURCES})

    set(HAVE_SDL_FILESYSTEM TRUE)

  endif()

  if(SDL_JOYSTICK)

    set(SDL_JOYSTICK_EMSCRIPTEN 1)

    file(GLOB EM_JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/emscripten/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${EM_JOYSTICK_SOURCES})

    set(HAVE_SDL_JOYSTICK TRUE)

  endif()

  if(SDL_POWER)

    set(SDL_POWER_EMSCRIPTEN 1)

    file(GLOB EM_POWER_SOURCES ${SDL2_SOURCE_DIR}/src/power/emscripten/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${EM_POWER_SOURCES})

    set(HAVE_SDL_POWER TRUE)

  endif()

  if(SDL_TIMERS)

    set(SDL_TIMER_UNIX 1)

    file(GLOB TIMER_SOURCES ${SDL2_SOURCE_DIR}/src/timer/unix/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${TIMER_SOURCES})

    set(HAVE_SDL_TIMERS TRUE)

    if(CLOCK_GETTIME)

      set(HAVE_CLOCK_GETTIME 1)

    endif()

  endif()

  if(SDL_VIDEO)

    set(SDL_VIDEO_DRIVER_EMSCRIPTEN 1)

    file(GLOB EM_VIDEO_SOURCES ${SDL2_SOURCE_DIR}/src/video/emscripten/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${EM_VIDEO_SOURCES})

    set(HAVE_SDL_VIDEO TRUE)

    #enable gles

    if(VIDEO_OPENGLES)

      set(SDL_VIDEO_OPENGL_EGL 1)

      set(HAVE_VIDEO_OPENGLES TRUE)

      set(SDL_VIDEO_OPENGL_ES2 1)

      set(SDL_VIDEO_RENDER_OGL_ES2 1)

    endif()

  endif()

elseif(UNIX AND NOT APPLE AND NOT ANDROID)

  if(SDL_AUDIO)

    if(SYSV5 OR SOLARIS OR HPUX)

        set(SDL_AUDIO_DRIVER_SUNAUDIO 1)

        file(GLOB SUN_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/sun/*.c)

        set(SOURCE_FILES ${SOURCE_FILES} ${SUN_AUDIO_SOURCES})

        set(HAVE_SDL_AUDIO TRUE)

    elseif(NETBSD)

        set(SDL_AUDIO_DRIVER_NETBSD 1)

        file(GLOB NETBSD_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/netbsd/*.c)

        set(SOURCE_FILES ${SOURCE_FILES} ${NETBSD_AUDIO_SOURCES})

        set(HAVE_SDL_AUDIO TRUE)

    elseif(AIX)

        set(SDL_AUDIO_DRIVER_PAUDIO 1)

        file(GLOB AIX_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/paudio/*.c)

        set(SOURCE_FILES ${SOURCE_FILES} ${AIX_AUDIO_SOURCES})

        set(HAVE_SDL_AUDIO TRUE)

    endif()

    CheckOSS()

    CheckALSA()

    CheckJACK()

    CheckPulseAudio()

    CheckESD()

    CheckARTS()

    CheckNAS()

    CheckSNDIO()

    CheckFusionSound()

    CheckLibSampleRate()

  endif()

  if(SDL_VIDEO)

    # Need to check for Raspberry PI first and add platform specific compiler flags, otherwise the test for GLES fails!

    CheckRPI()

    CheckX11()

    CheckMir()

    CheckDirectFB()

    CheckOpenGLX11()

    CheckOpenGLESX11()

    CheckWayland()

    CheckVivante()

    CheckKMSDRM()

  endif()

  if(UNIX)

    file(GLOB CORE_UNIX_SOURCES ${SDL2_SOURCE_DIR}/src/core/unix/*.c)

    set(SOURCE_FILES ${SOURCE_FILES} ${CORE_UNIX_SOURCES})

  endif()

  if(LINUX)

    check_c_source_compiles("

        #include <linux/input.h>

        #ifndef EVIOCGNAME

        #error EVIOCGNAME() ioctl not available

        #endif

        int main(int argc, char** argv) {}" HAVE_INPUT_EVENTS)