OrcaSlicer/deps/CMakeLists.txt

if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "4.0")
    set(CMAKE_POLICY_VERSION_MINIMUM 3.5 CACHE STRING "" FORCE)
endif()

#
# This CMake project downloads, configures and builds OrcaSlicer dependencies on Unix and Windows.
#
# When using this script, it's recommended to perform an out-of-source build using CMake.
#
# All the dependencies are installed in a `destdir` directory in the root of the build directory,
# in a traditional Unix-style prefix structure. The destdir can be used directly by CMake
# when building OrcaSlicer - to do this, set the CMAKE_PREFIX_PATH to ${destdir}/usr/local.
# Warning: On UNIX/Linux, you also need to set -DSLIC3R_STATIC=1 when building OrcaSlicer.
#
# For better clarity of console output, it's recommended to _not_ use a parallelized build
# for the top-level command, ie. use `make -j 1` or `ninja -j 1` to force single-threaded top-level
# build. This doesn't degrade performance as individual dependencies are built in parallel fashion
# if supported by the dependency.
#
# On Windows, architecture (64 vs 32 bits) is judged based on the compiler variant.
# To build dependencies for either 64 or 32 bit OS, use the respective compiler command line.
#
# WARNING: On UNIX platforms wxWidgets hardcode the destdir path into its `wx-config` utility,
# therefore, unfortunately, the installation cannot be copied/moved elsewhere without re-installing wxWidgets.
#

cmake_minimum_required(VERSION 3.2)
if (APPLE)
    # if CMAKE_OSX_DEPLOYMENT_TARGET is not set, set it to 12.0 (the lowest Xcode 27 accepts)
    if (NOT CMAKE_OSX_DEPLOYMENT_TARGET)
        set(CMAKE_OSX_DEPLOYMENT_TARGET "12.0" CACHE STRING "Minimum OS X deployment version" FORCE)
    endif ()
    message(STATUS "CMAKE_OSX_DEPLOYMENT_TARGET: ${CMAKE_OSX_DEPLOYMENT_TARGET}")

endif ()

if(POLICY CMP0135) # DOWNLOAD_EXTRACT_TIMESTAMP
    cmake_policy(SET CMP0135 NEW)
endif()

# project() reads this, so set it first. scripts/flatpak/make_deps_tar.sh packs deps/
# without cmake/, so the file is missing in a Flatpak build.
set(_rules_override "${CMAKE_CURRENT_LIST_DIR}/../cmake/modules/ClangClShowIncludes.cmake")
if (EXISTS "${_rules_override}")
    set(CMAKE_USER_MAKE_RULES_OVERRIDE "${_rules_override}")
endif ()
unset(_rules_override)

project(OrcaSlicer-deps)

# Backward compatibility for old CMake versions
if (CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_VERSION VERSION_LESS "3.25")
    set(LINUX ON CACHE BOOL "" FORCE)
endif ()

include(ExternalProject)
include(ProcessorCount)

ProcessorCount(NPROC)
if (NPROC EQUAL 0)
    set(NPROC 1)
endif ()

set(DEP_DOWNLOAD_DIR ${CMAKE_CURRENT_SOURCE_DIR}/DL_CACHE CACHE PATH "Path for downloaded source packages.")
set(FLATPAK FALSE CACHE BOOL "Toggles various build settings for flatpak, like /usr/local in DESTDIR or not building wxwidgets")
option(SLIC3R_CAD "Build the SolveSpace solver and OCCT ModelingAlgorithms module the parametric Design/CAD tab needs. Must match the main project's SLIC3R_CAD." ON)

if ("${DESTDIR}" STREQUAL "" OR "${DESTDIR}" STREQUAL "${AUTOGENERATED_DESTDIR}")
    if (LINUX AND (NOT DEFINED USE_OLD_DESTDIR_PREV OR USE_OLD_DESTDIR_PREV) AND EXISTS "${CMAKE_BINARY_DIR}/destdir/usr/local" AND NOT EXISTS "${CMAKE_BINARY_DIR}/OrcaSlicer_dep/usr/local")
        set(USE_OLD_DESTDIR TRUE)
        message(WARNING "You are using an old directory name for dependencies that is being deprecated. "
                "Please remove the \"destdir\" directory and rebuild to update to the new name. "
                "The current \"destdir\" directory will be used until then.")
    endif ()
    if (NOT USE_OLD_DESTDIR AND USE_OLD_DESTDIR_PREV)
        set(REGEN_DESTDIR TRUE)
    endif ()
