mirror/aseprite
1
0
Fork 0
mirror of https://github.com/aseprite/aseprite.git synced 2025-02-21 03:40:57 +00:00
Code Issues Packages Projects Releases Wiki Activity
aseprite/src/allegro/CMakeLists.txt

894 lines
26 KiB
CMake
Raw Blame History

# XXX build chm files
# XXX build devhelp files
# XXX resources (keyboard/language) - pretty useless except on DOS
# XXX install grabber.txt?
# XXX png plugin for grabber
# XXX what is fixbundle?
# XXX applehelp bundle?
# XXX projectbuilder application template?
# XXX allegro.m4?
# Ports that used to work which aren't supported yet:
# Haiku/BeOS port
# djgpp port
# QNX port
# BCC32
# Watcom
# DMC
# PSP port?
#-----------------------------------------------------------------------------#
#
# CMake setup
#
cmake_minimum_required(VERSION 2.6 FATAL_ERROR)
if(COMMAND cmake_policy)
cmake_policy(SET CMP0003 NEW)
endif(COMMAND cmake_policy)
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING
"Choose the type of build, options are:
None Debug Release RelWithDebInfo MinSizeRel Profile."
FORCE)
endif()
# Restrict configuration types to the selected build type.
# Note: This needs to be done before the project command
set(CMAKE_CONFIGURATION_TYPES "${CMAKE_BUILD_TYPE}" CACHE INTERNAL "internal")
#-----------------------------------------------------------------------------#
#
# Build options
#
# Set the project name.
project(ALLEGRO C CXX)
if(WIN32)
if(MINGW)
# As of CMake 2.6.2, support for building .rc files with mingw seems to
# be broken (uses wrong command line syntax) so we have to set this
# variable manually.
set(CMAKE_RC_COMPILE_OBJECT
"<CMAKE_RC_COMPILER> <FLAGS> -O coff -o <OBJECT> -i <SOURCE>")
if(NOT CMAKE_RC_COMPILER OR "${CMAKE_RC_COMPILER}" STREQUAL "")
string(REGEX REPLACE "gcc(.exe)?$" "windres"
GUESS_RC_COMPILER ${CMAKE_C_COMPILER})
find_program(CMAKE_RC_COMPILER ${GUESS_RC_COMPILER})
endif()
endif(MINGW)
enable_language(RC OPTIONAL)
message(STATUS "CMAKE_RC_COMPILER: ${CMAKE_RC_COMPILER}")
if(NOT CMAKE_RC_COMPILER)
message(FATAL_ERROR "Please set CMAKE_RC_COMPILER manually, e.g. *-windres.")
endif()
endif(WIN32)
set(ALLEGRO_VERSION 4.4.2)
string(REGEX MATCH "^[0-9]+[.][0-9]+" ALLEGRO_SOVERSION ${ALLEGRO_VERSION})
# Mac OS X -compatibility_version.
# XXX doesn't seem to work
set(COMPAT_VERSION 4.4.0)
set(ALLEGRO_DLL_SHORTVER 44)
# Search in the `cmake' directory for additional CMake modules.
list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
# Search for C header files in these directories.
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
include_directories(${CMAKE_BINARY_DIR}/include)
# Put libraries into `lib'.
set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib)
# Lists of all the source files.
include(FileList)
# Our own CMake macros and functions.
include(Common)
#-----------------------------------------------------------------------------#
#
# Build options
#
option(SHARED "Build shared library for main Allegro library" off)
set(BUILD_SHARED_LIBS ${SHARED}) # actual CMake variable
# On some 64-bit platforms, libraries should be installed into `lib64'
# instead of `lib'. Set this to 64 to do that.
set(LIB_SUFFIX "" CACHE STRING "Suffix for 'lib' directories, e.g. '64'")
option(MAGIC_MAIN "Enable magic main (Unix)" off)
option(WANT_FRAMEWORKS "Want frameworks on Mac OS X" off)
option(WANT_EMBED
"Make frameworks embeddable in application bundles (Mac OS X)" on)
set(FRAMEWORK_INSTALL_PREFIX "/Library/Frameworks" CACHE STRING
"Directory in which to install Mac OS X frameworks")
#-----------------------------------------------------------------------------#
#
# Unix platform checks
#
include(CheckIncludeFiles)
include(CheckFunctionExists)
include(CheckCSourceCompiles)
include(CheckCSourceRuns)
include(FindPkgConfig)
include(TestBigEndian)
if(UNIX)
test_big_endian(ALLEGRO_BIG_ENDIAN)
if(NOT ALLEGRO_BIG_ENDIAN)
set(ALLEGRO_LITTLE_ENDIAN 1)
endif(NOT ALLEGRO_BIG_ENDIAN)
check_include_files(dirent.h ALLEGRO_HAVE_DIRENT_H)
check_include_files(inttypes.h ALLEGRO_HAVE_INTTYPES_H)
check_include_files(linux/awe_voice.h ALLEGRO_HAVE_LINUX_AWE_VOICE_H)
check_include_files(linux/input.h ALLEGRO_HAVE_LINUX_INPUT_H)
# On some systems including linux/joystick.h without sys/types.h results
# in conflicting definitions of fd_set.
check_include_files("sys/types.h;linux/joystick.h" ALLEGRO_HAVE_LINUX_JOYSTICK_H)
check_include_files(linux/soundcard.h ALLEGRO_HAVE_LINUX_SOUNDCARD_H)
check_include_files(machine/soundcard.h ALLEGRO_HAVE_MACHINE_SOUNDCARD_H)
check_include_files(soundcard.h ALLEGRO_HAVE_SOUNDCARD_H)
check_include_files(stdint.h ALLEGRO_HAVE_STDINT_H)
check_include_files(sys/io.h ALLEGRO_HAVE_SYS_IO_H)
check_include_files(sys/stat.h ALLEGRO_HAVE_SYS_STAT_H)
check_include_files(sys/time.h ALLEGRO_HAVE_SYS_TIME_H)
check_include_files(sys/soundcard.h ALLEGRO_HAVE_SYS_SOUNDCARD_H)
check_include_files(sys/utsname.h ALLEGRO_HAVE_SYS_UTSNAME_H)
check_function_exists(getexecname ALLEGRO_HAVE_GETEXECNAME)
check_function_exists(memcmp ALLEGRO_HAVE_MEMCMP)
check_function_exists(mkstemp ALLEGRO_HAVE_MKSTEMP)
check_function_exists(mmap ALLEGRO_HAVE_MMAP)
check_function_exists(mprotect ALLEGRO_HAVE_MPROTECT)
check_function_exists(sched_yield ALLEGRO_HAVE_SCHED_YIELD)
check_function_exists(stricmp ALLEGRO_HAVE_STRICMP)
check_function_exists(strlwr ALLEGRO_HAVE_STRLWR)
check_function_exists(strupr ALLEGRO_HAVE_STRUPR)
check_function_exists(sysconf ALLEGRO_HAVE_SYSCONF)
check_c_source_compiles("
#include <sys/procfs.h>
#include <sys/ioctl.h>
int main(void) {
struct prpsinfo psinfo;
ioctl(0, PIOCPSINFO, &psinfo);
return 0;
}"
ALLEGRO_HAVE_SV_PROCFS_H
)
check_c_source_compiles("
#include <sys/procfs.h>
int main(void) {
struct prpsinfo psinfo;
psinfo.pr_argc = 0;
return 0;
}"
ALLEGRO_HAVE_PROCFS_ARGCV
)
check_c_source_compiles("
#include <unistd.h>
#include <sys/mman.h>
int main(void) {
void *x = MAP_FAILED;
}"
MAP_FAILED_DEFINED)
if(NOT MAP_FAILED_DEFINED)
set(MAP_FAILED "((void *) -1)")
endif()
check_c_source_runs("
static int notsupported = 1;
void test_ctor (void) __attribute__((constructor));
void test_ctor (void) { notsupported = 0; }
int main(void) { return (notsupported); }
"
ALLEGRO_USE_CONSTRUCTOR)
find_library(RT_LIBRARY rt)
check_c_source_compiles("
#include <time.h>
int main(void) {
struct timespec new_time_ns;
clock_gettime(CLOCK_MONOTONIC, &new_time_ns);
return 0;
}"
ALLEGRO_HAVE_POSIX_MONOTONIC_CLOCK
)
if(MAGIC_MAIN)
set(ALLEGRO_WITH_MAGIC_MAIN 1)
endif(MAGIC_MAIN)
# XXX const
# XXX inline
# XXX size_t
endif(UNIX)
#-----------------------------------------------------------------------------#
#
# Compiler and platform setup
#
option(STRICT_WARN "Halt at warnings" off)
set(INSTALL_PREFIX "")
if(CMAKE_COMPILER_IS_GNUCC)
set(COMPILER_GCC 1)
set(ALLEGRO_GCC 1)
set(WFLAGS "-W -Wall -Wno-unused-parameter")
set(WFLAGS_C_ONLY "-Wdeclaration-after-statement")
if(STRICT_WARN)
set(WFLAGS "${WFLAGS} -Werror -Wpointer-arith")
set(WFLAGS_C_ONLY "${WFLAGS_C_ONLY} -Wmissing-declarations")
set(WFLAGS_C_ONLY "${WFLAGS_C_ONLY} -Wstrict-prototypes")
endif(STRICT_WARN)
endif(CMAKE_COMPILER_IS_GNUCC)
if(MINGW)
set(ALLEGRO_MINGW32 1)
# Guess MINGDIR from the value of CMAKE_C_COMPILER if it's not set.
if("$ENV{MINGDIR}" STREQUAL "")
string(REGEX REPLACE "/bin/[^/]*$" "" MINGDIR "${CMAKE_C_COMPILER}")
message(STATUS "Guessed MinGW directory: ${MINGDIR}")
else("$ENV{MINGDIR}" STREQUAL "")
file(TO_CMAKE_PATH "$ENV{MINGDIR}" MINGDIR)
message(STATUS "Using MINGDIR: ${MINGDIR}")
endif("$ENV{MINGDIR}" STREQUAL "")
# Search in MINGDIR for headers and libraries.
set(CMAKE_PREFIX_PATH "${MINGDIR}")
# Install to MINGDIR
if(INSTALL_PREFIX STREQUAL "")
set(CMAKE_INSTALL_PREFIX ${MINGDIR})
else(INSTALL_PREFIX STREQUAL "")
set(CMAKE_INSTALL_PREFIX ${INSTALL_PREFIX})
endif(INSTALL_PREFIX STREQUAL "")
message(STATUS "CMAKE_INSTALL_PREFIX: ${CMAKE_INSTALL_PREFIX}")
endif(MINGW)
if(MSVC)
set(COMPILER_MSVC 1)
set(ALLEGRO_MSVC 1)
set(WFLAGS "/W3 -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE")
endif(MSVC)
if(WIN32)
set(ALLEGRO_WINDOWS 1)
endif()
if(APPLE)
set(ALLEGRO_MACOSX 1)
set(ALLEGRO_DARWIN 1)
# Hack to deal with Mac OS X 10.6. NSQuickDrawView is not defined by
# NSQuickDrawView.h when compiling in 64-bit mode, and 64-bit mode is the
# default when compiling on Snow Leopard.
if(${CMAKE_SYSTEM_PROCESSOR} STREQUAL i386)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -arch i386")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -arch i386")
endif()
# The Mac port simply uses too many deprecated things.
if(COMPILER_GCC)
set(WFLAGS "${WFLAGS} -Wno-deprecated-declarations")
endif(COMPILER_GCC)
endif(APPLE)
if(BEOS)
if(CMAKE_SYSTEM_NAME STREQUAL Haiku)
set(ALLEGRO_HAIKU 1)
else(CMAKE_SYSTEM_NAME STREQUAL Haiku)
set(ALLEGRO_BEOS 1)
endif(CMAKE_SYSTEM_NAME STREQUAL Haiku)
set(WFLAGS "-W -Wall -Wno-unused -Wno-multichar -Wno-ctor-dtor-privacy")
set(WFLAGS_C_ONLY "")
endif(BEOS)
if(UNIX AND NOT APPLE AND NOT BEOS)
set(ALLEGRO_UNIX 1)
endif()
if(PSP)
set(ALLEGRO_PSP 1)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -G0")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -G0 -fno-exceptions -fno-rtti")
set(CMAKE_INSTALL_PREFIX ${PSP_PREFIX})
endif(PSP)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WFLAGS} ${WFLAGS_C_ONLY}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WFLAGS}")
if(NOT BUILD_SHARED_LIBS)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DALLEGRO_STATICLINK")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DALLEGRO_STATICLINK")
endif()
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DDEBUGMODE=1")
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUGMODE=1")
list(APPEND CMAKE_BUILD_TYPES Profile)
mark_as_advanced(
CMAKE_C_FLAGS_PROFILE
CMAKE_CXX_FLAGS_PROFILE
CMAKE_EXE_LINKER_FLAGS_PROFILE
)
if(COMPILER_GCC)
set(CMAKE_C_FLAGS_PROFILE "-pg"
CACHE STRING "profiling flags")
set(CMAKE_CXX_FLAGS_PROFILE "${CMAKE_C_FLAGS_PROFILE}"
CACHE STRING "profiling flags")
set(CMAKE_EXE_LINKER_FLAGS_PROFILE "-pg"
CACHE STRING "profiling flags")
endif(COMPILER_GCC)
if(COMPILER_MSVC)
set(CMAKE_C_FLAGS_PROFILE "-Gd -Ox"
CACHE STRING "profiling flags")
set(CMAKE_CXX_FLAGS_PROFILE "${CMAKE_C_FLAGS_PROFILE}"
CACHE STRING "profiling flags")
set(CMAKE_EXE_LINKER_FLAGS_PROFILE "-profile"
CACHE STRING "profiling flags")
endif(COMPILER_MSVC)
#-----------------------------------------------------------------------------#
# Not sure if we want to support disabling these any more.
set(ALLEGRO_COLOR8 1)
set(ALLEGRO_COLOR16 1)
set(ALLEGRO_COLOR24 1)
set(ALLEGRO_COLOR32 1)
set(ALLEGRO_NO_ASM 1)
# ALLEGRO_MMX left undefined
# ALLEGRO_SSE left undefined
#-----------------------------------------------------------------------------#
#
# Unix modules
#
option(WANT_MODULES "Use modules for drivers (Unix)" on)
if(WANT_MODULES AND ALLEGRO_UNIX)
set(ALLEGRO_WITH_MODULES 1)
set(ALLEGRO_MODULES_PATH
${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}/allegro/${ALLEGRO_VERSION})
install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/modules.lst
DESTINATION "${ALLEGRO_MODULES_PATH}"
)
endif(WANT_MODULES AND ALLEGRO_UNIX)
function(add_our_module nm files)
if(ALLEGRO_WITH_MODULES)
add_library(${nm} MODULE ${files})
set_target_properties(${nm}
PROPERTIES
PREFIX ""
COMPILE_FLAGS -DALLEGRO_MODULE
)
target_link_libraries(${nm} ${ARGN})
install(TARGETS ${nm}
DESTINATION "${ALLEGRO_MODULES_PATH}"
)
endif(ALLEGRO_WITH_MODULES)
endfunction(add_our_module)
#-----------------------------------------------------------------------------#
#
# Platform drivers
#
set(PLATFORM_SOURCES)
set(PLATFORM_LIBS) # always link with these libraries
set(PLATFORM_LIBS_NON_MODULES) # only link with these if modules disabled
set(PLATFORM_LIBS_MODULES) # only link with these if modules enabled
# -- Unix --
option(WANT_OSS "Build OSS support" on)
option(WANT_ALSA "Build ALSA support" on)
option(WANT_JACK "Build JACK support" on)
option(WANT_SGIAUDIO "Build SGI audio support" on)
if(ALLEGRO_UNIX) # not MACOSX
find_package(Threads)
if(NOT CMAKE_USE_PTHREADS_INIT)
message(FATAL_ERROR "Unix port requires pthreads support.")
endif()
set(ALLEGRO_HAVE_LIBPTHREAD 1)
list(APPEND PLATFORM_LIBS m ${CMAKE_THREAD_LIBS_INIT})
list(APPEND PLATFORM_SOURCES ${ALLEGRO_SRC_UNIX_FILES})
find_library(DLOPEN_LIBRARY dl)
mark_as_advanced(DLOPEN_LIBRARY)
if(DLOPEN_LIBRARY)
list(APPEND PLATFORM_LIBS_MODULES ${DLOPEN_LIBRARY})
endif()
if(ALLEGRO_HAVE_POSIX_MONOTONIC_CLOCK)
list(APPEND PLATFORM_LIBS ${RT_LIBRARY})
endif(ALLEGRO_HAVE_POSIX_MONOTONIC_CLOCK)
if(WANT_OSS)
include(AllegroFindOSS)
if(OSS_FOUND)
set(ALLEGRO_WITH_OSSDIGI 1)
set(ALLEGRO_WITH_OSSMIDI 1)
include_directories(SYSTEM ${OSS_INCLUDE_DIR})
endif(OSS_FOUND)
endif(WANT_OSS)
if(WANT_ALSA)
pkg_check_modules(ALSA alsa)
if(ALSA_FOUND)
# ALSA 0.5 is beyond obsolete.
set(ALLEGRO_ALSA_VERSION 9)
set(ALLEGRO_WITH_ALSADIGI 1)
set(ALLEGRO_WITH_ALSAMIDI 1)
include_directories(SYSTEM ${ALSA_INCLUDE_DIRS})
list(APPEND PLATFORM_LIBS_NON_MODULES ${ALSA_LIBRARIES})
add_our_module(alleg-alsadigi src/unix/alsa9.c ${ALSA_LIBRARIES})
add_our_module(alleg-alsamidi src/unix/alsamidi.c ${ALSA_LIBRARIES})
endif(ALSA_FOUND)
endif(WANT_ALSA)
if(WANT_JACK)
pkg_check_modules(JACK jack)
if(JACK_FOUND)
set(ALLEGRO_WITH_JACKDIGI 1)
include_directories(SYSTEM ${JACK_INCLUDE_DIRS})
list(APPEND PLATFORM_LIBS_NON_MODULES ${JACK_LIBRARIES})
add_our_module(alleg-jack src/unix/jack.c ${JACK_LIBRARIES})
endif(JACK_FOUND)
endif(WANT_JACK)
# This is untested.
if(WANT_SGIAUDIO)
check_library_exists(audio alOpenPort "" SGIAUDIO_FOUND)
if(SGIAUDIO_FOUND)
set(ALLEGRO_WITH_SGIALDIGI 1)
list(APPEND PLATFORM_LIBS_NON_MODULES audio)
add_our_module(alleg-sgialdigi src/unix/sgial.c audio)
endif(SGIAUDIO_FOUND)
endif(WANT_SGIAUDIO)
# aRts is obsolete
# esd is obsolete
endif(ALLEGRO_UNIX)
# -- X11 --
option(WANT_X11 "Want X11 support (Unix)" on)
if(ALLEGRO_UNIX AND WANT_X11)
find_package(X11)
if(X11_FOUND)
set(ALLEGRO_WITH_XWINDOWS 1)
endif()
endif()
if(ALLEGRO_WITH_XWINDOWS)
include_directories(SYSTEM ${X11_INCLUDE_DIR})
list(APPEND PLATFORM_SOURCES ${ALLEGRO_SRC_X_FILES})
list(APPEND PLATFORM_LIBS ${X11_LIBRARIES})
if(X11_XShm_FOUND)
set(ALLEGRO_XWINDOWS_WITH_SHM 1)
list(APPEND PLATFORM_LIBS ${X11_Xext_LIB})
endif()
if(X11_Xcursor_FOUND)
set(ALLEGRO_XWINDOWS_WITH_XCURSOR 1)
list(APPEND PLATFORM_LIBS ${X11_Xcursor_LIB})
endif()
if(X11_Xcursor_FOUND)
set(ALLEGRO_XWINDOWS_WITH_XCURSOR 1)
list(APPEND PLATFORM_LIBS ${X11_Xcursor_LIB})
endif()
if(X11_Xpm_FOUND)
set(ALLEGRO_XWINDOWS_WITH_XPM 1)
list(APPEND PLATFORM_LIBS ${X11_Xpm_LIB})
endif()
find_library(X11_Xxf86vm_LIB Xxf86vm ${X11_LIB_SEARCH_PATH})
mark_as_advanced(X11_Xxf86vm_LIB)
if(X11_xf86vmode_FOUND)
set(ALLEGRO_XWINDOWS_WITH_XF86VIDMODE 1)
list(APPEND PLATFORM_LIBS ${X11_Xxf86vm_LIB})
endif()
check_library_exists(X11 XOpenIM "${X11_LIB_SEARCH_PATH}" XIM_FOUND)
if(XIM_FOUND)
set(ALLEGRO_XWINDOWS_WITH_XIM 1)
endif(XIM_FOUND)
check_library_exists(Xxf86dga XDGAQueryExtension
"${X11_LIB_SEARCH_PATH}" XDGA_FOUND)
if(XDGA_FOUND)
set(ALLEGRO_XWINDOWS_WITH_XF86DGA2 1)
list(APPEND PLATFORM_LIBS_NON_MODULES Xxf86dga ${X11_LIBRARIES})
add_our_module(alleg-dga2 src/x/xdga2.c Xxf86dga ${X11_LIBRARIES})
endif()
endif(ALLEGRO_WITH_XWINDOWS)
# -- Linux console --
option(WANT_LINUX_CONSOLE "Want Linux console support (Linux)" off)
option(WANT_LINUX_VGA "Want Linux console VGA driver (Linux)" on)
option(WANT_LINUX_FBCON "Want Linux console fbcon driver (Linux)" on)
option(WANT_LINUX_SVGALIB "Want Linux console SVGAlib driver (Linux)" on)
if(WANT_LINUX_CONSOLE AND CMAKE_SYSTEM_NAME STREQUAL Linux)
set(ALLEGRO_LINUX 1)
list(APPEND PLATFORM_SOURCES ${ALLEGRO_SRC_LINUX_FILES})
if(WANT_LINUX_VGA)
set(ALLEGRO_LINUX_VGA 1)
add_our_module(alleg-vga src/misc/vga.c)
endif()
if(WANT_LINUX_FBCON)
check_c_source_compiles("
#include <linux/fb.h>
int main(void) {
int x = FB_SYNC_ON_GREEN;
return 0;
}"
CAN_FBCON)
if(CAN_FBCON)
set(ALLEGRO_LINUX_FBCON 1)
add_our_module(alleg-fbcon src/linux/fbcon.c)
endif()
endif()
if(WANT_LINUX_SVGALIB)
find_package(Svgalib)
if(SVGALIB_FOUND)
set(ALLEGRO_LINUX_SVGALIB 1)
include_directories(SYSTEM ${SVGALIB_INCLUDE_DIR})
set(CMAKE_REQUIRED_LIBRARIES ${SVGALIB_LIBRARY})
check_c_source_compiles("
#include <vga.h>
int main(void) {
int x = vga_version;
return 0;
}"
ALLEGRO_LINUX_SVGALIB_HAVE_VGA_VERSION)
list(APPEND PLATFORM_LIBS_NON_MODULES ${SVGALIB_LIBRARY})
add_our_module(alleg-svgalib src/linux/svgalib.c
${SVGALIB_LIBRARY})
endif()
endif()
endif(WANT_LINUX_CONSOLE AND CMAKE_SYSTEM_NAME STREQUAL Linux)
# -- Windows --
if(WIN32)
find_package(DDraw)
find_package(DInput)
find_package(DSound)
find_package(DXGuid)
if(NOT DDRAW_FOUND OR NOT DINPUT_FOUND OR NOT DSOUND_FOUND OR NOT DXGUID_FOUND)
if(MSVC)
message(FATAL_ERROR
"DirectX required for Windows port. You might need to add DirectX include and lib directories to your INCLUDE and LIB environment variables.
")
elseif(MINGW)
message(FATAL_ERROR
"DirectX required for Windows port. Get it from the Allegro web site (dx80_mgw.zip).")
else()
message(FATAL_ERROR "DirectX required for Windows port.")
endif()
endif()
include_directories(SYSTEM
${DDRAW_INCLUDE_DIR}
${DINPUT_INCLUDE_DIR}
${DSOUND_INCLUDE_DIR}
${DXGUID_INCLUDE_DIR}
)
list(APPEND PLATFORM_SOURCES ${ALLEGRO_SRC_WIN_FILES})
list(APPEND PLATFORM_LIBS
kernel32
user32
gdi32
comdlg32
ole32
${DINPUT_LIBRARIES}
${DDRAW_LIBRARIES}
${DXGUID_LIBRARIES}
winmm
${DSOUND_LIBRARIES}
)
endif(WIN32)
# -- Haiku/BeOS --
if(BEOS)
list(APPEND PLATFORM_SOURCES ${ALLEGRO_SRC_BEOS_FILES})
list(APPEND PLATFORM_LIBS game midi device)
endif(BEOS)
# -- Mac OS X --
if(ALLEGRO_MACOSX)
list(APPEND PLATFORM_SOURCES ${ALLEGRO_SRC_MACOSX_FILES})
if(NOT SHARED)
list(APPEND PLATFORM_SOURCES src/macosx/main.m)
endif(NOT SHARED)
find_library(COCOA_LIBRARY Cocoa)
find_library(CARBON_LIBRARY Carbon)
find_library(IOKIT_LIBRARY IOKit)
find_library(COREAUDIO_LIBRARY CoreAudio)
find_library(AUDIOUNIT_LIBRARY AudioUnit)
find_library(AUDIOTOOLBOX_LIBRARY AudioToolbox)
find_package(QuickTime)
mark_as_advanced(COCOA_LIBRARY CARBON_LIBRARY IOKIT_LIBRARY)
mark_as_advanced(COREAUDIO_LIBRARY AUDIOUNIT_LIBRARY AUDIOTOOLBOX_LIBRARY)
mark_as_advanced(QUICKTIME_INCLUDE_DIR QUICKTIME_LIBRARY)
list(APPEND PLATFORM_LIBS
${COCOA_LIBRARY}
${CARBON_LIBRARY}
${IOKIT_LIBRARY}
${COREAUDIO_LIBRARY}
${AUDIOUNIT_LIBRARY}
${AUDIOTOOLBOX_LIBRARY}
${QUICKTIME_LIBRARY}
)
endif(ALLEGRO_MACOSX)
# -- PSP --
if(PSP)
include_directories(SYSTEM ${PSPSDK_PATH}/include)
link_directories(${PSPSDK_PATH}/lib)
list(APPEND PLATFORM_SOURCES ${ALLEGRO_SRC_PSP_FILES})
list(APPEND PLATFORM_LIBS
m pspaudio pspgu psprtc pspdebug pspdisplay pspge pspctrl pspsdk c pspnet pspnet_inet pspnet_resolver psputility pspuser pspkernel)
endif(PSP)
#-----------------------------------------------------------------------------#
#
# Generate and install headers
#
set(ALLEGRO_PUBLIC_HEADERS)
macro(add_headers location)
list(APPEND ALLEGRO_PUBLIC_HEADERS ${ARGN})
# We reuse MACOSX_PACKAGE_LOCATION on non-Mac platforms as well.
set_source_files_properties(${ARGN}
PROPERTIES
MACOSX_PACKAGE_LOCATION Headers/${location}
)
endmacro(add_headers)
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/include/allegro/platform/alplatf.h.cmake
${CMAKE_BINARY_DIR}/include/allegro/platform/alplatf.h
@ONLY
)
add_headers(allegro/platform
${CMAKE_BINARY_DIR}/include/allegro/platform/alplatf.h
)
if(UNIX)
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/include/allegro/platform/alunixac.h.cmake
${CMAKE_BINARY_DIR}/include/allegro/platform/alunixac.h
)
add_headers(allegro/platform
${CMAKE_BINARY_DIR}/include/allegro/platform/alunixac.h
)
endif(UNIX)
add_headers("" include/allegro.h)
add_headers(allegro ${ALLEGRO_INCLUDE_ALLEGRO_FILES})
add_headers(allegro/inline ${ALLEGRO_INCLUDE_ALLEGRO_INLINE_FILES})
add_headers(allegro/internal ${ALLEGRO_INCLUDE_ALLEGRO_INTERNAL_FILES})
add_headers(allegro/platform ${ALLEGRO_INCLUDE_ALLEGRO_PLATFORM_FILES})
# Platform-specific top-level headers.
if(ALLEGRO_LINUX)
add_headers("" include/linalleg.h)
endif(ALLEGRO_LINUX)
if(APPLE)
add_headers("" include/osxalleg.h)
endif(APPLE)
if(WIN32)
add_headers("" include/winalleg.h)
endif(WIN32)
if(ALLEGRO_WITH_XWINDOWS)
add_headers("" include/xalleg.h)
endif(ALLEGRO_WITH_XWINDOWS)
if(BEOS)
add_headers("" include/bealleg.h)
endif(BEOS)
#-----------------------------------------------------------------------------#
#
# Main library
#
# On Unix/Mac we don't ever use a -static postfix.
if(CMAKE_BUILD_TYPE STREQUAL Debug)
set(BUILD_TYPE_SUFFIX -debug)
elseif(CMAKE_BUILD_TYPE STREQUAL Profile)
set(BUILD_TYPE_SUFFIX -profile)
else()
set(BUILD_TYPE_SUFFIX "")
endif()
if(ALLEGRO_MODULES_PATH)
set(ALLEGRO_MODULES_PATH_FLAG
"-DALLEGRO_MODULES_PATH='\"${ALLEGRO_MODULES_PATH}\"'")
endif(ALLEGRO_MODULES_PATH)
if(APPLE)
# CMake 2.6.2 onwards passes these flags automatically.
if(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} STREQUAL 2.6 AND
${CMAKE_PATCH_VERSION} LESS 2)
set(ALLEGRO_LINK_FLAGS
"-compatibility_version ${COMPAT_VERSION} -current_version ${ALLEGRO_VERSION}")
endif()
endif(APPLE)
add_our_library(allegro
${ALLEGRO_SRC_FILES}
${ALLEGRO_SRC_C_FILES}
${PLATFORM_SOURCES}
${ALLEGRO_PUBLIC_HEADERS}
)
if(WIN32 AND SHARED)
set(allegro_OUTPUT_NAME alleg${ALLEGRO_DLL_SHORTVER})
else()
set(allegro_OUTPUT_NAME alleg)
endif()
set_target_properties(allegro
PROPERTIES
COMPILE_FLAGS "-DALLEGRO_SRC ${ALLEGRO_MODULES_PATH_FLAG}"
LINK_FLAGS "${ALLEGRO_LINK_FLAGS}"
OUTPUT_NAME ${allegro_OUTPUT_NAME}
VERSION ${ALLEGRO_VERSION}
SOVERSION ${ALLEGRO_SOVERSION}
)
if(WIN32)
if(SHARED)
# Make mingw not add lib prefix to DLL, to match MSVC.
set_target_properties(allegro
PROPERTIES
PREFIX ""
)
else(SHARED)
# Add a -static postfix on the main library for Windows.
# In earlier versions of Allegro this was "_s".
set_target_properties(allegro
PROPERTIES
POSTFIX "-static"
DEBUG_POSTFIX "-debug-static"
PROFILE_POSTFIX "-profile-static"
)
endif(SHARED)
endif(WIN32)
set_our_framework_properties(allegro Allegro)
set(link_with ${PLATFORM_LIBS})
if(ALLEGRO_WITH_MODULES)
list(APPEND link_with ${PLATFORM_LIBS_MODULES})
else()
list(APPEND link_with ${PLATFORM_LIBS_NON_MODULES})
endif()
target_link_libraries(allegro ${link_with})
sanitize_cmake_link_flags(static_link_with ${link_with})
set_target_properties(allegro
PROPERTIES
static_link_with "${static_link_with}"
)
install_our_library(allegro)
if(NOT WANT_FRAMEWORKS)
install_our_headers(${ALLEGRO_PUBLIC_HEADERS})
endif(NOT WANT_FRAMEWORKS)
if(APPLE AND SHARED OR WANT_FRAMEWORKS)
add_our_library(alleg-main STATIC
src/macosx/main.m
)
set_target_properties(alleg-main
PROPERTIES
OUTPUT_NAME alleg-main${BUILD_TYPE_SUFFIX}
COMPILE_FLAGS -DALLEGRO_SRC
)
target_link_libraries(allegro alleg-main)
install_our_library(alleg-main)
endif(APPLE AND SHARED OR WANT_FRAMEWORKS)
if(PSP)
add_our_library(alleg-main STATIC
src/psp/pmain.c
)
set_target_properties(alleg-main
PROPERTIES
OUTPUT_NAME alleg-main${BUILD_TYPE_SUFFIX}
COMPILE_FLAGS -DALLEGRO_SRC
)
target_link_libraries(alleg-main pspuser pspkernel)
target_link_libraries(allegro alleg-main)
install_our_library(alleg-main)
endif(PSP)
#-----------------------------------------------------------------------------#
#
# allegro-config script
#
if(UNIX) # including MACOSX
set(prefix "${CMAKE_INSTALL_PREFIX}")
set(INCLUDE_PREFIX "${CMAKE_INSTALL_PREFIX}") # not sure what this is
if(BUILD_SHARED_LIBS)
set(LINK_WITH_STATIC_LIBS no)
else()
set(LINK_WITH_STATIC_LIBS yes)
endif()
set(LIB_TO_LINK alleg${BUILD_TYPE_SUFFIX})
if(APPLE)
set(LDFLAGS "-framework Cocoa -lalleg-main")
else(APPLE)
set(LDFLAGS "")
endif(APPLE)
sanitize_cmake_link_flags(LIBS
${PLATFORM_LIBS}
${PLATFORM_LIBS_NON_MODULES}
${PLATFORM_LIBS_MODULES}
)
if(APPLE)
# XXX untested
set(ACCEPT_FRAMEWORKS yes)
set(FRAMEWORKS "-framework Cocoa -framework Allegro -lalleg-main${BUILD_TYPE_SUFFIX}")
else()
set(ACCEPT_FRAMEWORKS no)
set(FRAMEWORKS "")
endif()
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/misc/allegro-config.in
${CMAKE_BINARY_DIR}/allegro-config
@ONLY
)
install(PROGRAMS ${CMAKE_BINARY_DIR}/allegro-config
DESTINATION bin
)
endif(UNIX)
#-----------------------------------------------------------------------------#
Reference in New Issue View Git Blame Copy Permalink