diff -r 78f18a929123 CMakeLists.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/CMakeLists.txt	Fri Nov 16 08:34:32 2012 +0100
@@ -0,0 +1,1176 @@
+if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
+  message(FATAL_ERROR "Prevented in-tree built. This is bad practice.")
+endif()
+
+cmake_minimum_required(VERSION 2.6)
+project(SDL2 C)
+include(CheckFunctionExists)
+include(CheckLibraryExists)
+include(CheckIncludeFiles)
+include(CheckIncludeFile)
+include(CheckSymbolExists)
+include(CheckCSourceRuns)
+include(CheckCCompilerFlag)
+include(CheckTypeSize)
+include(CheckStructHasMember)
+include(CMakeDependentOption)
+include(FindPkgConfig)
+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 0)
+set(SDL_INTERFACE_AGE 0)
+set(SDL_BINARY_AGE 0)
+set(SDL_VERSION "${SDL_MAJOR_VERSION}.${SDL_MINOR_VERSION}.${SDL_MICRO_VERSION}")
+
+# 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}")
+set(LT_REVISION "${SDL_INTERFACE_AGE}")
+
+# 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(CMAKE_SIZEOF_VOID_P EQUAL 8)
+set(LIBNAME SDL2)
+if(NOT LIBTYPE)
+  set(LIBTYPE SHARED)
+endif(NOT LIBTYPE)
+
+# Get the platform
+if(WIN32)
+  if(NOT WINDOWS)
+    set(WINDOWS TRUE)
+  endif(NOT WINDOWS)
+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 "Haiku.*|BeOS.*")
+  set(BEOS TRUE)
+endif()
+
+# Don't mistake osx for unix
+if(UNIX AND NOT APPLE)
+  set(UNIX_SYS ON)
+else()
+  set(UNIX_SYS OFF)
+endif(UNIX AND NOT APPLE)
+
+# Default option knobs
+if(APPLE OR ARCH_64)
+  set(OPT_DEF_SSEMATH ON)
+endif()
+if(UNIX OR MINGW OR MSYS)
+  set(OPT_DEF_LIBC ON)
+endif(UNIX OR MINGW OR MSYS)
+
+# 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(CMAKE_COMPILER_IS_GNUCC)
+
+# Default flags, if not set otherwise
+if("$ENV{CFLAGS}" STREQUAL "")
+  if(USE_GCC OR USE_CLANG)
+    set(CMAKE_C_FLAGS "-g -O3")
+  endif(USE_GCC OR USE_CLANG)
+else("$ENV{CFLAGS}" STREQUAL "")
+  set(CMAKE_C_FLAGS "$ENV{CFLAGS}")
+  list(APPEND EXTRA_CFLAGS "$ENV{CFLAGS}")
+endif("$ENV{CFLAGS}" STREQUAL "")
+if(NOT ("$ENV{CFLAGS}" STREQUAL "")) # Hackish, but does the trick on Win32
+  list(APPEND EXTRA_LDFLAGS "$ENV{LDFLAGS}")
+endif(NOT ("$ENV{CFLAGS}" STREQUAL ""))
+
+# 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 "")
+
+if(CYGWIN)
+  # We build SDL on cygwin without the UNIX emulation layer
+  include_directories("-I/usr/include/mingw")
+  set(CMAKE_REQUIRED_FLAGS "-mno-cygwin")
+  check_c_source_compiles("int main(int argc, char **argv) {}"
+    HAVE_GCC_NO_CYGWIN)
+  set(CMAKE_REQUIRED_FLAGS)
+  if(HAVE_GCC_NO_CYGWIN)
+    list(APPEND EXTRA_LDFLAGS "-mno-cygwin")
+    list(APPEND SDL_LIBS "-mno-cygwin")
+  endif(HAVE_GCC_NO_CYGWIN)
+  set(SDL_CFLAGS "${SDL_CFLAGS} -I/usr/include/mingw")
+endif(CYGWIN)
+
+add_definitions(-DUSING_GENERATED_CONFIG_H)
+# General includes
+include_directories(${SDL2_BINARY_DIR}/include ${SDL2_SOURCE_DIR}/include)
+
+set(SDL_SUBSYSTEMS
+    Atomic Audio Video Render Events Joystick Haptic Power Threads Timers
+    File Loadso CPUinfo)
+foreach(_SUB ${SDL_SUBSYSTEMS})
+  string(TOUPPER ${_SUB} _OPT)
+  option(SDL_${_OPT} "Enable the ${_SUB} subsystem" ON)
+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" ${USE_GCC})
+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(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(FUSIONSOUND         "Use FusionSound audio driver" OFF)
+dep_option(FUSIONSOUND_SHARED  "Dynamically load fusionsound audio support" ON "FUSIONSOUND_SHARED" 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" ${UNIX_SYS})
+dep_option(PTHREADS_SEM        "Use pthread semaphores" ON "PTHREADS" OFF)
+set_option(SDL_DLOPEN          "Use dlopen for shared object loading" ON)
+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(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(RPATH               "Use an rpath when linking SDL" ${UNIX_SYS})
+set_option(CLOCK_GETTIME       "Use clock_gettime() instead of gettimeofday()" OFF)
+set_option(INPUT_EVENTS        "Use Linux 2.4 unified input interface" ${LINUX})
+set_option(INPUT_TSLIB         "Use the Touchscreen library for input" ${UNIX_SYS})
+set_option(VIDEO_X11           "Use X11 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})
+
+# 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 ON CACHE BOOL "Build a shared version of the library")
+set(SDL_STATIC ON CACHE BOOL "Build a static version of the library")
+
+# 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/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(ASSERTIONS STREQUAL "auto")
+set(HAVE_ASSERTIONS ${ASSERTIONS})
+
+# Compiler option evaluation
+if(USE_GCC)
+  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(DEPENDENCY_TRACKING)
+
+  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(NOT HAVE_GCC_ATOMICS)
+  endif(GCC_ATOMICS)
+
+  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)
+
+  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(HAVE_GCC_FVISIBILITY)
+  set(CMAKE_REQUIRED_FLAGS)
+
+  check_c_compiler_flag(-Wall HAVE_GCC_WALL)
+  if(HAVE_GCC_WALL)
+    if(CMAKE_SYSTEM_NAME MATCHES "Haiku|BeOS")
+      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-multichar")
+    endif(CMAKE_SYSTEM_NAME MATCHES "Haiku|BeOS")
+  endif(HAVE_GCC_WALL)
+endif(USE_GCC)
+
+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(HAVE_MMX)
+      set(CMAKE_REQUIRED_FLAGS)
+    endif(MMX)
+
+    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(HAVE_3DNOW)
+      set(CMAKE_REQUIRED_FLAGS)
+    endif(3DNOW)
+
+    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(HAVE_SSE)
+      set(CMAKE_REQUIRED_FLAGS)
+    endif(SSE)
+
+    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(HAVE_SSE2)
+      set(CMAKE_REQUIRED_FLAGS)
+    endif(SSE2)
+
+    if(SSEMATH)
+      if(SSE OR SSE2)
+        if(USE_GCC)
+          list(APPEND EXTRA_CFLAGS "-mfpmath=387")
+        endif(USE_GCC)
+        set(HAVE_SSEMATH TRUE)
+      endif(SSE OR SSE2)
+    endif(SSEMATH)
+
+    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)
+      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(HAVE_ALTIVEC_H_HDR)
+      endif(HAVE_ALTIVEC OR HAVE_ALTIVEC_H_HDR)
+    endif(ALTIVEC)
+  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(NOT ARCH_64)
+    set(HAVE_SSE TRUE)
+    set(HAVE_SSE2 TRUE)
+    set(SDL_ASSEMBLY_ROUTINES 1)
+  endif(USE_GCC OR USE_CLANG)
+# TODO:
+#else(ASSEMBLY)
+#  if(USE_GCC OR USE_CLANG)
+#    list(APPEND EXTRA_CFLAGS "-mno-sse" "-mno-sse2" "-mno-mmx")
+#  endif(USE_GCC OR USE_CLANG)
+endif(ASSEMBLY)
+
+# 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 ctype.h math.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
+            strlen _strrev _strupr _strlwr strchr strrchr strstr itoa _ltoa
+            _ultoa strtol strtoul strtoll strtod atoi atof strcmp strncmp
+            _stricmp _strnicmp sscanf atan atan2 ceil copysign cos cosf fabs
+            floor log pow scalbn sin sinf sqrt)
+      string(TOUPPER ${_FN} _UPPER)
+      set(HAVE_${_UPPER} 1)
+    endforeach()
+    if(NOT CYGWIN AND NOT MINGW)
+      set(HAVE_ALLOCA 1)
+    endif(NOT CYGWIN AND NOT MINGW)
+    set(HAVE_M_PI 1)
+    add_definitions(-D_USE_MATH_DEFINES) # needed for M_PI
+    set(STDC_HEADERS 1)
+  else(WINDOWS AND NOT MINGW)
+    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
+            strings.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
+            sscanf snprintf vsnprintf fseeko fseeko64 sigaction setjmp
+            nanosleep sysconf sysctlbyname
+            )
+      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)
+        string(TOUPPER ${_FN} _UPPER)
+        set(_HAVEVAR "HAVE_${_UPPER}")
+        check_function_exists("${_FN}" ${_HAVEVAR})
+      endforeach()
+      set(CMAKE_REQUIRED_LIBRARIES)
+      list(APPEND EXTRA_LIBS m)
+    endif(HAVE_LIBM)
+
+    check_library_exists(iconv iconv_open "" HAVE_LIBICONV)
+    if(HAVE_LIBICONV)
+      list(APPEND EXTRA_LIBS iconv)
+    endif(HAVE_LIBICONV)
+
+    check_struct_has_member("struct sigaction" "sa_sigaction" "signal.h" HAVE_SA_SIGACTION)
+  endif(WINDOWS AND NOT MINGW)
+else(LIBC)
+  if(WINDOWS)
+    set(HAVE_STDARG_H 1)
+    set(HAVE_STDDEF_H 1)
+  endif(WINDOWS)
+endif(LIBC)
+
+
+# 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(NOT SDL_${_OPT})
+endforeach()
+if(SDL_JOYSTICK)
+  file(GLOB JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/*.c)
+  set(SOURCE_FILES ${SOURCE_FILES} ${JOYSTICK_SOURCES})
+endif(SDL_JOYSTICK)
+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(NOT SDL_JOYSTICK)
+  file(GLOB HAPTIC_SOURCES ${SDL2_SOURCE_DIR}/src/haptic/*.c)
+  set(SOURCE_FILES ${SOURCE_FILES} ${HAPTIC_SOURCES})
+endif(SDL_HAPTIC)
+if(SDL_POWER)
+  file(GLOB POWER_SOURCES ${SDL2_SOURCE_DIR}/src/power/*.c)
+  set(SOURCE_FILES ${SOURCE_FILES} ${POWER_SOURCES})
+endif(SDL_POWER)
+# 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(DUMMYAUDIO)
+  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(DISKAUDIO)
+endif(SDL_AUDIO)
+
+if(SDL_DLOPEN)
+  # Relevant for Unix/Darwin only
+  if(UNIX OR APPLE)
+    CheckDLOPEN()
+  endif(UNIX OR APPLE)
+endif(SDL_DLOPEN)
+
+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(VIDEO_DUMMY)
+endif(SDL_VIDEO)
+
+# Platform-specific options and settings
+if(UNIX AND NOT APPLE)
+  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 OR OPENBSD)
+        set(SDL_AUDIO_DRIVER_BSD 1)
+        file(GLOB BSD_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/bsd/*.c)
+        set(SOURCE_FILES ${SOURCE_FILES} ${BSD_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()
+    CheckPulseAudio()
+    CheckESD()
+    CheckARTS()
+    CheckNAS()
+    CheckFusionSound()
+  endif(SDL_AUDIO)
+
+  if(SDL_VIDEO)
+    CheckX11()
+    CheckDirectFB()
+    CheckOpenGLX11()
+    CheckOpenGLESX11()
+  endif(SDL_VIDEO)
+
+  if(INPUT_EVENTS)
+    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)
+    if(HAVE_INPUT_EVENTS)
+      set(SDL_INPUT_LINUXEV 1)
+    endif(HAVE_INPUT_EVENTS)
+  endif(INPUT_EVENTS)
+
+  if(SDL_HAPTIC AND HAVE_INPUT_EVENTS)
+    if(LINUX)
+      set(SDL_HAPTIC_LINUX 1)
+      file(GLOB HAPTIC_SOURCES ${SDL2_SOURCE_DIR}/src/haptic/linux/*.c)
+      set(SOURCE_FILES ${SOURCE_FILES} ${HAPTIC_SOURCES})
+      set(HAVE_SDL_HAPTIC TRUE)
+    endif(LINUX)
+  endif(SDL_HAPTIC AND HAVE_INPUT_EVENTS)
+
+  if(INPUT_TSLIB)
+    check_c_source_compiles("
+        #include \"tslib.h\"
+        int main(int argc, char** argv) { }" HAVE_INPUT_TSLIB)
+    if(HAVE_INPUT_TSLIB)
+      set(SDL_INPUT_TSLIB 1)
+      list(APPEND EXTRA_LIBS ts)
+    endif(HAVE_INPUT_TSLIB)
+  endif(INPUT_TSLIB)
+
+  if(SDL_JOYSTICK)
+    CheckUSBHID()   # seems to be BSD specific - limit the test to BSD only?
+    if(LINUX)
+      set(SDL_JOYSTICK_LINUX 1)
+      file(GLOB JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/linux/*.c)
+      set(SOURCE_FILES ${SOURCE_FILES} ${JOYSTICK_SOURCES})
+      set(HAVE_SDL_JOYSTICK TRUE)
+    endif(LINUX)
+  endif(SDL_JOYSTICK)
+
+  CheckPTHREAD()
+
+  if(CLOCK_GETTIME)
+    check_library_exists(rt clock_gettime "" FOUND_CLOCK_GETTIME)
+    if(FOUND_CLOCK_GETTIME)
+      list(APPEND EXTRA_LIBS rt)
+      set(HAVE_CLOCK_GETTIME 1)
+    else(FOUND_CLOCK_GETTIME)
+      check_library_exists(c clock_gettime "" FOUND_CLOCK_GETTIME)
+      if(FOUND_CLOCK_GETTIME)
+        set(HAVE_CLOCK_GETTIME 1)
+      endif(FOUND_CLOCK_GETTIME)
+    endif(HAVE_CLOCK_GETTIME)
+  endif(CLOCK_GETTIME)
+
+  check_include_file(linux/version.h HAVE_LINUX_VERSION_H)
+  if(HAVE_LINUX_VERSION_H)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DHAVE_LINUX_VERSION_H")
+  endif(HAVE_LINUX_VERSION_H)
+
+  if(SDL_POWER)
+    if(LINUX)
+      set(SDL_POWER_LINUX 1)
+      file(GLOB POWER_SOURCES ${SDL2_SOURCE_DIR}/src/power/linux/*.c)
+      set(SOURCE_FILES ${SOURCE_FILES} ${POWER_SOURCES})
+      set(HAVE_SDL_POWER TRUE)
+    endif(LINUX)
+  endif(SDL_POWER)
+
+  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(SDL_TIMERS)
+
+  if(RPATH)
+    set(SDL_RLD_FLAGS "")
+    if(BSDI OR FREEBSD OR LINUX OR NETBSD)
+      set(SDL_RLD_FLAGS "-Wl,-rpath,\${libdir}")
+    elseif(SOLARIS)
+      set(SDL_RLD_FLAGS "-R\${libdir}")
+    endif()
+    set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
+    set(HAVE_RPATH TRUE)
+  endif(RPATH)
+
+elseif(WINDOWS)
+  find_program(WINDRES windres)
+
+  check_c_source_compiles("
+    #include <windows.h>
+    int main(int argc, char **argv) { }" HAVE_WIN32_CC)
+
+  file(GLOB WIN_SOURCES ${SDL2_SOURCE_DIR}/src/core/windows/*.c)
+  set(SOURCE_FILES ${SOURCE_FILES} ${WIN_SOURCES})
+
+  # Check for DirectX
+  if(DIRECTX)
+    if("$ENV{DXSDK_DIR}" STREQUAL "")
+      message_error("DIRECTX requires the \$DXSDK_DIR environment variable to be set")
+    endif("$ENV{DXSDK_DIR}" STREQUAL "")
+    set(CMAKE_REQUIRED_FLAGS "/I\"$ENV{DXSDK_DIR}\\Include\"")
+    check_include_file(d3d9.h HAVE_D3D_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)
+    check_include_file(xaudio2.h HAVE_XAUDIO2_H)
+    if(HAVE_D3D_H OR HAVE_DDRAW_H OR HAVE_DSOUND_H OR HAVE_DINPUT_H OR HAVE_XAUDIO2_H)
+      set(HAVE_DIRECTX TRUE)
+      # TODO: change $ENV{DXSDL_DIR} to get the path from the include checks
+      link_directories($ENV{DXSDK_DIR}\\lib\\${PROCESSOR_ARCH})
+      include_directories($ENV{DXSDK_DIR}\\Include)
+    endif()
+    set(CMAKE_REQUIRED_FLAGS)
+  endif(DIRECTX)
+
+  if(SDL_AUDIO)
+    set(SDL_AUDIO_DRIVER_WINMM 1)
+    file(GLOB WINMM_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/winmm/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${WINMM_AUDIO_SOURCES})
+    set(HAVE_SDL_AUDIO TRUE)
+
+    if(HAVE_DSOUND_H)
+      set(SDL_AUDIO_DRIVER_DSOUND 1)
+      file(GLOB DSOUND_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/directsound/*.c)
+      set(SOURCE_FILES ${SOURCE_FILES} ${DSOUND_AUDIO_SOURCES})
+    endif(HAVE_DSOUND_H)
+
+    if(HAVE_XAUDIO2_H)
+      set(SDL_AUDIO_DRIVER_XAUDIO2 1)
+      file(GLOB XAUDIO2_AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/xaudio2/*.c)
+      set(SOURCE_FILES ${SOURCE_FILES} ${XAUDIO2_AUDIO_SOURCES})
+    endif(HAVE_XAUDIO2_H)
+  endif(SDL_AUDIO)
+
+  if(SDL_VIDEO)
+    # requires SDL_LOADSO on Windows (IME, DX, etc.)
+    if(NOT SDL_LOADSO)
+      message_error("SDL_VIDEO requires SDL_LOADSO, which is not enabled")
+    endif(NOT SDL_LOADSO)
+    set(SDL_VIDEO_DRIVER_WINDOWS 1)
+    file(GLOB WIN_VIDEO_SOURCES ${SDL2_SOURCE_DIR}/src/video/windows/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${WIN_VIDEO_SOURCES})
+
+    if(RENDER_D3D AND HAVE_D3D_H)
+      set(SDL_VIDEO_RENDER_D3D 1)
+      set(HAVE_RENDER_D3D TRUE)
+    endif(RENDER_D3D AND HAVE_D3D_H)
+    set(HAVE_SDL_VIDEO TRUE)
+  endif(SDL_VIDEO)
+
+  if(SDL_THREADS)
+    set(SDL_THREAD_WINDOWS 1)
+    set(SOURCE_FILES ${SOURCE_FILES}
+      ${SDL2_SOURCE_DIR}/src/thread/windows/SDL_sysmutex.c
+      ${SDL2_SOURCE_DIR}/src/thread/windows/SDL_syssem.c
+      ${SDL2_SOURCE_DIR}/src/thread/windows/SDL_systhread.c
+      ${SDL2_SOURCE_DIR}/src/thread/generic/SDL_syscond.c)
+    set(HAVE_SDL_THREADS TRUE)
+  endif(SDL_THREADS)
+
+  if(SDL_POWER)
+    set(SDL_POWER_WINDOWS 1)
+    set(SOURCE_FILES ${SOURCE_FILES} ${SDL2_SOURCE_DIR}/src/power/windows/SDL_syspower.c)
+    set(HAVE_SDL_POWER TRUE)
+  endif(SDL_POWER)
+
+  # Libraries for Win32 native and MinGW
+  list(APPEND EXTRA_LIBS user32 gdi32 winmm imm32 ole32 oleaut32 version uuid)
+
+  # TODO: in configure.in the check for timers is set on
+  # cygwin | mingw32* - does this include mingw32CE?
+  if(SDL_TIMERS)
+    set(SDL_TIMER_WINDOWS 1)
+    file(GLOB TIMER_SOURCES ${SDL2_SOURCE_DIR}/src/timer/windows/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${TIMER_SOURCES})
+    set(HAVE_SDL_TIMERS TRUE)
+  endif(SDL_TIMERS)
+
+  if(SDL_LOADSO)
+    set(SDL_LOADSO_WINDOWS 1)
+    file(GLOB LOADSO_SOURCES ${SDL2_SOURCE_DIR}/src/loadso/windows/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${LOADSO_SOURCES})
+    set(HAVE_SDL_LOADSO TRUE)
+  endif(SDL_LOADSO)
+
+  file(GLOB CORE_SOURCES ${SDL2_SOURCE_DIR}/src/core/windows/*.c)
+  set(SOURCE_FILES ${SOURCE_FILES} ${CORE_SOURCES})
+
+  if(SDL_VIDEO)
+    if(VIDEO_OPENGL)
+      set(SDL_VIDEO_OPENGL 1)
+      set(SDL_VIDEO_OPENGL_WGL 1)
+      set(SDL_VIDEO_RENDER_OGL 1)
+      set(HAVE_VIDEO_OPENGL TRUE)
+    endif(VIDEO_OPENGL)
+  endif(SDL_VIDEO)
+
+  if(SDL_JOYSTICK)
+    if(HAVE_DINPUT_H)
+      set(SDL_JOYSTICK_DINPUT 1)
+      set(SOURCE_FILES ${SOURCE_FILES} ${SDL2_SOURCE_DIR}/src/joystick/windows/SDL_dxjoystick.c)
+      list(APPEND EXTRA_LIBS dinput8 dxguid dxerr)
+    else()
+      set(SDL_JOYSTICK_WINMM 1)
+      set(SOURCE_FILES ${SOURCE_FILES} ${SDL2_SOURCE_DIR}/src/joystick/windows/SDL_mmjoystick.c)
+    endif(HAVE_DINPUT_H)
+    set(HAVE_SDL_JOYSTICK TRUE)
+  endif(SDL_JOYSTICK)
+
+  if(SDL_HAPTIC AND HAVE_DINPUT_H)
+    set(SDL_HAPTIC_DINPUT 1)
+    set(SOURCE_FILES ${SOURCE_FILES} ${SDL2_SOURCE_DIR}/src/haptic/windows/SDL_syshaptic.c)
+    set(HAVE_SDL_HAPTIC TRUE)
+  endif(SDL_HAPTIC AND HAVE_DINPUT_H)
+
+  file(GLOB VERSION_SOURCES ${SDL2_SOURCE_DIR}/src/main/windows/*.rc)
+  file(GLOB SDLMAIN_SOURCES ${SDL2_SOURCE_DIR}/src/main/windows/*.c)
+  if(MINGW OR CYGWIN)
+    list(APPEND EXTRA_LIBS mingw32)
+    list(APPEND EXTRA_LDFLAGS "-mwindows")
+    set(SDL_CFLAGS "${SDL_CFLAGS} -Dmain=SDL_main")
+    list(APPEND SDL_LIBS "-lmingw32" "-lSDL2main" "-mwindows")
+  endif(MINGW OR CYGWIN)
+elseif(APPLE)
+  # TODO: rework this for proper MacOS X, iOS and Darwin support
+
+  # Requires the darwin file implementation
+  if(SDL_FILE)
+    file(GLOB EXTRA_SOURCES ${PROJECT_SOURCE_DIR}/src/file/cocoa/*.m)
+    set(SOURCE_FILES ${EXTRA_SOURCES} ${SOURCE_FILES})
+    set_source_files_properties(${EXTRA_SOURCES} PROPERTIES LANGUAGE C)
+    set(HAVE_SDL_FILE TRUE)
+    set(SDL_FRAMEWORK_COCOA 1)
+  else()
+    message_error("SDL_FILE must be enabled to build on MacOS X")
+  endif()
+
+  if(SDL_AUDIO)
+    set(MACOSX_COREAUDIO 1)
+    file(GLOB AUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/coreaudio/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${AUDIO_SOURCES})
+    set(HAVE_SDL_AUDIO TRUE)
+    set(SDL_FRAMEWORK_COREAUDIO 1)
+    set(SDL_FRAMEWORK_AUDIOUNIT 1)
+  endif()
+
+  if(SDL_JOYSTICK)
+    set(SDL_JOYSTICK_IOKIT 1)
+    file(GLOB JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/darwin/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${JOYSTICK_SOURCES})
+    set(HAVE_SDL_JOYSTICK TRUE)
+    set(SDL_FRAMEWORK_IOKIT 1)
+    set(SDL_FRAMEWORK_FF 1)
+  endif()
+
+  if(SDL_HAPTIC)
+    set(SDL_HAPTIC_IOKIT 1)
+    file(GLOB HAPTIC_SOURCES ${SDL2_SOURCE_DIR}/src/haptic/darwin/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${HAPTIC_SOURCES})
+    set(HAVE_SDL_HAPTIC TRUE)
+    set(SDL_FRAMEWORK_IOKIT 1)
+    set(SDL_FRAMEWORK_FF 1)
+    if(NOT SDL_JOYSTICK)
+      message(FATAL_ERROR "SDL_HAPTIC requires SDL_JOYSTICK to be enabled")
+    endif()
+  endif()
+
+  if(SDL_POWER)
+    set(SDL_POWER_MACOSX 1)
+    file(GLOB POWER_SOURCES ${SDL2_SOURCE_DIR}/src/power/macosx/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${POWER_SOURCES})
+    set(HAVE_SDL_POWER TRUE)
+    set(SDL_FRAMEWORK_CARBON 1)
+    set(SDL_FRAMEWORK_IOKIT 1)
+  endif()
+
+  # Actually load the frameworks at the end so we don't duplicate include.
+  if(SDL_FRAMEWORK_COCOA)
+    find_library(COCOA_LIBRARY Cocoa)
+    list(APPEND EXTRA_LIBS ${COCOA_LIBRARY})
+  endif()
+  if(SDL_FRAMEWORK_IOKIT)
+    find_library(IOKIT IOKit)
+    list(APPEND EXTRA_LIBS ${IOKIT})
+  endif()
+  if(SDL_FRAMEWORK_FF)
+    find_library(FORCEFEEDBACK ForceFeedback)
+    list(APPEND EXTRA_LIBS ${FORCEFEEDBACK})
+  endif()
+  if(SDL_FRAMEWORK_CARBON)
+    find_library(CARBON_LIBRARY Carbon)
+    list(APPEND EXTRA_LIBS ${CARBON_LIBRARY})
+  endif()
+  if(SDL_FRAMEWORK_COREAUDIO)
+    find_library(COREAUDIO CoreAudio)
+    list(APPEND EXTRA_LIBS ${COREAUDIO})
+  endif()
+  if(SDL_FRAMEWORK_AUDIOUNIT)
+    find_library(AUDIOUNIT AudioUnit)
+    list(APPEND EXTRA_LIBS ${AUDIOUNIT})
+  endif()
+
+  # iOS hack needed - http://code.google.com/p/ios-cmake/ ?
+  if(SDL_VIDEO)
+    CheckCOCOA()
+    if(VIDEO_OPENGL)
+      set(SDL_VIDEO_OPENGL 1)
+      set(SDL_VIDEO_OPENGL_CGL 1)
+      set(SDL_VIDEO_RENDER_OGL 1)
+      if(DARWIN)
+        find_library(OpenGL_LIBRARY OpenGL)
+        list(APPEND EXTRA_LIBRARIES ${OpenGL_LIBRARY})
+      endif(DARWIN)
+      set(HAVE_VIDEO_OPENGL TRUE)
+    endif(VIDEO_OPENGL)
+  endif(SDL_VIDEO)
+
+  CheckPTHREAD()
+elseif(BEOS)
+  if(SDL_VIDEO)
+    set(SDL_VIDEO_DRIVER_BWINDOW 1)
+    file(GLOB BWINDOW_SOURCES ${SDL2_SOURCE_DIR}/src/video/bwindow/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${BWINDOW_SOURCES})
+    set(HAVE_SDL_VIDEO TRUE)
+
+    if(VIDEO_OPENGL)
+      # TODO: Use FIND_PACKAGE(OpenGL) instead
+      set(SDL_VIDEO_OPENGL 1)
+      set(SDL_VIDEO_OPENGL_BGL 1)
+      set(SDL_VIDEO_RENDER_OGL 1)
+      list(APPEND EXTRA_LIBS GL)
+      set(HAVE_VIDEO_OPENGL TRUE)
+    endif(VIDEO_OPENGL)
+  endif(SDL_VIDEO)
+endif()
+
+# Dummies
+# configure.in does it differently:
+# if not have X
+#   if enable_X {  SDL_X_DISABLED = 1 }
+#   [add dummy sources]
+# so it always adds a dummy, without checking, if it was actually requested.
+# This leads to missing internal references on building, since the
+# src/X/*.c does not get included.
+if(NOT HAVE_SDL_JOYSTICK)
+  set(SDL_JOYSTICK_DISABLED 1)
+  if(SDL_JOYSTICK AND NOT APPLE) # results in unresolved symbols on OSX
+
+    file(GLOB JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/dummy/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${JOYSTICK_SOURCES})
+  endif()
+endif(NOT HAVE_SDL_JOYSTICK)
+if(NOT HAVE_SDL_HAPTIC)
+  set(SDL_HAPTIC_DISABLED 1)
+  file(GLOB HAPTIC_SOURCES ${SDL2_SOURCE_DIR}/src/haptic/dummy/*.c)
+  set(SOURCE_FILES ${SOURCE_FILES} ${HAPTIC_SOURCES})
+endif(NOT HAVE_SDL_HAPTIC)
+if(NOT HAVE_SDL_LOADSO)
+  set(SDL_LOADSO_DISABLED 1)
+  file(GLOB LOADSO_SOURCES ${SDL2_SOURCE_DIR}/src/loadso/dummy/*.c)
+  set(SOURCE_FILES ${SOURCE_FILES} ${JOYSTICK_SOURCES})
+endif(NOT HAVE_SDL_LOADSO)
+
+# We always need to have threads and timers around
+if(NOT HAVE_SDL_THREADS)
+  set(SDL_THREADS_DISABLED 1)
+  file(GLOB THREADS_SOURCES ${SDL2_SOURCE_DIR}/src/thread/generic/*.c)
+  set(SOURCE_FILES ${SOURCE_FILES} ${THREADS_SOURCES})
+endif(NOT HAVE_SDL_THREADS)
+if(NOT HAVE_SDL_TIMERS)
+  set(SDL_TIMERS_DISABLED 1)
+  file(GLOB TIMER_SOURCES ${SDL2_SOURCE_DIR}/src/timer/dummy/*.c)
+  set(SOURCE_FILES ${SOURCE_FILES} ${TIMER_SOURCES})
+endif(NOT HAVE_SDL_TIMERS)
+
+if(NOT SDLMAIN_SOURCES)
+  file(GLOB SDLMAIN_SOURCES ${SDL2_SOURCE_DIR}/src/main/dummy/*.c)
+endif(NOT SDLMAIN_SOURCES)
+
+# Append the -MMD -MT flags
+# if(DEPENDENCY_TRACKING)
+#   if(COMPILER_IS_GNUCC)
+#     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -MMD -MT \$@")
+#   endif(COMPILER_IS_GNUCC)
+# endif(DEPENDENCY_TRACKING)
+
+configure_file("${SDL2_SOURCE_DIR}/include/SDL_config.h.cmake"
+  "${SDL2_BINARY_DIR}/include/SDL_config.h")
+
+# Prepare the flags and remove duplicates
+if(EXTRA_LDFLAGS)
+  list(REMOVE_DUPLICATES EXTRA_LDFLAGS)
+endif(EXTRA_LDFLAGS)
+if(EXTRA_LIBS)
+  list(REMOVE_DUPLICATES EXTRA_LIBS)
+endif(EXTRA_LIBS)
+if(EXTRA_CFLAGS)
+  list(REMOVE_DUPLICATES EXTRA_CFLAGS)
+endif(EXTRA_CFLAGS)
+listtostr(EXTRA_CFLAGS _EXTRA_CFLAGS)
+set(EXTRA_CFLAGS ${_EXTRA_CFLAGS})
+
+# Compat helpers for the configuration files
+if(NOT WINDOWS OR CYGWIN)
+  # TODO: we need a Windows script, too
+  execute_process(COMMAND sh ${SDL2_SOURCE_DIR}/build-scripts/updaterev.sh)
+
+  set(prefix ${CMAKE_INSTALL_PREFIX})
+  set(exec_prefix "\${prefix}")
+  set(libdir "\${exec_prefix}/lib${LIB_SUFFIX}")
+  set(bindir "\${exec_prefix}/bin")
+  set(includedir "\${prefix}/include")
+  if(SDL_STATIC)
+    set(ENABLE_STATIC_TRUE "")
+    set(ENABLE_STATIC_FALSE "#")
+  else(SDL_STATIC)
+    set(ENABLE_STATIC_TRUE "#")
+    set(ENABLE_STATIC_FALSE "")
+  endif(SDL_STATIC)
+  if(SDL_SHARED)
+    set(ENABLE_SHARED_TRUE "")
+    set(ENABLE_SHARED_FALSE "#")
+  else(SDL_SHARED)
+    set(ENABLE_SHARED_TRUE "#")
+    set(ENABLE_SHARED_FALSE "")
+  endif(SDL_SHARED)
+
+  # Clean up the different lists
+  listtostr(EXTRA_LIBS _EXTRA_LIBS "-l")
+  set(SDL_STATIC_LIBS ${SDL_LIBS} ${EXTRA_LDFLAGS} ${_EXTRA_LIBS})
+  list(REMOVE_DUPLICATES SDL_STATIC_LIBS)
+  listtostr(SDL_STATIC_LIBS _SDL_STATIC_LIBS)
+  set(SDL_STATIC_LIBS ${_SDL_STATIC_LIBS})
+  listtostr(SDL_LIBS _SDL_LIBS)
+  set(SDL_LIBS ${_SDL_LIBS})
+
+  # MESSAGE(STATUS "SDL_LIBS: ${SDL_LIBS}")
+  # MESSAGE(STATUS "SDL_STATIC_LIBS: ${SDL_STATIC_LIBS}")
+
+  configure_file("${SDL2_SOURCE_DIR}/sdl2.pc.in"
+    "${SDL2_BINARY_DIR}/sdl2.pc" @ONLY)
+  configure_file("${SDL2_SOURCE_DIR}/sdl2-config.in"
+    "${SDL2_BINARY_DIR}/sdl2-config")
+  configure_file("${SDL2_SOURCE_DIR}/sdl2-config.in"
+    "${SDL2_BINARY_DIR}/sdl2-config" @ONLY)
+  configure_file("${SDL2_SOURCE_DIR}/SDL2.spec.in"
+    "${SDL2_BINARY_DIR}/SDL2.spec" @ONLY)
+endif(NOT WINDOWS OR CYGWIN)
+
+##### Info output #####
+message(STATUS "")
+message(STATUS "SDL2 was configured with the following options:")
+message(STATUS "")
+message(STATUS "Platform: ${CMAKE_SYSTEM}")
+message(STATUS "64-bit:   ${ARCH_64}")
+message(STATUS "Compiler: ${CMAKE_C_COMPILER}")
+message(STATUS "")
+message(STATUS "Subsystems:")
+foreach(_SUB ${SDL_SUBSYSTEMS})
+  string(TOUPPER ${_SUB} _OPT)
+  message_bool_option(${_SUB} SDL_${_OPT})
+endforeach()
+message(STATUS "")
+message(STATUS "Options:")
+list(SORT ALLOPTIONS)
+foreach(_OPT ${ALLOPTIONS})
+  # Longest option is VIDEO_X11_XSCREENSAVER = 22 characters
+  # Get the padding
+  string(LENGTH ${_OPT} _OPTLEN)
+  math(EXPR _PADLEN "23 - ${_OPTLEN}")
+  string(RANDOM LENGTH ${_PADLEN} ALPHABET " " _PADDING)
+  message_tested_option(${_OPT} ${_PADDING})
+endforeach()
+message(STATUS "")
+message(STATUS " CFLAGS:        ${CMAKE_C_FLAGS}")
+message(STATUS " EXTRA_CFLAGS:  ${EXTRA_CFLAGS}")
+message(STATUS " EXTRA_LDFLAGS: ${EXTRA_LDFLAGS}")
+message(STATUS " EXTRA_LIBS:    ${EXTRA_LIBS}")
+message(STATUS "")
+message(STATUS " Build Shared Library: ${SDL_SHARED}")
+message(STATUS " Build Static Library: ${SDL_STATIC}")
+message(STATUS "")
+if(UNIX)
+  message(STATUS "Something was not detected, although your are sure that it")
+  message(STATUS "has been properly installed? Then make sure, you have set")
+  message(STATUS "the CFLAGS and LDFLAGS environment variables correctly.")
+  message(STATUS "")
+endif(UNIX)
+
+# Ensure that the extra cflags are used at compile time
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}")
+
+# Always build SDLmain
+add_library(SDL2main STATIC ${SDLMAIN_SOURCES})
+set(_INSTALL_LIBS "SDL2main")
+
+if(SDL_SHARED)
+  add_library(SDL2 SHARED ${SOURCE_FILES})
+  set_target_properties(SDL2 PROPERTIES
+    VERSION ${SDL_VERSION}
+    SOVERSION ${LT_CURRENT})
+ set(_INSTALL_LIBS "SDL2" ${_INSTALL_LIBS})
+ target_link_libraries(SDL2 ${EXTRA_LIBS} ${EXTRA_LDFLAGS})
+endif(SDL_SHARED)
+
+if(SDL_STATIC)
+  add_library(SDL2-static STATIC ${SOURCE_FILES})
+  set_target_properties(SDL2-static PROPERTIES OUTPUT_NAME "SDL2")
+  # TODO: Win32 platforms keep the same suffix .lib for import and static
+  # libraries - do we need to consider this?
+  set(_INSTALL_LIBS "SDL2-static" ${_INSTALL_LIBS})
+  target_link_libraries(SDL2-static ${EXTRA_LIBS} ${EXTRA_LDFLAGS})
+endif(SDL_STATIC)
+
+##### Installation targets #####
+install(TARGETS ${_INSTALL_LIBS}
+  LIBRARY DESTINATION "lib${LIB_SUFFIX}"
+  ARCHIVE DESTINATION "lib${LIB_SUFFIX}")
+
+file(GLOB INCLUDE_FILES ${SDL2_SOURCE_DIR}/include/*.h)
+file(GLOB BIN_INCLUDE_FILES ${SDL2_BINARY_DIR}/include/*.h)
+foreach(_FNAME ${BIN_INCLUDE_FILES})
+  get_filename_component(_INCNAME ${_FNAME} NAME)
+  list(REMOVE_ITEM INCLUDE_FILES ${SDL2_SOURCE_DIR}/include/${_INCNAME})
+endforeach()
+list(APPEND INCLUDE_FILES ${BIN_INCLUDE_FILES})
+install(FILES ${INCLUDE_FILES} DESTINATION include/SDL2)
+
+if(NOT WINDOWS OR CYGWIN)
+  if(FREEBSD)
+    # FreeBSD uses ${PREFIX}/libdata/pkgconfig
+    install(FILES ${SDL2_BINARY_DIR}/sdl2.pc DESTINATION "libdata/pkgconfig")
+  else(FREEBSD)
+    install(FILES ${SDL2_BINARY_DIR}/sdl2.pc
+      DESTINATION "lib${LIB_SUFFIX}/pkgconfig")
+  endif(FREEBSD)
+  install(PROGRAMS ${SDL2_BINARY_DIR}/sdl2-config DESTINATION bin)
+  # TODO: what about the .spec file? Is it only needed for RPM creation?
+endif(NOT WINDOWS OR CYGWIN)
diff -r 78f18a929123 cmake/macros.cmake
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cmake/macros.cmake	Fri Nov 16 08:34:32 2012 +0100
@@ -0,0 +1,65 @@
+macro(SET_OPTION _NAME _DESC)
+  list(APPEND ALLOPTIONS ${_NAME})
+  if(${ARGC} EQUAL 3)
+    set(_DEFLT ${ARGV2})
+  else()
+    set(_DEFLT OFF)
+  endif()
+  option(${_NAME} ${_DESC} ${_DEFLT})
+endmacro()
+
+macro(DEP_OPTION _NAME _DESC _DEFLT _DEPTEST _FAILDFLT)
+  list(APPEND ALLOPTIONS ${_NAME})
+  cmake_dependent_option(${_NAME} ${_DESC} ${_DEFLT} ${_DEPTEST} ${_FAILDFLT})
+endmacro()
+
+macro(OPTION_STRING _NAME _DESC _VALUE)
+  list(APPEND ALLOPTIONS ${_NAME})
+  set(${_NAME} ${_VALUE} CACHE STRING "${_DESC}")
+  set(HAVE_${_NAME} ${_VALUE})
+ENDMACRO()
+
+# Message Output
+macro(MESSAGE_WARN _TEXT)
+  message(STATUS "*** WARNING: ${_TEXT}")
+endmacro()
+
+macro(MESSAGE_ERROR _TEXT)
+  message(FATAL_ERROR "*** ERROR: ${_TEXT}")
+endmacro()
+
+macro(MESSAGE_BOOL_OPTION _NAME _VALUE)
+  if(${_VALUE})
+    message(STATUS "  ${_NAME}:\tON")
+  else()
+    message(STATUS "  ${_NAME}:\tOFF")
+  endif()
+endmacro()
+
+macro(MESSAGE_TESTED_OPTION _NAME)
+  set(_REQVALUE ${${_NAME}})
+  set(_PAD " ")
+  if(${ARGC} EQUAL 2)
+    set(_PAD ${ARGV1})
+  endif()
+  if(NOT HAVE_${_NAME})
+    set(HAVE_${_NAME} OFF)
+  elseif("${HAVE_${_NAME}}" MATCHES "1|TRUE|YES|Y")
+    set(HAVE_${_NAME} ON)
+  endif()
+  message(STATUS "  ${_NAME}${_PAD}(Wanted: ${_REQVALUE}): ${HAVE_${_NAME}}")
+endmacro()
+
+macro(LISTTOSTR _LIST _OUTPUT)
+  if(${ARGC} EQUAL 3)
+    # prefix for each element
+    set(_LPREFIX ${ARGV2})
+  else()
+    set(_LPREFIX "")
+  endif()
+  # Do not use string(REPLACE ";" " ") here to avoid messing up list
+  # entries
+  foreach(_ITEM ${${_LIST}})
+    set(${_OUTPUT} "${_LPREFIX}${_ITEM} ${${_OUTPUT}}")
+  endforeach()
+endmacro()
diff -r 78f18a929123 cmake/sdlchecks.cmake
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cmake/sdlchecks.cmake	Fri Nov 16 08:34:32 2012 +0100
@@ -0,0 +1,808 @@
+macro(CheckDLOPEN)
+  check_function_exists(dlopen HAVE_DLOPEN)
+  if(NOT HAVE_DLOPEN)
+    foreach(_LIBNAME dl tdl)
+      check_library_exists("${_LIBNAME}" "dlopen" "" DLOPEN_LIB)
+      if(DLOPEN_LIB)
+        list(APPEND EXTRA_LIBS ${_LIBNAME})
+        set(_DLLIB ${_LIBNAME})
+        set(HAVE_DLOPEN TRUE)
+        break()
+      endif(DLOPEN_LIB)
+    endforeach()
+  endif()
+
+  if(HAVE_DLOPEN)
+    if(_DLLIB)
+      set(CMAKE_REQUIRED_LIBRARIES ${_DLLIB})
+    endif()
+    check_c_source_compiles("
+       #include <dlfcn.h>
+       #if defined(MAC_OS_X_VERSION_MIN_REQUIRED) && MAC_OS_X_VERSION_MIN_REQUIRED <= 1020
+       #error Use dlcompat for Mac OS X 10.2 compatibility
+       #endif
+       int main(int argc, char **argv) {}" HAVE_DLOPEN)
+    set(CMAKE_REQUIRED_LIBRARIES)
+  endif()
+
+  if (HAVE_DLOPEN)
+    set(SDL_LOADSO_DLOPEN 1)
+    set(HAVE_SDL_DLOPEN TRUE)
+    file(GLOB DLOPEN_SOURCES ${SDL2_SOURCE_DIR}/src/loadso/dlopen/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${DLOPEN_SOURCES})
+    set(HAVE_SDL_LOADSO TRUE)
+  endif()
+endmacro(CheckDLOPEN)
+
+# Requires:
+# - n/a
+macro(CheckOSS)
+  if(OSS)
+    set(OSS_HEADER_FILE "sys/soundcard.h")
+    check_c_source_compiles("
+        #include <sys/soundcard.h>
+        int main() { int arg = SNDCTL_DSP_SETFRAGMENT; }" OSS_FOUND)
+    if(NOT OSS_FOUND)
+      set(OSS_HEADER_FILE "soundcard.h")
+      check_c_source_compiles("
+          #include <soundcard.h>
+          int main() { int arg = SNDCTL_DSP_SETFRAGMENT; }" OSS_FOUND)
+    endif(NOT OSS_FOUND)
+
+    if(OSS_FOUND)
+      set(HAVE_OSS TRUE)
+      file(GLOB OSS_SOURCES ${SDL2_SOURCE_DIR}/src/audio/dsp/*.c)
+      if(OSS_HEADER_FILE STREQUAL "soundcard.h")
+        set(SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H 1)
+      endif(OSS_HEADER_FILE STREQUAL "soundcard.h")
+      set(SDL_AUDIO_DRIVER_OSS 1)
+      set(SOURCE_FILES ${SOURCE_FILES} ${OSS_SOURCES})
+      if(NETBSD OR OPENBSD)
+        list(APPEND EXTRA_LIBS ossaudio)
+      endif(NETBSD OR OPENBSD)
+      set(HAVE_SDL_AUDIO TRUE)
+    endif(OSS_FOUND)
+  endif(OSS)
+endmacro(CheckOSS)
+
+# Requires:
+# - n/a
+# Optional:
+# - ALSA_SHARED opt
+# - HAVE_DLOPEN opt
+macro(CheckALSA)
+  if(ALSA)
+    CHECK_INCLUDE_FILE(alsa/asoundlib.h HAVE_ASOUNDLIB_H)
+    if(HAVE_ASOUNDLIB_H)
+      CHECK_LIBRARY_EXISTS(asound snd_pcm_open "" HAVE_LIBASOUND)
+      set(HAVE_ALSA TRUE)
+      file(GLOB ALSA_SOURCES ${SDL2_SOURCE_DIR}/src/audio/alsa/*.c)
+      set(SOURCE_FILES ${SOURCE_FILES} ${ALSA_SOURCES})
+      set(SDL_AUDIO_DRIVER_ALSA 1)
+      if(ALSA_SHARED)
+        if(NOT HAVE_DLOPEN)
+          message_warn("You must have SDL_LoadObject() support for dynamic ALSA loading")
+        else()
+          find_library(_ALSA_LIB asound)
+          get_filename_component(F_ALSA_LIB ${_ALSA_LIB} NAME)
+          set(SDL_AUDIO_DRIVER_ALSA_DYNAMIC "\"${F_ALSA_LIB}\"")
+          set(HAVE_ALSA_SHARED TRUE)
+        endif(NOT HAVE_DLOPEN)
+      else(ALSA_SHARED)
+        list(APPEND EXTRA_LIBS asound)
+      endif(ALSA_SHARED)
+      set(HAVE_SDL_AUDIO TRUE)
+    endif(HAVE_ASOUNDLIB_H)
+  endif(ALSA)
+endmacro(CheckALSA)
+
+# Requires:
+# - PkgCheckModules
+# Optional:
+# - PULSEAUDIO_SHARED opt
+# - HAVE_DLOPEN opt
+macro(CheckPulseAudio)
+  if(PULSEAUDIO)
+    pkg_check_modules(PKG_PULSEAUDIO libpulse-simple)
+    if(PKG_PULSEAUDIO_FOUND)
+      set(HAVE_PULSEAUDIO TRUE)
+      file(GLOB PULSEAUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/pulseaudio/*.c)
+      set(SOURCE_FILES ${SOURCE_FILES} ${PULSEAUDIO_SOURCES})
+      set(SDL_AUDIO_DRIVER_PULSEAUDIO 1)
+      list(APPEND EXTRA_CFLAGS ${PKG_PULSEAUDIO_CFLAGS})
+      if(PULSEAUDIO_SHARED)
+        if(NOT HAVE_DLOPEN)
+          message_warn("You must have SDL_LoadObject() support for dynamic PulseAudio loading")
+        else()
+          find_library(D_PULSE_LIB pulse-simple)
+          get_filename_component(F_PULSE_LIB ${D_PULSE_LIB} NAME)
+          set(SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC "\"${F_PULSE_LIB}\"")
+          set(HAVE_PULSEAUDIO_SHARED TRUE)
+        endif(NOT HAVE_DLOPEN)
+      else(PULSEAUDIO_SHARED)
+        list(APPEND EXTRA_LDFLAGS ${PKG_PULSEAUDIO_LDFLAGS})
+      endif(PULSEAUDIO_SHARED)
+      set(HAVE_SDL_AUDIO TRUE)
+    endif(PKG_PULSEAUDIO_FOUND)
+  endif(PULSEAUDIO)
+endmacro(CheckPulseAudio)
+
+# Requires:
+# - PkgCheckModules
+# Optional:
+# - ESD_SHARED opt
+# - HAVE_DLOPEN opt
+macro(CheckESD)
+  if(ESD)
+    pkg_check_modules(PKG_ESD esound)
+    if(PKG_ESD_FOUND)
+      set(HAVE_ESD TRUE)
+      file(GLOB ESD_SOURCES ${SDL2_SOURCE_DIR}/src/audio/esd/*.c)
+      set(SOURCE_FILES ${SOURCE_FILES} ${ESD_SOURCES})
+      set(SDL_AUDIO_DRIVER_ESD 1)
+      list(APPEND EXTRA_CFLAGS ${PKG_ESD_CFLAGS})
+      if(ESD_SHARED)
+        if(NOT HAVE_DLOPEN)
+          message_warn("You must have SDL_LoadObject() support for dynamic ESD loading")
+        else()
+          find_library(D_ESD_LIB esd)
+          get_filename_component(F_ESD_LIB ${D_ESD_LIB} NAME)
+          set(SDL_AUDIO_DRIVER_ESD_DYNAMIC "\"${F_ESD_LIB}\"")
+          set(HAVE_ESD_SHARED TRUE)
+        endif(NOT HAVE_DLOPEN)
+      else(ESD_SHARED)
+        list(APPEND EXTRA_LDFLAGS ${PKG_ESD_LDFLAGS})
+      endif(ESD_SHARED)
+      set(HAVE_SDL_AUDIO TRUE)
+    endif(PKG_ESD_FOUND)
+  endif(ESD)
+endmacro(CheckESD)
+
+# Requires:
+# - n/a
+# Optional:
+# - ARTS_SHARED opt
+# - HAVE_DLOPEN opt
+macro(CheckARTS)
+  if(ARTS)
+    find_program(ARTS_CONFIG arts-config)
+    if(ARTS_CONFIG)
+      execute_process(CMD_ARTSCFLAGS ${ARTS_CONFIG} --cflags
+        OUTPUT_VARIABLE ARTS_CFLAGS OUTPUT_STRIP_TRAILING_WHITESPACE)
+      list(APPEND EXTRA_CFLAGS ${ARTS_CFLAGS})
+      execute_process(CMD_ARTSLIBS ${ARTS_CONFIG} --libs
+        OUTPUT_VARIABLE ARTS_LIBS OUTPUT_STRIP_TRAILING_WHITESPACE)
+      file(GLOB ARTS_SOURCES ${SDL2_SOURCE_DIR}/src/audio/arts/*.c)
+      set(SOURCE_FILES ${SOURCE_FILES} ${ARTS_SOURCES})
+      set(SDL_AUDIO_DRIVER_ARTS 1)
+      set(HAVE_ARTS TRUE)
+      if(ARTS_SHARED)
+        if(NOT HAVE_DLOPEN)
+          message_warn("You must have SDL_LoadObject() support for dynamic ARTS loading")
+        else()
+          # TODO
+          find_library(D_ARTS_LIB artsc)
+          get_filename_component(F_ARTS_LIB ${D_ARTS_LIB} NAME)
+          set(SDL_AUDIO_DRIVER_ARTS_DYNAMIC "\"${F_ARTS_LIB}\"")
+          set(HAVE_ARTS_SHARED TRUE)
+        endif(NOT HAVE_DLOPEN)
+      else(ARTS_SHARED)
+        list(APPEND EXTRA_LDFLAGS ${ARTS_LIBS})
+      endif(ARTS_SHARED)
+      set(HAVE_SDL_AUDIO TRUE)
+    endif(ARTS_CONFIG)
+  endif(ARTS)
+endmacro(CheckARTS)
+
+# Requires:
+# - n/a
+# Optional:
+# - NAS_SHARED opt
+# - HAVE_DLOPEN opt
+macro(CheckNAS)
+  if(NAS)
+    # TODO: set include paths properly, so the NAS headers are found
+    check_include_file(audio/audiolib.h HAVE_NAS_H)
+    find_library(D_NAS_LIB audio)
+    if(HAVE_NAS_H AND D_NAS_LIB)
+      set(HAVE_NAS TRUE)
+      file(GLOB NAS_SOURCES ${SDL2_SOURCE_DIR}/src/audio/nas/*.c)
+      set(SOURCE_FILES ${SOURCE_FILES} ${NAS_SOURCES})
+      set(SDL_AUDIO_DRIVER_NAS 1)
+      if(NAS_SHARED)
+        if(NOT HAVE_DLOPEN)
+          message_warn("You must have SDL_LoadObject() support for dynamic NAS loading")
+        else()
+          get_filename_component(F_NAS_LIB ${D_NAS_LIB} NAME)
+          set(SDL_AUDIO_DRIVER_NAS_DYNAMIC "\"${F_NAS_LIB}\"")
+          set(HAVE_NAS_SHARED TRUE)
+        endif(NOT HAVE_DLOPEN)
+      else(NAS_SHARED)
+        list(APPEND EXTRA_LIBS ${D_NAS_LIB})
+      endif(NAS_SHARED)
+      set(HAVE_SDL_AUDIO TRUE)
+    endif(HAVE_NAS_H AND D_NAS_LIB)
+  endif(NAS)
+endmacro(CheckNAS)
+
+# Requires:
+# - PkgCheckModules
+# Optional:
+# - FUSIONSOUND_SHARED opt
+# - HAVE_DLOPEN opt
+macro(CheckFusionSound)
+  if(FUSIONSOUND)
+    pkg_check_modules(PKG_FUSIONSOUND fusionsound>=1.0.0)
+    if(PKG_FUSIONSOUND_FOUND)
+      set(HAVE_FUSIONSOUND TRUE)
+      file(GLOB FUSIONSOUND_SOURCES ${SDL2_SOURCE_DIR}/src/audio/fusionsound/*.c)
+      set(SOURCE_FILES ${SOURCE_FILES} ${FUSIONSOUND_SOURCES})
+      set(SDL_AUDIO_DRIVER_FUSIONSOUND 1)
+      list(APPEND EXTRA_CFLAGS ${PKG_FUSIONSOUND_CFLAGS})
+      if(FUSIONSOUND_SHARED)
+        if(NOT HAVE_DLOPEN)
+          message_warn("You must have SDL_LoadObject() support for dynamic FusionSound loading")
+        else()
+          find_library(D_FUSIONSOUND_LIB fusionsound)
+          get_filename_component(F_FUSIONSOUND_LIB ${D_FUSIONSOUND_LIB} NAME)
+          set(SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC "\"${F_FUSIONSOUND_LIB}\"")
+          set(HAVE_FUSIONSOUND_SHARED TRUE)
+        endif(NOT HAVE_DLOPEN)
+      else(FUSIONSOUND_SHARED)
+        list(APPEND EXTRA_LDFLAGS ${PKG_FUSIONSOUND_LDFLAGS})
+      endif(FUSIONSOUND_SHARED)
+      set(HAVE_SDL_AUDIO TRUE)
+    endif(PKG_FUSIONSOUND_FOUND)
+  endif(FUSIONSOUND)
+endmacro(CheckFusionSound)
+
+# Requires:
+# - n/a
+# Optional:
+# - X11_SHARED opt
+# - HAVE_DLOPEN opt
+macro(CheckX11)
+  if(VIDEO_X11)
+    foreach(_LIB X11 Xext Xcursor Xinerama Xi Xrandr Xrender Xss Xxf86vm)
+      string(TOUPPER ${_LIB} _LNAME)
+      find_library(${_LNAME}_LIB ${_LIB})
+      if(${_LNAME}_LIB)
+        # reduce the library name for shared linking
+        get_filename_component(_TMP ${${_LNAME}_LIB} NAME)
+        set(${_LNAME}_LIB ${_TMP})
+      endif()
+    endforeach()
+
+    check_include_file(X11/Xcursor/Xcursor.h HAVE_XCURSOR_H)
+    check_include_file(X11/extensions/Xinerama.h HAVE_XINERAMA_H)
+    check_include_file(X11/extensions/XInput2.h HAVE_XINPUT_H)
+    check_include_file(X11/extensions/Xrandr.h HAVE_XRANDR_H)
+    check_include_file(X11/extensions/Xrender.h HAVE_XRENDER_H)
+    check_include_file(X11/extensions/scrnsaver.h HAVE_XSS_H)
+    check_include_file(X11/extensions/shape.h HAVE_XSHAPE_H)
+    check_include_files("X11/Xlib.h;X11/extensions/xf86vmode.h" HAVE_XF86VM_H)
+
+    if(X11_LIB)
+      set(HAVE_VIDEO_X11 TRUE)
+      set(HAVE_SDL_VIDEO TRUE)
+
+      file(GLOB X11_SOURCES ${SDL2_SOURCE_DIR}/src/video/x11/*.c)
+      set(SOURCE_FILES ${SOURCE_FILES} ${X11_SOURCES})
+      set(SDL_VIDEO_DRIVER_X11 1)
+
+      if(HAVE_GCC_FVISIBILITY)
+        set(X11_SYMBOLS_PRIVATE TRUE)
+      else()
+        set(X11_SYMBOLS_PRIVATE FALSE)
+      endif(HAVE_GCC_FVISIBILITY)
+
+      if(APPLE)
+        set(X11_SHARED OFF)
+        set(X11_SYMBOLS_PRIVATE TRUE)
+      endif(APPLE)
+
+      check_function_exists("shmat" HAVE_SHMAT)
+      if(NOT HAVE_SHMAT)
+        check_library_exists(ipc shmat "" HAVE_SHMAT)
+        if(HAVE_SHMAT)
+          list(APPEND EXTRA_LIBS ipc)
+        endif(HAVE_SHMAT)
+        if(NOT HAVE_SHMAT)
+          add_definitions(-DNO_SHARED_MEMORY)
+        endif(NOT HAVE_SHMAT)
+      endif(NOT HAVE_SHMAT)
+
+      if(X11_SHARED)
+        if(NOT HAVE_DLOPEN)
+          message_warn("You must have SDL_LoadObject() support for dynamic X11 loading")
+          set(HAVE_X11_SHARED FALSE)
+          if(X11_SYMBOLS_PRIVATE)
+            message_warn("You must have gcc4 (-fvisibility=hidden) for dynamic X11 loading")
+            set(HAVE_X11_SHARED TRUE)
+          endif(X11_SYMBOLS_PRIVATE)
+        else(NOT HAVE_DLOPEN)
+          set(HAVE_X11_SHARED TRUE)
+        endif()
+        if(HAVE_X11_SHARED)
+          set(SDL_VIDEO_DRIVER_X11_DYNAMIC "\"${X11_LIB}\"")
+          set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT "\"${XEXT_LIB}\"")
+        else(HAVE_X11_SHARED)
+          list(APPEND EXTRA_LIBS ${X11_LIB} ${XEXT_LIB})
+        endif(HAVE_X11_SHARED)
+      endif(X11_SHARED)
+
+      set(CMAKE_REQUIRED_LIBRARIES ${X11_LIB} ${X11_LIB})
+      check_c_source_compiles("
+          #include <X11/Xlib.h>
+          #include <X11/Xproto.h>
+          #include <X11/extensions/Xext.h>
+          #include <X11/extensions/extutil.h>
+          extern XExtDisplayInfo* XextAddDisplay(XExtensionInfo* a,Display* b,_Xconst char* c,XExtensionHooks* d,int e,XPointer f);
+          int main(int argc, char **argv) {}" HAVE_CONST_XEXT_ADDDISPLAY)
+      if(HAVE_CONST_XEXT_ADDDISPLAY)
+        set(SDL_VIDEO_DRIVER_X11_CONST_PARAM_XEXTADDDISPLAY 1)
+      endif(HAVE_CONST_XEXT_ADDDISPLAY)
+
+      check_c_source_compiles("
+          #include <X11/Xlib.h>
+          int main(int argc, char **argv) {
+            Display *display;
+            XEvent event;
+            XGenericEventCookie *cookie = &event.xcookie;
+            XNextEvent(display, &event);
+            XGetEventData(display, cookie);
+            XFreeEventData(display, cookie); }" HAVE_XGENERICEVENT)
+      if(HAVE_XGENERICEVENT)
+        set(SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS 1)
+      endif(HAVE_XGENERICEVENT)
+
+      check_function_exists(XkbKeycodeToKeysym SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM)
+
+      if(VIDEO_X11_XCURSOR AND HAVE_XCURSOR_H)
+        set(HAVE_VIDEO_X11_XCURSOR TRUE)
+        if(HAVE_X11_SHARED AND XCURSOR_LIB)
+          set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR "\"${XCURSOR_LIB}\"")
+        else(HAVE_X11_SHARED AND XCURSOR_LIB)
+          list(APPEND EXTRA_LIBS ${XCURSOR_LIB})
+        endif(HAVE_X11_SHARED AND XCURSOR_LIB)
+        set(SDL_VIDEO_DRIVER_X11_XCURSOR 1)
+      endif(VIDEO_X11_XCURSOR AND HAVE_XCURSOR_H)
+
+      if(VIDEO_X11_XINERAMA AND HAVE_XINERAMA_H)
+        set(HAVE_VIDEO_X11_XINERAMA TRUE)
+        if(HAVE_X11_SHARED AND XINERAMA_LIB)
+          set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA "\"${XINERAMA_LIB}\"")
+        else(HAVE_X11_SHARED AND XINERAMA_LIB)
+          list(APPEND EXTRA_LIBS ${XINERAMA_LIB})
+        endif(HAVE_X11_SHARED AND XINERAMA_LIB)
+        set(SDL_VIDEO_DRIVER_X11_XINERAMA 1)
+      endif(VIDEO_X11_XINERAMA AND HAVE_XINERAMA_H)
+
+      if(VIDEO_X11_XINPUT AND HAVE_XINPUT_H)
+        set(HAVE_VIDEO_X11_XINPUT TRUE)
+        if(HAVE_X11_SHARED AND XI_LIB)
+          set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2 "\"${XI_LIB}\"")
+        else(HAVE_X11_SHARED AND XI_LIB)
+          list(APPEND EXTRA_LIBS ${XI_LIB})
+        endif(HAVE_X11_SHARED AND XI_LIB)
+        set(SDL_VIDEO_DRIVER_X11_XINPUT2 1)
+
+        # Check for multitouch
+        check_c_source_compiles("
+            #include <X11/Xlib.h>
+            #include <X11/Xproto.h>
+            #include <X11/extensions/XInput2.h>
+            int event_type = XI_TouchBegin;
+            XITouchClassInfo *t;
+            Status XIAllowTouchEvents(Display *a,int b,unsigned int c,Window d,int f)
+            {
+              return (Status)0;
+            }
+            int main(int argc, char **argv) {}" HAVE_XINPUT2_MULTITOUCH)
+        if(HAVE_XINPUT2_MULTITOUCH)
+          set(SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH 1)
+        endif(HAVE_XINPUT2_MULTITOUCH)
+      endif(VIDEO_X11_XINPUT AND HAVE_XINPUT_H)
+
+      if(VIDEO_X11_XRANDR AND HAVE_XRANDR_H)
+        if(HAVE_X11_SHARED AND XRANDR_LIB)
+          set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR "\"${XRANDR_LIB}\"")
+        else(HAVE_X11_SHARED AND XRANDR_LIB)
+          list(APPEND EXTRA_LIBS ${XRANDR_LIB})
+        endif(HAVE_X11_SHARED AND XRANDR_LIB)
+        set(SDL_VIDEO_DRIVER_X11_XRANDR 1)
+        set(HAVE_VIDEO_X11_XRANDR TRUE)
+      endif(VIDEO_X11_XRANDR AND HAVE_XRANDR_H)
+
+      if(VIDEO_X11_XSCRNSAVER AND HAVE_XSS_H)
+        if(HAVE_X11_SHARED AND XSS_LIB)
+          set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS "\"${XSS_LIB}\"")
+        else(HAVE_X11_SHARED AND XSS_LIB)
+          list(APPEND EXTRA_LIBS ${XSS_LIB})
+        endif(HAVE_X11_SHARED AND XSS_LIB)
+        set(SDL_VIDEO_DRIVER_X11_XSCRNSAVER 1)
+        set(HAVE_VIDEO_X11_XSCRNSAVER TRUE)
+      endif(VIDEO_X11_XSCRNSAVER AND HAVE_XSS_H)
+
+      if(VIDEO_X11_XSHAPE AND HAVE_XSHAPE_H)
+        set(SDL_VIDEO_DRIVER_X11_XSHAPE 1)
+        set(HAVE_VIDEO_X11_XSHAPE TRUE)
+      endif(VIDEO_X11_XSHAPE AND HAVE_XSHAPE_H)
+
+      if(VIDEO_X11_XVM AND HAVE_XF86VM_H)
+        if(HAVE_X11_SHARED AND XF86VMODE_LIB)
+          set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE "\"${XF86VMODE_LIB}\"")
+        else(HAVE_X11_SHARED AND XF86VMODE_LIB)
+          list(APPEND EXTRA_LIBS ${XF86VMODE_LIB})
+        endif(HAVE_X11_SHARED AND XF86VMODE_LIB)
+        set(SDL_VIDEO_DRIVER_X11_XVIDMODE 1)
+        set(HAVE_VIDEO_X11_XVM TRUE)
+      endif(VIDEO_X11_XVM AND HAVE_XF86VM_H)
+
+      set(CMAKE_REQUIRED_LIBRARIES)
+    endif(X11_LIB)
+  endif(VIDEO_X11)
+endmacro(CheckX11)
+
+# Requires:
+# - n/a
+#
+macro(CheckCOCOA)
+  if(VIDEO_COCOA)
+    check_c_source_compiles("
+        #import <Cocoa/Cocoa.h>
+        int main (int argc, char** argv) {}" HAVE_VIDEO_COCOA)
+    if(HAVE_VIDEO_COCOA)
+      file(GLOB COCOA_SOURCES ${SDL2_SOURCE_DIR}/src/video/cocoa/*.m)
+      set(SOURCE_FILES ${SOURCE_FILES} ${COCOA_SOURCES})
+      set(SDL_VIDEO_DRIVER_COCOA 1)
+      set(HAVE_SDL_VIDEO TRUE)
+    endif(HAVE_VIDEO_COCOA)
+  endif(VIDEO_COCOA)
+endmacro(CheckCOCOA)
+
+# Requires:
+# - PkgCheckModules
+# Optional:
+# - DIRECTFB_SHARED opt
+# - HAVE_DLOPEN opt
+macro(CheckDirectFB)
+  if(VIDEO_DIRECTFB)
+    pkg_check_modules(PKG_DIRECTFB directfb>=1.0.0)
+    if(PKG_DIRECTFB_FOUND)
+      set(HAVE_VIDEO_DIRECTFB TRUE)
+      file(GLOB DIRECTFB_SOURCES ${SDL2_SOURCE_DIR}/src/video/directfb/*.c)
+      set(SOURCE_FILES ${SOURCE_FILES} ${DIRECTFB_SOURCES})
+      set(SDL_VIDEO_DRIVER_DIRECTFB 1)
+      set(SDL_VIDEO_RENDER_DIRECTFB 1)
+      list(APPEND EXTRA_CFLAGS ${PKG_DIRECTFB_CFLAGS})
+      if(DIRECTFB_SHARED)
+        if(NOT HAVE_DLOPEN)
+          message_warn("You must have SDL_LoadObject() support for dynamic DirectFB loading")
+        else()
+          find_library(D_DIRECTFB_LIB directfb)
+          get_filename_component(F_DIRECTFB_LIB ${D_DIRECTFB_LIB} NAME)
+          set(SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC "\"${F_DIRECTFB_LIB}\"")
+          set(HAVE_DIRECTFB_SHARED TRUE)
+        endif(NOT HAVE_DLOPEN)
+      else(DIRECTFB_SHARED)
+        list(APPEND EXTRA_LDFLAGS ${PKG_DIRECTFB_LDFLAGS})
+      endif(DIRECTFB_SHARED)
+      set(HAVE_SDL_VIDEO TRUE)
+    endif(PKG_DIRECTFB_FOUND)
+  endif(VIDEO_DIRECTFB)
+endmacro(CheckDirectFB)
+
+# Requires:
+# - nada
+macro(CheckOpenGLX11)
+  if(VIDEO_OPENGL)
+    check_c_source_compiles("
+        #include <GL/gl.h>
+        #include <GL/glx.h>
+        int main(int argc, char** argv) {}" HAVE_VIDEO_OPENGL)
+
+    if(HAVE_VIDEO_OPENGL)
+      set(HAVE_VIDEO_OPENGL TRUE)
+      set(SDL_VIDEO_OPENGL 1)
+      set(SDL_VIDEO_OPENGL_GLX 1)
+      set(SDL_VIDEO_RENDER_OGL 1)
+      list(APPEND EXTRA_LIBS GL)
+    endif(HAVE_VIDEO_OPENGL)
+  endif(VIDEO_OPENGL)
+endmacro(CheckOpenGLX11)
+
+# Requires:
+# - nada
+macro(CheckOpenGLESX11)
+  if(VIDEO_OPENGLES)
+    check_c_source_compiles("
+        #include <EGL/egl.h>
+        int main (int argc, char** argv) {}" HAVE_VIDEO_OPENGLES)
+    if(HAVE_VIDEO_OPENGLES)
+      check_c_source_compiles("
+          #include <GLES/gl.h>
+          #include <GLES/glext.h>
+          int main (int argc, char** argv) {}" HAVE_VIDEO_OPENGLES_V1)
+      if(HAVE_VIDEO_OPENGLES_V1)
+        set(SDL_VIDEO_OPENGL_ES 1)
+        set(SDL_VIDEO_RENDER_OGL_ES 1)
+      endif(HAVE_VIDEO_OPENGLES_V1)
+      check_c_source_compiles("
+          #include <GLES2/gl2.h>
+          #include <GLES2/gl2ext.h>
+          int main (int argc, char** argv) {}" HAVE_VIDEO_OPENGLES_V2)
+      if(HAVE_VIDEO_OPENGLES_V2)
+        set(SDL_VIDEO_OPENGL_ES2 1)
+        set(SDL_VIDEO_RENDER_OGL_ES2 1)
+      endif(HAVE_VIDEO_OPENGLES_V2)
+    endif(HAVE_VIDEO_OPENGLES)
+  endif(VIDEO_OPENGLES)
+endmacro(CheckOpenGLESX11)
+
+# Rquires:
+# - nada
+# Optional:
+# - THREADS opt
+# Sets:
+# PTHREAD_CFLAGS
+# PTHREAD_LIBS
+macro(CheckPTHREAD)
+  if(PTHREADS)
+    if(LINUX)
+      set(PTHREAD_CFLAGS "-D_REENTRANT")
+      set(PTHREAD_LDFLAGS "-lpthread")
+    elseif(BSDI)
+      set(PTHREAD_CFLAGS "-D_REENTRANT -D_THREAD_SAFE")
+      set(PTHREAD_LDFLAGS "")
+    elseif(DARWIN)
+      set(PTHREAD_CFLAGS "-D_THREAD_SAFE")
+      # causes Carbon.p complaints?
+      # set(PTHREAD_CFLAGS "-D_REENTRANT -D_THREAD_SAFE")
+      set(PTHREAD_LDFLAGS "")
+    elseif(FREEBSD)
+      set(PTHREAD_CFLAGS "-D_REENTRANT -D_THREAD_SAFE")
+      set(PTHREAD_LDFLAGS "-pthread")
+    elseif(NETBSD)
+      set(PTHREAD_CFLAGS "-D_REENTRANT -D_THREAD_SAFE")
+      set(PTHREAD_LDFLAGS "-lpthread")
+    elseif(OPENBSD)
+      set(PTHREAD_CFLAGS "-D_REENTRANT")
+      set(PTHREAD_LDFLAGS "-pthread")
+    elseif(SOLARIS)
+      set(PTHREAD_CFLAGS "-D_REENTRANT")
+      set(PTHREAD_LDFLAGS "-pthread -lposix4")
+    elseif(SYSV5)
+      set(PTHREAD_CFLAGS "-D_REENTRANT -Kthread")
+      set(PTHREAD_LDFLAGS "")
+    elseif(AIX)
+      set(PTHREAD_CFLAGS "-D_REENTRANT -mthreads")
+      set(PTHREAD_LDFLAGS "-pthread")
+    elseif(HPUX)
+      set(PTHREAD_CFLAGS "-D_REENTRANT")
+      set(PTHREAD_LDFLAGS "-L/usr/lib -pthread")
+    else()
+      set(PTHREAD_CFLAGS "-D_REENTRANT")
+      set(PTHREAD_LDFLAGS "-lpthread")
+    endif(LINUX)
+
+    # Run some tests
+    set(CMAKE_REQUIRED_FLAGS "${PTHREAD_CFLAGS} ${PTHREAD_LDFLAGS}")
+    check_c_source_runs("
+        #include <pthread.h>
+        int main(int argc, char** argv) {
+          pthread_attr_t type;
+          pthread_attr_init(&type);
+          return 0;
+        }" HAVE_PTHREADS)
+    if(HAVE_PTHREADS)
+      set(SDL_THREAD_PTHREAD 1)
+      list(APPEND EXTRA_CFLAGS ${PTHREAD_CFLAGS})
+      list(APPEND EXTRA_LDFLAGS ${PTHREAD_LDFLAGS})
+      set(SDL_CFLAGS "${SDL_CFLAGS} ${PTHREAD_CFLAGS}")
+      list(APPEND SDL_LIBS ${PTHREAD_LDFLAGS})
+
+      check_c_source_compiles("
+        #include <pthread.h>
+        int main(int argc, char **argv) {
+          pthread_mutexattr_t attr;
+          pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+        }" HAVE_RECURSIVE_MUTEXES)
+      if(HAVE_RECURSIVE_MUTEXES)
+        set(SDL_THREAD_PTHREAD_RECURSIVE_MUTEX 1)
+      else(HAVE_RECURSIVE_MUTEXES)
+        check_c_source_compiles("
+            #include <pthread.h>
+            int main(int argc, char **argv) {
+              pthread_mutexattr_t attr;
+              pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+            }" HAVE_RECURSIVE_MUTEXES_NP)
+        if(HAVE_RECURSIVE_MUTEXES_NP)
+          set(SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP 1)
+        endif(HAVE_RECURSIVE_MUTEXES_NP)
+      endif(HAVE_RECURSIVE_MUTEXES)
+
+      if(PTHREADS_SEM)
+        check_c_source_compiles("#include <pthread.h>
+                                 #include <semaphore.h>" HAVE_PTHREADS_SEM)
+        if(HAVE_PTHREADS_SEM)
+          check_c_source_compiles("
+              #include <pthread.h>
+              #include <semaphore.h>
+              int main(int argc, char **argv) {
+                  sem_timedwait(NULL, NULL);
+                  return 0;
+              }" HAVE_SEM_TIMEDWAIT)
+        endif(HAVE_PTHREADS_SEM)
+      endif(PTHREADS_SEM)
+
+      check_c_source_compiles("
+          #include <pthread.h>
+          int main(int argc, char** argv) {
+              pthread_spin_trylock(NULL);
+              return 0;
+          }" HAVE_PTHREAD_SPINLOCK)
+
+      check_c_source_compiles("
+          #include <pthread.h>
+          #include <pthread_np.h>
+          int main(int argc, char** argv) { return 0; }" HAVE_PTHREAD_NP_H)
+      check_function_exists(pthread_setname_np HAVE_PTHREAD_setNAME_NP)
+      check_function_exists(pthread_set_name_np HAVE_PTHREAD_set_NAME_NP)
+      set(CMAKE_REQUIRED_FLAGS)
+
+      set(SOURCE_FILES ${SOURCE_FILES}
+          ${SDL2_SOURCE_DIR}/src/thread/pthread/SDL_systhread.c
+          ${SDL2_SOURCE_DIR}/src/thread/pthread/SDL_sysmutex.c   # Can be faked, if necessary
+          ${SDL2_SOURCE_DIR}/src/thread/pthread/SDL_syscond.c    # Can be faked, if necessary
+          )
+      if(HAVE_PTHREADS_SEM)
+        set(SOURCE_FILES ${SOURCE_FILES}
+            ${SDL2_SOURCE_DIR}/src/thread/pthread/SDL_syssem.c)
+      else(HAVE_PTHREADS_SEM)
+        set(SOURCE_FILES ${SOURCE_FILES}
+            ${SDL2_SOURCE_DIR}/src/thread/generic/SDL_syssem.c)
+      endif(HAVE_PTHREADS_SEM)
+      set(HAVE_SDL_THREADS TRUE)
+    endif(HAVE_PTHREADS)
+  endif(PTHREADS)
+endmacro(CheckPTHREAD)
+
+# Requires
+# - nada
+# Optional:
+# Sets:
+# USB_LIBS
+# USB_CFLAGS
+macro(CheckUSBHID)
+  check_library_exists(usbhid hid_init "" LIBUSBHID)
+  if(LIBUSBHID)
+    check_include_file(usbhid.h HAVE_USBHID_H)
+    if(HAVE_USBHID_H)
+      set(USB_CFLAGS "-DHAVE_USBHID_H")
+    endif(HAVE_USBHID_H)
+
+    check_include_file(libusbhid.h HAVE_LIBUSBHID_H)
+    if(HAVE_LIBUSBHID_H)
+      set(USB_CFLAGS "${USB_CFLAGS} -DHAVE_LIBUSBHID_H")
+    endif(HAVE_LIBUSBHID_H)
+    set(USB_LIBS ${USB_LIBS} usbhid)
+  else(LIBUSBHID)
+    check_include_file(usb.h HAVE_USB_H)
+    if(HAVE_USB_H)
+      set(USB_CFLAGS "-DHAVE_USB_H")
+    endif(HAVE_USB_H)
+    check_include_file(libusb.h HAVE_LIBUSB_H)
+    if(HAVE_LIBUSB_H)
+      set(USB_CFLAGS "${USB_CFLAGS} -DHAVE_LIBUSB_H")
+    endif(HAVE_LIBUSB_H)
+    check_library_exists(usb hid_init "" LIBUSB)
+    if(LIBUSB)
+      set(USB_LIBS ${USB_LIBS} usb)
+    endif(LIBUSB)
+  endif(LIBUSBHID)
+
+  set(CMAKE_REQUIRED_FLAGS "${USB_CFLAGS}")
+  set(CMAKE_REQUIRED_LIBRARIES "${USB_LIBS}")
+  check_c_source_compiles("
+       #include <sys/types.h>
+        #if defined(HAVE_USB_H)
+        #include <usb.h>
+        #endif
+        #ifdef __DragonFly__
+        # include <bus/usb/usb.h>
+        # include <bus/usb/usbhid.h>
+        #else
+        # include <dev/usb/usb.h>
+        # include <dev/usb/usbhid.h>
+        #endif
+        #if defined(HAVE_USBHID_H)
+        #include <usbhid.h>
+        #elif defined(HAVE_LIBUSB_H)
+        #include <libusb.h>
+        #elif defined(HAVE_LIBUSBHID_H)
+        #include <libusbhid.h>
+        #endif
+        int main(int argc, char **argv) {
+          struct report_desc *repdesc;
+          struct usb_ctl_report *repbuf;
+          hid_kind_t hidkind;
+          return 0;
+        }" HAVE_USBHID)
+  if(HAVE_USBHID)
+    check_c_source_compiles("
+          #include <sys/types.h>
+          #if defined(HAVE_USB_H)
+          #include <usb.h>
+          #endif
+          #ifdef __DragonFly__
+          # include <bus/usb/usb.h>
+          # include <bus/usb/usbhid.h>
+          #else
+          # include <dev/usb/usb.h>
+          # include <dev/usb/usbhid.h>
+          #endif
+          #if defined(HAVE_USBHID_H)
+          #include <usbhid.h>
+          #elif defined(HAVE_LIBUSB_H)
+          #include <libusb.h>
+          #elif defined(HAVE_LIBUSBHID_H)
+          #include <libusbhid.h>
+          #endif
+          int main(int argc, char** argv) {
+            struct usb_ctl_report buf;
+            if (buf.ucr_data) { }
+            return 0;
+          }" HAVE_USBHID_UCR_DATA)
+    if(HAVE_USBHID_UCR_DATA)
+      set(USB_CFLAGS "${USB_CFLAGS} -DUSBHID_UCR_DATA")
+    endif(HAVE_USBHID_UCR_DATA)
+
+    check_c_source_compiles("
+          #include <sys/types.h>
+          #if defined(HAVE_USB_H)
+          #include <usb.h>
+          #endif
+          #ifdef __DragonFly__
+          #include <bus/usb/usb.h>
+          #include <bus/usb/usbhid.h>
+          #else
+          #include <dev/usb/usb.h>
+          #include <dev/usb/usbhid.h>
+          #endif
+          #if defined(HAVE_USBHID_H)
+          #include <usbhid.h>
+          #elif defined(HAVE_LIBUSB_H)
+          #include <libusb.h>
+          #elif defined(HAVE_LIBUSBHID_H)
+          #include <libusbhid.h>
+          #endif
+          int main(int argc, char **argv) {
+            report_desc_t d;
+            hid_start_parse(d, 1, 1);
+            return 0;
+          }" HAVE_USBHID_NEW)
+    if(HAVE_USBHID_NEW)
+      set(USB_CFLAGS "${USB_CFLAGS} -DUSBHID_NEW")
+    endif(HAVE_USBHID_NEW)
+
+    check_c_source_compiles("
+        #include <machine/joystick.h>
+        int main(int argc, char** argv) {
+            struct joystick t;
+            return 0;
+        }" HAVE_MACHINE_JOYSTICK)
+    if(HAVE_MACHINE_JOYSTICK)
+      set(SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H 1)
+    endif(HAVE_MACHINE_JOYSTICK)
+    set(SDL_JOYSTICK_USBHID 1)
+    file(GLOB BSD_JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/bsd/*.c)
+    set(SOURCE_FILES ${SOURCE_FILES} ${BSD_JOYSTICK_SOURCES})
+    list(APPEND EXTRA_CFLAGS ${USB_CFLAGS})
+    list(APPEND EXTRA_LIBS ${USB_LIBS})
+    set(HAVE_SDL_JOYSTICK TRUE)
+
+    set(CMAKE_REQUIRED_LIBRARIES)
+    set(CMAKE_REQUIRED_FLAGS)
+  endif(HAVE_USBHID)
+endmacro(CheckUSBHID)
diff -r 78f18a929123 include/SDL_config.h.cmake
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/include/SDL_config.h.cmake	Fri Nov 16 08:34:32 2012 +0100
@@ -0,0 +1,364 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2012 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef _SDL_config_h
+#define _SDL_config_h
+
+/**
+ *  \file SDL_config.h.in
+ *
+ *  This is a set of defines to configure the SDL features
+ */
+
+/* General platform specific identifiers */
+#include "SDL_platform.h"
+
+/* C language features */
+#cmakedefine const @HAVE_CONST@
+#cmakedefine inline @HAVE_INLINE@
+#cmakedefine volatile @HAVE_VOLATILE@
+
+/* C datatypes */
+#cmakedefine SIZEOF_VOIDP @SIZEOF_VOIDP@
+#cmakedefine HAVE_GCC_ATOMICS @HAVE_GCC_ATOMICS@
+#cmakedefine HAVE_GCC_SYNC_LOCK_TEST_AND_SET @HAVE_GCC_SYNC_LOCK_TEST_AND_SET@
+#cmakedefine HAVE_PTHREAD_SPINLOCK @HAVE_PTHREAD_SPINLOCK@
+
+/* Comment this if you want to build without any C library requirements */
+#cmakedefine HAVE_LIBC 1
+#if HAVE_LIBC
+
+/* Useful headers */
+#cmakedefine HAVE_ALLOCA_H 1
+#cmakedefine HAVE_SYS_TYPES_H 1
+#cmakedefine HAVE_STDIO_H 1
+#cmakedefine STDC_HEADERS 1
+#cmakedefine HAVE_STDLIB_H 1
+#cmakedefine HAVE_STDARG_H 1
+#cmakedefine HAVE_MALLOC_H 1
+#cmakedefine HAVE_MEMORY_H 1
+#cmakedefine HAVE_STRING_H 1
+#cmakedefine HAVE_STRINGS_H 1
+#cmakedefine HAVE_INTTYPES_H 1
+#cmakedefine HAVE_STDINT_H 1
+#cmakedefine HAVE_CTYPE_H 1
+#cmakedefine HAVE_MATH_H 1
+#cmakedefine HAVE_ICONV_H 1
+#cmakedefine HAVE_SIGNAL_H 1
+#cmakedefine HAVE_ALTIVEC_H 1
+#cmakedefine HAVE_PTHREAD_NP_H 1
+
+/* C library functions */
+#cmakedefine HAVE_MALLOC 1
+#cmakedefine HAVE_CALLOC 1
+#cmakedefine HAVE_REALLOC 1
+#cmakedefine HAVE_FREE 1
+#cmakedefine HAVE_ALLOCA 1
+#ifndef __WIN32__ /* Don't use C runtime versions of these on Windows */
+#cmakedefine HAVE_GETENV 1
+#cmakedefine HAVE_SETENV 1
+#cmakedefine HAVE_PUTENV 1
+#cmakedefine HAVE_UNSETENV 1
+#endif
+#cmakedefine HAVE_QSORT 1
+#cmakedefine HAVE_ABS 1
+#cmakedefine HAVE_BCOPY 1
+#cmakedefine HAVE_MEMSET 1
+#cmakedefine HAVE_MEMCPY 1
+#cmakedefine HAVE_MEMMOVE 1
+#cmakedefine HAVE_MEMCMP 1
+#cmakedefine HAVE_STRLEN 1
+#cmakedefine HAVE_STRLCPY 1
+#cmakedefine HAVE_STRLCAT 1
+#cmakedefine HAVE_STRDUP 1
+#cmakedefine HAVE__STRREV 1
+#cmakedefine HAVE__STRUPR 1
+#cmakedefine HAVE__STRLWR 1
+#cmakedefine HAVE_INDEX 1
+#cmakedefine HAVE_RINDEX 1
+#cmakedefine HAVE_STRCHR 1
+#cmakedefine HAVE_STRRCHR 1
+#cmakedefine HAVE_STRSTR 1
+#cmakedefine HAVE_ITOA 1
+#cmakedefine HAVE__LTOA 1
+#cmakedefine HAVE__UITOA 1
+#cmakedefine HAVE__ULTOA 1
+#cmakedefine HAVE_STRTOL 1
+#cmakedefine HAVE_STRTOUL 1
+#cmakedefine HAVE__I64TOA 1
+#cmakedefine HAVE__UI64TOA 1
+#cmakedefine HAVE_STRTOLL 1
+#cmakedefine HAVE_STRTOULL 1
+#cmakedefine HAVE_STRTOD 1
+#cmakedefine HAVE_ATOI 1
+#cmakedefine HAVE_ATOF 1
+#cmakedefine HAVE_STRCMP 1
+#cmakedefine HAVE_STRNCMP 1
+#cmakedefine HAVE__STRICMP 1
+#cmakedefine HAVE_STRCASECMP 1
+#cmakedefine HAVE__STRNICMP 1
+#cmakedefine HAVE_STRNCASECMP 1
+#cmakedefine HAVE_SSCANF 1
+#cmakedefine HAVE_SNPRINTF 1
+#cmakedefine HAVE_VSNPRINTF 1
+#cmakedefine HAVE_M_PI 1
+#cmakedefine HAVE_ATAN 1
+#cmakedefine HAVE_ATAN2 1
+#cmakedefine HAVE_CEIL 1
+#cmakedefine HAVE_COPYSIGN 1
+#cmakedefine HAVE_COS 1
+#cmakedefine HAVE_COSF 1
+#cmakedefine HAVE_FABS 1
+#cmakedefine HAVE_FLOOR 1
+#cmakedefine HAVE_LOG 1
+#cmakedefine HAVE_POW 1
+#cmakedefine HAVE_SCALBN 1
+#cmakedefine HAVE_SIN 1
+#cmakedefine HAVE_SINF 1
+#cmakedefine HAVE_SQRT 1
+#cmakedefine HAVE_FSEEKO 1
+#cmakedefine HAVE_FSEEKO64 1
+#cmakedefine HAVE_SIGACTION 1
+#cmakedefine HAVE_SA_SIGACTION 1
+#cmakedefine HAVE_SETJMP 1
+#cmakedefine HAVE_NANOSLEEP 1
+#cmakedefine HAVE_SYSCONF 1
+#cmakedefine HAVE_SYSCTLBYNAME 1
+#cmakedefine HAVE_CLOCK_GETTIME 1
+#cmakedefine HAVE_GETPAGESIZE 1
+#cmakedefine HAVE_MPROTECT 1
+#cmakedefine HAVE_ICONV 1
+#cmakedefine HAVE_PTHREAD_SETNAME_NP 1
+#cmakedefine HAVE_PTHREAD_SET_NAME_NP 1
+#cmakedefine HAVE_SEM_TIMEDWAIT 1
+#elif __WIN32__
+#cmakedefine HAVE_STDARG_H 1
+#cmakedefine HAVE_STDDEF_H 1
+#else
+/* We may need some replacement for stdarg.h here */
+#include <stdarg.h>
+#endif /* HAVE_LIBC */
+
+/* SDL internal assertion support */
+#cmakedefine SDL_DEFAULT_ASSERT_LEVEL @SDL_DEFAULT_ASSERT_LEVEL@
+
+/* Allow disabling of core subsystems */
+#cmakedefine SDL_ATOMIC_DISABLED @SDL_ATOMIC_DISABLED@
+#cmakedefine SDL_AUDIO_DISABLED @SDL_AUDIO_DISABLED@
+#cmakedefine SDL_CPUINFO_DISABLED @SDL_CPUINFO_DISABLED@
+#cmakedefine SDL_EVENTS_DISABLED @SDL_EVENTS_DISABLED@
+#cmakedefine SDL_FILE_DISABLED @SDL_FILE_DISABLED@
+#cmakedefine SDL_JOYSTICK_DISABLED @SDL_JOYSTICK_DISABLED@
+#cmakedefine SDL_HAPTIC_DISABLED @SDL_HAPTIC_DISABLED@
+#cmakedefine SDL_LOADSO_DISABLED @SDL_LOADSO_DISABLED@
+#cmakedefine SDL_RENDER_DISABLED @SDL_RENDER_DISABLED@
+#cmakedefine SDL_THREADS_DISABLED @SDL_THREADS_DISABLED@
+#cmakedefine SDL_TIMERS_DISABLED @SDL_TIMERS_DISABLED@
+#cmakedefine SDL_VIDEO_DISABLED @SDL_VIDEO_DISABLED@
+#cmakedefine SDL_POWER_DISABLED @SDL_POWER_DISABLED@
+
+/* Enable various audio drivers */
+#cmakedefine SDL_AUDIO_DRIVER_ALSA @SDL_AUDIO_DRIVER_ALSA@
+#cmakedefine SDL_AUDIO_DRIVER_ALSA_DYNAMIC @SDL_AUDIO_DRIVER_ALSA_DYNAMIC@
+#cmakedefine SDL_AUDIO_DRIVER_ARTS @SDL_AUDIO_DRIVER_ARTS@
+#cmakedefine SDL_AUDIO_DRIVER_ARTS_DYNAMIC @SDL_AUDIO_DRIVER_ARTS_DYNAMIC@
+#cmakedefine SDL_AUDIO_DRIVER_PULSEAUDIO @SDL_AUDIO_DRIVER_PULSEAUDIO@
+#cmakedefine SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC @SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC@
+#cmakedefine SDL_AUDIO_DRIVER_BEOSAUDIO @SDL_AUDIO_DRIVER_BEOSAUDIO@
+#cmakedefine SDL_AUDIO_DRIVER_BSD @SDL_AUDIO_DRIVER_BSD@
+#cmakedefine SDL_AUDIO_DRIVER_COREAUDIO @SDL_AUDIO_DRIVER_COREAUDIO@
+#cmakedefine SDL_AUDIO_DRIVER_DISK @SDL_AUDIO_DRIVER_DISK@
+#cmakedefine SDL_AUDIO_DRIVER_DUMMY @SDL_AUDIO_DRIVER_DUMMY@
+#cmakedefine SDL_AUDIO_DRIVER_XAUDIO2 @SDL_AUDIO_DRIVER_XAUDIO2@
+#cmakedefine SDL_AUDIO_DRIVER_DSOUND @SDL_AUDIO_DRIVER_DSOUND@
+#cmakedefine SDL_AUDIO_DRIVER_ESD @SDL_AUDIO_DRIVER_ESD@
+#cmakedefine SDL_AUDIO_DRIVER_ESD_DYNAMIC @SDL_AUDIO_DRIVER_ESD_DYNAMIC@
+#cmakedefine SDL_AUDIO_DRIVER_NAS @SDL_AUDIO_DRIVER_NAS@
+#cmakedefine SDL_AUDIO_DRIVER_NAS_DYNAMIC @SDL_AUDIO_DRIVER_NAS_DYNAMIC@
+#cmakedefine SDL_AUDIO_DRIVER_NDS @SDL_AUDIO_DRIVER_NDS@
+#cmakedefine SDL_AUDIO_DRIVER_OSS @SDL_AUDIO_DRIVER_OSS@
+#cmakedefine SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H @SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H@
+#cmakedefine SDL_AUDIO_DRIVER_PAUDIO @SDL_AUDIO_DRIVER_PAUDIO@
+#cmakedefine SDL_AUDIO_DRIVER_QSA @SDL_AUDIO_DRIVER_QSA@
+#cmakedefine SDL_AUDIO_DRIVER_SUNAUDIO @SDL_AUDIO_DRIVER_SUNAUDIO@
+#cmakedefine SDL_AUDIO_DRIVER_WINMM @SDL_AUDIO_DRIVER_WINMM@
+#cmakedefine SDL_AUDIO_DRIVER_FUSIONSOUND @SDL_AUDIO_DRIVER_FUSIONSOUND@
+#cmakedefine SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC @SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC@
+
+/* Enable various input drivers */
+#cmakedefine SDL_INPUT_LINUXEV @SDL_INPUT_LINUXEV@
+#cmakedefine SDL_INPUT_TSLIB @SDL_INPUT_TSLIB@
+#cmakedefine SDL_JOYSTICK_BEOS @SDL_JOYSTICK_BEOS@
+#cmakedefine SDL_JOYSTICK_DINPUT @SDL_JOYSTICK_DINPUT@
+#cmakedefine SDL_JOYSTICK_DUMMY @SDL_JOYSTICK_DUMMY@
+#cmakedefine SDL_JOYSTICK_IOKIT @SDL_JOYSTICK_IOKIT@
+#cmakedefine SDL_JOYSTICK_LINUX @SDL_JOYSTICK_LINUX@
+#cmakedefine SDL_JOYSTICK_NDS @SDL_JOYSTICK_NDS@
+#cmakedefine SDL_JOYSTICK_WINMM @SDL_JOYSTICK_WINMM@
+#cmakedefine SDL_JOYSTICK_USBHID @SDL_JOYSTICK_USBHID@
+#cmakedefine SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H @SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H@
+#cmakedefine SDL_HAPTIC_DUMMY @SDL_HAPTIC_DUMMY@
+#cmakedefine SDL_HAPTIC_LINUX @SDL_HAPTIC_LINUX@
+#cmakedefine SDL_HAPTIC_IOKIT @SDL_HAPTIC_IOKIT@
+#cmakedefine SDL_HAPTIC_DINPUT @SDL_HAPTIC_DINPUT@
+
+/* Enable various shared object loading systems */
+#cmakedefine SDL_LOADSO_BEOS @SDL_LOADSO_BEOS@
+#cmakedefine SDL_LOADSO_DLOPEN @SDL_LOADSO_DLOPEN@
+#cmakedefine SDL_LOADSO_DUMMY @SDL_LOADSO_DUMMY@
+#cmakedefine SDL_LOADSO_LDG @SDL_LOADSO_LDG@
+#cmakedefine SDL_LOADSO_WINDOWS @SDL_LOADSO_WINDOWS@
+
+/* Enable various threading systems */
+#cmakedefine SDL_THREAD_BEOS @SDL_THREAD_BEOS@
+#cmakedefine SDL_THREAD_NDS @SDL_THREAD_NDS@
+#cmakedefine SDL_THREAD_PTHREAD @SDL_THREAD_PTHREAD@
+#cmakedefine SDL_THREAD_PTHREAD_RECURSIVE_MUTEX @SDL_THREAD_PTHREAD_RECURSIVE_MUTEX@
+#cmakedefine SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP @SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP@
+#cmakedefine SDL_THREAD_WINDOWS @SDL_THREAD_WINDOWS@
+
+/* Enable various timer systems */
+#cmakedefine SDL_TIMER_BEOS @SDL_TIMER_BEOS@
+#cmakedefine SDL_TIMER_DUMMY @SDL_TIMER_DUMMY@
+#cmakedefine SDL_TIMER_NDS @SDL_TIMER_NDS@
+#cmakedefine SDL_TIMER_UNIX @SDL_TIMER_UNIX@
+#cmakedefine SDL_TIMER_WINDOWS @SDL_TIMER_WINDOWS@
+#cmakedefine SDL_TIMER_WINCE @SDL_TIMER_WINCE@
+
+/* Enable various video drivers */
+#cmakedefine SDL_VIDEO_DRIVER_BWINDOW @SDL_VIDEO_DRIVER_BWINDOW@
+#cmakedefine SDL_VIDEO_DRIVER_COCOA @SDL_VIDEO_DRIVER_COCOA@
+#cmakedefine SDL_VIDEO_DRIVER_DIRECTFB @SDL_VIDEO_DRIVER_DIRECTFB@
+#cmakedefine SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC @SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC@
+#cmakedefine SDL_VIDEO_DRIVER_DUMMY @SDL_VIDEO_DRIVER_DUMMY@
+#cmakedefine SDL_VIDEO_DRIVER_NDS @SDL_VIDEO_DRIVER_NDS@
+#cmakedefine SDL_VIDEO_DRIVER_WINDOWS @SDL_VIDEO_DRIVER_WINDOWS@
+#cmakedefine SDL_VIDEO_DRIVER_X11 @SDL_VIDEO_DRIVER_X11@
+#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC @SDL_VIDEO_DRIVER_X11_DYNAMIC@
+#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT @SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT@
+#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR @SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR@
+#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA @SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA@
+#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2 @SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2@
+#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR @SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR@
+#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS @SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS@
+#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE @SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE@
+#cmakedefine SDL_VIDEO_DRIVER_X11_XCURSOR @SDL_VIDEO_DRIVER_X11_XCURSOR@
+#cmakedefine SDL_VIDEO_DRIVER_X11_XINERAMA @SDL_VIDEO_DRIVER_X11_XINERAMA@
+#cmakedefine SDL_VIDEO_DRIVER_X11_XINPUT2 @SDL_VIDEO_DRIVER_X11_XINPUT2@
+#cmakedefine SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH @SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH@
+#cmakedefine SDL_VIDEO_DRIVER_X11_XRANDR @SDL_VIDEO_DRIVER_X11_XRANDR@
+#cmakedefine SDL_VIDEO_DRIVER_X11_XSCRNSAVER @SDL_VIDEO_DRIVER_X11_XSCRNSAVER@
+#cmakedefine SDL_VIDEO_DRIVER_X11_XSHAPE @SDL_VIDEO_DRIVER_X11_XSHAPE@
+#cmakedefine SDL_VIDEO_DRIVER_X11_XVIDMODE @SDL_VIDEO_DRIVER_X11_XVIDMODE@
+#cmakedefine SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS @SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS@
+#cmakedefine SDL_VIDEO_DRIVER_X11_CONST_PARAM_XEXTADDDISPLAY @SDL_VIDEO_DRIVER_X11_CONST_PARAM_XEXTADDDISPLAY@
+#cmakedefine SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM @SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM@
+
+#cmakedefine SDL_VIDEO_RENDER_D3D @SDL_VIDEO_RENDER_D3D@
+#cmakedefine SDL_VIDEO_RENDER_OGL @SDL_VIDEO_RENDER_OGL@
+#cmakedefine SDL_VIDEO_RENDER_OGL_ES @SDL_VIDEO_RENDER_OGL_ES@
+#cmakedefine SDL_VIDEO_RENDER_OGL_ES2 @SDL_VIDEO_RENDER_OGL_ES2@
+#cmakedefine SDL_VIDEO_RENDER_DIRECTFB @SDL_VIDEO_RENDER_DIRECTFB@
+
+/* Enable OpenGL support */
+#cmakedefine SDL_VIDEO_OPENGL @SDL_VIDEO_OPENGL@
+#cmakedefine SDL_VIDEO_OPENGL_ES @SDL_VIDEO_OPENGL_ES@
+#cmakedefine SDL_VIDEO_OPENGL_BGL @SDL_VIDEO_OPENGL_BGL@
+#cmakedefine SDL_VIDEO_OPENGL_CGL @SDL_VIDEO_OPENGL_CGL@
+#cmakedefine SDL_VIDEO_OPENGL_GLX @SDL_VIDEO_OPENGL_GLX@
+#cmakedefine SDL_VIDEO_OPENGL_WGL @SDL_VIDEO_OPENGL_WGL@
+#cmakedefine SDL_VIDEO_OPENGL_OSMESA @SDL_VIDEO_OPENGL_OSMESA@
+#cmakedefine SDL_VIDEO_OPENGL_OSMESA_DYNAMIC @SDL_VIDEO_OPENGL_OSMESA_DYNAMIC@
+
+/* Enable system power support */
+#cmakedefine SDL_POWER_LINUX @SDL_POWER_LINUX@
+#cmakedefine SDL_POWER_WINDOWS @SDL_POWER_WINDOWS@
+#cmakedefine SDL_POWER_MACOSX @SDL_POWER_MACOSX@
+#cmakedefine SDL_POWER_BEOS @SDL_POWER_BEOS@
+#cmakedefine SDL_POWER_NINTENDODS @SDL_POWER_NINTENDODS@
+#cmakedefine SDL_POWER_HARDWIRED @SDL_POWER_HARDWIRED@
+
+/* Enable assembly routines */
+#cmakedefine SDL_ASSEMBLY_ROUTINES @SDL_ASSEMBLY_ROUTINES@
+#cmakedefine SDL_ALTIVEC_BLITTERS @SDL_ALTIVEC_BLITTERS@
+
+
+/* Platform specific definitions */
+#if !defined(__WIN32__)
+#  if !defined(_STDINT_H_) && !defined(_STDINT_H) && !defined(HAVE_STDINT_H) && !defined(_HAVE_STDINT_H)
+typedef unsigned int size_t;
+typedef signed char int8_t;
+typedef unsigned char uint8_t;
+typedef signed short int16_t;
+typedef unsigned short uint16_t;
+typedef signed int int32_t;
+typedef unsigned int uint32_t;
+typedef signed long long int64_t;
+typedef unsigned long long uint64_t;
+typedef unsigned long uintptr_t;
+#  endif /* if (stdint.h isn't available) */
+#else /* __WIN32__ */
+#  if !defined(_STDINT_H_) && !defined(HAVE_STDINT_H) && !defined(_HAVE_STDINT_H)
+#    if defined(__GNUC__) || defined(__DMC__) || defined(__WATCOMC__)
+#define HAVE_STDINT_H	1
+#    elif defined(_MSC_VER)
+typedef signed __int8 int8_t;
+typedef unsigned __int8 uint8_t;
+typedef signed __int16 int16_t;
+typedef unsigned __int16 uint16_t;
+typedef signed __int32 int32_t;
+typedef unsigned __int32 uint32_t;
+typedef signed __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+#      ifndef _UINTPTR_T_DEFINED
+#        ifdef  _WIN64
+typedef unsigned __int64 uintptr_t;
+#          else
+typedef unsigned int uintptr_t;
+#        endif
+#define _UINTPTR_T_DEFINED
+#      endif
+/* Older Visual C++ headers don't have the Win64-compatible typedefs... */
+#      if ((_MSC_VER <= 1200) && (!defined(DWORD_PTR)))
+#define DWORD_PTR DWORD
+#      endif
+#      if ((_MSC_VER <= 1200) && (!defined(LONG_PTR)))
+#define LONG_PTR LONG
+#      endif
+#    else /* !__GNUC__ && !_MSC_VER */
+typedef signed char int8_t;
+typedef unsigned char uint8_t;
+typedef signed short int16_t;
+typedef unsigned short uint16_t;
+typedef signed int int32_t;
+typedef unsigned int uint32_t;
+typedef signed long long int64_t;
+typedef unsigned long long uint64_t;
+#      ifndef _SIZE_T_DEFINED_
+#define _SIZE_T_DEFINED_
+typedef unsigned int size_t;
+#      endif
+typedef unsigned int uintptr_t;
+#    endif /* __GNUC__ || _MSC_VER */
+#  endif /* !_STDINT_H_ && !HAVE_STDINT_H */
+#endif /* __WIN32__ */
+
+#endif /* _SDL_config_h */