else ()
    unset(AUTOGENERATED_DESTDIR CACHE)
endif ()

if ("${DESTDIR}" STREQUAL "" OR REGEN_DESTDIR)
    if (USE_OLD_DESTDIR) # backward compatibility for old directory name
        set(DESTDIR "${CMAKE_BINARY_DIR}/destdir" CACHE PATH "Path to dependencies install directory" FORCE)
    else ()
        set(DESTDIR "${CMAKE_BINARY_DIR}/OrcaSlicer_dep" CACHE PATH "Path to dependencies install directory" FORCE)
    endif ()
    set(DESTDIR_MSG "(generated automatically and saved to cache)")
    set(AUTOGENERATED_DESTDIR ${DESTDIR} CACHE STRING "Provides the last autogenerated destdir" FORCE)
    unset(REGEN_DESTDIR CACHE)
else ()
    set(DESTDIR_MSG "(from cache or command line)")
endif ()

if (NOT FLATPAK)
    set(DESTDIR "${DESTDIR}/usr/local/")
endif()

get_property(_is_multi GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)

if (_is_multi)
    option(DEP_DEBUG "Build debug variants (only applicable on Windows)" OFF)
    option(ORCA_INCLUDE_DEBUG_INFO "Includes debug information in a release build (like RelWithDebInfo) in a way that works with multi-configuration generators and incompatible dependencies. DEP_DEBUG option takes priority over this." OFF)
    option(AUTO_DEBUG_WORKAROUND "Automatically sets DEP_DEBUG and ORCA_INCLUDE_DEBUG_INFO based on CMAKE_BUILD_TYPE" ON)

    if (AUTO_DEBUG_WORKAROUND)
        set(DEP_DEBUG OFF)
        set(ORCA_INCLUDE_DEBUG_INFO OFF)
        if (CMAKE_BUILD_TYPE STREQUAL "Debug")
            set(DEP_DEBUG ON)
            message(STATUS "DEP_DEBUG has been automatically turned ON due to CMAKE_BUILD_TYPE being set to Debug")
        elseif (CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
            set(ORCA_INCLUDE_DEBUG_INFO ON)
            message(STATUS "ORCA_INCLUDE_DEBUG_INFO has been automatically turned ON due to CMAKE_BUILD_TYPE being set to RelWithDebInfo")
        endif ()
    endif ()
endif ()

if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
    option(DEP_WX_GTK3 "Build wxWidgets against GTK3" ON)
endif()

set(IS_CROSS_COMPILE FALSE)

if (APPLE)
    list(LENGTH CMAKE_OSX_ARCHITECTURES _arch_len)
    if (_arch_len GREATER 1)
        message(FATAL_ERROR "OrcaSlicer only supports building for one architecture at a time. Please make sure only one architecture is specified in CMAKE_OSX_ARCHITECTURES")
    endif ()
    set(CMAKE_FIND_FRAMEWORK LAST)
    set(CMAKE_FIND_APPBUNDLE LAST)
    list(FIND CMAKE_OSX_ARCHITECTURES ${CMAKE_SYSTEM_PROCESSOR} _arch_idx)
    message(STATUS "prusaslicer_add_cmake_project for Apple")
    if (CMAKE_OSX_ARCHITECTURES AND _arch_idx LESS 0)
        message(STATUS "prusaslicer_add_cmake_project for Apple crosscompiling")
        set(IS_CROSS_COMPILE TRUE)
        set(CMAKE_CXX_COMPILER_ID "Clang")
        string(REPLACE ";" "$<SEMICOLON>" CMAKE_OSX_ARCHS "${CMAKE_OSX_ARCHITECTURES}")
        set(_cmake_osx_arch -DCMAKE_OSX_ARCHITECTURES:STRING=${CMAKE_OSX_ARCHS})
        set(_cmake_args_osx_arch CMAKE_ARGS -DCMAKE_OSX_ARCHITECTURES:STRING=${CMAKE_OSX_ARCHS})
        message(STATUS "Detect Cross-compilation. Will build for target ${CMAKE_OSX_ARCHS}" )
    endif ()
endif ()


# On developer machines, it can be enabled to speed up compilation and suppress warnings coming from IGL.
# FIXME:
# Enabling this option is not safe. IGL will compile itself with its own version of Eigen while
# Slic3r compiles with a different version which will cause runtime errors.
# option(DEP_BUILD_IGL_STATIC "Build IGL as a static library. Might cause link errors and increase binary size." OFF)

message(STATUS "OrcaSlicer deps DESTDIR: ${DESTDIR} ${DESTDIR_MSG}")
message(STATUS "OrcaSlicer download dir for source packages: ${DEP_DOWNLOAD_DIR}")
message(STATUS "OrcaSlicer deps debug build: ${DEP_DEBUG}")

find_package(Git REQUIRED)

# The default command line for patching. Only works for newer
set(PATCH_CMD ${GIT_EXECUTABLE} apply --verbose --ignore-space-change --whitespace=fix)

if (NOT _is_multi AND NOT CMAKE_BUILD_TYPE)
    set(CMAKE_BUILD_TYPE Release)
    message(STATUS "Forcing CMAKE_BUILD_TYPE to Release as it was not specified.")
endif ()

function(orcaslicer_add_cmake_project projectname)
    cmake_parse_arguments(P_ARGS "FORWARD_CONFIG" "INSTALL_DIR;BUILD_COMMAND;INSTALL_COMMAND;SOURCE_DIR" "CMAKE_ARGS" ${ARGN})

    # MSVC is true for clang-cl as well, so the sub-build toolchain has to key on the
    # generator. A non-Visual-Studio superbuild passes its own generator down, and with
    # it the CMAKE_C_COMPILER / CMAKE_CXX_COMPILER forwarded below.
    set(_dep_msvc_gen FALSE)
    if (MSVC AND CMAKE_GENERATOR MATCHES "Visual Studio")
        set(_dep_msvc_gen TRUE)
    endif ()

    set(_configs_line -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE})
    if (_is_multi OR _dep_msvc_gen)
        if (P_ARGS_FORWARD_CONFIG)
            set(_configs_line -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE})
        elseif (ORCA_INCLUDE_DEBUG_INFO AND NOT DEP_DEBUG)
            set(_configs_line "-DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO} -DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
        else ()
            set(_configs_line "")
        endif ()
    endif ()

    if (P_ARGS_FORWARD_CONFIG)
        set(_target_config "$<CONFIG>")
    else()
        set(_target_config "Release")
    endif()

    if (_dep_msvc_gen)
      set(_gen CMAKE_GENERATOR "${DEP_MSVC_GEN}" CMAKE_GENERATOR_PLATFORM "${DEP_PLATFORM}")
      # The toolset picks the compiler here, not the CMAKE_<LANG>_COMPILER
      # forwarded below, so without it a clang-cl superbuild builds with cl.
      if (CMAKE_GENERATOR_TOOLSET)
        list(APPEND _gen CMAKE_GENERATOR_TOOLSET "${CMAKE_GENERATOR_TOOLSET}")
      endif ()
    else()
      set(_gen "")
    endif()

    if ($ENV{CMAKE_BUILD_PARALLEL_LEVEL})
      set(_build_j "")  # assume environment will control --build parallel setting
    elseif(_dep_msvc_gen)
      set(_build_j "/m")
    else()
      set(_build_j "-j${NPROC}")
    endif ()

    set(_source_dir_arg "")
    if (P_ARGS_SOURCE_DIR)
        set(_source_dir_arg SOURCE_DIR ${P_ARGS_SOURCE_DIR})
    endif ()

if (NOT IS_CROSS_COMPILE OR NOT APPLE)
    ExternalProject_Add(
        dep_${projectname}
        EXCLUDE_FROM_ALL    ON
        INSTALL_DIR         ${DESTDIR}
        DOWNLOAD_DIR        ${DEP_DOWNLOAD_DIR}/${projectname}
        ${_source_dir_arg}
        ${_gen}
        CMAKE_ARGS
            -DCMAKE_POLICY_VERSION_MINIMUM=3.5
            -DCMAKE_INSTALL_PREFIX:STRING=${DESTDIR}
            -DCMAKE_MODULE_PATH:STRING=${PROJECT_SOURCE_DIR}/../cmake/modules
            -DCMAKE_PREFIX_PATH:STRING=${DESTDIR}
            -DCMAKE_IGNORE_PREFIX_PATH:STRING=${CMAKE_IGNORE_PREFIX_PATH}
            -DCMAKE_DEBUG_POSTFIX:STRING=d
            -DCMAKE_C_COMPILER:STRING=${CMAKE_C_COMPILER}
            -DCMAKE_CXX_COMPILER:STRING=${CMAKE_CXX_COMPILER}
            -DCMAKE_C_COMPILER_LAUNCHER:STRING=${CMAKE_C_COMPILER_LAUNCHER}
            -DCMAKE_CXX_COMPILER_LAUNCHER:STRING=${CMAKE_CXX_COMPILER_LAUNCHER}
            -DCMAKE_USER_MAKE_RULES_OVERRIDE:STRING=${CMAKE_USER_MAKE_RULES_OVERRIDE}
            -DCMAKE_TOOLCHAIN_FILE:STRING=${CMAKE_TOOLCHAIN_FILE}
            -DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS}
            -DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS}
            -DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS}
            -DBUILD_SHARED_LIBS:BOOL=OFF
            ${_cmake_osx_arch}
            "${_configs_line}"
            ${DEP_CMAKE_OPTS}
            ${P_ARGS_CMAKE_ARGS}
       ${P_ARGS_UNPARSED_ARGUMENTS}
       BUILD_COMMAND ${CMAKE_COMMAND} --build . --config ${_target_config} -- ${_build_j}
       INSTALL_COMMAND ${CMAKE_COMMAND} --build . --target install --config ${_target_config}
    )

    if (FLATPAK)
        # Free up space during flatpak builds to prevent running out of space during CI/CD

        # note for future devs: shared libs may actually create a size reduction
        # but orcaslicer_deps tends to get really funny regarding linking after that (notably boost)
        # so, as much as I would like to use that, it's not happening
        if (NOT P_ARGS_SOURCE_DIR)
            ExternalProject_Add_Step(dep_${projectname} free_download_space
                    DEPENDEES download # do after download
                    COMMENT "Freeing Space: Removing source archive"
                    WORKING_DIRECTORY ${DEP_DOWNLOAD_DIR}
                    COMMAND ${CMAKE_COMMAND} -E rm -rf ${projectname}
            )
        endif ()
        ExternalProject_Add_Step(dep_${projectname} free_build_space
                DEPENDEES install # do after install
                COMMENT "Freeing Space: Removing source and build files"
                WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/dep_${projectname}-prefix/src
                COMMAND ${CMAKE_COMMAND} -E rm -rf dep_${projectname} dep_${projectname}-build
        )
    endif ()
