cmake_minimum_required(VERSION 3.5)

    set(BINARY_NAME openttd)

project(${BINARY_NAME})

    message(FATAL_ERROR "In-source builds not allowed. Please run \"cmake ..\" from the bin directory")

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake")

set(CMAKE_OSX_DEPLOYMENT_TARGET 10.9)

# Use GNUInstallDirs to allow customisation

# but set our own default data dir

    set(CMAKE_INSTALL_DATADIR "share/games")

include(GNUInstallDirs)

include(Options)

find_package(LZO)

find_package(PNG)

    find_package(Allegro)

        find_package(SDL2)

            find_package(SDL)

        find_package(Fluidsynth)

        find_package(Freetype)

        find_package(Fontconfig)

        find_package(ICU OPTIONAL_COMPONENTS i18n lx)

        find_package(XDG_basedir)

        find_package(Iconv)

        find_library(AUDIOTOOLBOX_LIBRARY AudioToolbox)

        find_library(AUDIOUNIT_LIBRARY AudioUnit)

        find_library(COCOA_LIBRARY Cocoa)

    find_package(Editbin REQUIRED)

find_package(SSE)

find_package(Xaudio2)

# IPO is only properly supported from CMake 3.9. Despite the fact we are

# CMake 3.5, still enable IPO if we detect we are 3.9+.

    cmake_policy(SET CMP0069 NEW)

    include(CheckIPOSupported)

    check_ipo_supported(RESULT IPO_FOUND)

show_options()

        message(FATAL_ERROR "SDL or SDL2 is required for this platform")

        message(FATAL_ERROR "AudioToolbox is required for this platform")

        message(FATAL_ERROR "AudioUnit is required for this platform")

        message(FATAL_ERROR "Cocoa is required for this platform")

    # C++17 for MSVC

    set(CMAKE_CXX_STANDARD 17)

    # C++11 for all other targets

    set(CMAKE_CXX_STANDARD 11)

set(CMAKE_CXX_STANDARD_REQUIRED YES)

set(CMAKE_CXX_EXTENSIONS NO)

set(CMAKE_EXPORT_COMPILE_COMMANDS YES)

list(APPEND GENERATED_SOURCE_FILES "${CMAKE_BINARY_DIR}/generated/rev.cpp")

    list(APPEND GENERATED_SOURCE_FILES "${CMAKE_BINARY_DIR}/generated/ottdres.rc")

# Generate a target to determine version, which is execute every 'make' run

add_custom_target(find_version

    Threads::Threads

)

    set_target_properties(openttd PROPERTIES INTERPROCEDURAL_OPTIMIZATION_RELEASE True)

    set_target_properties(openttd PROPERTIES INTERPROCEDURAL_OPTIMIZATION_MINSIZEREL True)

    set_target_properties(openttd PROPERTIES INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO True)

set_target_properties(openttd PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}/bin")

process_compile_flags()

    add_definitions(-DUNIX)

include(LinkPackage)

link_package(PNG TARGET PNG::PNG ENCOURAGED)

link_package(LZO ENCOURAGED)

link_package(XDG_basedir)

    link_package(Fluidsynth)

    link_package(SDL)

    link_package(SDL2 TARGET SDL2::SDL2)

    link_package(Fontconfig TARGET Fontconfig::Fontconfig)

    link_package(ICU_lx)

    link_package(ICU_i18n)

    link_package(Iconv TARGET Iconv::Iconv)

    target_link_libraries(openttd

        -DWITH_COCOA

        -DENABLE_COCOA_QUARTZ

    )

    add_definitions(

        -DWITH_PERSONAL_DIR

        -DPERSONAL_DIR="${PERSONAL_DIR}"

    )

    add_definitions(

        -DWITH_SHARED_DIR

        -DSHARED_DIR="${SHARED_DIR}"

    )

    add_definitions(

        -DGLOBAL_DATA_DIR="${GLOBAL_DIR}"

    )

link_package(SSE)

