CMakeLists.txt

# This file is part of KDGpu.
#
# SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
#
# SPDX-License-Identifier: MIT
#
# Contact KDAB at <info@kdab.com> for commercial licensing options.
#
cmake_minimum_required(VERSION 3.16)

option(KDGPU_USE_EXTERNAL_DEPENDENCIES
       "Assume all project dependencies are available on the system. Don't fetch through vcpkg." OFF
)

# vcpkg manifest mode
if(NOT KDGPU_USE_EXTERNAL_DEPENDENCIES)
    if(NOT DEFINED CMAKE_TOOLCHAIN_FILE)
        include(cmake/KDGpuFunctions.cmake)
        kdgpu_check_submodule_exists(vcpkg vcpkg)
        set(CMAKE_TOOLCHAIN_FILE ${CMAKE_SOURCE_DIR}/vcpkg/scripts/buildsystems/vcpkg.cmake)
    endif()
endif()

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
cmake_policy(SET CMP0090 NEW) # Stop export(PACKAGE) from modifying the system-wide cmake package system
cmake_policy(SET CMP0117 NEW) # Do not add /GR to CMAKE_CXX_FLAGS

add_definitions(-DKDGPU_ASSET_PATH="${CMAKE_CURRENT_BINARY_DIR}/assets")

if(KDGPU_LARGE_ASSETS)
    add_definitions(-DKDGPU_LARGE_ASSET_PATH="${CMAKE_CURRENT_BINARY_DIR}/assets/large-assets")
endif()

# Add a DEBUG define on DEBUG builds
add_compile_options("$<$<CONFIG:DEBUG>:-DDEBUG>")

if((CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT APPLE)
   OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT APPLE)
   OR (CMAKE_CXX_COMPILER_ID STREQUAL "Intel" AND NOT WIN32)
)
    # Linker warnings should be treated as errors
    set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--fatal-warnings ${CMAKE_SHARED_LINKER_FLAGS}")
    set(CMAKE_MODULE_LINKER_FLAGS "-Wl,--fatal-warnings ${CMAKE_MODULE_LINKER_FLAGS}")

    # Do not allow undefined symbols, even in non-symbolic shared libraries
    set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--no-undefined ${CMAKE_SHARED_LINKER_FLAGS}")
    set(CMAKE_MODULE_LINKER_FLAGS "-Wl,--no-undefined ${CMAKE_MODULE_LINKER_FLAGS}")
endif()

if(CMAKE_CXX_COMPILER_ID MATCHES "Clang|AppleClang|GNU")
    add_compile_options(-Wimplicit-fallthrough)
endif()

if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
    # cmake-lint: disable=C0301
    # Silences a warning on raspberry pi gcc. See:
    # https://stackoverflow.com/questions/48149323/what-does-the-gcc-warning-project-parameter-passing-for-x-changed-in-gcc-7-1-m
    add_compile_options(-Wno-psabi)
endif()

include(FeatureSummary)
include(CMakeDependentOption)

# The Vulkan SDK can be provided either as:
# - System Packages
# - LunarG SDK
# - From vpckg

set(USE_LOCAL_VULKAN_SDK OFF)
set(KDGPU_FETCH_VULKAN_SDK_FROM_VCPKG_DEFAULT ON)

if(NOT "$ENV{VULKAN_SDK}" STREQUAL "")
    # LunarG Vulkan SDK
    set(USE_LOCAL_VULKAN_SDK ON)
    set(KDGPU_FETCH_VULKAN_SDK_FROM_VCPKG_DEFAULT OFF)
    message(STATUS "Using Vulkan SDK (LunarG) from environment variable VULKAN_SDK: $ENV{VULKAN_SDK}")
elseif(EXISTS "/usr/include/vulkan/vulkan.h" OR EXISTS "/usr/local/include/vulkan/vulkan.h")
    # System Vulkan SDK
    set(USE_LOCAL_VULKAN_SDK ON)
    set(KDGPU_FETCH_VULKAN_SDK_FROM_VCPKG_DEFAULT OFF)
    message(STATUS "Using Vulkan SDK from system packages")
else()
    # vcpkg Vulkan SDK
    message(STATUS "Using Vulkan SDK from vcpkg")
endif()

option(KDGPU_BUILD_SHARED_LIBS "Build shared libraries" ON)
set(BUILD_SHARED_LIBS ${KDGPU_BUILD_SHARED_LIBS})