else()
    ExternalProject_Add(
        dep_${projectname}
        EXCLUDE_FROM_ALL    ON
        INSTALL_DIR         ${DESTDIR}
        DOWNLOAD_DIR        ${DEP_DOWNLOAD_DIR}/${projectname}
        ${_source_dir_arg}
        ${_gen}
        CMAKE_ARGS
            -DCMAKE_POLICY_VERSION_MINIMUM=3.5
            -DCMAKE_INSTALL_PREFIX:STRING=${DESTDIR}
            -DCMAKE_PREFIX_PATH:STRING=${DESTDIR}
            -DCMAKE_IGNORE_PREFIX_PATH:STRING=${CMAKE_IGNORE_PREFIX_PATH}
            -DCMAKE_C_COMPILER_LAUNCHER:STRING=${CMAKE_C_COMPILER_LAUNCHER}
            -DCMAKE_CXX_COMPILER_LAUNCHER:STRING=${CMAKE_CXX_COMPILER_LAUNCHER}
            -DCMAKE_USER_MAKE_RULES_OVERRIDE:STRING=${CMAKE_USER_MAKE_RULES_OVERRIDE}
            -DBUILD_SHARED_LIBS:BOOL=OFF
            ${_cmake_osx_arch}
            "${_configs_line}"
            ${DEP_CMAKE_OPTS}
            ${P_ARGS_CMAKE_ARGS}
       ${P_ARGS_UNPARSED_ARGUMENTS}
       BUILD_COMMAND ${CMAKE_COMMAND} --build . --config ${_target_config} -- ${_build_j}
       INSTALL_COMMAND ${CMAKE_COMMAND} --build . --target install --config ${_target_config}
    )

