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)

set_options()

set_directory_options()

find_package(ZLIB)

find_package(LibLZMA)

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)

find_package(Grfcodec)

# 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

        ${CMAKE_COMMAND}

                -DFIND_VERSION_BINARY_DIR=${CMAKE_BINARY_DIR}/generated

                -DCPACK_BINARY_DIR=${CMAKE_BINARY_DIR}

    openttd::settings

    openttd::basesets

    openttd::script_api

    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(ZLIB TARGET ZLIB::ZLIB ENCOURAGED)

link_package(LIBLZMA TARGET LibLZMA::LibLZMA ENCOURAGED)

link_package(LZO ENCOURAGED)

link_package(XDG_basedir)

    link_package(Fluidsynth)

    link_package(SDL)

    link_package(SDL2 TARGET SDL2::SDL2)

    link_package(Allegro)

    link_package(FREETYPE TARGET Freetype::Freetype)

    link_package(Fontconfig TARGET Fontconfig::Fontconfig)

    link_package(ICU_lx)

    link_package(ICU_i18n)

    link_package(Iconv TARGET Iconv::Iconv)

    target_link_libraries(openttd

        ${AUDIOTOOLBOX_LIBRARY}

        ${AUDIOUNIT_LIBRARY}

        ${COCOA_LIBRARY}

    )

    add_definitions(

        -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

        -DWITH_UNISCRIBE

    )

    target_link_libraries(openttd

        ws2_32

        winmm

        imm32

    )

    add_definitions(-D_SQ64)

include(CreateRegression)

create_regression()

include(InstallAndPackage)

    # the wrapped command with _reassemble_command_line().

    set(COMMAND_LINE "${ORIGINAL_COMMAND_LINE}")

    foreach(MULTI IN LISTS MULTIS)

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

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

endmacro()

macro(_reassemble_command_line)

    # Reassemble the command line as we original got it.

    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

# regenerations. This function replaces each file in OUTPUT with a .timestamp

# file, adds a command to touch it and move the original file in BYPRODUCTS,

# before calling add_custom_command().

    # Create a list of all the OUTPUTs (by removing our magic marker)

    string(REPLACE ":::;" "" OUTPUTS "${PARAM_OUTPUT}")

    # 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

        # timestamp on each run.

        get_filename_component(OUTPUT_FILENAME ${OUTPUT} NAME)

        string(APPEND PARAM_COMMAND ";:::;${CMAKE_COMMAND};-E;touch;${CMAKE_CURRENT_BINARY_DIR}/${OUTPUT_FILENAME}.timestamp")

        list(APPEND PARAM_BYPRODUCTS ${OUTPUT})

        # Mark this file as being a byproduct; we use this again with

        # 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

# replaced by add_custom_command_timestamp(), before calling add_custom_target().

#

# add_custom_target_timestamp(Name [ALL] [command1 [args1...]]

    set(PARAM_DEPENDS ":::")

    foreach(DEPEND IN LISTS 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})

# Macro which contains all bits to setup the compile flags correctly.

#

# compile_flags()

#

