mirror of
https://github.com/ZDoom/gzdoom.git
synced 2024-11-10 06:42:08 +00:00
cfe89ef6e6
Currently all it contains are the MIDI sources and the MIDI devices, the rest needs to be reworked first.
429 lines
17 KiB
CMake
429 lines
17 KiB
CMake
cmake_minimum_required( VERSION 2.8.7 )
|
|
project(GZDoom)
|
|
|
|
if( COMMAND cmake_policy )
|
|
if( POLICY CMP0011 )
|
|
cmake_policy( SET CMP0011 NEW )
|
|
endif()
|
|
if( POLICY CMP0054 )
|
|
cmake_policy( SET CMP0054 NEW )
|
|
endif()
|
|
endif()
|
|
|
|
list( APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake )
|
|
include( FindPackageHandleStandardArgs )
|
|
|
|
# Support cross compiling
|
|
option( FORCE_CROSSCOMPILE "Turn on cross compiling." NO )
|
|
if( FORCE_CROSSCOMPILE )
|
|
set( CMAKE_CROSSCOMPILING TRUE )
|
|
endif()
|
|
|
|
if(CMAKE_CROSSCOMPILING)
|
|
set(IMPORT_EXECUTABLES "IMPORTFILE-NOTFOUND" CACHE FILEPATH "Export file from native build.")
|
|
include(${IMPORT_EXECUTABLES})
|
|
endif()
|
|
|
|
# Recursive function to place PK3 archive source files into a hierarchy of source file in the IDE
|
|
function( assort_pk3_source_folder FOLDER_NAME PK3_DIR )
|
|
# Assort source files into folders in the IDE
|
|
file(GLOB PK3_SRCS ${PK3_DIR}/*) # Create list of all files in this folder
|
|
foreach(PK3_SRC ${PK3_SRCS})
|
|
# If there are subfolders, recurse into them
|
|
if(IS_DIRECTORY ${PK3_SRC})
|
|
get_filename_component(DIRNAME ${PK3_SRC} NAME)
|
|
# Exclude folder from list of source files
|
|
list(REMOVE_ITEM PK3_SRCS ${PK3_SRC})
|
|
# Recurse deeper into the filesystem folder tree
|
|
assort_pk3_source_folder( ${FOLDER_NAME}\\${DIRNAME} ${PK3_SRC} )
|
|
endif()
|
|
# Assign IDE group for current top-level source files
|
|
source_group(${FOLDER_NAME} FILES ${PK3_SRCS})
|
|
endforeach()
|
|
endfunction()
|
|
|
|
option( PK3_QUIET_ZIPDIR "Do not list files processed by zipdir" NO )
|
|
if( PK3_QUIET_ZIPDIR )
|
|
set( PK3_ZIPDIR_OPTIONS "-q" )
|
|
endif()
|
|
|
|
# Simplify pk3 building, add_pk3(filename srcdirectory)
|
|
function( add_pk3 PK3_NAME PK3_DIR )
|
|
# Generate target name. Just use "pk3" for main pk3 target.
|
|
string( REPLACE "." "_" PK3_TARGET ${PK3_NAME} )
|
|
|
|
if( NOT ZDOOM_OUTPUT_OLDSTYLE )
|
|
add_custom_command( OUTPUT ${ZDOOM_OUTPUT_DIR}/${PK3_NAME}
|
|
COMMAND zipdir -udf ${PK3_ZIPDIR_OPTIONS} ${ZDOOM_OUTPUT_DIR}/${PK3_NAME} ${PK3_DIR}
|
|
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${ZDOOM_OUTPUT_DIR}/${PK3_NAME} $<TARGET_FILE_DIR:zdoom>/${PK3_NAME}
|
|
DEPENDS zipdir )
|
|
else()
|
|
add_custom_command( OUTPUT ${ZDOOM_OUTPUT_DIR}/${PK3_NAME}
|
|
COMMAND zipdir -udf ${PK3_ZIPDIR_OPTIONS} ${ZDOOM_OUTPUT_DIR}/${PK3_NAME} ${PK3_DIR}
|
|
DEPENDS zipdir )
|
|
endif()
|
|
# Create a list of source files for this PK3, for use in the IDE
|
|
# Phase 1: Create a list of all source files for this PK3 archive, except
|
|
# for a couple of strife image file names that confuse CMake.
|
|
file(GLOB_RECURSE PK3_SRCS ${PK3_DIR}/*)
|
|
# Exclude from the source list some gzdoom .png files with brackets in the
|
|
# file names here, because they confuse CMake.
|
|
# This only affects the list of source files shown in the IDE.
|
|
# It does not actually remove the files from the PK3 archive.
|
|
# First replace that toxic bracket character with something we can handle
|
|
string(REPLACE "[" confusing_bracket PK3_SRCS "${PK3_SRCS}")
|
|
string(REPLACE "]" confusing_bracket PK3_SRCS "${PK3_SRCS}")
|
|
foreach(PK3_SRC ${PK3_SRCS}) # All source files at all levels
|
|
# Exclude those quarantined source file source file names that once had a bracket
|
|
if(${PK3_SRC} MATCHES confusing_bracket)
|
|
# message(STATUS "Ignoring PK3 file name containing brackets "${PK3_SRC})
|
|
list(REMOVE_ITEM PK3_SRCS ${PK3_SRC})
|
|
endif()
|
|
endforeach()
|
|
# Phase 2: Create the PK3 build rule, including the source file list for the IDE
|
|
# Touch the zipdir executable here so that the pk3s are forced to
|
|
# rebuild each time since their dependency has "changed."
|
|
add_custom_target( ${PK3_TARGET} ALL
|
|
COMMAND ${CMAKE_COMMAND} -E touch $<TARGET_FILE:zipdir>
|
|
DEPENDS ${ZDOOM_OUTPUT_DIR}/${PK3_NAME}
|
|
SOURCES ${PK3_SRCS})
|
|
# Phase 3: Assign source files to a nice folder structure in the IDE
|
|
assort_pk3_source_folder("Source Files" ${PK3_DIR})
|
|
# Phase 4: Add the resulting PK3 to the install target.
|
|
if( WIN32 )
|
|
set( INSTALL_PK3_PATH . CACHE STRING "Directory where zdoom.pk3 will be placed during install." )
|
|
else()
|
|
set( INSTALL_PK3_PATH share/games/doom CACHE STRING "Directory where zdoom.pk3 will be placed during install." )
|
|
endif()
|
|
install(FILES "${PROJECT_BINARY_DIR}/${PK3_NAME}"
|
|
DESTINATION ${INSTALL_PK3_PATH}
|
|
COMPONENT "Game resources")
|
|
endfunction()
|
|
|
|
# Macro for building libraries without debugging information
|
|
macro( make_release_only )
|
|
set( CMAKE_C_FLAGS_MINSIZEREL ${CMAKE_C_FLAGS_RELEASE} )
|
|
set( CMAKE_C_FLAGS_RELWITHDEBINFO ${CMAKE_C_FLAGS_RELEASE} )
|
|
string( REPLACE "/MT " "/MTd " CMAKE_C_FLAGS_DEBUG ${CMAKE_C_FLAGS_RELEASE} )
|
|
set( CMAKE_CXX_FLAGS_MINSIZEREL ${CMAKE_CXX_FLAGS_RELEASE} )
|
|
set( CMAKE_CXX_FLAGS_RELWITHDEBINFO ${CMAKE_CXX_FLAGS_RELEASE} )
|
|
string( REPLACE "/MT " "/MTd " CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_RELEASE} )
|
|
endmacro()
|
|
|
|
IF( NOT CMAKE_BUILD_TYPE )
|
|
SET( CMAKE_BUILD_TYPE Debug CACHE STRING
|
|
"Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel."
|
|
FORCE )
|
|
ENDIF()
|
|
|
|
set( ZDOOM_OUTPUT_DIR ${CMAKE_BINARY_DIR} CACHE PATH "Directory where zdoom.pk3 and the executable will be created." )
|
|
set( ZDOOM_EXE_NAME "gzdoom" CACHE FILEPATH "Name of the executable to create" )
|
|
if( MSVC )
|
|
# Allow the user to use ZDOOM_OUTPUT_DIR as a single release point.
|
|
# Use zdoom, zdoomd, zdoom64, and zdoomd64 for the binary names
|
|
option( ZDOOM_OUTPUT_OLDSTYLE "Don't use Release/Debug directories." OFF )
|
|
else()
|
|
set( ZDOOM_OUTPUT_OLDSTYLE OFF )
|
|
endif()
|
|
|
|
# Replacement variables for a possible long list of C/C++ compilers compatible with GCC
|
|
if( "${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" )
|
|
set( ZD_CMAKE_COMPILER_IS_GNUC_COMPATIBLE TRUE )
|
|
else()
|
|
set( ZD_CMAKE_COMPILER_IS_GNUC_COMPATIBLE FALSE )
|
|
endif()
|
|
|
|
if( "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" )
|
|
set( ZD_CMAKE_COMPILER_IS_GNUCXX_COMPATIBLE TRUE )
|
|
else()
|
|
set( ZD_CMAKE_COMPILER_IS_GNUCXX_COMPATIBLE FALSE )
|
|
endif()
|
|
|
|
if( ZD_CMAKE_COMPILER_IS_GNUCXX_COMPATIBLE )
|
|
set( PROFILE 0 CACHE BOOL "Enable profiling with gprof for Debug and RelWithDebInfo build types." )
|
|
endif()
|
|
|
|
option( NO_OPENAL "Disable OpenAL sound support" OFF )
|
|
|
|
find_package( BZip2 )
|
|
find_package( JPEG )
|
|
find_package( ZLIB )
|
|
|
|
include( TargetArch )
|
|
|
|
target_architecture(ZDOOM_TARGET_ARCH)
|
|
|
|
if( ${ZDOOM_TARGET_ARCH} MATCHES "x86_64" )
|
|
set( HAVE_VM_JIT ON )
|
|
option (HAVE_VULKAN "Enable Vulkan support" ON)
|
|
endif()
|
|
|
|
# no, we're not using external asmjit for now, we made too many modifications to our's.
|
|
# if the asmjit author uses our changes then we'll update this.
|
|
|
|
#if( ${HAVE_VM_JIT} )
|
|
# find_package( asmjit )
|
|
#endif()
|
|
|
|
# GME
|
|
#find_path( GME_INCLUDE_DIR gme/gme.h )
|
|
#find_library( GME_LIBRARIES gme )
|
|
#mark_as_advanced( GME_INCLUDE_DIR GME_LIBRARIES )
|
|
#FIND_PACKAGE_HANDLE_STANDARD_ARGS( GME
|
|
# REQUIRED_VARS GME_LIBRARIES GME_INCLUDE_DIR
|
|
#)
|
|
|
|
if( MSVC )
|
|
# Eliminate unreferenced functions and data
|
|
# Perform identical COMDAT folding
|
|
set( REL_LINKER_FLAGS "/opt:ref /opt:icf /nodefaultlib:msvcrt /TSAWARE /LARGEADDRESSAWARE" )
|
|
|
|
# String pooling
|
|
# Function-level linking
|
|
# Disable run-time type information
|
|
if ( HAVE_VULKAN )
|
|
set( ALL_C_FLAGS "/GF /Gy /GR- /permissive- /DHAVE_VULKAN" )
|
|
else()
|
|
set( ALL_C_FLAGS "/GF /Gy /GR- /permissive-" )
|
|
endif()
|
|
|
|
# Use SSE 2 as minimum always as the true color drawers needs it for __vectorcall
|
|
#set( ALL_C_FLAGS "${ALL_C_FLAGS} /arch:SSE2") # This is already the default
|
|
|
|
|
|
# if( CMAKE_SIZEOF_VOID_P MATCHES "4")
|
|
# # SSE2 option (to allow x87 in 32 bit and disallow extended feature sets which have not yet been checked for precision)
|
|
# option (ZDOOM_USE_SSE2 "Use SSE2 instruction set")
|
|
# if (ZDOOM_USE_SSE2)
|
|
# set( ALL_C_FLAGS "${ALL_C_FLAGS} /arch:SSE2")
|
|
# else ()
|
|
# if (MSVC_VERSION GREATER 1699)
|
|
# # On Visual C++ 2012 and later SSE2 is the default, so we need to switch it off explicitly
|
|
# set( ALL_C_FLAGS "${ALL_C_FLAGS} /arch:IA32")
|
|
# endif ()
|
|
# endif ()
|
|
# else()
|
|
# set( ALL_C_FLAGS "${ALL_C_FLAGS} /arch:SSE2")
|
|
# endif()
|
|
|
|
# Avoid CRT DLL dependancies in release builds, optionally generate assembly output for checking crash locations.
|
|
option( ZDOOM_GENERATE_ASM "Generate assembly output." OFF )
|
|
if( ZDOOM_GENERATE_ASM )
|
|
set( REL_C_FLAGS "/MT /Oy /Oi /FAcs /GS-" )
|
|
else()
|
|
set( REL_C_FLAGS "/MT /Oy /Oi /GS-" )
|
|
endif()
|
|
|
|
|
|
# Debug allocations in debug builds
|
|
set( DEB_C_FLAGS "/D _CRTDBG_MAP_ALLOC /MTd" )
|
|
|
|
# Disable warnings for unsecure CRT functions from VC8+
|
|
set( ALL_C_FLAGS "${ALL_C_FLAGS} /wd4996 /DUNICODE /D_UNICODE /D_WIN32_WINNT=0x0600" )
|
|
|
|
# The CMake configurations set /GR and /MD by default, which conflict with our settings.
|
|
string(REPLACE "/MD " " " CMAKE_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELEASE} )
|
|
string(REPLACE "/MD " " " CMAKE_CXX_FLAGS_MINSIZEREL ${CMAKE_CXX_FLAGS_MINSIZEREL} )
|
|
string(REPLACE "/MD " " " CMAKE_CXX_FLAGS_RELWITHDEBINFO ${CMAKE_CXX_FLAGS_RELWITHDEBINFO} )
|
|
string(REPLACE "/Ob1 " "/Ob2 " CMAKE_CXX_FLAGS_RELWITHDEBINFO ${CMAKE_CXX_FLAGS_RELWITHDEBINFO} )
|
|
string(REPLACE "/MDd " " " CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG} )
|
|
string(REPLACE "/MD " " " CMAKE_C_FLAGS_RELEASE ${CMAKE_C_FLAGS_RELEASE} )
|
|
string(REPLACE "/MD " " " CMAKE_C_FLAGS_MINSIZEREL ${CMAKE_C_FLAGS_MINSIZEREL} )
|
|
string(REPLACE "/MD " " " CMAKE_C_FLAGS_RELWITHDEBINFO ${CMAKE_C_FLAGS_RELWITHDEBINFO} )
|
|
string(REPLACE "/MDd " " " CMAKE_C_FLAGS_DEBUG ${CMAKE_C_FLAGS_DEBUG} )
|
|
string(REPLACE " /GR" " " CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} )
|
|
else()
|
|
set( REL_LINKER_FLAGS "" )
|
|
if ( HAVE_VULKAN )
|
|
set( ALL_C_FLAGS "-ffp-contract=off -DHAVE_VULKAN" )
|
|
else()
|
|
set( ALL_C_FLAGS "-ffp-contract=off" )
|
|
endif()
|
|
|
|
if ( UNIX )
|
|
include(CheckSymbolExists)
|
|
check_symbol_exists( "fts_set" "fts.h" HAVE_FTS )
|
|
if ( NOT HAVE_FTS )
|
|
include ( FindPkgConfig )
|
|
pkg_check_modules( MUSL_FTS musl-fts )
|
|
if ( MUSL_FTS_FOUND )
|
|
set ( ALL_C_FLAGS "${ALL_C_FLAGS} ${MUSL_FTS_LDFLAGS}" )
|
|
else ( MUSL_FTS_FOUND )
|
|
message (ERROR "fts_* functions not found in the system" )
|
|
endif ( MUSL_FTS_FOUND )
|
|
endif ( NOT HAVE_FTS )
|
|
endif ( UNIX )
|
|
|
|
set( REL_C_FLAGS "" )
|
|
set( DEB_C_FLAGS "" )
|
|
|
|
|
|
if( APPLE )
|
|
if( CMAKE_CXX_COMPILER_ID STREQUAL "Clang" )
|
|
# With standard Apple tools -stdlib=libc++ needs to be specified in order to get
|
|
# C++11 support using SDKs 10.7 and 10.8.
|
|
set( CMAKE_CXX_FLAGS "-stdlib=libc++ ${CMAKE_CXX_FLAGS}" )
|
|
set( CMAKE_EXE_LINKER_FLAGS "-stdlib=libc++ ${CMAKE_EXE_LINKER_FLAGS}" )
|
|
elseif( CMAKE_CXX_COMPILER_ID STREQUAL "GNU" )
|
|
# If we're compiling with a custom GCC on the Mac (which we know since g++-4.2 doesn't support C++11) statically link libgcc.
|
|
set( ALL_C_FLAGS "-static-libgcc" )
|
|
endif()
|
|
elseif( NOT MINGW )
|
|
# Generic GCC/Clang requires position independent executable to be enabled explicitly
|
|
set( ALL_C_FLAGS "${ALL_C_FLAGS} -fPIE" )
|
|
set( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pie" )
|
|
endif( APPLE )
|
|
endif()
|
|
|
|
set( CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${REL_LINKER_FLAGS}" )
|
|
set( CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL} ${REL_LINKER_FLAGS}" )
|
|
set( CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} ${REL_LINKER_FLAGS}" )
|
|
|
|
set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ALL_C_FLAGS}" )
|
|
set( CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${REL_C_FLAGS}" )
|
|
set( CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL} ${REL_C_FLAGS}" )
|
|
set( CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} ${REL_C_FLAGS}" )
|
|
set( CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${DEB_C_FLAGS} -D_DEBUG" )
|
|
|
|
set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ALL_C_FLAGS}" )
|
|
set( CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${REL_C_FLAGS}" )
|
|
set( CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} ${REL_C_FLAGS}" )
|
|
set( CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${REL_C_FLAGS}" )
|
|
set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${DEB_C_FLAGS} -D_DEBUG" )
|
|
|
|
option(FORCE_INTERNAL_ZLIB "Use internal zlib")
|
|
option(FORCE_INTERNAL_JPEG "Use internal jpeg")
|
|
option(FORCE_INTERNAL_BZIP2 "Use internal bzip2")
|
|
option(FORCE_INTERNAL_GME "Use internal gme" ON)
|
|
mark_as_advanced( FORCE_INTERNAL_GME )
|
|
option(FORCE_INTERNAL_ASMJIT "Use internal asmjit" ON)
|
|
mark_as_advanced( FORCE_INTERNAL_ASMJIT )
|
|
|
|
if (HAVE_VULKAN)
|
|
add_subdirectory( libraries/glslang/glslang)
|
|
add_subdirectory( libraries/glslang/spirv )
|
|
add_subdirectory( libraries/glslang/OGLCompilersDLL )
|
|
endif()
|
|
|
|
# Fast math flags, required by some subprojects
|
|
set( ZD_FASTMATH_FLAG "" )
|
|
if( ZD_CMAKE_COMPILER_IS_GNUCXX_COMPATIBLE )
|
|
set( ZD_FASTMATH_FLAG "-ffast-math -ffp-contract=fast" )
|
|
elseif( MSVC )
|
|
set( ZD_FASTMATH_FLAG "/fp:fast" )
|
|
endif()
|
|
|
|
if( ZLIB_FOUND AND NOT FORCE_INTERNAL_ZLIB )
|
|
message( STATUS "Using system zlib, includes found at ${ZLIB_INCLUDE_DIR}" )
|
|
else()
|
|
message( STATUS "Using internal zlib" )
|
|
set( SKIP_INSTALL_ALL TRUE ) # Avoid installing zlib alongside zdoom
|
|
add_subdirectory( libraries/zlib )
|
|
set( ZLIB_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/libraries/zlib )
|
|
set( ZLIB_LIBRARIES z )
|
|
set( ZLIB_LIBRARY z )
|
|
endif()
|
|
|
|
if( HAVE_VM_JIT AND UNIX )
|
|
check_symbol_exists( "backtrace" "execinfo.h" HAVE_BACKTRACE )
|
|
if( NOT HAVE_BACKTRACE )
|
|
set( CMAKE_REQUIRED_FLAGS "-lexecinfo" )
|
|
check_symbol_exists( "backtrace" "execinfo.h" HAVE_LIBEXECINFO )
|
|
if( HAVE_LIBEXECINFO )
|
|
set( ALL_C_FLAGS "${ALL_C_FLAGS} -lexecinfo" )
|
|
else( HAVE_LIBEXECINFO )
|
|
set( HAVE_VM_JIT NO )
|
|
endif( HAVE_LIBEXECINFO )
|
|
endif( NOT HAVE_BACKTRACE )
|
|
endif( HAVE_VM_JIT AND UNIX )
|
|
|
|
if( ${HAVE_VM_JIT} )
|
|
if( ASMJIT_FOUND AND NOT FORCE_INTERNAL_ASMJIT )
|
|
message( STATUS "Using system asmjit, includes found at ${ASMJIT_INCLUDE_DIR}" )
|
|
else()
|
|
message( STATUS "Using internal asmjit" )
|
|
set( SKIP_INSTALL_ALL TRUE ) # Avoid installing asmjit alongside zdoom
|
|
add_subdirectory( libraries/asmjit )
|
|
set( ASMJIT_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/libraries/asmjit )
|
|
set( ASMJIT_LIBRARIES asmjit )
|
|
set( ASMJIT_LIBRARY asmjit )
|
|
endif()
|
|
endif()
|
|
|
|
if( JPEG_FOUND AND NOT FORCE_INTERNAL_JPEG )
|
|
message( STATUS "Using system jpeg library, includes found at ${JPEG_INCLUDE_DIR}" )
|
|
else()
|
|
message( STATUS "Using internal jpeg library" )
|
|
add_subdirectory( libraries/jpeg )
|
|
set( JPEG_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/libraries/jpeg )
|
|
set( JPEG_LIBRARIES jpeg )
|
|
set( JPEG_LIBRARY jpeg )
|
|
endif()
|
|
|
|
if( BZIP2_FOUND AND NOT FORCE_INTERNAL_BZIP2 )
|
|
message( STATUS "Using system bzip2 library, includes found at ${BZIP2_INCLUDE_DIR}" )
|
|
else()
|
|
message( STATUS "Using internal bzip2 library" )
|
|
add_subdirectory( libraries/bzip2 )
|
|
set( BZIP2_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libraries/bzip2" )
|
|
set( BZIP2_LIBRARIES bz2 )
|
|
set( BZIP2_LIBRARY bz2 )
|
|
endif()
|
|
|
|
if( GME_FOUND AND NOT FORCE_INTERNAL_GME )
|
|
message( STATUS "Using system gme library, includes found at ${GME_INCLUDE_DIR}" )
|
|
else()
|
|
message( STATUS "Using internal gme library" )
|
|
# Use MAME as it's balanced emulator: well-accurate, but doesn't eats lot of CPU
|
|
# Nuked OPN2 is very accurate emulator, but it eats too much CPU for the workflow
|
|
set( GME_YM2612_EMU "MAME" )
|
|
add_subdirectory( libraries/game-music-emu )
|
|
set( GME_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libraries/game-music-emu" )
|
|
set( GME_LIBRARIES gme )
|
|
endif()
|
|
|
|
set( LZMA_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libraries/lzma/C" )
|
|
set( ADL_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libraries/adlmidi" )
|
|
set( OPN_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libraries/opnmidi" )
|
|
set( TIMIDITYPP_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libraries/timidityplus" )
|
|
set( TIMIDITY_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libraries/timidity" )
|
|
set( WILDMIDI_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libraries/wildmidi" )
|
|
set( OPLSYNTH_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libraries/oplsynth" )
|
|
set( ZMUSIC_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libraries/zmusic" )
|
|
|
|
if( NOT CMAKE_CROSSCOMPILING )
|
|
if( NOT CROSS_EXPORTS )
|
|
set( CROSS_EXPORTS "" )
|
|
endif()
|
|
endif()
|
|
|
|
# Install the entire docs directory in the distributed zip package
|
|
if( WIN32 )
|
|
set( INSTALL_DOCS_PATH docs CACHE STRING "Directory where the documentation will be placed during install." )
|
|
else()
|
|
set( INSTALL_DOCS_PATH share/doc/${ZDOOM_EXE_NAME} CACHE STRING "Directory where the zdoom documentation will be placed during install." )
|
|
endif()
|
|
install(DIRECTORY docs/
|
|
DESTINATION ${INSTALL_DOCS_PATH}
|
|
COMPONENT "Documentation")
|
|
|
|
add_subdirectory( libraries/lzma )
|
|
add_subdirectory( tools )
|
|
add_subdirectory( libraries/dumb )
|
|
add_subdirectory( libraries/gdtoa )
|
|
add_subdirectory( libraries/adlmidi )
|
|
add_subdirectory( libraries/opnmidi )
|
|
add_subdirectory( libraries/timidity )
|
|
add_subdirectory( libraries/timidityplus )
|
|
add_subdirectory( libraries/wildmidi )
|
|
add_subdirectory( libraries/oplsynth )
|
|
add_subdirectory( libraries/zmusic )
|
|
add_subdirectory( wadsrc )
|
|
add_subdirectory( wadsrc_bm )
|
|
add_subdirectory( wadsrc_lights )
|
|
add_subdirectory( wadsrc_extra )
|
|
add_subdirectory( src )
|
|
|
|
if( NOT CMAKE_CROSSCOMPILING )
|
|
export(TARGETS ${CROSS_EXPORTS} FILE "${CMAKE_BINARY_DIR}/ImportExecutables.cmake" )
|
|
endif()
|