endif()

endfunction(orcaslicer_add_cmake_project)


if (MSVC)
    if ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "AMD64")
        message(STATUS "\nDetected X64 compiler => building X64 deps bundle\n")
        set(DEPS_ARCH "x64")
        include("deps-windows.cmake")
    elseif ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "X86")
        message(STATUS "\nDetected X86 compiler => building X86 deps bundle\n")
        set(DEPS_ARCH "x86")
        include("deps-windows.cmake")
    elseif ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "ARM64")
        message(STATUS "\nDetected ARM64 compiler => building ARM64 deps bundle\n")
        set(DEPS_ARCH "arm64")
        include("deps-windows.cmake")
    else ()
        message(FATAL_ERROR "Unable to detect architecture: ${CMAKE_SYSTEM_PROCESSOR}")
    endif ()
elseif (APPLE)
    message("OS X SDK Path: ${CMAKE_OSX_SYSROOT}")
    if (CMAKE_OSX_DEPLOYMENT_TARGET)
        set(DEP_OSX_TARGET "${CMAKE_OSX_DEPLOYMENT_TARGET}")
        message("OS X Deployment Target: ${DEP_OSX_TARGET}")
    else ()
        # Attempt to infer the SDK version from the CMAKE_OSX_SYSROOT,
        # this is done because wxWidgets need the min version explicitly set
        string(REGEX MATCH "[0-9]+[.][0-9]+[.]sdk$" DEP_OSX_TARGET "${CMAKE_OSX_SYSROOT}")
        string(REGEX MATCH "^[0-9]+[.][0-9]+" DEP_OSX_TARGET "${DEP_OSX_TARGET}")

        if (NOT DEP_OSX_TARGET)
            message(FATAL_ERROR "Could not determine OS X SDK version. Please use -DCMAKE_OSX_DEPLOYMENT_TARGET=<version>")
        endif ()

        message("OS X Deployment Target (inferred from SDK): ${DEP_OSX_TARGET}")
    endif ()

    include("deps-macos.cmake")
