CMakeLists.txt

project(3rdparty)

option(AX_WITH_JPEG "Build with internal jpeg support" ON)
option(AX_WITH_WEBP "Build with internal webp support" ON)
option(AX_WITH_CLIPPER2 "Build with internal Clipper2 support" ON)
option(AX_WITH_POLY2TRI "Build with internal poly2tri support" ON)
option(AX_WITH_FASTLZ "Build with internal fastlz support" ON)
option(AX_WITH_TRACY "Build with internal Tracy support" ON)

option(AX_WITH_CURL "Build with internal curl support" ON)
option(AX_WITH_UNZIP "Build with internal unzip support" ON)
option(AX_WITH_ASTCENC "Build with internal ASTCENC support" ON)
option(AX_WITH_CARES "Build with internal c-ares support" OFF)
option(AX_WITH_KCP "Build with internal kcp support" OFF)
option(AX_WITH_OBOE "Build with oboe support" OFF)
option(AX_WITH_LLHTTP "Build with internal LLHTTP support" ON)

# some libs not depended by axmol
option(AX_WITH_LZ4 "Build with internal lz4 support" OFF)

if(LINUX OR MACOSX OR WINDOWS)
  option(AX_WITH_DOCTEST "Build with doctest support" ON)
endif()

# by default, enable ios,macOS openal-soft framework for legal license LGPL-2.1
option(ALSOFT_OSX_FRAMEWORK "" ON)

# Enable static library for openal-soft. This has an impact on the
# license of the final product since the source of the whole game must
# then be available under terms compatible with the LGPL (e.g. GPL,
# MPL). Consequently, we set it to OFF by default.
option(
  AX_USE_ALSOFT_STATIC
  "Link with OpenAL as a static library (LGPL-compatible apps only)."
  OFF
)