macro(compile_flags)

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

        # For MSVC two generators are available

        # - a command line generator (Ninja) using CMAKE_BUILD_TYPE to specify the

        #   configuration of the build tree

        # - an IDE generator (Visual Studio) using CMAKE_CONFIGURATION_TYPES to

        endforeach()

        # "If /Zc:rvalueCast is specified, the compiler follows section 5.4 of the

        # 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.

    add_compile_options(

        "$<$<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

            -Wcast-qual

            -Wextra

            -Wsign-compare

            -fno-strict-aliasing

        )

        # 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)

            add_compile_options(

                # GCC 4.2+ automatically assumes that signed overflows do

                # not occur in signed arithmetics, whereas we are not

                "-fno-tree-vrp"

                # -flifetime-dse=2 (default since GCC 6) doesn't play

                # 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 ...

            -wd873

            # warning #1292: unknown attribute "fallthrough"

            -wd1292

            # warning #1899: multicharacter character literal (potential portability problem)

            -wd1899

            # 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()

                        ${GRF_PNG_BINARY_FILE}

                MAIN_DEPENDENCY ${GRF_PNG_SOURCE_FILE}

                COMMENT "Copying ${GRF_PNG_SOURCE_FILE_NAME} sprite file"

        )

        list(APPEND GRF_PNG_BINARY_FILES ${GRF_PNG_BINARY_FILE})

    add_custom_command(OUTPUT ${GRF_BINARY_FILE}

            COMMAND ${CMAKE_COMMAND}

                    -DGRF_SOURCE_FOLDER=${CMAKE_CURRENT_SOURCE_DIR}

                    -DGRF_BINARY_FILE=${GRF_BINARY_FILE}

                    -DNFORENUM_EXECUTABLE=${NFORENUM_EXECUTABLE}

    # build folder before we can run the regression

    file(GLOB_RECURSE REGRESSION_SOURCE_FILES ${CMAKE_SOURCE_DIR}/regression/*)

    foreach(REGRESSION_SOURCE_FILE IN LISTS REGRESSION_SOURCE_FILES)

        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

                        ${REGRESSION_SOURCE_FILE}

                        ${REGRESSION_BINARY_FILE}

                MAIN_DEPENDENCY ${REGRESSION_SOURCE_FILE}

                COMMENT "Copying ${REGRESSION_SOURCE_FILE_NAME} regression file"

        )

        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.

    add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/regression/regression.cfg

            COMMAND ${CMAKE_COMMAND} -E copy

                    ${CMAKE_SOURCE_DIR}/regression/regression.cfg

    # Find all the tests we have, and create a target for them

    file(GLOB REGRESSION_TESTS ${CMAKE_SOURCE_DIR}/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}

                        -DOPENTTD_EXECUTABLE=$<TARGET_FILE:openttd>

                        -DEDITBIN_EXECUTABLE=${EDITBIN_EXECUTABLE}

                        -DREGRESSION_TEST=${REGRESSION_TEST_NAME}

                        -DEDITBIN_EXECUTABLE=${EDITBIN_EXECUTABLE}

                        -DREGRESSION_TEST=${REGRESSION_TEST_NAME}

                        -P "${CMAKE_SOURCE_DIR}/cmake/scripts/Regression.cmake"

                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

            DEPENDS ${REGRESSION_TARGETS})

endmacro()

# add_endian_definition()

#

function(add_endian_definition)

    include(TestBigEndian)

    TEST_BIG_ENDIAN(IS_BIG_ENDIAN)

        add_definitions(-DTTD_ENDIAN=TTD_BIG_ENDIAN)

        add_definitions(-DTTD_ENDIAN=TTD_LITTLE_ENDIAN)

endfunction()

    REQUIRED_VARS

        Allegro_LIBRARY

        Allegro_INCLUDE_DIR

    VERSION_VAR Allegro_VERSION

)

    set(Allegro_LIBRARIES ${Allegro_LIBRARY})

    set(Allegro_INCLUDE_DIRS ${Allegro_INCLUDE_DIR})

mark_as_advanced(

    Allegro_INCLUDE_DIR

    Allegro_LIBRARY

)

# 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(

    EDITBIN_EXECUTABLE editbin.exe

    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

    FOUND_VAR EDITBIN_FOUND

    REQUIRED_VARS EDITBIN_EXECUTABLE

)

    REQUIRED_VARS

        Fluidsynth_LIBRARY

        Fluidsynth_INCLUDE_DIR

    VERSION_VAR Fluidsynth_VERSION

)

    set(Fluidsynth_LIBRARIES ${Fluidsynth_LIBRARY})

    set(Fluidsynth_INCLUDE_DIRS ${Fluidsynth_INCLUDE_DIR})

mark_as_advanced(

    Fluidsynth_INCLUDE_DIR

    Fluidsynth_LIBRARY

)

  NAMES

    fontconfig

  PATHS

    ${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)

    foreach(VLINE ${_contents})

      if(VLINE MATCHES "^#define[\t ]+FC_${VPART}[\t ]+([0-9]+)$")

        set(Fontconfig_VERSION_PART "${CMAKE_MATCH_1}")

        else()

          set(Fontconfig_VERSION "${Fontconfig_VERSION_PART}")

        endif()

      endif()

    endforeach()

  endforeach()

include(FindPackageHandleStandardArgs)

find_package_handle_standard_args(Fontconfig

  FOUND_VAR

    Fontconfig_FOUND

  REQUIRED_VARS

find_package(PkgConfig QUIET)

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})

    # Check the libraries returned by pkg-config really exist.

    unset(PC_LIBRARIES)

    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})

        set(ICU_${MOD_NAME}_INCLUDE_DIRS ${PC_ICU_${MOD_NAME}_INCLUDE_DIRS})

        set(ICU_VERSION ${PC_ICU_${MOD_NAME}_VERSION})

    endif()

# with Windows.

#

# NOTE: this is based on the assumption that the debug file has the same

# 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()

        set(LZO_LIBRARY_RELEASE ${LZO_LIBRARY})

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

    endif()

    REQUIRED_VARS

        LZO_LIBRARY

        LZO_INCLUDE_DIR

    VERSION_VAR LZO_VERSION

)

    set(LZO_LIBRARIES ${LZO_LIBRARY})

    set(LZO_INCLUDE_DIRS ${LZO_INCLUDE_DIR})

mark_as_advanced(

    LZO_INCLUDE_DIR

    LZO_LIBRARY

)

# Autodetect if SSE4.1 can be used. If so, the assumption is, so can the other

# SSE version (SSE 2.0, SSSE 3.0).

include(CheckCXXSourceCompiles)

set(CMAKE_REQUIRED_FLAGS "")

    set(CMAKE_REQUIRED_FLAGS "-msse4.1")