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