set(ANDROID_SHARED_LOADS "" CACHE INTERNAL "The android shared libraries load source code")
set(ANDROID_SHARED_LOAD_FILE_NAME "SharedLoader.java" CACHE INTERNAL "The android shared load java file name")
set(ANDROID_SHARED_LOAD_FILE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/${ANDROID_SHARED_LOAD_FILE_NAME}.in" CACHE INTERNAL "The android shared libraries load config code file")

cmake_policy(SET CMP0079 NEW)

# Enable -fPIC flag when compiling as shared libs...
if(BUILD_SHARED_LIBS AND UNIX AND NOT ANDROID)
  set(CMAKE_POSITION_INDEPENDENT_CODE ON)
endif()

if(WINRT)
  add_definitions(-D_CRT_SECURE_NO_WARNINGS=1)
endif()

if(NOT DEFINED AX_USE_LUAJIT)
  set(AX_USE_LUAJIT FALSE CACHE INTERNAL "Use luajit instead plainlua")
endif()

if(NOT AX_USE_LUAJIT)
  message(STATUS "Using plainlua https://lua.org")
  set(AX_LUA_ENGINE "plainlua" CACHE INTERNAL "")
else()
  message(STATUS "Using luajit https://luajit.org")
  set(AX_LUA_ENGINE "luajit" CACHE INTERNAL "")
endif()

add_library(3rdparty INTERFACE)

set(_1kfetch_cache_dir "${_AX_ROOT}/cache" CACHE STRING "" FORCE)

# fetch prebuilts of 1kdist and git sources
include(${_AX_ROOT}/1k/fetch.cmake)

function(ax_add_3rd source_dir)
  set(options EXCLUDE_FROM_ALL NO_LINK)
  set(multiValueArgs TARGETS OPTIONS)
  cmake_parse_arguments(opt "${options}" "" "${multiValueArgs}" ${ARGN})

  foreach(OPTION ${opt_OPTIONS})
    _1kparse_option("${OPTION}")
    set(${OPTION_KEY} "${OPTION_VALUE}" CACHE BOOL "" FORCE)
  endforeach()

  set(binary_dir "")

  if(IS_ABSOLUTE ${source_dir})
    string(LENGTH "${_AX_ROOT}/cache/" _offset)
    string(LENGTH ${source_dir} _len)
    math(EXPR _len "${_len} - ${_offset}" OUTPUT_FORMAT DECIMAL)
    string(SUBSTRING ${source_dir} ${_offset} ${_len} _path)
    set(binary_dir "${ENGINE_BINARY_PATH}/3rdparty/${_path}")
  endif()

  if(opt_EXCLUDE_FROM_ALL)
    add_subdirectory(${source_dir} ${binary_dir} EXCLUDE_FROM_ALL)
  else()
    add_subdirectory(${source_dir} ${binary_dir})
  endif()

  if(NOT opt_TARGETS) # if opt_TARGETS not specified use source_dir as target name
    list(APPEND opt_TARGETS ${source_dir})
  endif()

  foreach(tgt ${opt_TARGETS})
    get_target_property(tgt_type ${tgt} TYPE)

    if(NOT ${opt_NO_LINK})
      if(tgt_type STREQUAL "STATIC_LIBRARY" OR tgt_type STREQUAL "SHARED_LIBRARY" OR tgt_type STREQUAL "INTERFACE_LIBRARY")
        target_link_libraries(3rdparty INTERFACE ${tgt})
      endif()
    else()
      add_dependencies(3rdparty ${tgt})
    endif()

    if(NOT (tgt_type STREQUAL "INTERFACE_LIBRARY"))
      set_target_properties(${tgt} PROPERTIES
        ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib" # Windows/Linux/macOS, .a, .lib
        RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin" # Windows .dll, .exe
        FOLDER "3rdparty"
      )

      get_target_property(_apple_framework ${tgt} MACOSX_FRAMEWORK_NAME)
      if(NOT _apple_framework)
        set_target_properties(${tgt} PROPERTIES
          LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib" # .so, .dylib, windows imported .lib
        )
      endif()
    endif()

  endforeach()
endfunction()

# bellow are header only libs
target_include_directories(3rdparty
  INTERFACE "robin-map/include"
)

if(ANDROID)
  target_include_directories(3rdparty
    INTERFACE "jni.hpp/include"
  )
endif()

ax_add_3rd(fmt OPTIONS "FMT_MODULE OFF")
if (TARGET fmt-c)
  set_target_properties(fmt-c PROPERTIES FOLDER "3rdparty")
endif()

# bellow are non header only libs

# cpufeatures
if(ANDROID)
  add_subdirectory(android-specific/cpufeatures)
endif()

ax_add_3rd(zlib)

if(NOT EMSCRIPTEN)
  option(AX_WITH_WEBSOCKET_PARSER "Build with websocket parser" ON)

  if(AX_WITH_WEBSOCKET_PARSER)
    ax_add_3rd(websocket-parser)
  endif()
endif()

# libpng
ax_add_3rd(png)

if(AX_ENABLE_PHYSICS_2D)
  set(box2d_opts "BOX2D_BUILD_UNIT_TESTS OFF" "BOX2D_BUILD_TESTBED OFF")
  ax_add_3rd(box2d OPTIONS ${box2d_opts})
endif()

ax_add_3rd(freetype OPTIONS
  "DISABLE_FORCE_DEBUG_POSTFIX ON"
  "SKIP_INSTALL_ALL TRUE"
  "FT_DISABLE_HARFBUZZ TRUE"
  "FT_DISABLE_BROTLI TRUE"
  "FT_DISABLE_BZIP2 TRUE"
)
target_include_directories(freetype PRIVATE "${PNG_INCLUDE_DIR}")

if(WINRT)
  target_compile_definitions(freetype PUBLIC "generic=GenericFromFreeTypeLibrary")
endif()

target_include_directories(3rdparty INTERFACE "freetype/include")

if(AX_ENABLE_NAVMESH)
  ax_add_3rd(recast)
endif()

if(AX_ENABLE_PHYSICS_3D)
  set(jolt_opts "DEBUG_RENDERER_IN_DISTRIBUTION ON")

  set(USE_SSE4_1_OPT "USE_SSE4_1 OFF")
  set(USE_SSE4_2_OPT "USE_SSE4_2 OFF")
  set(USE_AVX_OPT "USE_AVX OFF")
  set(USE_AVX2_OPT "USE_AVX2 OFF")
  set(USE_AVX512_OPT "USE_AVX512 OFF")

  if (AX_ISA_LEVEL GREATER_EQUAL 2)
    set(USE_SSE4_1_OPT "USE_SSE4_1 ON")
  endif()
  if (AX_ISA_LEVEL GREATER_EQUAL 3)
    set(USE_SSE4_2_OPT "USE_SSE4_2 ON")
  endif()
  if (AX_ISA_LEVEL GREATER_EQUAL 4)
    set(USE_AVX_OPT "USE_AVX ON")
    set(USE_AVX2_OPT "USE_AVX2 ON")
    set(USE_AVX512_OPT "USE_AVX2 ON")
  endif()

  list(APPEND jolt_opts
    ${USE_SSE4_1_OPT}
    ${USE_SSE4_2_OPT}
    ${USE_AVX_OPT}
    ${USE_AVX2_OPT}
    ${USE_AVX512_OPT}
  )
  ax_add_3rd(jolt TARGETS Jolt OPTIONS ${jolt_opts})
endif()

if(AX_WITH_JPEG AND NOT WINRT AND NOT EMSCRIPTEN)
  ax_add_3rd(jpeg-turbo)
endif()

ax_add_3rd(openssl TARGETS OpenSSL::SSL OpenSSL::Crypto)

if(AX_WITH_WEBP)
  ax_add_3rd(webp)
endif()

ax_add_3rd(pugixml)
ax_add_3rd(xxhash)

if(AX_WITH_FASTLZ)
  ax_add_3rd(fastlz)
endif()

if(AX_WITH_CLIPPER2)
  ax_add_3rd(clipper2)
endif()

ax_add_3rd(ConvertUTF)

if(AX_WITH_POLY2TRI)
  ax_add_3rd(poly2tri)
  target_compile_definitions(poly2tri PUBLIC P2T_STATIC_EXPORTS)
endif()

if(AX_WITH_ASTCENC)
  ax_add_3rd(astcenc)
endif()

# use lua/js specific libs by property to prevent conflict
if(AX_ENABLE_EXT_LUA)
  add_subdirectory(lua/${AX_LUA_ENGINE})
  add_subdirectory(lua/tolua)
  add_subdirectory(lua/lua-cjson)
  set_property(TARGET 3rdparty APPEND PROPERTY
    AX_LUA_DEPEND ${AX_LUA_ENGINE} tolua lua-cjson
  )

  if(AX_USE_LUAJIT)
    target_compile_definitions(lua-cjson PRIVATE USING_LUAJIT=1)
  endif()
endif()

if(AX_WITH_CURL AND NOT EMSCRIPTEN)
  ax_add_3rd(curl)
endif()

if(AX_ENABLE_AUDIO)
  # The openal-soft(LGPL 2.1)
  if(NOT EMSCRIPTEN)
    set(alsoft_opts
      "ALSOFT_ENABLE_MODULES OFF"
      "ALSOFT_DLOPEN OFF"
      "ALSOFT_UTILS OFF"
      "ALSOFT_EXAMPLES OFF"
      "ALSOFT_INSTALL OFF"
      "ALSOFT_INSTALL_CONFIG OFF"
      "ALSOFT_INSTALL_HRTF_DATA OFF"
      "ALSOFT_INSTALL_AMBDEC_PRESETS OFF"
      "ALSOFT_INSTALL_UTILS OFF"
      "ALSOFT_ENABLE_MODULES OFF"
    )

    if(AX_USE_ALSOFT_STATIC)
      list(APPEND alsoft_opts "LIBTYPE STATIC")
    endif()

    if(ANDROID)
      if(AX_WITH_OBOE)
        _1kfetch(oboe)
        set(ALSOFT_BACKEND_OPENSL OFF CACHE BOOL "Enable OpenSL backend" FORCE)
        set(OBOE_SOURCE "${oboe_SOURCE_DIR}" CACHE STRING "Source directory for Oboe." FORCE)
      endif()

      list(APPEND alsoft_opts
        "ALSOFT_RTKIT OFF"
        "ALSOFT_BACKEND_PIPEWIRE OFF"
        "ALSOFT_BACKEND_PULSEAUDIO OFF"
        "ALSOFT_BACKEND_ALSA OFF"
        "ALSOFT_BACKEND_OSS OFF"
        "ALSOFT_BACKEND_SOLARIS OFF"
        "ALSOFT_BACKEND_SNDIO OFF"
        "ALSOFT_BACKEND_JACK OFF"
        "ALSOFT_BACKEND_PORTAUDIO OFF"
        "ALSOFT_BACKEND_SDL2 OFF"
      )
    elseif(WINDOWS)
      list(APPEND alsoft_opts
        "ALSOFT_RTKIT OFF"
        "ALSOFT_BACKEND_WASAPI ON"
        "ALSOFT_BACKEND_WAVE OFF"
        "ALSOFT_BACKEND_DSOUND OFF"
        "ALSOFT_BACKEND_WINMM OFF"
      )
    elseif(APPLE)
      list(APPEND alsoft_opts "ALSOFT_RTKIT OFF")
    endif()

    if(WINRT)
      set(ALSOFT_CPPWINRT_VERSION ${AX_CPPWINRT_VERSION} CACHE STRING "" FORCE)
    endif()

    ax_add_3rd(openal EXCLUDE_FROM_ALL TARGETS OpenAL;alsoft.common OPTIONS ${alsoft_opts})

    set_target_properties(OpenAL alsoft.common PROPERTIES CXX_STANDARD ${_AX_CXX_STD})
    set_target_properties(alsoft.default_hrtf_data PROPERTIES FOLDER "3rdparty")

    if(AX_USE_ALSOFT_STATIC)
      target_compile_definitions(3rdparty INTERFACE AL_LIBTYPE_STATIC=1)
    elseif(ANDROID)
      set(ANDROID_SHARED_LOADS "${ANDROID_SHARED_LOADS}System.loadLibrary(\"openal\");" CACHE INTERNAL "Android Shared Loads")
      target_link_options(OpenAL PRIVATE "${_16KPAGE_SIZE_LD_FLAGS}")
    endif()
  endif()

  # opus
  if(AX_ENABLE_OPUS)
    ax_add_3rd(opus)
  endif()

  # The ogg contains vorbis & opus(optional) decoders
  ax_add_3rd(ogg)
endif()

if(WINDOWS OR LINUX OR ANDROID OR WASM)
  if(AX_ENABLE_VK OR AX_ENABLE_GL)
    ax_add_3rd(glad)
  endif()
endif()

if((WINDOWS AND NOT WINRT) OR MACOSX OR LINUX)
  set(_glfw_options "GLFW_BUILD_DOCS OFF" "GLFW_INSTALL OFF")
  if(LINUX)
    list(APPEND _glfw_options "GLFW_BUILD_X11 ON")
    if(AX_ENABLE_WAYLAND)
      list(APPEND _glfw_options "GLFW_BUILD_WAYLAND ON")
    else()
      list(APPEND _glfw_options "GLFW_BUILD_WAYLAND OFF")
    endif()
  endif()
  ax_add_3rd(glfw OPTIONS ${_glfw_options})
  set_target_properties(glfw PROPERTIES OUTPUT_NAME glfw)
  set_target_properties(update_mappings PROPERTIES FOLDER "3rdparty")

  if(NOT WINDOWS)
    target_link_libraries(3rdparty INTERFACE pthread)
  endif()

  target_include_directories(3rdparty INTERFACE "glfw/include/GLFW")
endif()

# unzip depend on zlib
if(AX_WITH_UNZIP)
  ax_add_3rd(unzip)
endif()

if(AX_WITH_CARES)
  ax_add_3rd(c-ares)
endif()

if(AX_WITH_LLHTTP)
  ax_add_3rd(llhttp)
endif()

# libvlc
if(AX_ENABLE_VLC_MEDIA AND(NOT _AX_HAVE_VLC))
  message(STATUS "Using axmol prebuilt libvlc")
  ax_add_3rd(vlc TARGETS VLC::vlc;VLC::vlccore)
endif()

if(AX_WITH_LZ4)
  if(NOT BUILD_SHARED_LIBS)
    set(lz4_tgt lz4_static)
  else()
    set(lz4_tgt lz4_shared)
  endif()

  _1kfetch(lz4)
  ax_add_3rd(${lz4_SOURCE_DIR}/build/cmake NO_LINK TARGETS ${lz4_tgt} OPTIONS
    "LZ4_BUILD_CLI OFF"
    "LZ4_BUILD_LEGACY_LZ4C OFF"
  )
endif()

if(AX_WITH_DOCTEST)
  ax_add_3rd(doctest NO_LINK)
endif()

# kcp
if(AX_WITH_KCP)
  _1kfetch(kcp)
  ax_add_3rd(${kcp_SOURCE_DIR} TARGETS kcp)
endif()

if(WIN32 AND AX_GLES_PROFILE)
  if(WINRT)
    ax_add_3rd(angle TARGETS angle::GLESv2;angle::EGL)
  else()
    add_subdirectory(angle)
  endif()
endif()

# tracy
if(AX_PROFILER_BACKEND STREQUAL "TRACY")
  set(AX_WITH_TRACY ON CACHE BOOL "" FORCE)
else()
  set(AX_WITH_TRACY OFF CACHE BOOL "" FORCE)
endif()

if(AX_WITH_TRACY)
  _1kfetch(tracy)
  set(TRACY_ENABLE ON CACHE BOOL "" FORCE)
  set(TRACY_ON_DEMAND ON CACHE BOOL "" FORCE)
  ax_add_3rd(${tracy_SOURCE_DIR} TARGETS TracyClient)
endif()

# yasio
ax_add_3rd(yasio)

# simdjson
ax_add_3rd(simdjson)

# openxr
if (AX_ENABLE_OPENXR)
  _1kfetch(openxr)
  ax_add_3rd(${openxr_SOURCE_DIR} TARGETS openxr_loader)
  set_target_properties(openxr_loader PROPERTIES DEBUG_POSTFIX "")
endif()

if(ANDROID)
  function(config_android_shared_libs package_name target_folder)
    string(REPLACE "." "/" package_path ${package_name})
    set(ANDROID_PACKAGE_NAME ${package_name})
    configure_file(${ANDROID_SHARED_LOAD_FILE_PATH} ${target_folder}/${package_path}/${ANDROID_SHARED_LOAD_FILE_NAME} @ONLY)
  endfunction()
endif()

# Disable -fPIC flag for other libs...
if(BUILD_SHARED_LIBS AND UNIX AND NOT ANDROID)
  set(CMAKE_POSITION_INDEPENDENT_CODE OFF)
endif()