CMakeLists.txt

   1 cmake_minimum_required(VERSION 3.0)
   2 if(COMMAND cmake_policy)
   3   cmake_policy(SET CMP0003 NEW)
   4   cmake_policy(SET CMP0026 NEW)
   5 endif(COMMAND cmake_policy)
   6
   7
   8 project(k8vavoom)
   9 include(CheckIncludeFile)
  10
  11
  12 option(WITH_SDL2       "Use SDL2 library" ON)
  13 option(WITH_OPENGL     "Use OpenGL library" ON)
  14 option(WITH_MIMALLOC   "Use mi-malloc memory allocator" ON)
  15 option(WITH_MOJOAL     "Enable MojoAL OpenAL impletentation over SDL Mixer" OFF)
  16 option(WITH_SYS_OPUS   "Enable Opus support via system libopus and libopusfile (if off, internal libraries will be used)" OFF)
  17 option(WITH_SYS_VORBIS "Enable Vorbis support via libvorbis (if off, stb_vorbis will be used)" OFF)
  18 option(WITH_LIBMAD     "Enable MP3 support via libmad (if off, dr_mp3 will be used)" OFF)
  19 option(WITH_SYS_FLAC   "Enable FLAC support via libflac (if off, dr_flac will be used)" OFF)
  20 option(WITH_FLUID      "Enable FluidSynth support" ON)
  21 option(WITH_LIBJIT     "Enable LibJIT support in VavoomC compiler (don't use!)" OFF)
  22 option(WITH_XRANDR     "Enable XRandR support for DPI detection (don't use!)" OFF)
  23 option(WITH_WNT64      "Enable 64-bit build" OFF)
  24 if(WIN32)
  25 option(WITH_SYS_FLUID  "Use system FluidSynth library" OFF)
  26 else(WIN32)
  27 option(WITH_SYS_FLUID  "Use system FluidSynth library" ON)
  28 endif(WIN32)
  29
  30 if(WITH_OPENGL)
  31   option(WITH_GLES "Use hacks for GL4ES (experimental)" OFF)
  32   option(WITH_GL4ES "Use GL4ES directly (experimental)" OFF)
  33   if(WITH_GL4ES)
  34     if(WITH_GLES)
  35       set(WITH_GL4ES ON)
  36     endif()
  37     if(GL4ES_LIBRARY_DIR STREQUAL "")
  38       message(FATAL_ERROR "GL4ES_LIBRARY_DIR not setted")
  39     endif()
  40     if(GL4ES_INCLUDE_DIR STREQUAL "")
  41       message(FATAL_ERROR "GL4ES_INCLUDE_DIR not setted")
  42     endif()
  43   endif()
  44 endif()
  45
  46 option(WITH_STB_JPEG   "Use stb_image to load jpegs" ON)
  47 option(WITH_SYS_LIBJPG "Use system libjpg (if stb_image is off)" ON)
  48
  49 option(WITH_OLD_CPU "Use pIV CPU instruction set" OFF)
  50
  51 #option(WITH_RPATH "Use -rpath" OFF)
  52 set(RPATH_VALUE "" CACHE STRING "-rpath linker option value")
  53
  54 # default is SSE2
  55 option(WITH_SSE3 "Use SSE3 instruction set (may not compile)" OFF)
  56 option(WITH_SSE4 "Use SSE4 instruction set (may not compile)" OFF)
  57 option(WITH_SSE41 "Use SSE4.1 instruction set (may not compile)" OFF)
  58 option(WITH_SSE42 "Use SSE4.2 instruction set (may not compile)" OFF)
  59 option(NO_SSE "Disable all SSE instructions" OFF)
  60 option(INSANE_AVX "Use AVX2 instruction set (don't do this, it won't give you any noticeable speedup and may be broken)" OFF)
  61
  62 # do not tempt poor things
  63 if("$ENV{USER}" STREQUAL "ketmar")
  64   option(WITH_GCC_ANAL "Turn on gcc10 static analyzer" OFF)
  65   option(WITH_GCC_IDIOCITY "Turn on gcc idiotic pseudo-warnings (don't care, won't fix)" OFF)
  66 else()
  67   set(WITH_GCC_ANAL OFF)
  68   set(WITH_GCC_IDIOCITY OFF)
  69 endif()
  70
  71 option(WITH_GLAD "Use supplied GLAD for GL bindings" OFF)
  72 option(NO_PTHREAD "Disable pthreads, use C11 threads instead" OFF)
  73 option(NO_MEMRCHR "Disable usage of memrchr()" OFF)
  74 option(NO_RAWTTY "Disable raw TTY control" OFF)
  75
  76 option(WITH_STRTODEX "Use internal strtod implementation to parse floats" ON)
  77
  78 # do not tempt poor things
  79 if("$ENV{USER}" STREQUAL "ketmar")
  80   option(DEBUG_FPU_CHECKS "Use FPU and turn on some checks (GNU/Linux only)" OFF)
  81   option(UNSTABLE_OPTIMISATIONS "Use -O3 (WARNING! DON'T DO THAT! NEVER!)" OFF)
  82 else()
  83   set(DEBUG_FPU_CHECKS OFF)
  84   set(UNSTABLE_OPTIMISATIONS OFF)
  85 endif()
  86
  87 if(CMAKE_CROSSCOMPILING AND WIN32)
  88   option(SDL2_OVERRIDE "Some specific changes for custom-built SDL2 (do not turn on if you don't know what it is)" ON)
  89 else(CMAKE_CROSSCOMPILING AND WIN32)
  90   option(SDL2_OVERRIDE "Some specific changes for custom-built SDL2 (do not turn on if you don't know what it is)" OFF)
  91 endif(CMAKE_CROSSCOMPILING AND WIN32)
  92
  93 if(CMAKE_CROSSCOMPILING AND WIN32)
  94   #if(MINGW)
  95   option(WITH_WINE "Use wine to run built executables" ON)
  96   option(WITH_STATIC_OPENAL "Use special flags to link with static OpenAL" ON)
  97   #endif(MINGW)
  98   set(WITH_STRTODEX ON)
  99 endif(CMAKE_CROSSCOMPILING AND WIN32)
 100
 101 if(NSWITCH)
 102   option(WITH_NXLINK "Redirect standard output to NXLink" OFF)
 103   set(NO_SSE ON) # set it right away for proper logging and cflags
 104   set(WITH_MIMALLOC OFF)
 105 endif(NSWITCH)
 106
 107 option(FOSSIL_REPO_PATH "Local path to k8vavoom Fossil repository (leave empty if unsure)" OFF)
 108
 109
 110
 111 if(CYGWIN)
 112   set(WITH_MIMALLOC OFF)
 113 endif()
 114
 115 # perform some platform and compiler checks
 116 set(VV_STACK_REALIGN OFF)
 117 if(CMAKE_CROSSCOMPILING AND WIN32)
 118   # cross-compiling to shitdoze
 119   message(STATUS "Cross-compiling to shitdoze...")
 120 elseif(CMAKE_CROSSCOMPILING)
 121   # cross-compiling to something else, let's play safe
 122   message(STATUS "Turning off SSE and mi-malloc")
 123   set(NO_SSE ON)
 124   set(WITH_MIMALLOC OFF)
 125 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "(i[0-9]86|x86|X86|amd64|AMD64|x86_64)")
 126   # compiling to x86
 127   #if(CMAKE_SIZEOF_VOID_P EQUAL 8)
 128   #  set(OPUS_CPU_X64 1)
 129   #else()
 130   #  set(OPUS_CPU_X86 1)
 131   #endif()
 132   set(VV_STACK_REALIGN ON)
 133 #elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "(arm|aarch64)")
 134 #  set(OPUS_CPU_ARM 1)
 135 else()
 136   # compiling to something else, let's play safe
 137   add_definitions(-DVV_NOT_X86)
 138   message(STATUS "Turning off SSE and mi-malloc")
 139   set(NO_SSE ON)
 140   set(WITH_MIMALLOC OFF)
 141 endif()
 142
 143 set( RES_FLAGS -Fpe-i386 )
 144
 145 if (WITH_WNT64)
 146     message(STATUS "*** 64-bit builds are UNSUPPORTED ***")
 147     add_definitions(-DSTK_TIMET_FIX)
 148     set( RES_FLAGS -Fpe-x86-64 )
 149 endif ()
 150
 151 set(K8_UNFUCK_AS_GCC ON)
 152 set(K8_UNFUCK_AS_SHITLANG OFF)
 153 if(NOT CMAKE_COMPILER_IS_GNUCC)
 154   if (APPLE OR CMAKE_HOST_APPLE OR XCODE_VERSION)
 155     message(FATAL_ERROR "Apple platform is not supported.")
 156     return()
 157   endif(APPLE OR CMAKE_HOST_APPLE OR XCODE_VERSION)
 158
 159   if (MSVC OR MSVC80 OR MSVC_IDE)
 160     message(FATAL_ERROR "m$ compilers aren't supported. GTFO.")
 161     return()
 162   endif(MSVC OR MSVC80 OR MSVC_IDE)
 163
 164   message(WARNING "Only GNU C/C++ compilers are supported to build k8vavoom and tools!")
 165   message(WARNING "Your compiler is not GNU, please, don't report bugs.")
 166   set(K8_UNFUCK_AS_GCC OFF)
 167
 168   if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 169     message(WARNING "And, by the way. clang sux.")
 170     set(K8_UNFUCK_AS_SHITLANG ON)
 171   endif()
 172 endif(NOT CMAKE_COMPILER_IS_GNUCC)
 173
 174 option(ENABLE_CLIENT      "Build client executable" ON)
 175 option(ENABLE_SERVER      "Build dedicated server executable (don't do that!)" OFF)
 176 option(ENABLE_MASTER      "Build master server (no reason to build it)" OFF)
 177 option(ENABLE_QUERY_DEMO  "Build query demo (can be used to send rcon commands)" OFF)
 178 option(ENABLE_VCCRUN      "Build vccrun executable" OFF)
 179 option(ENABLE_MD2FIXER    "Build fixmd2 executable (you don't need it)" OFF)
 180
 181 option(ENABLE_VCCRUN_ONLY "Build ONLY vccrun" OFF)
 182 option(ENABLE_UTILS_ONLY "Build ONLY utils" OFF)
 183
 184 if(UNIX)
 185   option(ENABLE_WRAPPERS "Enable creation of wrapper scripts" ON)
 186 endif(UNIX)
 187
 188
 189 #  COMMAND git rev-parse --verify -q --short=16 HEAD
 190
 191 execute_process(
 192   COMMAND git rev-parse --verify -q HEAD
 193   WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
 194   OUTPUT_VARIABLE GIT_COMMIT_HASH
 195   ERROR_VARIABLE GIT_ERROR
 196   RESULT_VARIABLE GET_EXEC_RESULT
 197   OUTPUT_STRIP_TRAILING_WHITESPACE
 198 )
 199
 200 if(NOT ${GET_EXEC_RESULT} EQUAL 0)
 201   set(GIT_COMMIT_HASH "UNKNOWN")
 202 else()
 203   if(NOT ${GIT_ERROR} STREQUAL "")
 204     set(GIT_COMMIT_HASH "UNKNOWN")
 205   endif()
 206
 207   if(${GIT_COMMIT_HASH} STREQUAL "")
 208     set(GIT_COMMIT_HASH "UNKNOWN")
 209   endif()
 210 endif()
 211
 212 #message(STATUS "hash=" ${GIT_COMMIT_HASH})
 213 #message(STATUS "error=" ${GIT_ERROR})
 214
 215 #add_definitions("-DVV_GIT_COMMIT_HASH=${GIT_COMMIT_HASH}")
 216
 217
 218 if(ENABLE_UTILS_ONLY)
 219   set(ENABLE_CLIENT OFF)
 220   set(ENABLE_SERVER OFF)
 221   set(ENABLE_VCCRUN OFF)
 222   set(ENABLE_VCCRUN_ONLY OFF)
 223   set(WITH_LIBJIT OFF)
 224 elseif(ENABLE_VCCRUN_ONLY)
 225   #set(WITH_SYS_VORBIS OFF)
 226   #set(WITH_LIBMAD OFF)
 227   #set(WITH_SYS_FLAC OFF)
 228   #set(WITH_SYS_LIBJPG OFF)
 229   #set(WITH_SYS_ZLIB OFF)
 230   set(ENABLE_CLIENT OFF)
 231   set(ENABLE_SERVER OFF)
 232   set(ENABLE_MASTER OFF)
 233   set(ENABLE_QUERY_DEMO OFF)
 234   set(ENABLE_VCCRUN ON)
 235   set(ENABLE_MD2FIXER OFF)
 236
 237   if (NOT WITH_SYS_VORBIS OR NOT WITH_SYS_FLAC)
 238     message(SEND_ERROR "OpenAL, Vorbis and Flac are required")
 239     return()
 240   endif()
 241 else()
 242   if(NOT ENABLE_CLIENT)
 243     if(NOT ENABLE_SERVER)
 244       message(STATUS "Neither client, nor server was requested")
 245     else(NOT ENABLE_SERVER)
 246       message(STATUS "Server-only build, turning off SDL2, OpenGL and OpenAL")
 247     endif(NOT ENABLE_SERVER)
 248     set(WITH_SDL2 OFF)
 249     set(WITH_OPENGL OFF)
 250     set(WITH_GL4ES OFF)
 251     set(WITH_SYS_VORBIS OFF)
 252     set(WITH_SYS_OPUS OFF)
 253     set(WITH_LIBMAD OFF)
 254     set(WITH_SYS_FLAC OFF)
 255   endif(NOT ENABLE_CLIENT)
 256 endif()
 257
 258 if(NOT CMAKE_BUILD_TYPE)
 259   set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE)
 260 endif()
 261
 262 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++14")
 263
 264 if(NOT SDL2_OVERRIDE)
 265   check_include_file(SDL2/SDL.h HAVE_SDL2_SUBDIR)
 266   if(HAVE_SDL2_SUBDIR)
 267     #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -lSDL2main -lSDL2")
 268     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -lSDL2")
 269     add_definitions(-DVAVOOM_ARCH_LINUX_SPECIAL_SDL=1)
 270   endif(HAVE_SDL2_SUBDIR)
 271 endif(NOT SDL2_OVERRIDE)
 272
 273 if(WITH_WNT64)
 274   add_definitions(-DSDL_MAIN_HANDLED)
 275 endif(WITH_WNT64)
 276
 277
 278 set(UNFUCK_GCC_FLAGS "")
 279 set(UNFUCK_GXX_FLAGS "")
 280
 281 if(K8_UNFUCK_AS_SHITLANG)
 282  set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wno-ignored-optimization-argument")
 283  set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wno-unused-command-line-argument")
 284  set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wno-unknown-warning-option")
 285 endif(K8_UNFUCK_AS_SHITLANG)
 286
 287 if(K8_UNFUCK_AS_GCC)
 288   #set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Werror=format-security")
 289   set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fno-aggressive-loop-optimizations")
 290   set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fcommon") # fuck you, shitcc10
 291   if(WITH_GCC_ANAL)
 292     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fanalyzer")
 293   endif(WITH_GCC_ANAL)
 294 endif(K8_UNFUCK_AS_GCC)
 295
 296 # WARNING! do not touch anything here even if you think you know what you're doing.
 297 #          any change may and WILL break the code.
 298 set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fno-delete-null-pointer-checks")
 299 set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fno-strict-aliasing")
 300 set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fno-strict-overflow")
 301 set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fwrapv")
 302 if(K8_UNFUCK_AS_GCC)
 303   set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fno-diagnostics-show-caret")
 304 endif(K8_UNFUCK_AS_GCC)
 305 if(K8_UNFUCK_AS_GCC AND UNIX AND NOT CMAKE_CROSSCOMPILING)
 306   # i refuse to upgrade, lol
 307   if("$ENV{USER}" STREQUAL "ketmar")
 308     set(UNFUCK_GXX_FLAGS "${UNFUCK_GXX_FLAGS} -Wabi=10")
 309     set(UNFUCK_GXX_FLAGS "${UNFUCK_GXX_FLAGS} -fabi-version=10")
 310   endif()
 311 endif(K8_UNFUCK_AS_GCC AND UNIX AND NOT CMAKE_CROSSCOMPILING)
 312
 313 set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fsigned-char")
 314 set(UNFUCK_GXX_FLAGS "${UNFUCK_GXX_FLAGS} -fexceptions")
 315 if(NSWITCH)
 316   set(UNFUCK_GXX_FLAGS "${UNFUCK_GXX_FLAGS} -frtti")
 317 endif(NSWITCH)
 318
 319 set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wall")
 320 #set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wno-frame-address")
 321
 322 if(NOT WITH_GCC_IDIOCITY)
 323   if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 6.0)
 324     # k8: fuck you, gcc. i have my own style, gtfo.
 325     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wno-misleading-indentation")
 326     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wno-ignored-attributes")
 327   endif()
 328 endif(NOT WITH_GCC_IDIOCITY)
 329
 330 if(VV_STACK_REALIGN)
 331   set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mstackrealign")
 332   message(STATUS "enabled stack realign")
 333 endif(VV_STACK_REALIGN)
 334
 335 if(WITH_STRTODEX)
 336   add_definitions(-DVCORE_ALLOW_STRTODEX=1)
 337 endif(WITH_STRTODEX)
 338
 339
 340 ##############
 341 ## warnings ##
 342 ##############
 343
 344 if(RPATH_VALUE)
 345   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-rpath -Wl,${RPATH_VALUE}")
 346 endif(RPATH_VALUE)
 347
 348 set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Werror=format-security")
 349 set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wparentheses")
 350
 351 if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 9.0)
 352   set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fno-diagnostics-show-line-numbers")
 353   set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fno-diagnostics-show-labels")
 354 endif()
 355
 356 if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 6.9)
 357   set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wimplicit-fallthrough")
 358   set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wshadow=local")
 359   set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Walloc-zero")
 360 endif()
 361
 362 if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.7)
 363   #set(UNFUCK_GXX_FLAGS "${UNFUCK_GXX_FLAGS} -Wno-class-memaccess")
 364   set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wmultistatement-macros")
 365   set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wmissing-attributes")
 366   set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wcast-function-type")
 367   set(UNFUCK_GXX_FLAGS "${UNFUCK_GXX_FLAGS} -Wsuggest-override")
 368 endif()
 369
 370 if(WITH_GCC_IDIOCITY)
 371   # don't use!
 372   set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wextra")
 373   set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wno-ignored-attributes")
 374   set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wno-unused-parameter")
 375   set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wno-misleading-indentation")
 376   if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 9.0)
 377     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wno-address-of-packed-member")
 378   endif()
 379   # for mi-malloc
 380   if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 6.0)
 381     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wno-invalid-memory-model")
 382   endif()
 383 else(WITH_GCC_IDIOCITY)
 384   # for mi-malloc
 385   if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 6.0)
 386     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wno-invalid-memory-model")
 387   endif()
 388
 389   if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 9.0)
 390     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wno-misleading-indentation")
 391   endif()
 392   if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 9.0)
 393     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wno-address-of-packed-member")
 394   endif()
 395 endif(WITH_GCC_IDIOCITY)
 396
 397 set(UNFUCK_GXX_FLAGS "${UNFUCK_GXX_FLAGS} -Wno-old-style-cast")
 398 set(UNFUCK_GXX_FLAGS "${UNFUCK_GXX_FLAGS} -Woverloaded-virtual")
 399 set(UNFUCK_GXX_FLAGS "${UNFUCK_GXX_FLAGS} -Wsign-promo")
 400 set(UNFUCK_GXX_FLAGS "${UNFUCK_GXX_FLAGS} -Wmultiple-inheritance")
 401 set(UNFUCK_GXX_FLAGS "${UNFUCK_GXX_FLAGS} -Wvirtual-inheritance")
 402
 403 # this protects some shitpp classes from MT code; we don't need this
 404 set(UNFUCK_GXX_FLAGS "${UNFUCK_GXX_FLAGS} -fno-threadsafe-statics")
 405 # who cares, i don't use std
 406 set(UNFUCK_GXX_FLAGS "${UNFUCK_GXX_FLAGS} -fno-use-cxa-get-exception-ptr")
 407
 408
 409 ###########################
 410 ## some math/FPU options ##
 411 ###########################
 412
 413 if(NOT DEBUG_FPU_CHECKS AND NOT NSWITCH)
 414   # use -ffast-math, 'cause why not?
 415   # k8: nope, i command my former self to not do this
 416   #set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -ffast-math")
 417   if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 6.0)
 418     # on gcc 5.x leads to internal compiler errors
 419     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fno-math-errno")
 420   endif()
 421 endif(NOT DEBUG_FPU_CHECKS AND NOT NSWITCH)
 422
 423
 424 ##########################################
 425 ## unfuck idiotic gcc code downgradizer ##
 426 ##########################################
 427
 428 # WARNING! do not touch anything here even if you think you know what you're doing.
 429 #          any change may and WILL break the code.
 430
 431 # actually, we don't need strict floating point math compliance, so let's use "-ffast-math"
 432 # no, no fuckin' way. with "-ffast-math" not-a-number is EQUAL TO ZERO!
 433 # fuck you, gcc.
 434 set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fno-unsafe-math-optimizations")
 435 set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fno-associative-math")
 436 set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fno-reciprocal-math")
 437 set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fno-finite-math-only")
 438 set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fsigned-zeros")
 439 set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fsignaling-nans") # do not touch my NaNs!
 440 set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -frounding-math") # get lost!
 441 set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -ffp-contract=off") # do not use fused fmadd, even if it is available
 442 # we don't need strict standards compliance
 443 # note that this may modify NaNs, so if we'll use NaN-boxing, we should put "-fsignaling-nans" after fastmath
 444 #set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -ffast-math")
 445
 446 # force gcc to unroll some loops
 447 set(K8_OPT_GCC_FLAGS "${K8_OPT_GCC_FLAGS} -funroll-loops")
 448 set(K8_OPT_GCC_FLAGS "${K8_OPT_GCC_FLAGS} -fpredictive-commoning")
 449
 450 # consider more optimisation options (from O3):
 451 #   -ftree-partial-pre
 452 #   -ftree-loop-distribute-patterns
 453
 454 # and force gcc to not vectrosize (whatever it is)
 455 set(K8_OPT_GCC_FLAGS "${K8_OPT_GCC_FLAGS} -fno-tree-vectorize")
 456 set(K8_OPT_GCC_FLAGS "${K8_OPT_GCC_FLAGS} -fvect-cost-model=cheap")
 457 set(K8_OPT_GCC_FLAGS "${K8_OPT_GCC_FLAGS} -fsimd-cost-model=cheap")
 458
 459 # pointer alias analysis; no wai
 460 set(K8_OPT_GCC_FLAGS "${K8_OPT_GCC_FLAGS} -fno-tree-pta")
 461 # but allow function inlining
 462 set(K8_OPT_GCC_FLAGS "${K8_OPT_GCC_FLAGS} -finline-functions")
 463 # duplicate loop invariant branches (whatever it is)
 464 #set(K8_OPT_GCC_FLAGS "${K8_OPT_GCC_FLAGS} -funswitch-loops")
 465
 466 if("$ENV{USER}" STREQUAL "ketmar")
 467   set(K8_NATIVE_ARCH "-march=nehalem")
 468   set(K8_NATIVE_TUNE "-mtune=nehalem")
 469 else()
 470   set(K8_NATIVE_ARCH "-march=native")
 471   set(K8_NATIVE_TUNE "-mtune=native")
 472 endif()
 473
 474 if(NOT NO_SSE)
 475   if(DEBUG_FPU_CHECKS)
 476     message(STATUS "BUILD: using FPU")
 477     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mfpmath=387")
 478     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -ffloat-store")
 479     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -fsignaling-nans")
 480     add_definitions(-DUSE_FPU_MATH=1)
 481   elseif(INSANE_AVX)
 482     message(STATUS "BUILD: using AVX2 instriction set")
 483     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} ${K8_NATIVE_ARCH}")
 484     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} ${K8_NATIVE_TUNE}")
 485     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mavx2")
 486     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mfpmath=sse")
 487   elseif (WITH_SSE42)
 488     message(STATUS "BUILD: using SSE4.2 instriction set")
 489     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} ${K8_NATIVE_ARCH}")
 490     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} ${K8_NATIVE_TUNE}")
 491     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -msse4.2")
 492     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mno-avx")
 493     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mfpmath=sse")
 494   elseif (WITH_SSE41)
 495     message(STATUS "BUILD: using SSE4.1 instriction set")
 496     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} ${K8_NATIVE_ARCH}")
 497     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} ${K8_NATIVE_TUNE}")
 498     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -msse4.1")
 499     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mno-avx")
 500     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mfpmath=sse")
 501   elseif (WITH_SSE4)
 502     message(STATUS "BUILD: using SSE4 instriction set")
 503     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} ${K8_NATIVE_ARCH}")
 504     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} ${K8_NATIVE_TUNE}")
 505     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -msse4")
 506     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mno-avx")
 507     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mfpmath=sse")
 508   elseif (WITH_SSE3)
 509     message(STATUS "BUILD: using SSE3 instriction set")
 510     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} ${K8_NATIVE_ARCH}")
 511     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} ${K8_NATIVE_TUNE}")
 512     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -msse3")
 513     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mno-avx")
 514     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mfpmath=sse")
 515   else()
 516     if(NOT WIN32)
 517       if(WITH_OLD_CPU)
 518         message(STATUS "BUILD: using SSE2/p4 instriction set")
 519         set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -march=pentium4")
 520         set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mtune=pentium4")
 521         set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -msse2")
 522       else(WITH_OLD_CPU)
 523         message(STATUS "BUILD: using SSE2/native instriction set")
 524         set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} ${K8_NATIVE_ARCH}")
 525         set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} ${K8_NATIVE_TUNE}")
 526         set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -msse4")
 527       endif(WITH_OLD_CPU)
 528       #set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -msse2")
 529       set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mno-avx")
 530       set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mfpmath=sse")
 531     else(NOT WIN32)
 532       message(STATUS "BUILD: using SSE4/nehalem instriction set")
 533       #set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -march=pentium4")
 534       #set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mtune=pentium4")
 535       set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -march=nehalem")
 536       set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mtune=nehalem")
 537       set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -msse4")
 538       set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mno-avx")
 539       set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -mfpmath=sse")
 540     endif(NOT WIN32)
 541   endif()
 542 endif(NOT NO_SSE)
 543
 544 if(NOT WIN32)
 545   if(NOT NO_PTHREAD)
 546     set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -pthread")
 547     set(CMAKE_C_LINK_EXECUTABLE "${CMAKE_C_LINK_EXECUTABLE} -pthread")
 548     set(CMAKE_CXX_LINK_EXECUTABLE "${CMAKE_CXX_LINK_EXECUTABLE} -pthread")
 549   endif(NOT NO_PTHREAD)
 550 else(NOT WIN32)
 551   set(CMAKE_C_LINK_EXECUTABLE "${CMAKE_C_LINK_EXECUTABLE} -mwindows")
 552   set(CMAKE_CXX_LINK_EXECUTABLE "${CMAKE_CXX_LINK_EXECUTABLE} -mwindows")
 553   set(NO_RAWTTY ON)
 554 endif(NOT WIN32)
 555
 556
 557 #if(ENABLE_SIGNAL_HANDLER)
 558 #  set(UNFUCK_GCC_FLAGS "${UNFUCK_GCC_FLAGS} -Wno-frame-address")
 559 #endif(ENABLE_SIGNAL_HANDLER)
 560
 561
 562 if(UNSTABLE_OPTIMISATIONS)
 563   set(VV_OPTIM "-O3")
 564   message(STATUS "USING UNSTABLE GCC CODE DEGRADIZER OPTIONS!")
 565 else(UNSTABLE_OPTIMISATIONS)
 566   set(VV_OPTIM "-O2")
 567 endif(UNSTABLE_OPTIMISATIONS)
 568
 569
 570 ############################
 571 ## unfuck all build types ##
 572 ############################
 573 string(REGEX REPLACE "-O[0-9]" " " CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
 574 string(REGEX REPLACE "-O[0-9]" " " CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
 575
 576 set(CMAKE_C_FLAGS_DEBUG   "${CMAKE_C_FLAGS_DEBUG} -O0 -g ${UNFUCK_GCC_FLAGS}")
 577 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g ${UNFUCK_GCC_FLAGS} ${UNFUCK_GXX_FLAGS}")
 578
 579 string(REGEX REPLACE "-O[0-9]" " " CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
 580 string(REGEX REPLACE "-O[0-9]" " " CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
 581
 582 set(CMAKE_C_FLAGS_RELEASE   "${CMAKE_C_FLAGS_RELEASE} ${VV_OPTIM} ${UNFUCK_GCC_FLAGS} ${K8_OPT_GCC_FLAGS}")
 583 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${VV_OPTIM} ${UNFUCK_GCC_FLAGS} ${UNFUCK_GXX_FLAGS} ${K8_OPT_GCC_FLAGS}")
 584
 585 string(REGEX REPLACE "-O[0-9]" " " CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}")
 586 string(REGEX REPLACE "-O[0-9]" " " CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
 587
 588 set(CMAKE_C_FLAGS_RELWITHDEBINFO   "${CMAKE_C_FLAGS_RELWITHDEBINFO} ${VV_OPTIM} -g ${UNFUCK_GCC_FLAGS} ${K8_OPT_GCC_FLAGS}")
 589 set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${VV_OPTIM} -g ${UNFUCK_GCC_FLAGS} ${UNFUCK_GXX_FLAGS} ${K8_OPT_GCC_FLAGS}")
 590
 591 string(REGEX REPLACE "-O[0-9]" " " CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL}")
 592 string(REGEX REPLACE "-O[0-9]" " " CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL}")
 593
 594 set(CMAKE_C_FLAGS_MINSIZEREL   "${CMAKE_C_FLAGS_RELWITHDEBINFO} -Os ${UNFUCK_GCC_FLAGS}")
 595 set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -Os ${UNFUCK_GCC_FLAGS} ${UNFUCK_GXX_FLAGS}")
 596
 597
 598 add_definitions(-DZDBSP_DISABLE_SSE=1)
 599
 600 if(NOT WITH_MIMALLOC)
 601   add_definitions(-DVAVOOM_DISABLE_MIMALLOC)
 602   message(STATUS "Using system memory allocator")
 603 endif(NOT WITH_MIMALLOC)
 604
 605 set(VAVOOM_MAIN_DEPS "")
 606
 607 if(WITH_WINE)
 608   set(WINERUN "$ENV{K8VAVOOM_WINE}")
 609   if(NOT WINERUN)
 610     set(WINERUN "wine")
 611   endif(NOT WINERUN)
 612 else(WITH_WINE)
 613   set(WINERUN "")
 614 endif(WITH_WINE)
 615
 616
 617 ## message(STATUS "BUILD: ${CMAKE_BUILD_TYPE}")
 618 ## message(STATUS "cflags  : ${CMAKE_C_FLAGS}")
 619 ## message(STATUS "cxxflags: ${CMAKE_CXX_FLAGS}")
 620 ## message(STATUS "cflags  (dbg): ${CMAKE_C_FLAGS_DEBUG}")
 621 ## message(STATUS "cxxflags(dbg): ${CMAKE_CXX_FLAGS_DEBUG}")
 622
 623 if(NOT DEFINED DATADIR)
 624   set(DATADIR share/k8vavoom)
 625 endif(NOT DEFINED DATADIR)
 626 if(NOT DEFINED BINDIR)
 627   set(BINDIR bin)
 628 endif(NOT DEFINED BINDIR)
 629 if(NOT DEFINED SPECSDIR)
 630   set(SPECSDIR specs)
 631 endif(NOT DEFINED SPECSDIR)
 632
 633
 634 #
 635 #  **** Check for inttypes.h ****
 636 #
 637 ### find_path(INTTYPES_INCLUDE_DIR inttypes.h)
 638 ### if(INTTYPES_INCLUDE_DIR)
 639 ###   add_definitions(-DHAVE_INTTYPES_H=1)
 640 ### endif(INTTYPES_INCLUDE_DIR)
 641
 642
 643 #
 644 #  **** Check for newtwork libraries ****
 645 #
 646 if(WIN32)
 647   set(NET_LIBRARIES wsock32)
 648 else(WIN32)
 649   set(NET_LIBRARIES "")
 650 endif(WIN32)
 651
 652
 653 #
 654 #  **** pkg-config is required ****
 655 #
 656 FIND_PACKAGE(PkgConfig REQUIRED)
 657
 658
 659 #
 660 #  **** Check for zlib ****
 661 #
 662 #if(WITH_SYS_ZLIB)
 663 #  find_package(ZLIB)
 664 #  if(ZLIB_FOUND)
 665 #    include_directories(${ZLIB_INCLUDE_DIR})
 666 #  else(ZLIB_FOUND)
 667 #    message(STATUS "WARNING: Zlib not found, using internal zlib")
 668 #    set(WITH_SYS_ZLIB OFF)
 669 #    set(ZLIB_LIBRARIES z)
 670 #    set(VAVOOM_MAIN_DEPS ${VAVOOM_MAIN_DEPS} z)
 671 #  endif(ZLIB_FOUND)
 672 #else(WITH_SYS_ZLIB)
 673 #  add_definitions(-DUSE_INTERNAL_ZLIB=1)
 674 #  add_definitions(-DHAVE_ZLIB_H=1)
 675 #  message(STATUS "Using built-in zlib")
 676 #  set(ZLIB_LIBRARIES "z")
 677 #  set(VAVOOM_MAIN_DEPS ${VAVOOM_MAIN_DEPS} z)
 678 #endif(WITH_SYS_ZLIB)
 679 #set(MAIN_LIBS z ${MAIN_LIBS})
 680
 681
 682 #
 683 #  **** Check for libjpeg ****
 684 #
 685 if(ENABLE_CLIENT OR ENABLE_SERVER OR ENABLE_VCCRUN)
 686   if(WITH_STB_JPEG)
 687   else(WITH_STB_JPEG)
 688     add_definitions(-DVAVOOM_DISABLE_STB_IMAGE_JPEG=1)
 689     if(WITH_SYS_LIBJPG)
 690       find_package(JPEG)
 691       if(JPEG_FOUND)
 692         include_directories(${JPEG_INCLUDE_DIR})
 693         set(MAIN_LIBS ${JPEG_LIBRARIES} ${MAIN_LIBS})
 694         add_definitions(-DVAVOOM_USE_LIBJPG=1)
 695       else(JPEG_FOUND)
 696         message(STATUS "WARNING: LibJpeg not found, using internal jpeg reader")
 697         set(WITH_SYS_LIBJPG OFF)
 698       endif(JPEG_FOUND)
 699     endif(WITH_SYS_LIBJPG)
 700
 701     if(NOT WITH_SYS_LIBJPG)
 702       set(MAIN_LIBS jpeg ${MAIN_LIBS})
 703       set(VAVOOM_MAIN_DEPS ${VAVOOM_MAIN_DEPS} jpeg)
 704     endif(NOT WITH_SYS_LIBJPG)
 705   endif(WITH_STB_JPEG)
 706 endif(ENABLE_CLIENT OR ENABLE_SERVER OR ENABLE_VCCRUN)
 707
 708
 709 #
 710 #  **** Check for liblzma ****
 711 #
 712 #if(WITH_SYS_LZMA)
 713 #  find_package(LibLZMA)
 714 #  if(LIBLZMA_FOUND)
 715 #    include_directories(${LIBLZMA_INCLUDE_DIRS})
 716 #    #message(STATUS "***: " ${LIBLZMA_INCLUDE_DIRS})
 717 #    #message(STATUS "***: " ${LIBLZMA_LIBRARIES})
 718 #    set(MAIN_LIBS ${LIBLZMA_LIBRARIES} ${MAIN_LIBS})
 719 #  else(LIBLZMA_FOUND)
 720 #    message(STATUS "WARNING: LibLzma not found, using internal lzma decoder")
 721 #    set(WITH_SYS_LZMA OFF)
 722 #  endif(LIBLZMA_FOUND)
 723 #endif(WITH_SYS_LZMA)
 724 #
 725 #if(NOT WITH_SYS_LZMA)
 726 #  set(MAIN_LIBS lzma ${MAIN_LIBS})
 727 #  set(VAVOOM_MAIN_DEPS ${VAVOOM_MAIN_DEPS} lzma)
 728 #  add_definitions(-DUSE_INTERNAL_LZMA=1)
 729 #endif(NOT WITH_SYS_LZMA)
 730 #
 731 #if(NOT WITH_SYS_LZMA)
 732 #  message(STATUS "LZMA: using internal liblzma")
 733 #  set(LIBLZMA_LIBRARIES "lzma")
 734 #  add_definitions(-DUSE_INTERNAL_LZMA=1)
 735 #endif(NOT WITH_SYS_LZMA)
 736
 737
 738 #
 739 #  **** Check for OpenAL ****
 740 #
 741 if(ENABLE_CLIENT OR ENABLE_VCCRUN)
 742   if(WITH_MOJOAL)
 743     if(NOT WITH_SDL2)
 744       message(FATAL_ERROR "WITH_SDL2 required for MojoAL")
 745     endif(NOT WITH_SDL2)
 746     #check_include_file(SDL2/SDL_mixer.h HAVE_SDL2_SUBDIR)
 747     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -lSDL2_mixer")
 748     add_definitions(-DVAVOOM_USE_MOJOAL=1)
 749   else(WITH_MOJOAL)
 750     find_package(OpenAL REQUIRED)
 751     include_directories(${OPENAL_INCLUDE_DIR})
 752     if(WITH_STATIC_OPENAL)
 753       #k8: my MXE builds are static. live with it.
 754       add_definitions(-DAL_LIBTYPE_STATIC=1)
 755     endif(WITH_STATIC_OPENAL)
 756     set(MAIN_LIBS ${OPENAL_LIBRARY} ${MAIN_LIBS})
 757     if(WIN32)
 758       set(MAIN_LIBS ${OPENAL_LIBRARY} winmm ${MAIN_LIBS})
 759     endif(WIN32)
 760   endif(WITH_MOJOAL)
 761 endif(ENABLE_CLIENT OR ENABLE_VCCRUN)
 762
 763 if(WIN32)
 764   set(VAVOOM_SHITDOZE_LIBS winmm setupapi samplerate)
 765 else(WIN32)
 766   set(VAVOOM_SHITDOZE_LIBS )
 767 endif(WIN32)
 768
 769 set(MAIN_LIBS ${VAVOOM_SHITDOZE_LIBS} ${MAIN_LIBS})
 770
 771 set(NEED_SYS_OGG OFF)
 772 if(WITH_SYS_VORBIS)
 773   set(NEED_SYS_OGG ON)
 774 endif(WITH_SYS_VORBIS)
 775
 776 if(WITH_SYS_OPUS)
 777   set(NEED_SYS_OGG ON)
 778 endif(WITH_SYS_OPUS)
 779
 780 #
 781 #  **** Check for libogg ****
 782 #
 783 if(NEED_SYS_OGG)
 784   PKG_CHECK_MODULES(OGG ogg)
 785   if(OGG_FOUND)
 786     message(STATUS "Found libogg: ${OGG_LIBRARIES}")
 787     include_directories(${OGG_INCLUDE_DIRS})
 788     set(MAIN_LIBS ${OGG_LIBRARIES} ${MAIN_LIBS})
 789   endif(OGG_FOUND)
 790 endif(NEED_SYS_OGG)
 791
 792
 793 #
 794 #  **** Check for Vorbis ****
 795 #
 796 if(WITH_SYS_VORBIS)
 797   PKG_CHECK_MODULES(VORBIS vorbis)
 798   if(OGG_FOUND AND VORBIS_FOUND)
 799     message(STATUS "Found Vorbis: ${VORBIS_LIBRARIES}")
 800     set(VORBIS_FOUND ON)
 801     include_directories(${VORBIS_INCLUDE_DIRS})
 802     set(MAIN_LIBS ${VORBIS_LIBRARIES} ${MAIN_LIBS})
 803   else(OGG_FOUND AND VORBIS_FOUND)
 804     message(STATUS "Could NOT find OggVorbis libraries")
 805     set(VORBIS_FOUND OFF)
 806     message(FATAL_ERROR "You need libvorbis to compile k8vavoom.")
 807     return()
 808   endif(OGG_FOUND AND VORBIS_FOUND)
 809 else(WITH_SYS_VORBIS)
 810   set(VORBIS_FOUND OFF)
 811   message(STATUS "using stb_vorbis for Ogg/Vorbis decoding")
 812 endif(WITH_SYS_VORBIS)
 813
 814
 815 #
 816 #  **** Check for Opus ****
 817 #
 818 set(OPUS_USE_INTERNAL OFF)
 819 if(WITH_SYS_OPUS)
 820   PKG_CHECK_MODULES(OPUS opusfile opus)
 821   if(OPUS_FOUND AND OGG_FOUND)
 822     message(STATUS "Found Opus: ${OPUS_LIBRARIES}")
 823     set(OPUS_FOUND ON)
 824     include_directories(${OPUS_INCLUDE_DIRS})
 825     set(MAIN_LIBS ${OPUS_LIBRARIES} ${MAIN_LIBS})
 826   else(OPUS_FOUND AND OGG_FOUND)
 827     message(STATUS "Could NOT find Opus libraries")
 828     set(OPUS_FOUND OFF)
 829     message(FATAL_ERROR "You need libopus to compile k8vavoom.")
 830     return()
 831   endif(OPUS_FOUND AND OGG_FOUND)
 832 else(WITH_SYS_OPUS)
 833   set(OPUS_FOUND OFF)
 834   set(OPUS_USE_INTERNAL ON)
 835   include_directories(${CMAKE_SOURCE_DIR}/libs/opus/libopus/include)
 836   include_directories(${CMAKE_SOURCE_DIR}/libs/opus/libopusfile/include)
 837   if(OGG_FOUND)
 838     set(MAIN_LIBS opusfile opus ${MAIN_LIBS})
 839     message(STATUS "using built-in libopus and system libogg")
 840   else(OGG_FOUND)
 841     # use built-in libogg
 842     include_directories(${CMAKE_SOURCE_DIR}/libs/opus/libogg/include)
 843     set(MAIN_LIBS opusfile opus ogg ${MAIN_LIBS})
 844     add_definitions(-DVV_BUILTIN_OGG)
 845     message(STATUS "using built-in libopus and libogg")
 846   endif(OGG_FOUND)
 847   add_definitions(-DVV_BUILTIN_OPUS)
 848 endif(WITH_SYS_OPUS)
 849
 850
 851
 852
 853 if(ENABLE_CLIENT OR ENABLE_VCCRUN_ONLY OR ENABLE_VCCRUN)
 854   set(XMPLITE_FOUND ON)
 855   set(MAIN_LIBS xmplite ${MAIN_LIBS})
 856   include_directories(libs/xmplite)
 857   add_definitions(-DLIBXMP_CORE_PLAYER)
 858   add_definitions(-DXMP_SYM_VISIBILITY)
 859 endif(ENABLE_CLIENT OR ENABLE_VCCRUN_ONLY OR ENABLE_VCCRUN)
 860
 861
 862 #
 863 #  **** Check for libmad ****
 864 #
 865 if(WITH_LIBMAD)
 866   find_path(MAD_INCLUDE_DIRS mad.h)
 867   find_library(MAD_LIBRARIES NAMES mad)
 868   if(MAD_LIBRARIES)
 869     message(STATUS "Found LibMAD: ${MAD_LIBRARIES}")
 870     set(LIBMAD_FOUND ON)
 871     include_directories(${MAD_INCLUDE_DIRS})
 872     set(MAIN_LIBS ${MAD_LIBRARIES} ${MAIN_LIBS})
 873   else(MAD_LIBRARIES)
 874     message(STATUS "Could NOT find LibMAD libraries")
 875     set(LIBMAD_FOUND OFF)
 876   endif(MAD_LIBRARIES)
 877 else(WITH_LIBMAD)
 878   set(LIBMAD_FOUND OFF)
 879   message(STATUS "using dr_mp3 for MP3 decoding")
 880 endif(WITH_LIBMAD)
 881
 882
 883 #
 884 #  **** Check for FLAC ****
 885 #
 886 if(WITH_SYS_FLAC)
 887   PKG_CHECK_MODULES(FLAC flac)
 888   if(FLAC_FOUND)
 889     message(STATUS "Found FLAC: ${FLAC_LIBRARIES}")
 890     include_directories(${FLAC_INCLUDE_DIRS})
 891     set(MAIN_LIBS ${FLAC_LIBRARIES} ${MAIN_LIBS})
 892   else(FLAC_FOUND)
 893     message(STATUS "Could NOT find FLAC library")
 894     set(FLAC_FOUND OFF)
 895   endif(FLAC_FOUND)
 896 else(WITH_SYS_FLAC)
 897   set(FLAC_FOUND OFF)
 898   message(STATUS "using dr_flac for FLAC decoding")
 899 endif(WITH_SYS_FLAC)
 900
 901
 902 #
 903 #  **** Check for LibJIT ****
 904 #
 905 if(WITH_LIBJIT)
 906   PKG_CHECK_MODULES(LIBJIT libjit)
 907   if(LIBJIT_FOUND)
 908     message(STATUS "Found LibJIT: ${LIBJIT_LIBRARIES}")
 909     include_directories(${LIBJIT_INCLUDE_DIRS})
 910     set(MAIN_LIBS ${LIBJIT_LIBRARIES} ${MAIN_LIBS})
 911   else(LIBJIT_FOUND)
 912     message(STATUS "Could not find LibJIT library (this is OK)")
 913     set(LIBJIT_FOUND OFF)
 914   endif(LIBJIT_FOUND)
 915 else(WITH_LIBJIT)
 916   set(LIBJIT_FOUND OFF)
 917   #message(STATUS "LibJIT disabled by user")
 918 endif(WITH_LIBJIT)
 919
 920 if(LIBJIT_FOUND)
 921   add_definitions(-DUSE_LIBJIT)
 922 endif(LIBJIT_FOUND)
 923
 924
 925 #
 926 #  **** Check for FluidSynth ****
 927 #
 928 if(WITH_FLUID AND ENABLE_CLIENT)
 929   if(WITH_SYS_FLUID)
 930     PKG_CHECK_MODULES(FLUID fluidsynth)
 931     #message(STATUS, "FINC:" ${FLUID_INCLUDE_DIRS})
 932     #message(STATUS, "FLIB:" ${FLUID_LIBRARIES})
 933     if(WIN32 AND FLUID_FOUND)
 934       PKG_CHECK_MODULES(GLIB glib-2.0)
 935       if(GLIB_FOUND)
 936         include_directories(${GLIB_INCLUDE_DIRS})
 937         set(MAIN_LIBS ${GLIB_LIBRARIES} ${MAIN_LIBS})
 938       else(GLIB_FOUND)
 939         set(FLUID_FOUND OFF)
 940       endif(GLIB_FOUND)
 941     endif(WIN32 AND FLUID_FOUND)
 942     if(FLUID_FOUND)
 943       message(STATUS "Found FluidSynth: ${FLUID_LIBRARIES}")
 944       set(FLUID_FOUND ON)
 945       include_directories(${FLUID_INCLUDE_DIRS})
 946       set(MAIN_LIBS ${FLUID_LIBRARIES} ${MAIN_LIBS})
 947     else(FLUID_INCLUDE_DIRS AND FLUID_LIBRARIES)
 948       message(STATUS "Could NOT find FluidSynth libraries")
 949       if(NOT WIN32)
 950         message(STATUS "Using built-in FluidSynth")
 951         set(WITH_SYS_FLUID OFF)
 952         set(FLUID_FOUND ON)
 953       endif(NOT WIN32)
 954     endif(FLUID_FOUND)
 955   else(WITH_SYS_FLUID)
 956     message(STATUS "Using built-in FluidSynth")
 957     set(FLUID_FOUND ON)
 958   endif(WITH_SYS_FLUID)
 959 else(WITH_FLUID)
 960   set(FLUID_FOUND OFF)
 961 endif(WITH_FLUID AND ENABLE_CLIENT)
 962
 963 if(FLUID_FOUND AND NOT WITH_SYS_FLUID AND ENABLE_CLIENT)
 964   add_definitions(-DBUILTIN_FLUID)
 965   include_directories(${CMAKE_CURRENT_SOURCE_DIR}/libs/fluidsynth_lite/include)
 966   include_directories(${CMAKE_CURRENT_BINARY_DIR}/libs/fluidsynth_lite/include)
 967   set(MAIN_LIBS libfluidsynth_lite ${MAIN_LIBS})
 968 endif(FLUID_FOUND AND NOT WITH_SYS_FLUID AND ENABLE_CLIENT)
 969
 970
 971 #
 972 #  **** Platform specific library checks ****
 973 #
 974 #if(NOT WIN32)
 975   # ---------------- Other *NIX platforms ----------------
 976   if(WITH_SDL2)
 977     if(CMAKE_CROSSCOMPILING AND ANDROID)
 978       if(SDL2_INCLUDE_DIRS STREQUAL "")
 979         message(FATAL_ERROR "SDL2_INCLUDE_DIRS not specified")
 980       endif()
 981       if(SDL2_LIBRARIES STREQUAL "")
 982         message(FATAL_ERROR "SDL2_LIBRARIES not specified")
 983       endif()
 984       set(SDL2_FOUND ON)
 985     else()
 986       find_package(SDL2 REQUIRED)
 987       #PKG_SEARCH_MODULE(SDL2 REQUIRED sdl2)
 988     endif()
 989     include_directories(${SDL2_INCLUDE_DIRS})
 990     set(MAIN_LIBS ${SDL2_LIBRARIES} ${MAIN_LIBS})
 991     #message(STATUS "SDL2 INCLUDES:" ${SDL2_INCLUDE_DIRS})
 992     #message(STATUS "SDL2 LIBS:" ${SDL2_LIBRARIES})
 993   else(WITH_SDL2)
 994     set(OPENGL_FOUND OFF)
 995     set(WITH_OPENGL OFF)
 996   endif(WITH_SDL2)
 997
 998   if(WITH_OPENGL)
 999     if(NOT WITH_SDL2)
1000       message(SEND_ERROR "SDL2 required for OpenGL")
1001       return()
1002     endif(NOT WITH_SDL2)
1003     set(OpenGL_GL_PREFERENCE LEGACY)
1004     if(NSWITCH)
1005       # massive fucking hack because nothing works right
1006       set(OPENGL_gl_LIBRARY "-L$ENV{PORTLIBS_PREFIX}/lib -lEGL -lglapi -ldrm_nouveau")
1007       set(OPENGL_INCLUDE_DIR "$ENV{PORTLIBS_PREFIX}/include")
1008       set(OPENGL_FOUND ON)
1009     elseif(WITH_GL4ES)
1010       set(OPENGL_gl_LIBRARY "-L${GL4ES_LIBRARY_DIR} -lGL")
1011       set(OPENGL_INCLUDE_DIR "${GL4ES_INCLUDE_DIR}")
1012       set(OPENGL_FOUND ON)
1013     else()
1014       find_package(OpenGL REQUIRED)
1015     endif()
1016     if(OPENGL_FOUND)
1017       message(STATUS "Found OpenGL")
1018       include_directories(${OPENGL_INCLUDE_DIR})
1019       if(NSWITCH OR WITH_GL4ES)
1020         # have to reorder this shit or else it doesn't link
1021         set(MAIN_LIBS ${MAIN_LIBS} ${OPENGL_gl_LIBRARY})
1022       else()
1023         set(MAIN_LIBS ${OPENGL_gl_LIBRARY} ${MAIN_LIBS})
1024       endif()
1025     endif(OPENGL_FOUND)
1026   else(WITH_OPENGL)
1027     set(OPENGL_FOUND OFF)
1028   endif(WITH_OPENGL)
1029 #endif(NOT WIN32)
1030
1031 if(WITH_OPENGL)
1032   if(WITH_GLES)
1033     add_definitions(-DGL4ES_HACKS)
1034   endif()
1035   if(WITH_GL4ES)
1036     add_definitions(-DGL4ES_NO_CONSTRUCTOR)
1037   endif()
1038 endif()
1039
1040 if(ANDROID)
1041   add_definitions(-UDEBUG)
1042   set(MAIN_LIBS log android ${MAIN_LIBS})
1043 endif()
1044
1045 if(WITH_GLAD)
1046   add_definitions(-DUSE_GLAD=1)
1047   if(GLAD_INCLUDE_DIR AND GLAD_LIBRARY)
1048     include_directories(${GLAD_INCLUDE_DIR})
1049     set(MAIN_LIBS ${GLAD_LIBRARY} ${MAIN_LIBS})
1050   else(GLAD_INCLUDE_DIR AND GLAD_LIBRARY)
1051     include_directories("libs/glad")
1052     set(MAIN_LIBS glad ${MAIN_LIBS})
1053     set(VAVOOM_MAIN_DEPS ${VAVOOM_MAIN_DEPS} glad)
1054   endif(GLAD_INCLUDE_DIR AND GLAD_LIBRARY)
1055 endif(WITH_GLAD)
1056
1057 if(CYGWIN)
1058   set(NO_SINCOS ON)
1059 endif()
1060
1061 if(NSWITCH)
1062   message(STATUS "Building for Switch")
1063   include_directories("$ENV{DEVKITPRO}/libnx/include")
1064   include_directories("$ENV{PORTLIBS_PREFIX}/include")
1065   add_definitions(-D__SWITCH__)
1066   # add libnx at the end of lib list
1067   set(MAIN_LIBS ${MAIN_LIBS} "-L$ENV{PORTLIBS_PREFIX}/lib -lnx")
1068   message(STATUS "Libs: ${MAIN_LIBS}")
1069   # why the fuck does this not work properly in the toolchain file
1070   set(CMAKE_C_COMPILER "aarch64-none-elf-gcc")
1071   set(CMAKE_CXX_COMPILER "aarch64-none-elf-g++")
1072   set(CMAKE_AR "aarch64-none-elf-gcc-ar")
1073   set(CMAKE_RANLIB "aarch64-none-elf-gcc-ranlib")
1074   # enable necessary switches
1075   set(NO_SSE ON)
1076   set(NO_SIGNALS ON)
1077   set(NO_SYSCONF ON)
1078   set(NO_SINCOS ON)
1079   set(NO_MEMRCHR ON)
1080   set(NO_RAWTTY ON)
1081   set(WITH_MIMALLOC OFF)
1082   # turn on nxlink if necessary
1083   if(WITH_NXLINK)
1084     add_definitions(-DSWITCH_NXLINK=1)
1085   endif(WITH_NXLINK)
1086 else(NSWITCH)
1087   ### GnuTLS
1088   # # #FindGnuTLS()
1089   # # find_package(GnuTLS)
1090   # # if(GNUTLS_FOUND)
1091   # #   include_directories(${GNUTLS_INCLUDE_DIR})
1092   # #   set(MAIN_LIBS ${GNUTLS_LIBRARIES} ${MAIN_LIBS})
1093   # #   add_definitions(${GNUTLS_DEFINITIONS})
1094   # #   add_definitions(-DUSE_GNU_TLS)
1095   # # endif(GNUTLS_FOUND)
1096
1097   if(ENABLE_VCCRUN)
1098     PKG_CHECK_MODULES(GNUTLS gnutls)
1099     if(GNUTLS_FOUND)
1100       #message(STATUS "GnuTLS INC: " ${GNUTLS_INCLUDE_DIR})
1101       #message(STATUS "GnuTLS LIB: " ${GNUTLS_LIBRARIES})
1102       #message(STATUS "GnuTLS DEF: " ${GNUTLS_DEFINITIONS})
1103       include_directories(${GNUTLS_INCLUDE_DIR})
1104       set(MAIN_LIBS ${GNUTLS_LIBRARIES} ${MAIN_LIBS})
1105       add_definitions(${GNUTLS_DEFINITIONS})
1106       add_definitions(-DUSE_GNU_TLS)
1107     endif(GNUTLS_FOUND)
1108   endif(ENABLE_VCCRUN)
1109 endif(NSWITCH)
1110
1111
1112 ##
1113 ## XRandR
1114 ##
1115 if(WITH_XRANDR)
1116   PKG_CHECK_MODULES(XRANDR xrandr)
1117   PKG_CHECK_MODULES(X11 x11)
1118   if(XRANDR_FOUND AND X11_FOUND)
1119     message(STATUS "Found XRandR: ${XRANDR_LIBRARIES}")
1120     include_directories(${XRANDR_INCLUDE_DIRS})
1121     include_directories(${X11_INCLUDE_DIRS})
1122     set(MAIN_LIBS ${X11_LIBRARIES} ${XRANDR_LIBRARIES} ${MAIN_LIBS})
1123     add_definitions(-DUSE_XRANDR=1)
1124   else(XRANDR_FOUND AND X11_FOUND)
1125     message(STATUS "Could NOT find XRandR")
1126   endif(XRANDR_FOUND AND X11_FOUND)
1127   #add_definitions(-DUSE_XRANDR=1)
1128   #set(MAIN_LIBS xrandr X11 Xrandr ${MAIN_LIBS})
1129 endif(WITH_XRANDR)
1130
1131
1132 if(NO_SSE)
1133   add_definitions(-DNO_SSE=1)
1134 endif(NO_SSE)
1135
1136 if(NO_PTHREAD)
1137   add_definitions(-DNO_PTHREAD=1)
1138 endif(NO_PTHREAD)
1139
1140 if(NO_SINCOS)
1141   add_definitions(-DNO_SINCOS=1)
1142 endif(NO_SINCOS)
1143
1144 if(NO_SIGNALS)
1145   add_definitions(-DNO_SIGNALS=1)
1146 endif(NO_SIGNALS)
1147
1148 if(NO_SYSCONF)
1149   add_definitions(-DNO_SYSCONF=1)
1150 endif(NO_SYSCONF)
1151
1152 if(NO_MEMRCHR)
1153   add_definitions(-DNO_MEMRCHR=1)
1154 endif(NO_MEMRCHR)
1155
1156 if(NO_RAWTTY)
1157   add_definitions(-DNO_RAWTTY=1)
1158 endif(NO_RAWTTY)
1159
1160 ### if(CMAKE_EXECUTABLE_FORMAT STREQUAL "ELF")
1161 ###   add_subdirectory(libs/libbacktrace)
1162 ###   #include_directories(${CMAKE_CURRENT_SOURCE_DIR}/libbacktrace)
1163 ###   set(MAIN_LIBS backtrace ${MAIN_LIBS})
1164 ###   add_definitions(-DHAVE_BACKTRACE=1)
1165 ### endif()
1166
1167
1168 message(STATUS "=== BUILD OPTIONS ===")
1169 message(STATUS "BUILD: ${CMAKE_BUILD_TYPE}")
1170 if(WITH_WINE)
1171   message(STATUS "WINE COMMAND: " ${WINERUN})
1172 endif(WITH_WINE)
1173 #message(STATUS "cflags  : ${CMAKE_C_FLAGS}")
1174 #message(STATUS "cxxflags: ${CMAKE_CXX_FLAGS}")
1175
1176 message(STATUS "=== COMPONENTS ===")
1177 message(STATUS "  Vavoom Client: " ${ENABLE_CLIENT})
1178 message(STATUS "  Vavoom Server: " ${ENABLE_SERVER})
1179 message(STATUS "  Vavoom Master: " ${ENABLE_MASTER})
1180 message(STATUS "  Vavoom Query : " ${ENABLE_QUERY_DEMO})
1181 message(STATUS "  VccRun       : " ${ENABLE_VCCRUN})
1182 message(STATUS "  strtodEx     : " ${WITH_STRTODEX})
1183 if(ENABLE_VCCRUN)
1184   if(GNUTLS_FOUND)
1185     message(STATUS "  GNUTLS       : ON")
1186   endif(GNUTLS_FOUND)
1187 endif(ENABLE_VCCRUN)
1188 if(SDL2_OVERRIDE)
1189   message(STATUS "SDL2 override mode")
1190 else(SDL2_OVERRIDE)
1191   if(NOT HAVE_SDL2_SUBDIR)
1192     message(STATUS "SDL2 non-subdir mode")
1193   endif(NOT HAVE_SDL2_SUBDIR)
1194 endif(SDL2_OVERRIDE)
1195
1196
1197 add_subdirectory(libs)
1198
1199 if(ENABLE_UTILS_ONLY)
1200   add_subdirectory(utils)
1201 elseif(NOT ENABLE_VCCRUN_ONLY)
1202   if(NOT CMAKE_CROSSCOMPILING OR WIN32)
1203     add_subdirectory(utils)
1204   endif(NOT CMAKE_CROSSCOMPILING OR WIN32)
1205   add_subdirectory(source)
1206   if(NOT CMAKE_CROSSCOMPILING OR WIN32)
1207     #add_subdirectory(progs)
1208     add_subdirectory(basev)
1209   endif(NOT CMAKE_CROSSCOMPILING OR WIN32)
1210   #foreach(DIR ${EXTRA_SUBDIRS})
1211   #  add_subdirectory(${DIR})
1212   #endforeach(DIR)
1213 endif()
1214
1215 if(ENABLE_VCCRUN)
1216   add_subdirectory(vccrun)
1217 endif(ENABLE_VCCRUN)