CMakeLists.txt

cmake_minimum_required(VERSION 3.16)
project(Utils)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

set(SR_COMMON_BUILD_SCRIPT_PATH ${PROJECT_SOURCE_DIR}/py/BuildGenerator.py CACHE INTERNAL "" FORCE)
set(SR_COMMON_PCH_HEADER_PATH ${PROJECT_SOURCE_DIR}/inc/Utils/pch.h CACHE INTERNAL "" FORCE)

if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND NOT MSVC AND NOT ANDROID_NDK)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++ -std=c++20")
endif()

set(SR_COMMON_USE_CLANG_EMULATION OFF CACHE INTERNAL "" FORCE)

if (MSVC)
    if (CMAKE_CXX_COMPILER MATCHES "clang-cl")
        set(SR_COMMON_USE_CLANG_EMULATION ON CACHE INTERNAL "" FORCE)

        add_definitions(-DSR_COMMON_USE_CLANG_EMULATION=1)
        add_compile_definitions(SR_COMMON_USE_CLANG_EMULATION)
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSR_COMMON_USE_CLANG_EMULATION")

        message(STATUS "Using Clang compiler emulation for MSVC")
    endif()
endif()

set(BUILD_SHARED_LIBS OFF CACHE INTERNAL "" FORCE)
set(SKIP_INSTALL_ALL ON)

if (SR_EMSCRIPTEN OR WIN32)
    set(ZLIB_ONLY_STATIC ON CACHE INTERNAL "" FORCE)
endif()

option(SR_COMMON_ASSIMP "" ON)

option(SR_COMMON_ZLIB "" ON)
option(SR_COMMON_LIBPNG "" OFF)
option(SR_COMMON_OPENSSL "" OFF)
option(SR_COMMON_SDL "" OFF)
option(SR_COMMON_CURL "" OFF)
option(SR_COMMON_JSON "" OFF)
option(SR_COMMON_MYHTML "" OFF)
option(SR_COMMON_LITEHTML "" OFF)
option(SR_COMMON_ASIO "" OFF)
option(SR_COMMON_GNS "" OFF)
option(SR_COMMON_MESHOPTIMIZER "" ON)

option(SR_COMMON_DLL_EXPORTS "" ON)
option(SR_COMMON_GIT_METADATA "" ON)
option(SR_COMMON_STATIC_LIBRARY "" ON)
option(SR_COMMON_EMBED_RESOURCES "" OFF)
option(SR_COMMON_CI_BUILD "" OFF)

option(SR_USE_PCH "" ON)

if (SR_COMMON_GNS AND WIN32)
    include(cmake/InstallProtobuf.cmake)
endif()

include(cmake/Linker.cmake)
include(cmake/CopyDLLToExeFolder.cmake)
include(cmake/UseAssimp.cmake)

macro(SR_UTILS_INCLUDE_DIRECTORIES_APPEND var)
    set_property(GLOBAL APPEND PROPERTY SR_UTILS_INCLUDE_DIRECTORIES "${var}")
endmacro(SR_UTILS_INCLUDE_DIRECTORIES_APPEND)

if (WIN32)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNOMINMAX")
endif()

if (UNIX)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
endif()

if (SR_COMMON_ZLIB)
    message(STATUS "SRCommon will be using zlib")

    add_compile_definitions(SR_COMMON_ZLIB)
    set(ZLIB_BUILD_EXAMPLES OFF)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DASSIMP_BUILD_ZLIB=OFF")
    set(ASSIMP_BUILD_ZLIB OFF CACHE INTERNAL "" FORCE)
    set(ZLIB_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/libs/zlib ${CMAKE_CURRENT_BINARY_DIR}/libs/zlib)
    set(SR_ZLIB_INCLUDE_DIRS ${ZLIB_INCLUDE_DIR})
    add_subdirectory(libs/zlib)

    if (ZLIB_ONLY_STATIC)
        message(STATUS "Zlib will be built as a static library")
    else()
        message(STATUS "Zlib will be built as a shared library")
    endif()
endif()

SRUseAssimpIfPossible(SRCommon)