option(KDGPU_BUILD_TESTS "Build tests" ON)
option(KDGPU_BUILD_EXAMPLES "Build examples" ON)
option(KDGPU_BUILD_KDGPUKDGUI "Build KDGpuKDGui" ON)
option(KDGPU_BUILD_KDGPUUTILS "Build KDGpuUtils" ON)
option(KDGPU_BUILD_KDGPUEXAMPLE "Build KDGpuExample" ON)
option(KDGPU_FETCH_VULKAN_SDK_FROM_VCPKG "Fetch Vulkan SDK from vcpkg" ${KDGPU_FETCH_VULKAN_SDK_FROM_VCPKG_DEFAULT})
option(KDGPU_BUILD_IN_STRICT_MODE "Build with strict options" OFF)

# Ensure KDGpuKDGui, KDGpuUtils and KDGpuExample are ON when examples are ON
if(KDGPU_BUILD_EXAMPLES)
    message(STATUS "examples requires KDGpuExample, enabling this feature.")
    set(KDGPU_BUILD_KDGPUEXAMPLE
        ON
        CACHE BOOL "Build KDGpuExample" FORCE
    )
endif()

# Ensure KDGpuKDGui, KDGpuUtils are ON when KDGpuExample is ON
if(KDGPU_BUILD_KDGPUEXAMPLE)
    message(STATUS "KDGpuExample requires KDGpuKDGui and KDGpuUtils, enabling those features.")
    set(KDGPU_BUILD_KDGPUKDGUI
        ON
        CACHE BOOL "Build KDGpuKDGui" FORCE
    )
    set(KDGPU_BUILD_KDGPUUTILS
        ON
        CACHE BOOL "Build KDGpuUtils" FORCE
    )
endif()

set(KDGPU_BUILD_ASSETS "KDGPU_BUILD_TESTS OR KDGPU_BUILD_EXAMPLES")

find_program(DXC_EXECUTABLE dxc HINTS "$ENV{VULKAN_SDK}/bin")
find_program(SLANGC_EXECUTABLE slangc HINTS "$ENV{VULKAN_SDK}/bin")
set(DXC_EXECUTABLE_FOUND OFF)
set(SLANGC_EXECUTABLE_FOUND OFF)

if(DXC_EXECUTABLE)
    set(DXC_EXECUTABLE_FOUND ON)
endif()

if(SLANGC_EXECUTABLE)
    set(SLANGC_EXECUTABLE_FOUND ON)
endif()

message(STATUS "DXC executable: Found: ${DXC_EXECUTABLE_FOUND} ${DXC_EXECUTABLE}")
message(STATUS "Slang executable: Found: ${SLANGC_EXECUTABLE_FOUND} ${SLANGC_EXECUTABLE}")

option(KDGPU_HLSL_SUPPORT "Try to find and use the dxc HLSL to SPIR-V compiler" ${DXC_EXECUTABLE_FOUND})
option(KDGPU_SLANG_SUPPORT "Try to find and use the Slang to SPIR-V compiler" ${SLANGC_EXECUTABLE_FOUND})
option(KDGPU_CODE_COVERAGE "Code Coverage" OFF)

add_feature_info(KDGpuKDGui ${KDGPU_BUILD_KDGPUKDGUI} "Build KDGpuKDGui")
add_feature_info(KDGpuExample ${KDGPU_BUILD_KDGPUEXAMPLE} "Build KDGpuExample")
add_feature_info(KDGpuStrictMode ${KDGPU_BUILD_IN_STRICT_MODE} "Build KDGpu Strict Mode")

option(KDGPU_BUILD_KDXR "Build KDXr" ON)
add_feature_info(OpenXR ${KDGPU_BUILD_KDXR} "Enable support for OpenXR")

set(CMAKE_POSITION_INDEPENDENT_CODE ON)

# vcpkg conditional features
if(KDGPU_BUILD_KDGPUKDGUI)
    list(APPEND VCPKG_MANIFEST_FEATURES "kdgpukdgui")
endif()

if(KDGPU_BUILD_KDGPUUTILS)
    list(APPEND VCPKG_MANIFEST_FEATURES "kdgpuutils")
endif()

if(KDGPU_BUILD_KDGPUEXAMPLE)
    list(APPEND VCPKG_MANIFEST_FEATURES "kdgpuexample")
endif()

if(KDGPU_BUILD_EXAMPLES)
    list(APPEND VCPKG_MANIFEST_FEATURES "examples")
endif()

if(KDGPU_BUILD_TESTS)
    list(APPEND VCPKG_MANIFEST_FEATURES "testing")
endif()

if(KDGPU_HLSL_SUPPORT AND NOT DXC_EXECUTABLE)
    list(APPEND VCPKG_MANIFEST_FEATURES "hlsl")
endif()

if(KDGPU_SLANG_SUPPORT AND NOT SLANGC_EXECUTABLE)
    list(APPEND VCPKG_MANIFEST_FEATURES "slang")
endif()

