CMakeLists.txt

cmake_minimum_required(VERSION 3.20)

if(PLAT_MACOS_X86_64)
    set(CMAKE_OSX_ARCHITECTURES "x86_64")

    set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
    set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
    set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
    set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

    set(GLEW_PATH "/usr/local/opt/glew")
    set(CMAKE_IGNORE_PATH "/opt/homebrew")
    set(CMAKE_IGNORE_PATH "/opt/homebrew/include")
    set(CMAKE_IGNORE_PATH "/opt/homebrew/lib")

    list(APPEND CMAKE_PREFIX_PATH /usr/local)
endif()

# Generated by scripts/increment_version.py to keep Flatpak
# and binary versions all in sync.
include(cmake_modules/version.cmake)
project(OpenJKDF2 VERSION ${OPENJKDF2_PROJECT_VERSION})

# All of our supported platforms
set(PLAT_LINUX_32 FALSE CACHE BOOL "Linux 32-bit target")
set(PLAT_LINUX_64 FALSE CACHE BOOL "Linux 64-bit target")
set(PLAT_MACOS FALSE CACHE BOOL "MacOS target")
set(PLAT_MACOS_X86_64 FALSE CACHE BOOL "MacOS x86_64")
set(PLAT_MINGW_X86_64 FALSE CACHE BOOL "MinGW Win64 target")
set(PLAT_WASM FALSE CACHE BOOL "Emscripten WASM target")
set(PLAT_HOOKS FALSE CACHE BOOL "Hook DLL target")
set(PLAT_MSVC FALSE CACHE BOOL "Windows 64-bit MSVC")
set(PLAT_ANDROID_ARM64 FALSE CACHE BOOL "Android AArch64")
set(PLAT_TWL FALSE CACHE BOOL "Nintendo DSi")
set(PLAT_AUTO FALSE CACHE BOOL "Target the host OS")

# Set PLAT_AUTO if a platform isn't specifically selected
if(NOT PLAT_LINUX_32 AND NOT PLAT_LINUX_64 AND NOT PLAT_MACOS AND NOT PLAT_MACOS_X86_64 AND NOT PLAT_MINGW_X86_64 AND NOT PLAT_WASM AND NOT PLAT_HOOKS AND NOT PLAT_TWL)
    set(PLAT_AUTO TRUE)
endif()

# Internal targets: Stuff like OpenGL vs D3D, OpenAL vs null sound, etc
set(TARGET_COMPILE_FREEGLUT FALSE)
set(TARGET_USE_CURL FALSE)
set(TARGET_USE_PHYSFS FALSE)
set(TARGET_USE_BASICSOCKETS FALSE)
set(TARGET_USE_GAMENETWORKINGSOCKETS FALSE)
set(TARGET_USE_LIBSMACKER FALSE)
set(TARGET_USE_LIBSMUSHER FALSE)
set(TARGET_USE_SDL2 FALSE)
set(TARGET_USE_OPENGL FALSE)
set(TARGET_USE_OPENAL FALSE)
set(TARGET_USE_D3D FALSE)
set(TARGET_POSIX FALSE)
set(TARGET_LINUX FALSE)
set(TARGET_MACOS FALSE)
set(TARGET_WIN32 FALSE)
set(TARGET_WASM FALSE)
set(TARGET_ANDROID FALSE)
set(TARGET_ANDROID_ARM64 FALSE)
set(TARGET_TWL FALSE)
set(TARGET_HOOKS FALSE)
set(TARGET_NO_BLOBS FALSE)
set(TARGET_CAN_JKGM FALSE)
set(OPENJKDF2_USE_BLOBS FALSE CACHE BOOL "Use blobs")

# Options for compiling
if(DEFINED ENV{TARGET_BUILD_TESTS})
    set(TARGET_BUILD_TESTS $ENV{TARGET_BUILD_TESTS})
else()
    set(TARGET_BUILD_TESTS FALSE)
endif()

set(DEBUG_QOL_CHEATS $ENV{DEBUG_QOL_CHEATS})

# Options for compiling
if(DEFINED ENV{OPENJKDF2_NO_ASAN})
    set(OPENJKDF2_NO_ASAN $ENV{OPENJKDF2_NO_ASAN})
else()
    set(OPENJKDF2_NO_ASAN TRUE)
endif()

if(${CMAKE_SYSTEM_NAME} MATCHES "Linux" AND PLAT_AUTO)
    set(PLAT_LINUX_64 TRUE)
elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin" AND PLAT_AUTO)
    set(PLAT_MACOS TRUE)
elseif(${CMAKE_SYSTEM_NAME} MATCHES "Windows" AND PLAT_AUTO)
    set(PLAT_MSVC TRUE)
endif()

# General defs
add_compile_definitions(
    OPENJKDF2_PROJECT_NAME=${PROJECT_NAME}
    OPENJKDF2_PROJECT_VERSION=${PROJECT_VERSION}
    OPENJKDF2_MAJOR_VERSION=${PROJECT_VERSION_MAJOR}
    OPENJKDF2_MINOR_VERSION=${PROJECT_VERSION_MINOR}
    OPENJKDF2_PATCH_VERSION=${PROJECT_VERSION_PATCH}
    OPENJKDF2_TWEAK_VERSION=${PROJECT_VERSION_TWEAK}
    OPENJKDF2_RELEASE_VERSION_STRING=\"v${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}\"
    OPENJKDF2_RELEASE_VERSION_STRING_W=L\"v${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}\"
    OPENJKDF2_RELEASE_COMMIT=\"${OPENJKDF2_RELEASE_COMMIT}\"
    OPENJKDF2_RELEASE_COMMIT_SHORT=\"${OPENJKDF2_RELEASE_COMMIT_SHORT}\"
    OPENJKDF2_RELEASE_COMMIT_W=L\"${OPENJKDF2_RELEASE_COMMIT}\"
    OPENJKDF2_RELEASE_COMMIT_SHORT_W=L\"${OPENJKDF2_RELEASE_COMMIT_SHORT}\"
    QOL_IMPROVEMENTS
)

set(CMAKE_C_STANDARD 11)
set(CMAKE_C_STANDARD_REQUIRED TRUE)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED TRUE)

# Default macros
macro(plat_link_and_package)
    message(FATAL_ERROR "Unknown target! Cannot continue.")
endmacro()
macro(plat_extra_deps)
endmacro()

if(PLAT_LINUX_32)
    include(cmake_modules/plat_linux_32.cmake)
elseif(PLAT_LINUX_64)
    include(cmake_modules/plat_linux_64.cmake)
elseif(PLAT_MACOS)
    include(cmake_modules/plat_macos.cmake)
elseif(PLAT_MACOS_X86_64)
    include(cmake_modules/plat_macos_x86_64.cmake)
elseif(PLAT_MINGW_X86_64)
    include(cmake_modules/plat_mingw_x86_64.cmake)
elseif(PLAT_WASM)
    include(cmake_modules/plat_wasm.cmake)
elseif(PLAT_HOOKS)
    include(cmake_modules/plat_hooks.cmake)
elseif(PLAT_ANDROID_ARM64)
    include(cmake_modules/plat_android_arm64.cmake)
elseif(PLAT_MSVC)
    include(cmake_modules/plat_msvc.cmake)
elseif(PLAT_TWL)
    include(cmake_modules/plat_twl.cmake)
else()
    message(FATAL_ERROR "Unknown platform! Cannot continue.")
endif()

# Establishes compile options, binary/library names, defines, etc
plat_initialize()

if(NOT CMAKE_BUILD_TYPE)
  set(CMAKE_BUILD_TYPE Release)
endif()

# CMake module paths
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake_modules")
if(TARGET_LINUX OR TARGET_MACOS OR PLAT_MSVC OR TARGET_ANDROID)
    list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake_modules_linux")
endif()

if(TARGET_ANDROID)
    set(GLEW_INCLUDE_DIRS "")
endif()

if(TARGET_USE_OPENAL AND TARGET_FIND_OPENAL)
    find_package(OpenAL REQUIRED)
endif()

# idk
set(JSON_Install OFF CACHE INTERNAL "")
add_subdirectory(${CMAKE_SOURCE_DIR}/3rdparty/json)

# All of the includes
include_directories(
    ${PROJECT_SOURCE_DIR}/src
    ${PROJECT_SOURCE_DIR}/src/external/libsmacker
    ${PROJECT_SOURCE_DIR}/src/external/libsmusher/src
    ${PROJECT_SOURCE_DIR}/src/external/nativefiledialog-extended
)

if(TARGET_USE_SDL2)
    include_directories(${SDL_INCLUDE_DIRS} ${SDL_MIXER_INCLUDE_DIRS})
endif()