add_definitions_based_on_options()

    add_definitions(

        -DUNICODE

        -D_UNICODE

        winmm

        imm32

    )

    add_definitions(-D_SQ64)

include(CreateRegression)

create_regression()

    foreach(MULTI IN LISTS MULTIS)

        string(REPLACE "${MULTI}" "${MULTI};:::" COMMAND_LINE "${COMMAND_LINE}")

    cmake_parse_arguments(PARAM "${OPTIONS}" "${SINGLES}" "${MULTIS}" ${COMMAND_LINE})

endmacro()

    set(NEW_COMMAND_LINE ${PARAM_UNPARSED_ARGUMENTS})

    foreach(OPTION IN LISTS OPTIONS)

            list(APPEND NEW_COMMAND_LINE "${OPTION}")

    foreach(SINGLE IN LISTS SINGLES)

            list(APPEND NEW_COMMAND_LINE "${SINGLE}" "${PARAM_${SINGLE}}")

    foreach(MULTI IN LISTS MULTIS)

            # Replace our special marker with the name of the MULTI again. This

            # restores for example multiple COMMANDs again.

            string(REPLACE ":::" "${MULTI}" PARAM_${MULTI} "${PARAM_${MULTI}}")

            list(APPEND NEW_COMMAND_LINE "${PARAM_${MULTI}}")

endmacro()

# Generated files can be older than their dependencies, causing useless

    # Reset the OUTPUT and BYPRODUCTS as an empty list (if needed).

    # Because they are MULTIS, we need to add our special marker here.

    set(PARAM_OUTPUT ":::")

        set(PARAM_BYPRODUCTS ":::")

    foreach(OUTPUT IN LISTS OUTPUTS)

        # For every output, we add a 'cmake -E touch' entry to update the

        # add_custom_target_timestamp() to know if we should point to the

        # '.timestamp' variant or not.

        set_source_files_properties(${OUTPUT} PROPERTIES BYPRODUCT ${CMAKE_CURRENT_BINARY_DIR}/${OUTPUT_FILENAME}.timestamp)

    # Reassemble and call the wrapped command

    _reassemble_command_line()

    add_custom_command(${NEW_COMMAND_LINE})

# Generated files can be older than their dependencies, causing useless

# regenerations. This function adds a .timestamp file for each file in DEPENDS

        # Check if the output is produced by add_custom_command_timestamp()

        get_source_file_property(BYPRODUCT ${DEPEND} BYPRODUCT)

            # If it is not, just keep it as DEPEND

            list(APPEND PARAM_DEPENDS "${DEPEND}")

            # If it is, the BYPRODUCT property points to the timestamp we want to depend on

            list(APPEND PARAM_DEPENDS "${BYPRODUCT}")

    # Reassemble and call the wrapped command

    _reassemble_command_line()

    add_custom_target(${NEW_COMMAND_LINE})

# compile_flags()

#

