CMakeLists.txt

   1 cmake_minimum_required(VERSION 3.0)
   2 project(alure)
   3
   4 IF(COMMAND CMAKE_POLICY)
   5     CMAKE_POLICY(SET CMP0003 NEW)
   6     CMAKE_POLICY(SET CMP0005 NEW)
   7     IF(POLICY CMP0042)
   8         CMAKE_POLICY(SET CMP0042 NEW)
   9     ENDIF(POLICY CMP0042)
  10 ENDIF(COMMAND CMAKE_POLICY)
  11
  12 set(CMAKE_MODULE_PATH "${alure_SOURCE_DIR}/cmake")
  13
  14 include(CheckCXXCompilerFlag)
  15 include(CheckCXXSourceCompiles)
  16 include(GNUInstallDirs)
  17
  18 find_package(OpenAL REQUIRED)
  19 find_package(Threads)
  20
  21 set(CXX_FLAGS )
  22
  23 option(ALURE_DISABLE_RTTI "Disable run-time type information" OFF)
  24 if(MSVC)
  25     if(ALURE_DISABLE_RTTI)
  26         check_cxx_compiler_flag(/GR- HAVE_GRX_SWITCH)
  27         if(HAVE_GRX_SWITCH)
  28             set(CXX_FLAGS ${CXX_FLAGS} /GR-)
  29         endif()
  30     endif()
  31 else()
  32     check_cxx_compiler_flag(-std=c++11 HAVE_STD_CXX11)
  33     if(HAVE_STD_CXX11)
  34         set(CXX_FLAGS -std=c++11 ${CXX_FLAGS})
  35     endif()
  36
  37     check_cxx_compiler_flag(-Wall HAVE_WALL_SWITCH)
  38     if(HAVE_WALL_SWITCH)
  39         set(CXX_FLAGS ${CXX_FLAGS} -Wall)
  40     endif()
  41     check_cxx_compiler_flag(-Wextra HAVE_WEXTRA_SWITCH)
  42     if(HAVE_WEXTRA_SWITCH)
  43         set(CXX_FLAGS ${CXX_FLAGS} -Wextra)
  44     endif()
  45
  46     if(ALURE_DISABLE_RTTI)
  47         check_cxx_compiler_flag(-fno-rtti HAVE_NO_RTTI_SWITCH)
  48         if(HAVE_NO_RTTI_SWITCH)
  49             set(CXX_FLAGS ${CXX_FLAGS} -fno-rtti)
  50         endif()
  51     endif()
  52 endif()
  53
  54 unset(EXPORT_DECL)
  55 set(VISIBILITY_FLAGS )
  56 if(WIN32)
  57     set(EXPORT_DECL "__declspec(dllexport)")
  58 else()
  59     set(OLD_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
  60     # Yes GCC, really don't accept visibility modes you don't support
  61     set(CMAKE_REQUIRED_FLAGS "${OLD_REQUIRED_FLAGS} -Wattributes -Werror")
  62
  63     check_cxx_source_compiles("int foo() __attribute__((visibility(\"default\")));
  64                                 int main() {return 0;}" HAVE_GCC_DEFAULT_VISIBILITY)
  65     if(HAVE_GCC_DEFAULT_VISIBILITY)
  66         set(EXPORT_DECL "__attribute__((visibility(\"default\")))")
  67     endif()
  68
  69     if(HAVE_GCC_DEFAULT_VISIBILITY)
  70         check_cxx_compiler_flag(-fvisibility=hidden HAVE_VISIBILITY_HIDDEN_SWITCH)
  71         if(HAVE_VISIBILITY_HIDDEN_SWITCH)
  72             set(VISIBILITY_FLAGS ${VISIBILITY_FLAGS} -fvisibility=hidden)
  73         endif()
  74     endif()
  75
  76     set(CMAKE_REQUIRED_FLAGS "${OLD_REQUIRED_FLAGS}")
  77 endif()
  78
  79
  80 set(LINKER_OPTS )
  81 if(MSVC)
  82     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH:NO")
  83     set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SAFESEH:NO")
  84     set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /SAFESEH:NO")
  85 else()
  86     option(ALURE_STATIC_GCCRT "Static-link libgcc and libstdc++ runtimes" OFF)
  87     if(ALURE_STATIC_GCCRT)
  88         set(OLD_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
  89         set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} -static-libgcc -static-libstdc++)
  90         check_cxx_source_compiles(
  91 "#include <vector>
  92 int main()
  93 {
  94     std::vector<int> test;
  95     return test.size();
  96 }"
  97             HAVE_STATIC_GCCRT_SWITCHES
  98         )
  99         if(HAVE_STATIC_GCCRT_SWITCHES)
 100             set(LINKER_OPTS ${LINKER_OPTS} -static-libgcc -static-libstdc++)
 101         endif()
 102         set(CMAKE_REQUIRED_LIBRARIES ${OLD_REQUIRED_LIBRARIES})
 103         unset(OLD_REQUIRED_LIBRARIES)
 104     endif()
 105 endif()
 106
 107
 108 set(alure_srcs src/devicemanager.cpp
 109                src/device.cpp
 110                src/context.cpp
 111                src/buffer.cpp
 112                src/source.cpp
 113                src/sourcegroup.cpp
 114                src/auxeffectslot.cpp
 115                src/effect.cpp
 116 )
 117 set(alure_libs ${OPENAL_LIBRARY})
 118 set(decoder_incls )
 119
 120 unset(HAVE_WAVE)
 121 unset(HAVE_VORBISFILE)
 122 unset(HAVE_FLAC)
 123 unset(HAVE_OPUSFILE)
 124 unset(HAVE_LIBSNDFILE)
 125 unset(HAVE_MPG123)
 126 unset(HAVE_MINIMP3)
 127
 128 option(ALURE_BUILD_SHARED "Build shared library" ON)
 129 option(ALURE_BUILD_STATIC "Build static library" ON)
 130
 131 if(NOT ALURE_BUILD_SHARED AND NOT ALURE_BUILD_STATIC)
 132     message(FATAL_ERROR "Neither shared or static libraries are enabled!")
 133 endif()
 134
 135 option(ALURE_ENABLE_WAVE    "Enables the built-in wave file decoder"     ON)
 136 option(ALURE_ENABLE_VORBIS  "Enables the built-in libvorbisfile decoder" ON)
 137 option(ALURE_ENABLE_FLAC    "Enables the built-in FLAC decoder"          ON)
 138 option(ALURE_ENABLE_OPUS    "Enables the built-in libopusfile decoder"   ON)
 139 option(ALURE_ENABLE_SNDFILE "Enables the built-in libsndfile decoder"    ON)
 140 option(ALURE_ENABLE_MPG123  "Enables the built-in libmpg123 decoder"     ON)
 141 option(ALURE_ENABLE_MINIMP3 "Enables the built-in MINIMP3 decoder"       ON)
 142
 143 if(ALURE_ENABLE_WAVE)
 144     set(alure_srcs ${alure_srcs} src/decoders/wave.cpp)
 145     set(HAVE_WAVE 1)
 146 endif()
 147
 148 find_package(Ogg)
 149 if(OGG_FOUND)
 150     set(decoder_incls ${decoder_incls} ${OGG_INCLUDE_DIRS})
 151     find_package(Vorbis)
 152     if(VORBIS_FOUND AND ALURE_ENABLE_VORBIS)
 153         set(decoder_incls ${decoder_incls} ${VORBIS_INCLUDE_DIRS})
 154         set(alure_libs ${alure_libs} ${VORBIS_LIBRARIES})
 155         set(alure_srcs ${alure_srcs} src/decoders/vorbisfile.cpp)
 156         set(HAVE_VORBISFILE 1)
 157     endif()
 158
 159     find_package(Opus)
 160     if(OPUS_FOUND AND ALURE_ENABLE_OPUS)
 161         set(decoder_incls ${decoder_incls} ${OPUS_INCLUDE_DIRS})
 162         set(alure_libs ${alure_libs} ${OPUS_LIBRARIES})
 163         set(alure_srcs ${alure_srcs} src/decoders/opusfile.cpp)
 164         set(HAVE_OPUSFILE 1)
 165     endif()
 166     set(alure_libs ${alure_libs} ${OGG_LIBRARIES})
 167 endif()
 168
 169 if(ALURE_ENABLE_FLAC)
 170     set(alure_srcs ${alure_srcs} src/decoders/dr_flac.h src/decoders/flac.cpp)
 171     set(HAVE_FLAC 1)
 172 endif()
 173
 174 find_package(SndFile)
 175 if(SNDFILE_FOUND AND ALURE_ENABLE_SNDFILE)
 176     set(decoder_incls ${decoder_incls} ${SNDFILE_INCLUDE_DIRS})
 177     set(alure_libs ${alure_libs} ${SNDFILE_LIBRARIES})
 178     set(alure_srcs ${alure_srcs} src/decoders/sndfile.cpp)
 179     set(HAVE_LIBSNDFILE 1)
 180 endif()
 181
 182 find_package(MPG123)
 183 if(MPG123_FOUND AND ALURE_ENABLE_MPG123)
 184     set(decoder_incls ${decoder_incls} ${MPG123_INCLUDE_DIRS})
 185     set(alure_libs ${alure_libs} ${MPG123_LIBRARIES})
 186     set(alure_srcs ${alure_srcs} src/decoders/mpg123.cpp)
 187     set(HAVE_MPG123 1)
 188 endif()
 189
 190 if(ALURE_ENABLE_MINIMP3)
 191     set(alure_srcs ${alure_srcs} src/decoders/minimp3.h src/decoders/mp3.hpp src/decoders/mp3.cpp)
 192     set(HAVE_MINIMP3 1)
 193 endif()
 194
 195
 196 CONFIGURE_FILE(
 197     "${alure_SOURCE_DIR}/config.h.in"
 198     "${alure_BINARY_DIR}/config.h")
 199
 200
 201 unset(TARGET_NAMES)
 202 unset(MAIN_TARGET)
 203
 204 if(ALURE_BUILD_SHARED)
 205     add_library(alure2 SHARED ${alure_srcs})
 206     if(EXPORT_DECL)
 207         target_compile_definitions(alure2 PRIVATE ALURE_API=${EXPORT_DECL} ALURE_TEMPLATE=template
 208                                                   NOMINMAX)
 209     endif()
 210     target_include_directories(alure2
 211         PUBLIC $<BUILD_INTERFACE:${alure_SOURCE_DIR}/include/AL> ${OPENAL_INCLUDE_DIR}
 212         PRIVATE ${alure_SOURCE_DIR}/include ${alure_SOURCE_DIR}/src ${alure_BINARY_DIR}
 213                 ${decoder_incls}
 214     )
 215     target_compile_options(alure2 PRIVATE ${CXX_FLAGS} ${VISIBILITY_FLAGS})
 216     target_link_libraries(alure2 PUBLIC ${alure_libs} PRIVATE Threads::Threads ${LINKER_OPTS})
 217
 218     set(TARGET_NAMES ${TARGET_NAMES} alure2)
 219     if(NOT MAIN_TARGET)
 220         set(MAIN_TARGET alure2)
 221     endif()
 222 endif()
 223
 224 if(ALURE_BUILD_STATIC)
 225     add_library(alure2_s STATIC ${alure_srcs})
 226     target_compile_definitions(alure2_s PUBLIC ALURE_STATIC_LIB PRIVATE NOMINMAX)
 227     target_include_directories(alure2_s
 228         PUBLIC $<BUILD_INTERFACE:${alure_SOURCE_DIR}/include/AL> ${OPENAL_INCLUDE_DIR}
 229         PRIVATE ${alure_SOURCE_DIR}/include ${alure_SOURCE_DIR}/src ${alure_BINARY_DIR}
 230                 ${decoder_incls}
 231     )
 232     target_compile_options(alure2_s PRIVATE ${CXX_FLAGS} ${VISIBILITY_FLAGS})
 233     target_link_libraries(alure2_s PUBLIC ${alure_libs} PRIVATE Threads::Threads)
 234
 235     set(TARGET_NAMES ${TARGET_NAMES} alure2_s)
 236     if(NOT MAIN_TARGET)
 237         set(MAIN_TARGET alure2_s)
 238     endif()
 239 endif()
 240
 241 install(TARGETS ${TARGET_NAMES} EXPORT alure2
 242     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
 243     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
 244     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
 245     INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} ${CMAKE_INSTALL_INCLUDEDIR}/AL
 246 )
 247 export(
 248     TARGETS ${TARGET_NAMES}
 249     NAMESPACE Alure2::
 250     FILE Alure2Config.cmake
 251 )
 252 install(
 253     EXPORT alure2
 254     DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Alure2
 255     NAMESPACE Alure2::
 256     FILE Alure2Config.cmake
 257 )
 258 install(FILES
 259     include/AL/alure2.h
 260     include/AL/alure2-aliases.h
 261     include/AL/alure2-typeviews.h
 262     include/AL/alure2-alext.h
 263     include/AL/efx.h
 264     include/AL/efx-presets.h
 265     DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/AL
 266 )
 267
 268
 269 option(ALURE_BUILD_EXAMPLES "Build example programs" ON)
 270 if(ALURE_BUILD_EXAMPLES)
 271     add_executable(alure-enum examples/alure-enum.cpp)
 272     target_compile_options(alure-enum PRIVATE ${CXX_FLAGS})
 273     target_link_libraries(alure-enum PRIVATE ${MAIN_TARGET} ${LINKER_OPTS})
 274
 275     add_executable(alure-play examples/alure-play.cpp)
 276     target_compile_options(alure-play PRIVATE ${CXX_FLAGS})
 277     target_link_libraries(alure-play PRIVATE ${MAIN_TARGET} ${LINKER_OPTS})
 278
 279     add_executable(alure-stream examples/alure-stream.cpp)
 280     target_compile_options(alure-stream PRIVATE ${CXX_FLAGS})
 281     target_link_libraries(alure-stream PRIVATE ${MAIN_TARGET} ${LINKER_OPTS})
 282
 283     add_executable(alure-reverb examples/alure-reverb.cpp)
 284     target_compile_options(alure-reverb PRIVATE ${CXX_FLAGS})
 285     target_link_libraries(alure-reverb PRIVATE ${MAIN_TARGET} ${LINKER_OPTS})
 286
 287     add_executable(alure-hrtf examples/alure-hrtf.cpp)
 288     target_compile_options(alure-hrtf PRIVATE ${CXX_FLAGS})
 289     target_link_libraries(alure-hrtf PRIVATE ${MAIN_TARGET} ${LINKER_OPTS})
 290
 291     find_package(PhysFS)
 292     if(PHYSFS_FOUND)
 293         add_executable(alure-physfs examples/alure-physfs.cpp)
 294         target_include_directories(alure-physfs PRIVATE ${PHYSFS_INCLUDE_DIR})
 295         target_compile_options(alure-physfs PRIVATE ${CXX_FLAGS})
 296         target_link_libraries(alure-physfs PRIVATE ${MAIN_TARGET} ${PHYSFS_LIBRARY} ${LINKER_OPTS})
 297     endif()
 298
 299     find_package(DUMB)
 300     if(DUMB_FOUND)
 301         add_executable(alure-dumb examples/alure-dumb.cpp)
 302         target_include_directories(alure-dumb PRIVATE ${DUMB_INCLUDE_DIRS})
 303         target_compile_options(alure-dumb PRIVATE ${CXX_FLAGS})
 304         target_link_libraries(alure-dumb PRIVATE ${MAIN_TARGET} ${DUMB_LIBRARIES} ${LINKER_OPTS})
 305     endif()
 306 endif()