if(KDGPU_BUILD_KDXR)
    list(APPEND VCPKG_MANIFEST_FEATURES "openxr")
endif()

if(NOT USE_LOCAL_VULKAN_SDK AND KDGPU_FETCH_VULKAN_SDK_FROM_VCPKG)
    # Use vcpkg to fetch Vulkan SDK when env variable VULKAN_SDK is not set
    list(APPEND VCPKG_MANIFEST_FEATURES "vulkan-sdk")
endif()

# Deduce VCPKG_HOST_TRIPLET if not already set
if(NOT DEFINED VCPKG_HOST_TRIPLET)
    # Determine OS
    if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
        set(VCPKG_HOST_OS "windows")
    elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
        set(VCPKG_HOST_OS "linux")
    elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
        set(VCPKG_HOST_OS "osx")
    endif()

    # Determine architecture
    if(CMAKE_HOST_SYSTEM_PROCESSOR)
        set(PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}")
    elseif(APPLE OR UNIX)
        # On macOS/linux, try to detect ARM vs Intel
        execute_process(
            COMMAND uname -m
            OUTPUT_VARIABLE PROCESSOR
            OUTPUT_STRIP_TRAILING_WHITESPACE
        )
    endif()

    if(PROCESSOR MATCHES "x86_64|AMD64|amd64|x64")
        set(VCPKG_HOST_ARCH "x64")
    elseif(PROCESSOR MATCHES "x86|i686|i386")
        set(VCPKG_HOST_ARCH "x86")
    elseif(PROCESSOR MATCHES "aarch64|arm64")
        set(VCPKG_HOST_ARCH "arm64")
    elseif(PROCESSOR MATCHES "arm")
        set(VCPKG_HOST_ARCH "arm")
    else()
        message(WARNING "Unknown processor: ${PROCESSOR}, defaulting to x64")
        set(VCPKG_HOST_ARCH "x64")
    endif()

    # Construct triplet
    set(VCPKG_HOST_TRIPLET "${VCPKG_HOST_ARCH}-${VCPKG_HOST_OS}")
    message(STATUS "Deduced VCPKG_HOST_TRIPLET: ${VCPKG_HOST_TRIPLET}")
endif()

message(STATUS "Vcpkg manifest features: ${VCPKG_MANIFEST_FEATURES}")

# Register Project once all vcpkg features have been set
project(
    KDGpu
    LANGUAGES CXX C
    VERSION 0.10.0
)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

include(CheckAtomic)
include(GNUInstallDirs)
include(KDGpuCompileShader)
include(ECMEnableSanitizers)

if(KDGPU_CODE_COVERAGE)
    if(NOT (KDGPU_BUILD_TESTS AND CMAKE_CXX_COMPILER_ID MATCHES "Clang|AppleClang|GNU"))
        message(FATAL_ERROR "KDGPU_CODE_COVERAGE=ON requires:\n" "  - KDGPU_BUILD_TESTS=ON\n"
                            "  - Compiler: Clang or GCC"
        )
    endif()
    include(cmake/CodeCoverage.cmake)
endif()

# Note: Set before including dependencies.cmake, so 3rd party libs end up in the correct dir
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")

# Package Dependencies
include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/dependencies.cmake)

# Add sources
add_subdirectory(src)

# Feature Summary
add_feature_info(KDGpu-DXC ${KDGPU_HLSL_SUPPORT} "HLSL Shader Support")
add_feature_info(KDGpu-Slang ${KDGPU_SLANG_SUPPORT} "Slang Shader Support")
add_feature_info(KDGpu-Assets ${KDGPU_BUILD_ASSETS} "Build Assets")
if(KDGPU_BUILD_ASSETS)
    add_subdirectory(assets)
endif()

add_feature_info(KDGpu-Tests ${KDGPU_BUILD_TESTS} "Build Tests")
add_feature_info(KDGpu-CodeCoverage ${KDGPU_CODE_COVERAGE} "Code Coverage Support")
if(KDGPU_BUILD_TESTS)
    enable_testing()
    add_subdirectory(tests)
endif()

add_feature_info(KDGpu-Examples ${KDGPU_BUILD_EXAMPLES} "Build Examples")
if(KDGPU_BUILD_EXAMPLES)
    add_subdirectory(examples)
endif()

option(KDGPU_DOCS "Build the API documentation" OFF)

add_feature_info(KDGpu-Documentation ${KDGPU_DOCS} "Build Documentation")
if(KDGPU_DOCS)
    add_subdirectory(docs)
endif()

feature_summary(WHAT PACKAGES_FOUND PACKAGES_NOT_FOUND ENABLED_FEATURES DISABLED_FEATURES INCLUDE_QUIET_PACKAGES)