macro(compile_flags)

        # Switch to MT (static) instead of MD (dynamic) binary

        # For MSVC two generators are available

        # C++11 standard". We need C++11 for the way we use threads.

        add_compile_options(/Zc:rvalueCast)

            # Enable multi-threaded compilation.

            add_compile_options(/MP)

        # Add DPI manifest to project; other WIN32 targets get this via ottdres.rc

        list(APPEND GENERATED_SOURCE_FILES "${CMAKE_SOURCE_DIR}/os/windows/openttd.manifest")

    # Add some -D flags for Debug builds. We cannot use add_definitions(), because

    # it does not appear to support the $<> tags.

        "$<$<CONFIG:Debug>:-D_DEBUG>"

        "$<$<NOT:$<CONFIG:Debug>>:-D_FORTIFY_SOURCE=2>" # FORTIFY_SOURCE should only be used in non-debug builds (requires -O1+)

    )

        add_link_options(

            "$<$<NOT:$<CONFIG:Debug>>:-fstack-protector>" # Prevent undefined references when _FORTIFY_SOURCE > 0

        )

    # Prepare a generator that checks if we are not a debug, and don't have asserts

    # on. We need this later on to set some compile options for stable releases.

    set(IS_STABLE_RELEASE "$<AND:$<NOT:$<CONFIG:Debug>>,$<NOT:$<BOOL:${OPTION_USE_ASSERTS}>>>")

        add_compile_options(/W3)

        add_compile_options(

            -W

            -Wall

        # When we are a stable release (Release build + USE_ASSERTS not set),

        # assertations are off, which trigger a lot of warnings. We disable

        # these warnings for these releases.

            add_compile_options(

                "$<${IS_STABLE_RELEASE}:-Wno-unused-variable>"

                "$<${IS_STABLE_RELEASE}:-Wno-unused-but-set-parameter>"

                "$<${IS_STABLE_RELEASE}:-Wno-unused-but-set-variable>"

            )

            add_compile_options(

                "$<${IS_STABLE_RELEASE}:-Wno-unused-variable>"

                "$<${IS_STABLE_RELEASE}:-Wno-unused-parameter>"

            )

        # Ninja processes the output so the output from the compiler

        # isn't directly to a terminal; hence, the default is

        # non-coloured output. We can override this to get nicely

        # coloured output, but since that might yield odd results with

        # IDEs, we extract it to an option.

                add_compile_options (-fdiagnostics-color=always)

                add_compile_options (-fcolor-diagnostics)

            include(CheckCXXCompilerFlag)

            check_cxx_compiler_flag("-flifetime-dse=1" LIFETIME_DSE_FOUND)

                # well with our custom pool item allocator

                "$<$<BOOL:${LIFETIME_DSE_FOUND}>:-flifetime-dse=1>"

            )

        add_compile_options(

            -Wall

            # warning #873: function ... ::operator new ... has no corresponding operator delete ...

            # warning #2160: anonymous union qualifier is ignored

            -wd2160

        )

        message(FATAL_ERROR "No warning flags are set for this compiler yet; please consider creating a Pull Request to add support for this compiler.")

        # rdynamic is used to get useful stack traces from crash reports.

        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -rdynamic")

