CMakeLists.txt

cmake_minimum_required (VERSION 3.16)

project (pygmalion)

set (pygmalion_VERSION_MAJOR 0)
set (pygmalion_VERSION_MINOR 1)

ENABLE_TESTING()

include(CheckCXXCompilerFlag)

option(OPTIMIZE_FOR_BMI "Build for BMI" OFF)
option(OPTIMIZE_FOR_BMI2 "Build for BMI2" OFF)
option(OPTIMIZE_FOR_AVX2 "Build for AVX2" OFF)
option(OPTIMIZE_FOR_AVX "Build for AVX" OFF)
option(OPTIMIZE_FOR_NATIVE "Build with -march=native" OFF)

option(OPTIMIZE_LINK_TIME "Link time optimizations" OFF)


option(USE_COMPACT_SLIDERS "Build with compact slider magics" OFF)
option(USE_INDIRECT_SLIDERS "Build with indirect slider magics" OFF)

option(BUILD_TESTS "Build with tests" OFF)
option(BUILD_MODULE_ENGINES "Build module engines" OFF)


if(USE_COMPACT_SLIDERS)
    add_definitions(-DPYGMALION_SLIDERMAGIC_COMPACT)
    message("-- building with compact slider magics")
else()
    message("-- NOT building with compact slider magics")
endif()

if(USE_INDIRECT_SLIDERS)
    add_definitions(-DPYGMALION_SLIDERMAGIC_INDIRECT)
    message("-- building with indirect slider magics")
else()
    message("-- NOT building with indirect slider magics")
endif()

if(MSVC)
    CHECK_CXX_COMPILER_FLAG("/bigobj" COMPILER_SUPPORTS_BIGOBJ)
    if(COMPILER_SUPPORTS_BIGOBJ )
        add_compile_options("/bigobj")
    endif()
    if(OPTIMIZE_FOR_BMI)
        add_definitions(-DPYGMALION_CPU_BMI)
        if(OPTIMIZE_FOR_BMI2)
            add_definitions(-DPYGMALION_CPU_BMI2)
        endif()
    endif()

    if(OPTIMIZE_FOR_AVX2)
        CHECK_CXX_COMPILER_FLAG("/arch:AVX2" COMPILER_SUPPORTS_ARCH_AVX2)
        if(COMPILER_SUPPORTS_ARCH_AVX2 )
            message("-- building with /arch:AVX2")
            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:AVX2")
        else()
            message("-- NOT building with /arch:AVX2")
        endif()
    else()
        if(OPTIMIZE_FOR_AVX)
            CHECK_CXX_COMPILER_FLAG("/arch:AVX" COMPILER_SUPPORTS_ARCH_AVX)
            if(COMPILER_SUPPORTS_ARCH_AVX )
                message("-- building with /arch:AVX")
                set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:AVX")
            else()
                message("-- NOT building with /arch:AVX")
            endif()
        endif()
    endif()
else()
    if(OPTIMIZE_FOR_BMI)
        message("-- trying to build with -mbmi")
        CHECK_CXX_COMPILER_FLAG("-mbmi" COMPILER_SUPPORTS_MBMI)
        if(COMPILER_SUPPORTS_MBMI)
            message("-- building with -mbmi")
            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mbmi")
        else()
            message("-- NOT building with -mbmi")
        endif()
    endif()
    if(OPTIMIZE_FOR_BMI2)
        message("-- trying to build with -mbmi2")
        CHECK_CXX_COMPILER_FLAG("-mbmi2" COMPILER_SUPPORTS_MBMI2)
        if(COMPILER_SUPPORTS_MBMI2)
            message("-- building with -mbmi2")
            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mbmi2")
        else()
            message("-- NOT building with -mbmi2")
        endif()
    endif()
    if(OPTIMIZE_FOR_AVX2)
        message("-- trying to build with -mavx2")
        CHECK_CXX_COMPILER_FLAG("-mavx2" COMPILER_SUPPORTS_MAVX2)
        if(COMPILER_SUPPORTS_MAVX2)
            message("-- building with -mavx2")
            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx2")
        else()
            message("-- NOT building with -mavx2")
            message("-- trying to build with -mavx")
            CHECK_CXX_COMPILER_FLAG("-mavx" COMPILER_SUPPORTS_MAVX)
            if(COMPILER_SUPPORTS_MAVX)
                message("-- building with -mavx")
                set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx")
            else()
                message("-- NOT building with -mavx")
            endif()
        endif()
    else()
        if(OPTIMIZE_FOR_AVX)
            message("-- trying to build with -mavx")
            CHECK_CXX_COMPILER_FLAG("-mavx" COMPILER_SUPPORTS_MAVX)
            if(COMPILER_SUPPORTS_MAVX)
                message("-- building with -mavx")
                set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx")
            else()
                message("-- NOT building with -mavx")
            endif()
        endif()
    endif()
# Modify compile flags to change optimization level from O2 to O3
string(REGEX REPLACE "([\\/\\-]O)2" "\\13"
  CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
string(REGEX REPLACE "([\\/\\-]O)2" "\\13"
  CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
string(REGEX REPLACE "([\\/\\-]O)2" "\\13"
  CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL}")
string(REGEX REPLACE "([\\/\\-]O)2" "\\13"
  CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
endif()
    
if(OPTIMIZE_FOR_NATIVE)
    message("-- trying to build with -march=native")
    CHECK_CXX_COMPILER_FLAG("-march=native" COMPILER_SUPPORTS_MARCH_NATIVE)
    if(COMPILER_SUPPORTS_MARCH_NATIVE)
        message("-- building with -march=native")
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
    else()
        message("-- NOT building with -march=native")
    endif()
endif()

if(OPTIMIZE_LINK_TIME)
    message("-- trying to build with -flto")
    CHECK_CXX_COMPILER_FLAG("-flto" COMPILER_SUPPORTS_FLTO)
    if(COMPILER_SUPPORTS_FLTO)
        message("-- building with -flto")
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto")
    else()
        message("-- NOT building with -flto")
    endif()
else()
    message("-- NOT building with -flto")
endif()

add_subdirectory(pygmalion-intrinsics)
add_subdirectory(pygmalion-state)
add_subdirectory(pygmalion-mechanics)
add_subdirectory(pygmalion-dynamics)
add_subdirectory(pygmalion-evaluation)
add_subdirectory(pygmalion-search)
add_subdirectory(pygmalion-frontend)

add_subdirectory(pygmalion-tictactoe-state)
add_subdirectory(pygmalion-tictactoe-mechanics)
add_subdirectory(pygmalion-tictactoe-dynamics)
add_subdirectory(pygmalion-tictactoe-evaluation)
add_subdirectory(pygmalion-tictactoe-search)

add_subdirectory(pygmalion-chess-state)
add_subdirectory(pygmalion-chess-mechanics)
add_subdirectory(pygmalion-chess-dynamics)
add_subdirectory(pygmalion-chess-evaluation)
add_subdirectory(pygmalion-chess-search)
add_subdirectory(pygmalion-chess-frontend)