if(TARGET_USE_OPENAL AND NOT OPENAL_COMPILING_FROM_SRC)
    include_directories(${OPENAL_INCLUDE_DIR})
endif()

# All of the base sources
file(GLOB ENGINE_SOURCE_FILES ${PROJECT_SOURCE_DIR}/src/*.c
                       ${PROJECT_SOURCE_DIR}/src/*/*.c
                       ${PROJECT_SOURCE_DIR}/src/General/*.cpp
                       ${PROJECT_SOURCE_DIR}/src/Platform/Common/*.c
                       ${PROJECT_SOURCE_DIR}/src/Platform/Common/*.cpp)

# Game main
file(GLOB GAME_MAIN_SOURCE_FILES ${PROJECT_SOURCE_DIR}/src/main.c)

# Remove test sources from glob
file(GLOB TEST_SRCS ${PROJECT_SOURCE_DIR}/src/Tests/*.c)
list(REMOVE_ITEM ENGINE_SOURCE_FILES ${TEST_SRCS})
list(REMOVE_ITEM ENGINE_SOURCE_FILES ${PROJECT_SOURCE_DIR}/src/main.c)

# Fcaseopen
file(GLOB FCASEOPEN_SRCS ${PROJECT_SOURCE_DIR}/src/external/fcaseopen/*.c)
list(APPEND ENGINE_SOURCE_FILES ${FCASEOPEN_SRCS})
include_directories(${PROJECT_SOURCE_DIR}/src/external/fcaseopen)

# The rest of the conditional/TARGET_* dependencies
include(cmake_modules/config_platform_deps.cmake)

# globals.c/globals.c/precompiled resources preprocessing.
# This includes selection for most of the files in src/platform/*
include(cmake_modules/precompile_globals.cmake)

#set( CMAKE_VERBOSE_MAKEFILE on )

add_library(sith_engine OBJECT ${ENGINE_SOURCE_FILES})
plat_specific_deps()

if(TARGET_ANDROID)
    add_library(${BIN_NAME} SHARED ${GAME_MAIN_SOURCE_FILES})
    target_link_libraries(${BIN_NAME} PRIVATE ${SDL2_COMMON_LIBS} sith_engine)
elseif(TARGET_HOOKS)
    add_library(${BIN_NAME} SHARED ${GAME_MAIN_SOURCE_FILES})
    add_library("${BIN_NAME}_kvm" SHARED ${GAME_MAIN_SOURCE_FILES})

    SET_TARGET_PROPERTIES(${BIN_NAME} PROPERTIES PREFIX "")
    SET_TARGET_PROPERTIES("${BIN_NAME}_kvm" PROPERTIES PREFIX "")

    target_link_libraries(${BIN_NAME} PRIVATE ${SDL2_COMMON_LIBS} sith_engine)
    target_link_libraries(${BIN_NAME}_kvm PRIVATE  ${SDL2_COMMON_LIBS} sith_engine)
else()
    add_executable(${BIN_NAME} ${GAME_MAIN_SOURCE_FILES})
    target_link_libraries(${BIN_NAME} PRIVATE ${SDL2_COMMON_LIBS} sith_engine)

    if(TARGET_BUILD_TESTS AND TARGET_MACOS)
        add_executable(rle_test src/Tests/rle_test.c)
        target_link_libraries(rle_test PRIVATE ${SDL2_COMMON_LIBS} sith_engine)
        macos_target_add_standard_deps(rle_test)
    endif()
endif()

# TODO byacc and flex

# Allow platforms to add extra dependencies, ie Frameworks on macOS or PkgConfig on Linux
plat_extra_deps()

if(NOT OPENJKDF2_NO_ASAN)
    #add_compile_options(-fsanitize=address -fsanitize=float-divide-by-zero)
    #add_link_options(-fsanitize=address -fsanitize=float-divide-by-zero)
    
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fsanitize=float-divide-by-zero")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fsanitize=float-divide-by-zero")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address -fsanitize=float-divide-by-zero")
    set(SANITIZE_ADDRESS TRUE)
    target_link_libraries(${BIN_NAME} PRIVATE "-static-libsan")

    #add_compile_options(-fsanitize=leak)
    #add_link_options(-fsanitize=leak)
endif()

include(cmake_modules/misc_stdcpp_fs_fix.cmake)

# Runs all the target_link_libraries, platform-specific post-build packaging, etc
plat_link_and_package()