if (SR_COMMON_ASSIMP)
    include(cmake/AssimpConfigure.cmake)
    add_subdirectory(libs/assimp)

    target_compile_definitions(assimp PUBLIC ${SR_ASSIMP_DISABLED_IMPORTERS})

    if (SR_COMMON_USE_CLANG_EMULATION)
        target_compile_options(assimp PRIVATE -Wno-deprecated-copy)
        target_compile_options(assimp PRIVATE -Wno-unused-function)
    endif()
endif()

if (SR_COMMON_LIBPNG AND SR_COMMON_ZLIB)
    message(STATUS "SRCommon will be using libpng")

    add_compile_definitions(SR_COMMON_LIBPNG)
    set(PNG_STATIC ON CACHE INTERNAL "" FORCE)
    set(PNG_TESTS OFF CACHE INTERNAL "" FORCE)
    set(PNG_TOOLS OFF CACHE INTERNAL "" FORCE)
    set(PNG_SHARED OFF CACHE INTERNAL "" FORCE)
    set(PNG_USE_BUNDLED_ZLIB OFF CACHE INTERNAL "" FORCE)
    set(ZLIB_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/libs/zlib ${CMAKE_CURRENT_BINARY_DIR}/libs/zlib)

    add_subdirectory(libs/libpng)

    set(PNG_LIBRARY png_static CACHE INTERNAL "" FORCE)
    set(PNG_PNG_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/libs/libpng CACHE INTERNAL "" FORCE)
endif()

if (NOT ANDROID_NDK AND NOT SR_EMSCRIPTEN)
    if (UNIX AND NOT APPLE)
        find_package(X11 REQUIRED)
    endif()
    set(SR_EFSW_USE ON CACHE INTERNAL "" FORCE)
else()
    set(SR_EFSW_USE OFF CACHE INTERNAL "" FORCE)
endif()

if (SR_COMMON_SDL)
    add_subdirectory(libs/SDL)
endif()

if (SR_COMMON_JSON)
    set(JSON_BuildTests OFF CACHE INTERNAL "" FORCE)

    add_subdirectory(libs/json)
endif()

if (SR_COMMON_GIT_METADATA)
    add_subdirectory(libs/cmake-git-version-tracking)
endif()

set(SR_COMMON_CPPTRACE_ENABLED OFF)
if (NOT ANDROID_NDK AND UNIX AND NOT SR_EMSCRIPTEN)
    set(SR_COMMON_CPPTRACE_ENABLED ON)

    if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
        message(WARNING "Clang compiler is used. Stack tracing will not work.")
        set(CPPTRACE_UNWIND_WITH_NOTHING ON)
    endif()

    add_subdirectory(libs/cpptrace)
endif()

if (SR_COMMON_CURL)
    set(BUILD_LIBCURL_DOCS OFF CACHE INTERNAL "" FORCE)
    set(ENABLE_CURL_MANUAL OFF CACHE INTERNAL "" FORCE)
    set(BUILD_MISC_DOCS OFF CACHE INTERNAL "" FORCE)
    set(USE_MANUAL OFF CACHE INTERNAL "" FORCE)
    set(BUILD_CURL_EXE OFF CACHE INTERNAL "" FORCE)
    set(BUILD_TESTING OFF CACHE INTERNAL "" FORCE)
    set(BUILD_SHARED_LIBS OFF CACHE INTERNAL "" FORCE)
    set(USE_OPENSSL ${SR_COMMON_OPENSSL} CACHE INTERNAL "" FORCE)
    set(CURL_USE_OPENSSL ${SR_COMMON_OPENSSL} CACHE INTERNAL "" FORCE)
    set(BUILD_STATIC_CURL ON CACHE INTERNAL "" FORCE)

    if(WIN32)
        add_definitions("-DCURL_STATICLIB")
    endif()

    add_subdirectory(libs/curl)
endif()

set(ICU_PREBUILT_VERSION "69.1")

if (NOT ANDROID_NDK AND NOT SR_EMSCRIPTEN)
    add_subdirectory(libs/nativefiledialog)
    add_subdirectory(libs/tinyfiledialogs)
