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