endmacro()

        )

        list(APPEND GRF_PNG_BINARY_FILES ${GRF_PNG_BINARY_FILE})

    add_custom_command(OUTPUT ${GRF_BINARY_FILE}

            COMMAND ${CMAKE_COMMAND}

        string(REGEX REPLACE "^${CMAKE_SOURCE_DIR}/regression/" "${CMAKE_BINARY_DIR}/ai/" REGRESSION_BINARY_FILE "${REGRESSION_SOURCE_FILE}")

        string(REGEX REPLACE "^${CMAKE_SOURCE_DIR}/regression/" "" REGRESSION_SOURCE_FILE_NAME "${REGRESSION_SOURCE_FILE}")

            continue()

        add_custom_command(OUTPUT ${REGRESSION_BINARY_FILE}

                COMMAND ${CMAKE_COMMAND} -E copy

        )

        list(APPEND REGRESSION_BINARY_FILES ${REGRESSION_BINARY_FILE})

    # Copy the regression configuration in a special folder, so all autogenerated

    # folders end up in the same place after running regression.

    foreach(REGRESSION_TEST IN LISTS REGRESSION_TESTS)

        get_filename_component(REGRESSION_TEST_NAME "${REGRESSION_TEST}" NAME)

            continue()

        add_custom_target(regression_${REGRESSION_TEST_NAME}

                COMMAND ${CMAKE_COMMAND}

                WORKING_DIRECTORY ${CMAKE_BINARY_DIR})

        list(APPEND REGRESSION_TARGETS regression_${REGRESSION_TEST_NAME})

    # Create a new target which runs the regression

    add_custom_target(regression

    include(TestBigEndian)

    TEST_BIG_ENDIAN(IS_BIG_ENDIAN)

        add_definitions(-DTTD_ENDIAN=TTD_BIG_ENDIAN)

        add_definitions(-DTTD_ENDIAN=TTD_LITTLE_ENDIAN)

endfunction()

    VERSION_VAR Allegro_VERSION

)

    set(Allegro_LIBRARIES ${Allegro_LIBRARY})

    set(Allegro_INCLUDE_DIRS ${Allegro_INCLUDE_DIR})

mark_as_advanced(

    Allegro_INCLUDE_DIR

# Autodetect editbin. Only useful for MSVC.

        get_filename_component(MSVC_COMPILE_DIRECTORY ${CMAKE_CXX_COMPILER} DIRECTORY)

        set(EDITBIN_DIRECTORY ${MSVC_COMPILE_DIRECTORY})

        # For clang-cl build

        # find editbin.exe from environmental variable VCToolsInstallDir

        set(EDITBIN_DIRECTORY "$ENV{VCToolsInstallDir}/bin/Hostx64/x64")

message(CHECK_START "Finding editbin.exe")

find_program(

    HINTS ${EDITBIN_DIRECTORY}

)

    message(CHECK_PASS "found")

    message(CHECK_FAIL "not found , please manually specify EDITBIN_DIRECTORY")

include(FindPackageHandleStandardArgs)

find_package_handle_standard_args(Editbin

    VERSION_VAR Fluidsynth_VERSION

)

    set(Fluidsynth_LIBRARIES ${Fluidsynth_LIBRARY})

    set(Fluidsynth_INCLUDE_DIRS ${Fluidsynth_INCLUDE_DIR})

mark_as_advanced(

    Fluidsynth_INCLUDE_DIR

    ${PKG_FONTCONFIG_LIBRARY_DIRS}

)

  file(STRINGS ${Fontconfig_INCLUDE_DIR}/fontconfig/fontconfig.h _contents REGEX "^#define[ \t]+FC_[A-Z]+[ \t]+[0-9]+$")

  unset(Fontconfig_VERSION)

  foreach(VPART MAJOR MINOR REVISION)

      endif()

    endforeach()

  endforeach()

include(FindPackageHandleStandardArgs)

find_package_handle_standard_args(Fontconfig

set(ICU_KNOWN_COMPONENTS "uc" "i18n" "le" "lx" "io")

foreach(MOD_NAME IN LISTS ICU_FIND_COMPONENTS)

        message(FATAL_ERROR "Unknown ICU component: ${MOD_NAME}")

    endif()

    pkg_check_modules(PC_ICU_${MOD_NAME} QUIET icu-${MOD_NAME})

    foreach(LIBRARY IN LISTS PC_ICU_${MOD_NAME}_LIBRARIES)

        unset(PC_LIBRARY CACHE)

        find_library(PC_LIBRARY NAMES ${LIBRARY})

            unset(PC_ICU_${MOD_NAME}_FOUND)

        endif()

        list(APPEND PC_LIBRARIES ${PC_LIBRARY})

    endforeach()

    unset(PC_LIBRARY CACHE)

        set(ICU_COMPONENT_FOUND TRUE)

        set(ICU_${MOD_NAME}_FOUND TRUE)

        set(ICU_${MOD_NAME}_LIBRARIES ${PC_LIBRARIES})

# name as the optimized file. This is not always the case, but so far

# experiences has shown that in those case vcpkg CMake files do the right

# thing.

        set(LZO_LIBRARY_DEBUG ${LZO_LIBRARY})

        string(REPLACE "/debug/lib/" "/lib/" LZO_LIBRARY_RELEASE ${LZO_LIBRARY})

    else()

    VERSION_VAR LZO_VERSION

)

    set(LZO_LIBRARIES ${LZO_LIBRARY})

    set(LZO_INCLUDE_DIRS ${LZO_INCLUDE_DIR})

mark_as_advanced(

    LZO_INCLUDE_DIR

include(CheckCXXSourceCompiles)

set(CMAKE_REQUIRED_FLAGS "")

    set(CMAKE_REQUIRED_FLAGS "-msse4.1")

check_cxx_source_compiles("

    #include <xmmintrin.h>

    VERSION_VAR XDG_basedir_VERSION

)

    set(XDG_basedir_LIBRARIES ${XDG_basedir_LIBRARY})

    set(XDG_basedir_INCLUDE_DIRS ${XDG_basedir_INCLUDE_DIR})

mark_as_advanced(

    XDG_basedir_INCLUDE_DIR

include(GNUInstallDirs)

# If requested, use FHS layout; otherwise fall back to a flat layout.

    set(BINARY_DESTINATION_DIR "${CMAKE_INSTALL_BINDIR}")

    set(DATA_DESTINATION_DIR "${CMAKE_INSTALL_DATADIR}/${BINARY_NAME}")

    set(DOCS_DESTINATION_DIR "${CMAKE_INSTALL_DOCDIR}")

    set(MAN_DESTINATION_DIR "${CMAKE_INSTALL_MANDIR}")

    set(BINARY_DESTINATION_DIR ".")

    set(DATA_DESTINATION_DIR ".")

    set(DOCS_DESTINATION_DIR ".")

    set(MAN_DESTINATION_DIR ".")

install(TARGETS openttd

        RUNTIME

# A Linux manual only makes sense when using FHS. Otherwise it is a very odd

# file with little context to what it is.

    set(MAN_SOURCE_FILE ${CMAKE_SOURCE_DIR}/docs/openttd.6)

    set(MAN_BINARY_FILE ${CMAKE_BINARY_DIR}/docs/${BINARY_NAME}.6)

    install(CODE

                    ${MAN_BINARY_FILE}.gz

            DESTINATION ${MAN_DESTINATION_DIR}/man6

            COMPONENT manual)

# TODO -- Media files

# TODO -- Menu files

    set(ARCHITECTURE "amd64")

    string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" ARCHITECTURE)

# Windows is a bit more annoying to detect; using the size of void pointer

# seems to be the most robust.

        set(ARCHITECTURE "win64")

        set(ARCHITECTURE "win32")

set(CPACK_SYSTEM_NAME "${ARCHITECTURE}")

set(CPACK_STRIP_FILES YES)

set(CPACK_OUTPUT_FILE_PREFIX "bundles")

    set(CPACK_GENERATOR "Bundle")

    include(PackageBundle)

    set(CPACK_PACKAGE_FILE_NAME "openttd-#CPACK_PACKAGE_VERSION#-macosx")

    set(CPACK_GENERATOR "ZIP")

        list(APPEND CPACK_GENERATOR "NSIS")

        include(PackageNSIS)

    set(CPACK_PACKAGE_FILE_NAME "openttd-#CPACK_PACKAGE_VERSION#-windows-${CPACK_SYSTEM_NAME}")

    # With FHS, we can create deb/rpm/... Without it, they would be horribly broken

    # and not work. The other way around is also true; with FHS they are not

    # usable, and only flat formats work.

        set(CPACK_GENERATOR "DEB")

        include(PackageDeb)

        set(CPACK_GENERATOR "TXZ")

    set(CPACK_PACKAGE_FILE_NAME "openttd-#CPACK_PACKAGE_VERSION#-linux-${CPACK_SYSTEM_NAME}")

    message(FATAL_ERROR "Unknown OS found for packaging; please consider creating a Pull Request to add support for this OS.")

include(CPack)

function(link_package NAME)

    cmake_parse_arguments(LP "ENCOURAGED" "TARGET" "" ${ARGN})

        string(TOUPPER "${NAME}" UCNAME)

        add_definitions(-DWITH_${UCNAME})

            target_link_libraries(openttd ${LP_TARGET})

            message(STATUS "${NAME} found -- -DWITH_${UCNAME} -- ${LP_TARGET}")

        else()

            target_link_libraries(openttd ${${NAME}_LIBRARIES} ${${NAME}_LIBRARY})