else()
    #set(ASSIMP_ANDROID_JNIIOSYSTEM ON CACHE INTERNAL "" FORCE)
    #set(ASSIMP_BUILD_ALL_EXPORTERS_BY_DEFAULT OFF CACHE INTERNAL "" FORCE)
    #set(ASSIMP_BUILD_ALL_IMPORTERS_BY_DEFAULT OFF CACHE INTERNAL "" FORCE)
endif()

add_subdirectory(libs/glm)

if (SR_COMMON_MESHOPTIMIZER)
    message(STATUS "SRCommon will be using meshoptimizer")

    add_compile_definitions(SR_COMMON_MESHOPTIMIZER)

    set(MESHOPT_BUILD_DEMO OFF CACHE INTERNAL "" FORCE)
    set(MESHOPT_BUILD_GLTFPACK OFF CACHE INTERNAL "" FORCE)
    set(MESHOPT_BUILD_SHARED_LIBS OFF CACHE INTERNAL "" FORCE)
    set(MESHOPT_INSTALL OFF CACHE INTERNAL "" FORCE)

    add_subdirectory(libs/meshoptimizer)
endif()

if (SR_UTILS_FMT_HEADER_ONLY)
    add_definitions(
        -DFMT_HEADER_ONLY
    )
endif()

if (SR_EMSCRIPTEN)
    #add_definitions(-DFMT_USE_CONSTEXPR=0)
endif()

add_subdirectory(libs/fmt)

if (SR_TRACY_ENABLE)
    add_definitions(-DTRACY_DELAYED_INIT)
    add_definitions(-DTRACY_MANUAL_LIFETIME)
    #add_subdirectory(libs/tracy)
    list(APPEND SR_UTILS_LINK_LIBRARIES libs/tracy/public/TracyClient.cpp)
endif()

add_subdirectory(libs/rapidyaml)
add_subdirectory(libs/entt)

include("${PROJECT_SOURCE_DIR}/cmake/BuildGenerator.cmake")
SR_COMMON_GENERATE_BUILD_SOURCES(${PROJECT_SOURCE_DIR})
SR_COMMON_GET_SOURCES(Utils)

list(APPEND SR_UTILS_LINK_LIBRARIES ${Utils_SOURCES})

define_property(GLOBAL PROPERTY SR_UTILS_INCLUDE_DIRECTORIES
    BRIEF_DOCS "Contains linkable libraries"
    FULL_DOCS "Contains paths to libraries for linking"
)

set_property(GLOBAL PROPERTY SR_UTILS_INCLUDE_DIRECTORIES "")

include(cmake/SRCommonIncludes.cmake)

if (SR_COMMON_ASIO)
    add_library(asio INTERFACE)
    target_include_directories(asio INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/libs/asio/asio/include)
    target_include_directories(asio INTERFACE ${CMAKE_CURRENT_BINARY_DIR}/libs/asio/asio/include)
endif()

if (SR_COMMON_GNS)
    message(STATUS "GameNetworkingSockets will be included in the build.")

    add_compile_definitions(SR_COMMON_GNS)
    set(BUILD_SHARED_LIB OFF CACHE INTERNAL "" FORCE)
    set(BUILD_STATIC_LIB ON CACHE INTERNAL "" FORCE)
    set(BUILD_EXAMPLES OFF CACHE INTERNAL "" FORCE)
    set(BUILD_TESTS OFF CACHE INTERNAL "" FORCE)
    set(BUILD_TOOLS OFF CACHE INTERNAL "" FORCE)
    set(ENABLE_ICE OFF CACHE INTERNAL "" FORCE)
    set(USE_STEAMWEBRTC OFF CACHE INTERNAL "" FORCE)
    set(LTO OFF CACHE INTERNAL "" FORCE)

    if (WIN32)
        set(USE_CRYPTO "BCrypt" CACHE STRING "" FORCE)
    else()
        set(USE_CRYPTO "OpenSSL" CACHE STRING "" FORCE)
    endif()

    add_subdirectory(libs/GameNetworkingSockets)
    SR_UTILS_INCLUDE_DIRECTORIES_APPEND(${CMAKE_CURRENT_SOURCE_DIR}/libs/GameNetworkingSockets/include)