elseif (MINGW)
    message(STATUS "Building for MinGW...")
    include("deps-mingw.cmake")
else()
    include("deps-linux.cmake")
endif()

if(FLATPAK)
    # flatpak bundles some deps with the layer, so attempt to find them first
    # also, yes, this reduces CI by not needing to vendor certain deps
    find_package(ZLIB)
    find_package(PNG)
    find_package(EXPAT)
    find_package(CURL)
    find_package(JPEG)
    find_package(Freetype)
    find_package(OpenSSL 1.1...<3.2)
    find_package(CURL)
endif()

set(ZLIB_PKG "")
if (NOT ZLIB_FOUND)
    include(ZLIB/ZLIB.cmake)
    set(ZLIB_PKG dep_ZLIB)
endif ()
set(PNG_PKG "")
if (NOT PNG_FOUND)
    include(PNG/PNG.cmake)
    set(PNG_PKG dep_PNG)
endif ()
set(EXPAT_PKG "")
find_package(EXPAT)
if (NOT EXPAT_FOUND)
    include(EXPAT/EXPAT.cmake)
    set(EXPAT_PKG dep_EXPAT)
endif ()

# The order of includes respects the dependencies between libraries
set(DEP_Boost_COMPONENTS system iostreams filesystem thread log locale regex date_time)
include(Boost/Boost.cmake)

include(Cereal/Cereal.cmake)
include(Qhull/Qhull.cmake)
include(GLEW/GLEW.cmake)

include(GLFW/GLFW.cmake)
include(OpenCSG/OpenCSG.cmake)
set(SLVS_PKG "")
if (SLIC3R_CAD)
    include(SLVS/SLVS.cmake)
    set(SLVS_PKG dep_SLVS)
endif ()

include(TBB/TBB.cmake)

