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