endif()

if (SR_EFSW_USE)
    set(BUILD_SHARED_LIBS OFF CACHE INTERNAL "" FORCE)
    add_subdirectory(libs/efsw)
    SR_UTILS_INCLUDE_DIRECTORIES_APPEND(${CMAKE_CURRENT_SOURCE_DIR}/libs/efsw/include)
    add_compile_definitions(SR_EFSW_USE)
endif()

if (SR_COMMON_STATIC_LIBRARY)
    add_library(Utils STATIC ${SR_UTILS_LINK_LIBRARIES})
else()
    add_library(Utils SHARED ${SR_UTILS_LINK_LIBRARIES})
    add_library(Utils::lib ALIAS Utils)

    if (UNIX)
        target_compile_options(Utils PRIVATE -fPIC)
        if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
            target_link_libraries(Utils atomic)
        endif()
    endif()

    SR_COPY_SHARED_MODULE_TO_EXECUTABLE_FOLDER(Utils)
    SR_COPY_STATIC_LIBRARY_TO_LIBRARY_FOLDER(Utils)
endif()

if (SR_COMMON_USE_CLANG_EMULATION)
    target_compile_options(Utils PUBLIC "-Wno-microsoft-include")
    target_compile_options(Utils PUBLIC "-Wno-deprecated-declarations")
    target_compile_options(Utils PUBLIC "-Wno-delete-incomplete")
endif()

if (SR_USE_PCH)
    target_compile_definitions(Utils PUBLIC SR_USE_PCH)
    target_precompile_headers(Utils PUBLIC ${SR_COMMON_PCH_HEADER_PATH})
endif()

if (SR_TRACY_ENABLE)
    #target_link_libraries(Utils TracyClient)
    SR_UTILS_INCLUDE_DIRECTORIES_APPEND(libs/tracy/public)
endif()

if (UNIX AND NOT APPLE AND NOT SR_EMSCRIPTEN AND NOT ANDROID_NDK)
    find_package(TBB REQUIRED)
    target_link_libraries(Utils TBB::tbb)
endif()

if (NOT ANDROID_NDK AND UNIX AND NOT APPLE AND NOT SR_EMSCRIPTEN)
    target_link_libraries(Utils ${X11_LIBRARIES})
    target_link_libraries(Utils ${X11_Xrandr_LIB})
    SR_UTILS_INCLUDE_DIRECTORIES_APPEND(${X11_Xrandr_INCLUDE_PATH})

    target_link_libraries(Utils ${X11_Xfixes_LIB})
    SR_UTILS_INCLUDE_DIRECTORIES_APPEND(${X11_Xfixes_INCLUDE_PATH})

    if (X11_xcb_randr_FOUND)
        target_link_libraries(Utils ${X11_xcb_randr_LIB})
        SR_UTILS_INCLUDE_DIRECTORIES_APPEND(${X11_xcb_randr_INCLUDE_PATH})
    endif()

    target_link_libraries(Utils bfd)
endif()

if (WIN32)
    target_link_libraries(Utils wininet)
endif()

if (SR_COMMON_MYHTML)
    set(MyHTML_BUILD_WITHOUT_THREADS ON CACHE INTERNAL "" FORCE)
    set(MyCORE_BUILD_WITHOUT_THREADS ON CACHE INTERNAL "" FORCE)
    set(MyHTML_BUILD_SHARED OFF CACHE INTERNAL "" FORCE)
    set(PROJECT_OPTIMIZATION_LEVEL "" CACHE INTERNAL "" FORCE)

    add_compile_definitions(SR_COMMON_MYHTML)

    add_subdirectory(libs/myhtml)
    SR_UTILS_INCLUDE_DIRECTORIES_APPEND(${CMAKE_CURRENT_SOURCE_DIR}/libs/myhtml/include)
    target_link_libraries(Utils myhtml_static)
endif()