include(Blosc/Blosc.cmake)
include(OpenEXR/OpenEXR.cmake)
include(OpenVDB/OpenVDB.cmake)

include(GMP/GMP.cmake)
include(MPFR/MPFR.cmake)
include(Eigen/Eigen.cmake)
include(CGAL/CGAL.cmake)

include(NLopt/NLopt.cmake)
include(libnoise/libnoise.cmake)

include(Draco/Draco.cmake)

# I *think* 1.1 is used for *just* md5 hashing?
# 3.1 has everything in the right place, but the md5 funcs used are deprecated
# a grep across the repo shows it is used for other things
# TODO: update openssl and everything that uses <openssl/md5.h>
set(OPENSSL_PKG "")
if(NOT OPENSSL_FOUND)
    include(OpenSSL/OpenSSL.cmake)
    set(OPENSSL_PKG dep_OpenSSL)
endif()

include(FFMPEG/FFMPEG.cmake)
include(Assimp/Assimp.cmake)

include(DataChannel/DataChannel.cmake)
set(DATACHANNEL_PKG dep_DataChannel)

# we don't want to load a "wrong" openssl when loading curl
# so, just don't even bother
# ...i think this is how it works? change if wrong
set(CURL_PKG "")
if (NOT OPENSSL_FOUND OR NOT CURL_FOUND)
    include(CURL/CURL.cmake)
    set(CURL_PKG dep_CURL)
endif ()

set(JPEG_PKG "")
if (NOT JPEG_FOUND)
    include(JPEG/JPEG.cmake)
    set(JPEG_PKG dep_JPEG)
endif()

# flatpak builds wxwidgets separately, so it is not included in the deps target
set(WXWIDGETS_PKG "")
include(wxWidgets/wxWidgets.cmake)
if (NOT FLATPAK)
    set(WXWIDGETS_PKG "dep_wxWidgets")
endif()

set(FREETYPE_PKG "")
if(NOT FREETYPE_FOUND)
    include(FREETYPE/FREETYPE.cmake)
    set(FREETYPE_PKG "dep_FREETYPE")
endif()

execute_process(
    COMMAND ${GIT_EXECUTABLE} rev-parse --is-inside-work-tree
    RESULT_VARIABLE REV_PARSE_RESULT
    OUTPUT_VARIABLE REV_PARSE_OUTPUT
    OUTPUT_STRIP_TRAILING_WHITESPACE
)

# Will output "true" and have a 0 return code if within a git repo
if((REV_PARSE_RESULT EQUAL 0) AND (REV_PARSE_OUTPUT STREQUAL "true"))
    set(IN_GIT_REPO TRUE)
    # Find relative path from root to source used for adjusting patch command
    file(RELATIVE_PATH BINARY_DIR_REL  ${CMAKE_SOURCE_DIR}/.. ${CMAKE_BINARY_DIR})
endif ()

include(OCCT/OCCT.cmake)
include(OpenCV/OpenCV.cmake)
include(python3/python3.cmake)
include(wxInspector/wxInspector.cmake)

set(_dep_list
    dep_Boost
    dep_TBB
    ${OPENSSL_PKG}
    ${CURL_PKG}
    ${WXWIDGETS_PKG}
    dep_Cereal
    dep_Draco
    dep_NLopt
    dep_OpenVDB
    dep_OpenCSG
    ${SLVS_PKG}
    dep_OpenCV
    dep_Eigen
    dep_CGAL
    dep_GLFW
    dep_OCCT
    ${FREETYPE_PKG}
    ${PNG_PKG}
    ${ZLIB_PKG}
    ${EXPAT_PKG}
    dep_libnoise
    dep_python3
    dep_wxInspector
    dep_FFMPEG
    dep_Assimp
    ${DATACHANNEL_PKG}
    )

if (MSVC)
    # Experimental
    #list(APPEND _dep_list "dep_qhull")
else()
    list(APPEND _dep_list "dep_Qhull")
    # Not working, static build has different Eigen
    #list(APPEND _dep_list "dep_libigl")
endif()

add_custom_target(deps ALL DEPENDS ${_dep_list})

# Note: I'm not using any of the LOG_xxx options in ExternalProject_Add() commands
# because they seem to generate bogus build files (possibly a bug in ExternalProject).