if (SR_COMMON_LITEHTML)
    add_subdirectory(libs/litehtml)
    SR_UTILS_INCLUDE_DIRECTORIES_APPEND(${CMAKE_CURRENT_SOURCE_DIR}/libs/litehtml/include)
    target_link_libraries(Utils litehtml)
endif()

include(cmake/SRCommonLinking.cmake)

if (MSVC)
    target_compile_options(Utils PUBLIC /openmp)
endif()

if (SR_UTILS_FMT_HEADER_ONLY)
else()
    target_link_libraries(Utils fmt::fmt)
endif()

target_link_libraries(Utils ryml::ryml EnTT)

if (SR_COMMON_CPPTRACE_ENABLED)
    target_link_libraries(Utils cpptrace::cpptrace)
endif()

get_property(SR_UTILS_INCLUDE_DIRECTORIES_CONTENT GLOBAL PROPERTY SR_UTILS_INCLUDE_DIRECTORIES)
message("SRCommon include directories: ${SR_UTILS_INCLUDE_DIRECTORIES_CONTENT}")
target_include_directories(Utils PUBLIC ${SR_UTILS_INCLUDE_DIRECTORIES_CONTENT})

set(SR_UTILS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} CACHE INTERNAL "" FORCE)
set(SR_UTILS_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR} CACHE INTERNAL "" FORCE)

include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/CopyFiles.cmake)

if (SR_COMMON_DLL_EXPORTS)
    message("SRCommon will be using DLL exports")
    target_compile_definitions(Utils PUBLIC SR_COMMON_DLL_EXPORTS)
endif()

set(SR_UTILS_DEPENDENCIES "")

if (NOT SR_COMMON_CI_BUILD)
    include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/CopyFiles.cmake)
    add_custom_target(CopyUtilsFiles)
    add_custom_command(TARGET CopyUtilsFiles
        PRE_BUILD
        COMMAND ${CMAKE_COMMAND}
            -DSR_UTILS_SOURCE_DIR=${SR_UTILS_SOURCE_DIR}
            -DSR_UTILS_BINARY_DIR=${SR_UTILS_BINARY_DIR}
            -DSR_ICU=${SR_ICU}
            -DSR_TRACY_ENABLE=${SR_TRACY_ENABLE}
            -P "${CMAKE_CURRENT_SOURCE_DIR}/cmake/CopyFiles.cmake"
        COMMENT "SRCommon: Copy utils source files to build directory"
    )

    set(SR_UTILS_DEPENDENCIES ${SR_UTILS_DEPENDENCIES} "CopyUtilsFiles")
endif()

SR_UTILS_INCLUDE_DIRECTORIES_APPEND(${CMAKE_CURRENT_BINARY_DIR}/include)
SR_UTILS_INCLUDE_DIRECTORIES_APPEND(${CMAKE_CURRENT_BINARY_DIR}/libs)
SR_UTILS_INCLUDE_DIRECTORIES_APPEND(${CMAKE_CURRENT_BINARY_DIR}/libs/cssparser)

if (SR_COMMON_ZLIB)
    SR_UTILS_INCLUDE_DIRECTORIES_APPEND(${CMAKE_CURRENT_BINARY_DIR}/libs/zlib)
endif()

if (SR_COMMON_CI_BUILD)
    message("SRCommon is built as a part of CI build.")

    file(WRITE cmake/main.cpp "int main() { return 0; }")
    add_executable(SR_UTILS_CI cmake/main.cpp)
    target_link_libraries(SR_UTILS_CI Utils)
endif()

if (SR_COMMON_EMBED_RESOURCES)
    add_dependencies(${PROJECT_NAME} CopyUtilsFiles EmbedResourcesTarget)
endif()

set_target_properties(Utils PROPERTIES
    BUILD_RPATH "\$ORIGIN"
    INSTALL_RPATH "\$ORIGIN"
)

if (MSVC AND NOT SR_COMMON_USE_CLANG_EMULATION)
    #target_compile_options(Utils PUBLIC /WX)
    #target_compile_options(Utils PUBLIC /W4)
    #target_compile_options(Utils PUBLIC /permissive- /sdl)
endif()