CMakeLists.txt

cmake_minimum_required(VERSION 3.30)

include(CMakeDependentOption)
include(FetchContent)

# GitHub actions?
if("$ENV{GITHUB_ACTIONS}" STREQUAL "")
    set(GITHUB_CI FALSE CACHE BOOL "GitHub Actions runner" FORCE)
else()
    set(GITHUB_CI TRUE CACHE BOOL "GitHub Actions runner" FORCE)
    message(STATUS "Detected environment: GitHub Actions...")
endif()

# Create project
file(READ "${CMAKE_CURRENT_SOURCE_DIR}/Include/NRI.h" ver_h)
string(REGEX MATCH "NRI_VERSION ([0-9]*)" _ ${ver_h})
set(NRI_VERSION ${CMAKE_MATCH_1})

project(NRI VERSION ${NRI_VERSION} LANGUAGES CXX)
message("NRI: v${NRI_VERSION}:")

# Test packages availability ("find_package" works only for X11)
if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
    find_path(XLIB_HEADERS NAMES "X11/Xlib.h")
    find_path(WAYLAND_HEADERS NAMES "wayland-client.h")
endif()

# Architecture
if(CMAKE_GENERATOR_PLATFORM STREQUAL "ARM64EC")
    set(IS_ARM64 FALSE)
    set(BIN_ARCHITECTURE "x64")
    set(NVAPI_BIN_ARCHITECTURE "amd64")
    set(WGPU_BIN_ARCHITECTURE "x86_64")
elseif((CMAKE_GENERATOR_PLATFORM MATCHES "ARM64") OR (CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|ARM64"))
    set(IS_ARM64 TRUE)
    set(BIN_ARCHITECTURE "arm64")
    set(NVAPI_BIN_ARCHITECTURE "aarch64")
    set(WGPU_BIN_ARCHITECTURE "aarch64")
elseif(CMAKE_SIZEOF_VOID_P EQUAL 8)
    set(IS_ARM64 FALSE)
    set(BIN_ARCHITECTURE "x64")
    set(NVAPI_BIN_ARCHITECTURE "amd64")
    set(WGPU_BIN_ARCHITECTURE "x86_64")
elseif(CMAKE_SIZEOF_VOID_P EQUAL 4)
    set(IS_ARM64 FALSE)
    set(BIN_ARCHITECTURE "x86")
    set(NVAPI_BIN_ARCHITECTURE "x86")
    if(WIN32)
        set(WGPU_BIN_ARCHITECTURE "i686")
    endif()
else()
    message(FATAL_ERROR "NRI: unsupported architecture or platform '${CMAKE_SYSTEM_NAME}', '${CMAKE_SYSTEM_PROCESSOR}'")
endif()

# Options
set(NRI_AGILITY_SDK_DIR "AgilitySDK" CACHE STRING "Directory where Agility SDK will be copied relative to the directory with binaries")
set(NRI_AGILITY_SDK_VERSION_MAJOR "619" CACHE STRING "Agility SDK major version") # 721 ("D3D12_ERROR_INVALID_REDIST" if Windows developer mode is not enabled)
set(NRI_AGILITY_SDK_VERSION_MINOR "6" CACHE STRING "Agility SDK minor version") # 3-preview
set(NRI_WGPU_VERSION "v29.0.1.1")
set(NRI_SHADERS_PATH "${CMAKE_CURRENT_SOURCE_DIR}/_Shaders" CACHE STRING "Shader output path override")
set(NRI_NVAPI_CUSTOM_PATH "" CACHE STRING "Path to a custom NVAPI library directory")

# A shared library on iOS requires framework packaging and code signing
if(IOS)
    set(NRI_STATIC_LIBRARY_DEFAULT ON)
else()
    set(NRI_STATIC_LIBRARY_DEFAULT OFF)
endif()

option(NRI_STATIC_LIBRARY "Build static library" ${NRI_STATIC_LIBRARY_DEFAULT})
option(NRI_ENABLE_DEBUG_NAMES_AND_ANNOTATIONS "Enable debug names, host and device annotations" ON)
option(NRI_ENABLE_NONE_SUPPORT "Enable NONE backend" ON)
option(NRI_ENABLE_VALIDATION_SUPPORT "Enable Validation backend (otherwise 'enableNRIValidation' is ignored)" ON)
option(NRI_ENABLE_IMGUI_EXTENSION "Enable 'NRIImgui' extension" OFF)
option(NRI_STREAMER_THREAD_SAFE "'NRIStreamer' thread safety (OFF is faster)" ON)

# Metal 4 requires Xcode 26 or newer (AppleClang 17 or newer)
set(NRI_METAL_SUPPORT_DEFAULT ON)
if(APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 17)
    set(NRI_METAL_SUPPORT_DEFAULT OFF)
    message(STATUS "NRI: Metal 4 backend is disabled by default (requires Xcode 26 or newer)")
endif()

# Internal shaders are precompiled, which requires the Metal toolchain ("xcodebuild -downloadComponent MetalToolchain")
if(APPLE AND NRI_METAL_SUPPORT_DEFAULT)
    if(IOS)
        set(NRI_METAL_PROBE_SDK iphoneos)
    else()
        set(NRI_METAL_PROBE_SDK macosx)
    endif()

    execute_process(COMMAND xcrun -sdk ${NRI_METAL_PROBE_SDK} metal --version RESULT_VARIABLE NRI_METAL_PROBE_RESULT OUTPUT_QUIET ERROR_QUIET)

    if(NOT NRI_METAL_PROBE_RESULT EQUAL 0)
        set(NRI_METAL_SUPPORT_DEFAULT OFF)
        message(STATUS "NRI: Metal 4 backend is disabled by default (the Metal toolchain for '${NRI_METAL_PROBE_SDK}' is not installed)")
    endif()
endif()

# Metal Shader Converter (macOS and iOS devices, no simulator build) is enabled by default if installed
set(NRI_METAL_SHADER_CONVERTER_DEFAULT OFF)
if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
    set(NRI_METAL_SHADER_CONVERTER_SUPPORTED ON)
    set(NRI_METAL_SHADER_CONVERTER_FIND_ARGS "")
elseif(IOS AND NOT CMAKE_OSX_SYSROOT MATCHES "[Ss]imulator")
    set(NRI_METAL_SHADER_CONVERTER_SUPPORTED ON)
    set(NRI_METAL_SHADER_CONVERTER_FIND_ARGS PATHS "/usr/local/lib_iOS" NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
else()
    set(NRI_METAL_SHADER_CONVERTER_SUPPORTED OFF)
endif()

if(NRI_METAL_SHADER_CONVERTER_SUPPORTED)
    set(NRI_METAL_SHADER_CONVERTER_INCLUDE_PATH "" CACHE PATH "Path to Metal Shader Converter headers")
    set(NRI_METAL_SHADER_CONVERTER_LIBRARY "" CACHE FILEPATH "Path to the Metal Shader Converter library")

    find_library(NRI_METAL_SHADER_CONVERTER_PROBE NAMES metalirconverter ${NRI_METAL_SHADER_CONVERTER_FIND_ARGS} NO_CACHE)
    if(NRI_METAL_SHADER_CONVERTER_LIBRARY OR NRI_METAL_SHADER_CONVERTER_PROBE)
        set(NRI_METAL_SHADER_CONVERTER_DEFAULT ON)
    endif()
endif()

cmake_dependent_option(NRI_ENABLE_D3D11_SUPPORT "Enable D3D11 backend" ON "WIN32" OFF)
cmake_dependent_option(NRI_ENABLE_D3D12_SUPPORT "Enable D3D12 backend" ON "WIN32" OFF)
cmake_dependent_option(NRI_ENABLE_NVTX_SUPPORT "Annotations for NVIDIA Nsight Systems" ON "NOT IOS" OFF)
cmake_dependent_option(NRI_ENABLE_VK_SUPPORT "Enable Vulkan backend" ON "NOT IOS" OFF)
cmake_dependent_option(NRI_ENABLE_NIS_SDK "Enable NVIDIA Image Sharpening SDK" OFF "NOT IOS" OFF)
cmake_dependent_option(NRI_ENABLE_WGPU_SUPPORT "Enable WebGPU backend" ${GITHUB_CI} "WGPU_BIN_ARCHITECTURE; NOT ANDROID; NOT IOS" OFF)
cmake_dependent_option(NRI_ENABLE_METAL_SUPPORT "Enable Metal 4 backend" ${NRI_METAL_SUPPORT_DEFAULT} "APPLE" OFF)
cmake_dependent_option(NRI_ENABLE_METAL_SHADER_CONVERTER "Enable DXIL conversion in the Metal backend" ${NRI_METAL_SHADER_CONVERTER_DEFAULT} "NRI_ENABLE_METAL_SUPPORT; NRI_METAL_SHADER_CONVERTER_SUPPORTED" OFF)
cmake_dependent_option(NRI_METAL_CPP_PRIVATE_IMPLEMENTATION "Compile metal-cpp implementation into NRI (static NRI: turn OFF if the app provides it)" ON "NRI_ENABLE_METAL_SUPPORT; NRI_STATIC_LIBRARY" ${NRI_ENABLE_METAL_SUPPORT})
cmake_dependent_option(NRI_ENABLE_AMDAGS "Enable AMD AGS library for D3D" ON "(NRI_ENABLE_D3D11_SUPPORT OR NRI_ENABLE_D3D12_SUPPORT); NOT IS_ARM64" OFF)
cmake_dependent_option(NRI_ENABLE_NVAPI "Enable NVAPI library for D3D" ON "(NRI_ENABLE_D3D11_SUPPORT OR NRI_ENABLE_D3D12_SUPPORT)" OFF)
cmake_dependent_option(NRI_ENABLE_AGILITY_SDK_SUPPORT "Enable Agility SDK support to unlock access to latest D3D12 features" ON "NRI_ENABLE_D3D12_SUPPORT" OFF)
cmake_dependent_option(NRI_ENABLE_XLIB_SUPPORT "Enable X11 support" ON "XLIB_HEADERS" OFF)
cmake_dependent_option(NRI_ENABLE_WAYLAND_SUPPORT "Enable Wayland support" ON "WAYLAND_HEADERS" OFF)
cmake_dependent_option(NRI_ENABLE_NGX_SDK "Enable NVIDIA NGX (DLSS) SDK" OFF "(NRI_ENABLE_D3D11_SUPPORT OR NRI_ENABLE_D3D12_SUPPORT OR NRI_ENABLE_VK_SUPPORT); WIN32 OR NOT IS_ARM64" OFF)
cmake_dependent_option(NRI_ENABLE_FFX_SDK "Enable AMD FidelityFX SDK" OFF "(NRI_ENABLE_VK_SUPPORT OR NRI_ENABLE_D3D12_SUPPORT); WIN32; NOT IS_ARM64" OFF)
cmake_dependent_option(NRI_ENABLE_XESS_SDK "Enable INTEL XeSS SDK" OFF "NRI_ENABLE_D3D12_SUPPORT; WIN32; NOT IS_ARM64" OFF)

# ShaderMake required?
if(NRI_ENABLE_NIS_SDK)
    set(NRI_ENABLE_SHADERMAKE ON)
else()
    set(NRI_ENABLE_SHADERMAKE OFF)
endif()

# Self-build?
if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR}) # if not submodule
    get_property(IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)

    if(IS_MULTI_CONFIG)
        set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "")
    endif()

    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/_Bin" CACHE STRING "") # .dll
    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/_Bin" CACHE STRING "") # .so
endif()

# Enable grouping of source files into folders in IDEs
set_property(GLOBAL PROPERTY USE_FOLDERS ON)

# Compile definitions
set(COMPILE_DEFINITIONS "")
foreach(opt IN ITEMS
    NRI_STATIC_LIBRARY
    NRI_ENABLE_NVTX_SUPPORT
    NRI_ENABLE_DEBUG_NAMES_AND_ANNOTATIONS
    NRI_ENABLE_NONE_SUPPORT
    NRI_ENABLE_VK_SUPPORT
    NRI_ENABLE_WGPU_SUPPORT
    NRI_ENABLE_METAL_SUPPORT
    NRI_ENABLE_METAL_SHADER_CONVERTER
    NRI_METAL_CPP_PRIVATE_IMPLEMENTATION
    NRI_ENABLE_VALIDATION_SUPPORT
    NRI_ENABLE_NIS_SDK
    NRI_ENABLE_IMGUI_EXTENSION
    NRI_ENABLE_D3D11_SUPPORT
    NRI_ENABLE_D3D12_SUPPORT
    NRI_ENABLE_NVAPI
    NRI_ENABLE_AMDAGS
    NRI_ENABLE_AGILITY_SDK_SUPPORT
    NRI_ENABLE_XLIB_SUPPORT
    NRI_ENABLE_WAYLAND_SUPPORT
    NRI_ENABLE_NGX_SDK
    NRI_ENABLE_FFX_SDK
    NRI_ENABLE_XESS_SDK
    NRI_ENABLE_SHADERMAKE
    NRI_STREAMER_THREAD_SAFE
)
    if(${opt})
        message(STATUS "${opt}")
        list(APPEND COMPILE_DEFINITIONS "${opt}=1")
    endif()
endforeach()

# Construct list of dependencies # TODO: update to latest releases from time to time
set(DEPS)

# Dependencies:
# - URL - good (no fat ".git" folder)
# - GIT_REPOSITORY - worse (because of ".git" folder)
# - GIT_SHALLOW = 0 - worse ^ 2 (needed to workaround Cmake's inability to shalow-clone a commit hash, which is a non-ToT PR, so even more fat useless ".git" folder)
if(NRI_ENABLE_AGILITY_SDK_SUPPORT)
    # Agility SDK
    fetchcontent_declare(
        agilitysdk
        DOWNLOAD_EXTRACT_TIMESTAMP 1
        DOWNLOAD_NO_PROGRESS 1
        SOURCE_SUBDIR "ignore CMakeLists.txt"
        URL "https://www.nuget.org/api/v2/package/Microsoft.Direct3D.D3D12/1.${NRI_AGILITY_SDK_VERSION_MAJOR}.${NRI_AGILITY_SDK_VERSION_MINOR}"
    )
    list(APPEND DEPS agilitysdk)
endif()

if(NRI_ENABLE_NVTX_SUPPORT)
    # NVTX
    fetchcontent_declare(
        nvtx
        DOWNLOAD_EXTRACT_TIMESTAMP 1
        DOWNLOAD_NO_PROGRESS 1
        SOURCE_SUBDIR "ignore CMakeLists.txt"
        URL "https://github.com/NVIDIA/NVTX/archive/refs/tags/v3.6.0.zip"
    )
    list(APPEND DEPS nvtx)
endif()

if(NRI_ENABLE_METAL_SUPPORT)
    # metal-cpp (macOS 27 SDK, the backend requires macOS 26+)
    fetchcontent_declare(
        metal_cpp
        DOWNLOAD_EXTRACT_TIMESTAMP 1
        DOWNLOAD_NO_PROGRESS 1
        SOURCE_SUBDIR "ignore CMakeLists.txt"
        URL "https://github.com/apple/metal-cpp/archive/27c4382b7151d55a51692cdcb27aaa98752240de.zip"
    )
    list(APPEND DEPS metal_cpp)
endif()

if(NRI_ENABLE_VK_SUPPORT)
    # Vulkan headers
    fetchcontent_declare(
        vulkan_headers
        DOWNLOAD_EXTRACT_TIMESTAMP 1
        DOWNLOAD_NO_PROGRESS 1
        SOURCE_SUBDIR "ignore CMakeLists.txt"
        URL "https://github.com/KhronosGroup/Vulkan-Headers/archive/refs/tags/v1.4.365.zip"
    )
    list(APPEND DEPS vulkan_headers)

    # Vulkan MA
    fetchcontent_declare(
        vma
        DOWNLOAD_EXTRACT_TIMESTAMP 1
        DOWNLOAD_NO_PROGRESS 1
        SOURCE_SUBDIR "ignore CMakeLists.txt"
        URL "https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator/archive/3aa921224c154a0d2c43912bc88e1c42ce1f7607.zip"
    )
    list(APPEND DEPS vma)
endif()

set(NGX_VERSION "310.9.1")
if(IS_ARM64)
    set(NGX_WINDOWS_DIR "Windows_aarch64")
    set(NGX_WINDOWS_LIB_DIR "Windows_aarch64")
else()
    set(NGX_WINDOWS_DIR "Windows_x86_64")
    set(NGX_WINDOWS_LIB_DIR "Windows_x86_64/x64")
endif()

if(NRI_ENABLE_NGX_SDK)
    # NVIDIA NGX SDK
    fetchcontent_declare(
        ngx
        DOWNLOAD_EXTRACT_TIMESTAMP 1
        DOWNLOAD_NO_PROGRESS 1
        SOURCE_SUBDIR "ignore CMakeLists.txt"
        URL "https://github.com/NVIDIA/DLSS/archive/refs/tags/v${NGX_VERSION}.zip"
    )
    list(APPEND DEPS ngx)
endif()

if(NRI_ENABLE_FFX_SDK)
    # Keep the legacy SDK for Vulkan (the newer FSR SDK only supports D3D12)
    if(NRI_ENABLE_VK_SUPPORT)
        fetchcontent_declare(
            ffx
            DOWNLOAD_EXTRACT_TIMESTAMP 1
            DOWNLOAD_NO_PROGRESS 1
            SOURCE_SUBDIR "ignore CMakeLists.txt"
            URL "https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/releases/download/v1.1.4/FidelityFX-SDK-v1.1.4.zip"
        )
        list(APPEND DEPS ffx)
    endif()

    if(NRI_ENABLE_D3D12_SUPPORT)
        fetchcontent_declare(
            fsr
            DOWNLOAD_EXTRACT_TIMESTAMP 1
            DOWNLOAD_NO_PROGRESS 1
            SOURCE_SUBDIR "ignore CMakeLists.txt"
            URL "https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/archive/refs/tags/v2.3.0.zip"
        )
        list(APPEND DEPS fsr)
    endif()
endif()

if(NRI_ENABLE_XESS_SDK)
    # INTEL XeSS SDK
    fetchcontent_declare(
        xess
        DOWNLOAD_EXTRACT_TIMESTAMP 1
        DOWNLOAD_NO_PROGRESS 1
        SOURCE_SUBDIR "ignore CMakeLists.txt"
        URL "https://github.com/intel/xess/archive/refs/tags/v3.0.2.zip"
    )
    list(APPEND DEPS xess)
endif()

if(NRI_ENABLE_D3D12_SUPPORT)
    # D3D12 MA
    fetchcontent_declare(
        d3d12ma
        DOWNLOAD_EXTRACT_TIMESTAMP 1
        DOWNLOAD_NO_PROGRESS 1
        SOURCE_SUBDIR "ignore CMakeLists.txt"
        URL "https://github.com/GPUOpen-LibrariesAndSDKs/D3D12MemoryAllocator/archive/1d86c1130f61453634b1df85782e1fecfd59a525.zip"
    )
    list(APPEND DEPS d3d12ma)
endif()

if(NRI_ENABLE_WGPU_SUPPORT)
    if(WIN32)
        set(WGPU_NATIVE_PACKAGE "wgpu-windows-${WGPU_BIN_ARCHITECTURE}-msvc-release.zip")
        set(WGPU_NATIVE_LIB_NAME "wgpu_native.dll.lib")
        set(WGPU_NATIVE_RUNTIME_NAME "wgpu_native.dll")
    elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
        set(WGPU_NATIVE_PACKAGE "wgpu-linux-${WGPU_BIN_ARCHITECTURE}-release.zip")
        set(WGPU_NATIVE_LIB_NAME "libwgpu_native.so")
        set(WGPU_NATIVE_RUNTIME_NAME "${WGPU_NATIVE_LIB_NAME}")
    elseif(APPLE)
        set(WGPU_NATIVE_PACKAGE "wgpu-macos-${WGPU_BIN_ARCHITECTURE}-release.zip")
        set(WGPU_NATIVE_LIB_NAME "libwgpu_native.dylib")
        set(WGPU_NATIVE_RUNTIME_NAME "${WGPU_NATIVE_LIB_NAME}")
    endif()

    fetchcontent_declare(
        wgpu_native
        DOWNLOAD_EXTRACT_TIMESTAMP 1
        DOWNLOAD_NO_PROGRESS 1
        SOURCE_SUBDIR "ignore CMakeLists.txt"
        URL "https://github.com/gfx-rs/wgpu-native/releases/download/${NRI_WGPU_VERSION}/${WGPU_NATIVE_PACKAGE}"
    )
    list(APPEND DEPS wgpu_native)
endif()

if(NRI_ENABLE_AMDAGS)
    # AMD AGS
    fetchcontent_declare(
        amdags
        DOWNLOAD_EXTRACT_TIMESTAMP 1
        DOWNLOAD_NO_PROGRESS 1
        SOURCE_SUBDIR "ignore CMakeLists.txt"
        URL "https://github.com/GPUOpen-LibrariesAndSDKs/AGS_SDK/archive/refs/tags/v6.3.1.zip"
    )
    list(APPEND DEPS amdags)
endif()

if(NRI_ENABLE_NVAPI)
    # NV API
    if(NRI_NVAPI_CUSTOM_PATH)
        get_filename_component(nvapi_SOURCE_DIR "${NRI_NVAPI_CUSTOM_PATH}" ABSOLUTE)
        message("NRI: using custom NVAPI from '${nvapi_SOURCE_DIR}'")
    else()
        fetchcontent_declare(
            nvapi
            DOWNLOAD_EXTRACT_TIMESTAMP 1
            DOWNLOAD_NO_PROGRESS 1
            SOURCE_SUBDIR "ignore CMakeLists.txt"
            URL "https://github.com/NVIDIA/nvapi/archive/70d337db9186e968eab622f7e786de7e437faf3d.zip"
        )
        list(APPEND DEPS nvapi)
    endif()
endif()

if(NRI_ENABLE_SHADERMAKE AND NOT TARGET ShaderMake)
    # ShaderMake
    option(SHADERMAKE_TOOL "" ON)

    fetchcontent_declare(
        shadermake
        DOWNLOAD_EXTRACT_TIMESTAMP 1
        DOWNLOAD_NO_PROGRESS 1
        URL "https://github.com/NVIDIA-RTX/ShaderMake/archive/3f01623a76b092ac127d2debd79a672f55d77665.zip"
    )
    list(APPEND DEPS shadermake)
endif()

# Download dependencies
if(DEPS)
    message("NRI: downloading dependencies:")
    message(STATUS "${DEPS} ...")

    fetchcontent_makeavailable(${DEPS})

    # Delete original archives
    foreach(DEP IN LISTS DEPS)
        file(REMOVE_RECURSE "${FETCHCONTENT_BASE_DIR}/${DEP}-tmp")
    endforeach()
endif()

# NVAPI
if(NRI_ENABLE_NVAPI)
    find_library(NVAPI_LIB
        NAMES
            nvapi64 nvapia64 nvapi
        PATHS
            "${nvapi_SOURCE_DIR}/${NVAPI_BIN_ARCHITECTURE}"
        REQUIRED
    ) # statically linked

    set(NVAPI_HEADERS
        "${nvapi_SOURCE_DIR}/nvapi.h"
        "${nvapi_SOURCE_DIR}/nvHLSLExtns.h"
        "${nvapi_SOURCE_DIR}/nvShaderExtnEnums.h"
    )
    source_group("External/nvapi"
        FILES
            ${NVAPI_HEADERS}
    )
endif()

# AMDAGS
if(NRI_ENABLE_AMDAGS)
    find_library(AGS_LIB
        NAMES
            amd_ags_${BIN_ARCHITECTURE}
        PATHS
            "${amdags_SOURCE_DIR}/ags_lib/lib"
        REQUIRED
    ) # dynamically loaded

    set(AMDAGS_HEADERS
        "${amdags_SOURCE_DIR}/ags_lib/inc/amd_ags.h"
        "${amdags_SOURCE_DIR}/ags_lib/hlsl/ags_shader_intrinsics_dx11.hlsl"
        "${amdags_SOURCE_DIR}/ags_lib/hlsl/ags_shader_intrinsics_dx12.hlsl"
    )
    source_group("External/amdags"
        FILES
            ${AMDAGS_HEADERS}
    )
    set_source_files_properties(${AMDAGS_HEADERS}
        PROPERTIES
            VS_SETTINGS "ExcludedFromBuild=true" # do not compile HLSL
    )
endif()

# Shared
if(NRI_ENABLE_NGX_SDK)
    if(WIN32)
        if((NOT DEFINED CMAKE_MSVC_RUNTIME_LIBRARY) OR (${CMAKE_MSVC_RUNTIME_LIBRARY} MATCHES "DLL"))
            set(NGX_SUFFIX "d")
            message("NRI: using NGX LIB with dynamic runtime")
        else()
            set(NGX_SUFFIX "s")
            message("NRI: using NGX LIB with static runtime")
        endif()

        set(NGX_LIB "${ngx_SOURCE_DIR}/lib/${NGX_WINDOWS_LIB_DIR}/nvsdk_ngx_${NGX_SUFFIX}$<$<CONFIG:Debug>:_dbg>.lib")
    else()
        set(NGX_LIB "${ngx_SOURCE_DIR}/lib/Linux_x86_64/libnvsdk_ngx.a")
    endif()
endif()

set(SHARED_SOURCE
    "Source/NRIConfig.h"
    "Source/Shared/DeviceBase.h"
    "Source/Shared/HelperInterface.h"
    "Source/Shared/HelperInterface.hpp"
    "Source/Shared/ImguiInterface.h"
    "Source/Shared/ImguiInterface.hpp"
    "Source/Shared/Lock.h"
    "Source/Shared/NIS.h"
    "Source/Shared/Shared.cpp"
    "Source/Shared/SharedExternal.h"
    "Source/Shared/SharedExternal.hpp"
    "Source/Shared/SharedLibrary.hpp"
    "Source/Shared/StreamerInterface.h"
    "Source/Shared/StreamerInterface.hpp"
    "Source/Shared/UpscalerInterface.h"
    "Source/Shared/UpscalerInterface.hpp"
    "Source/Shared/SharedVideo.h"
)

add_library(NRI_Shared STATIC)
target_sources(NRI_Shared
    PRIVATE
        ${SHARED_SOURCE}
)
target_include_directories(NRI_Shared
    PUBLIC
        "Include"
        "Source/Shared"
    PRIVATE
        $<$<BOOL:${NRI_ENABLE_AGILITY_SDK_SUPPORT}>:
            ${agilitysdk_SOURCE_DIR}/build/native/include
        >
        $<$<BOOL:${NRI_ENABLE_VK_SUPPORT}>:
            ${vulkan_headers_SOURCE_DIR}/include
        >
        $<$<BOOL:${NRI_ENABLE_NGX_SDK}>:
            ${ngx_SOURCE_DIR}/include
        >
        $<$<AND:$<BOOL:${NRI_ENABLE_FFX_SDK}>,$<BOOL:${NRI_ENABLE_D3D12_SUPPORT}>>:
            ${fsr_SOURCE_DIR}/Kits/FidelityFX/api/include
            ${fsr_SOURCE_DIR}/Kits/FidelityFX/upscalers/include
        >
        $<$<AND:$<BOOL:${NRI_ENABLE_FFX_SDK}>,$<NOT:$<BOOL:${NRI_ENABLE_D3D12_SUPPORT}>>>:
            ${ffx_SOURCE_DIR}/ffx-api/include/ffx_api
        >
        $<$<BOOL:${NRI_ENABLE_XESS_SDK}>:
            ${xess_SOURCE_DIR}/inc/xess
        >
)
target_compile_definitions(NRI_Shared
    PUBLIC
        WIN32_LEAN_AND_MEAN
        NOMINMAX
        _CRT_SECURE_NO_WARNINGS
        ${COMPILE_DEFINITIONS}
)
target_compile_options(NRI_Shared
    PUBLIC
        # Options for Clang/GCC compilers
        # No "nullability-completeness" caused by VMA
        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>:
            $<$<NOT:$<CXX_COMPILER_FRONTEND_VARIANT:MSVC>>:
                -Wextra
                -Werror
                -fvisibility=hidden
            >
            -Wno-missing-field-initializers
            -Wno-nullability-completeness
        >
        # Options for MSVC frontend
        $<$<CXX_COMPILER_FRONTEND_VARIANT:MSVC>:
            /W4
            /WX
            /wd4324
            $<$<CONFIG:Release>:/Zi>
        >
)
target_compile_features(NRI_Shared
    PUBLIC
        cxx_std_17
)
target_link_libraries(NRI_Shared
    PRIVATE
        $<$<BOOL:${NRI_ENABLE_NGX_SDK}>:
            ${NGX_LIB}
        >
        $<$<BOOL:${NRI_ENABLE_XESS_SDK}>:
            ${xess_SOURCE_DIR}/lib/libxess.lib
        >
)
set_target_properties(NRI_Shared
    PROPERTIES
        POSITION_INDEPENDENT_CODE ON           # enable PIC...
        INTERFACE_POSITION_INDEPENDENT_CODE ON # ...and propagate to all consumers
        FOLDER "NRI"
)

# NONE
if(NRI_ENABLE_NONE_SUPPORT)
    set(NONE_SOURCE "Source/NONE/ImplNONE.cpp")

    add_library(NRI_NONE STATIC)
    target_sources(NRI_NONE
        PRIVATE
            ${NONE_SOURCE}
    )
    target_link_libraries(NRI_NONE
        PRIVATE
            NRI_Shared
    )
    set_target_properties(NRI_NONE
        PROPERTIES
            FOLDER "NRI"
    )
endif()

# D3D11
if(NRI_ENABLE_D3D11_SUPPORT)
    set(D3D11_SOURCE
        "Source/D3D11/BufferD3D11.h"
        "Source/D3D11/BufferD3D11.hpp"
        "Source/D3D11/CommandAllocatorD3D11.h"
        "Source/D3D11/CommandAllocatorD3D11.hpp"
        "Source/D3D11/CommandBufferD3D11.h"
        "Source/D3D11/CommandBufferD3D11.hpp"
        "Source/D3D11/CommandBufferEmuD3D11.h"
        "Source/D3D11/CommandBufferEmuD3D11.hpp"
        "Source/D3D11/DescriptorD3D11.h"
        "Source/D3D11/DescriptorD3D11.hpp"
        "Source/D3D11/DescriptorPoolD3D11.h"
        "Source/D3D11/DescriptorPoolD3D11.hpp"
        "Source/D3D11/DescriptorSetD3D11.h"
        "Source/D3D11/DescriptorSetD3D11.hpp"
        "Source/D3D11/DeviceD3D11.h"
        "Source/D3D11/DeviceD3D11.hpp"
        "Source/D3D11/FenceD3D11.h"
        "Source/D3D11/FenceD3D11.hpp"
        "Source/D3D11/ImplD3D11.cpp"
        "Source/D3D11/MemoryD3D11.h"
        "Source/D3D11/PipelineCacheD3D11.h"
        "Source/D3D11/PipelineCacheD3D11.hpp"
        "Source/D3D11/PipelineD3D11.h"
        "Source/D3D11/PipelineD3D11.hpp"
        "Source/D3D11/PipelineLayoutD3D11.h"
        "Source/D3D11/PipelineLayoutD3D11.hpp"
        "Source/D3D11/QueryPoolD3D11.h"
        "Source/D3D11/QueryPoolD3D11.hpp"
        "Source/D3D11/QueueD3D11.h"
        "Source/D3D11/QueueD3D11.hpp"
        "Source/D3D11/SharedD3D11.h"
        "Source/D3D11/SharedD3D11.hpp"
        "Source/D3D11/SwapChainD3D11.h"
        "Source/D3D11/SwapChainD3D11.hpp"
        "Source/D3D11/TextureD3D11.h"
        "Source/D3D11/TextureD3D11.hpp"
    )

    add_library(NRI_D3D11 STATIC)
    target_sources(NRI_D3D11
        PRIVATE
            ${D3D11_SOURCE}
            $<$<BOOL:${NRI_ENABLE_NVAPI}>:
                ${NVAPI_HEADERS}
            >
            $<$<BOOL:${NRI_ENABLE_AMDAGS}>:
                ${AMDAGS_HEADERS}
            >
    )
    target_include_directories(NRI_D3D11
        PRIVATE
            $<$<BOOL:${NRI_ENABLE_NVAPI}>:
                "${nvapi_SOURCE_DIR}"
            >
            $<$<BOOL:${NRI_ENABLE_AMDAGS}>:
                "${amdags_SOURCE_DIR}/ags_lib/inc"
            >
    )
    target_link_libraries(NRI_D3D11
        PRIVATE
            NRI_Shared
            d3d11
            dxgi
            dxguid
            $<$<BOOL:${NRI_ENABLE_NVAPI}>:
                ${NVAPI_LIB}
            >
    )
    set_target_properties(NRI_D3D11
        PROPERTIES
            FOLDER "NRI"
    )
endif()

# D3D12
if(NRI_ENABLE_D3D12_SUPPORT)
    message("NRI: using Windows SDK ${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}")

    set(D3D12_VMA "${d3d12ma_SOURCE_DIR}/include/D3D12MemAlloc.h")
    source_group("External/Vma"
        FILES
            ${D3D12_VMA}
    )

    set(D3D12_SOURCE
        "Source/D3D12/AccelerationStructureD3D12.h"
        "Source/D3D12/AccelerationStructureD3D12.hpp"
        "Source/D3D12/BufferD3D12.h"
        "Source/D3D12/BufferD3D12.hpp"
        "Source/D3D12/CommandAllocatorD3D12.h"
        "Source/D3D12/CommandAllocatorD3D12.hpp"
        "Source/D3D12/CommandBufferD3D12.h"
        "Source/D3D12/CommandBufferD3D12.hpp"
        "Source/D3D12/DescriptorD3D12.h"
        "Source/D3D12/DescriptorD3D12.hpp"
        "Source/D3D12/DescriptorHeapD3D12.h"
        "Source/D3D12/DescriptorHeapD3D12.hpp"
        "Source/D3D12/DescriptorPoolD3D12.h"
        "Source/D3D12/DescriptorPoolD3D12.hpp"
        "Source/D3D12/DescriptorSetD3D12.h"
        "Source/D3D12/DescriptorSetD3D12.hpp"
        "Source/D3D12/DeviceD3D12.h"
        "Source/D3D12/DeviceD3D12.hpp"
        "Source/D3D12/FenceD3D12.h"
        "Source/D3D12/FenceD3D12.hpp"
        "Source/D3D12/ImplD3D12.cpp"
        "Source/D3D12/MemoryAllocatorD3D12.h"
        "Source/D3D12/MemoryD3D12.h"
        "Source/D3D12/MemoryD3D12.hpp"
        "Source/D3D12/MicromapD3D12.h"
        "Source/D3D12/MicromapD3D12.hpp"
        "Source/D3D12/PipelineCacheD3D12.h"
        "Source/D3D12/PipelineCacheD3D12.hpp"
        "Source/D3D12/PipelineD3D12.h"
        "Source/D3D12/PipelineD3D12.hpp"
        "Source/D3D12/PipelineLayoutD3D12.h"
        "Source/D3D12/PipelineLayoutD3D12.hpp"
        "Source/D3D12/QueryPoolD3D12.h"
        "Source/D3D12/QueryPoolD3D12.hpp"
        "Source/D3D12/QueueD3D12.h"
        "Source/D3D12/QueueD3D12.hpp"
        "Source/D3D12/SharedD3D12.h"
        "Source/D3D12/SharedD3D12.hpp"
        "Source/D3D12/SwapChainD3D12.h"
        "Source/D3D12/SwapChainD3D12.hpp"
        "Source/D3D12/TextureD3D12.h"
        "Source/D3D12/TextureD3D12.hpp"
        "Source/D3D12/TransferContextD3D12.h"
        "Source/D3D12/TransferContextD3D12.hpp"
        "Source/D3D12/VideoHelpersD3D12.h"
        "Source/D3D12/VideoPictureD3D12.h"
        "Source/D3D12/VideoPictureD3D12.hpp"
        "Source/D3D12/VideoSessionD3D12.h"
        "Source/D3D12/VideoSessionD3D12.hpp"
        "Source/D3D12/VideoSessionParametersD3D12.h"
        "Source/D3D12/VideoSessionParametersD3D12.hpp"
    )

    add_library(NRI_D3D12 STATIC)
    target_sources(NRI_D3D12
        PRIVATE
            ${D3D12_SOURCE}
            ${D3D12_VMA}
            $<$<BOOL:${NRI_ENABLE_NVAPI}>:
                ${NVAPI_HEADERS}
            >
            $<$<BOOL:${NRI_ENABLE_AMDAGS}>:
                ${AMDAGS_HEADERS}
            >
    )
    target_include_directories(NRI_D3D12
        PRIVATE
            "${d3d12ma_SOURCE_DIR}/include"
            "${d3d12ma_SOURCE_DIR}/src"
            $<$<BOOL:${NRI_ENABLE_NVAPI}>:
                "${nvapi_SOURCE_DIR}"
            >
            $<$<BOOL:${NRI_ENABLE_AMDAGS}>:
                "${amdags_SOURCE_DIR}/ags_lib/inc"
            >
            $<$<BOOL:${NRI_ENABLE_AGILITY_SDK_SUPPORT}>:
                ${agilitysdk_SOURCE_DIR}/build/native/include
            >
    )
    target_compile_definitions(NRI_D3D12
        PRIVATE
            NRI_AGILITY_SDK_VERSION_MAJOR=$<IF:$<BOOL:${NRI_ENABLE_AGILITY_SDK_SUPPORT}>,${NRI_AGILITY_SDK_VERSION_MAJOR},D3D12_SDK_VERSION>
    )
    target_link_libraries(NRI_D3D12
        PRIVATE
            NRI_Shared
            d3d12
            dxgi
            dxguid
            $<$<BOOL:${NRI_ENABLE_NVAPI}>:
                ${NVAPI_LIB}
            >
    )
    set_target_properties(NRI_D3D12
        PROPERTIES
            FOLDER "NRI"
    )

    if(NRI_ENABLE_AGILITY_SDK_SUPPORT)
        message("NRI: using AgilitySDK v1.${NRI_AGILITY_SDK_VERSION_MAJOR}.${NRI_AGILITY_SDK_VERSION_MINOR}")

        # Generate "NRIAgilitySDK.h"
        file(WRITE Include/NRIAgilitySDK.h
            "// This file is auto-generated during project deployment. Do not modify!\n"
            "#ifdef __cplusplus\n"
            "extern \"C\" {\n"
            "#endif\n\n"
            "__declspec(dllexport) extern const uint32_t D3D12SDKVersion;\n"
            "const uint32_t D3D12SDKVersion = ${NRI_AGILITY_SDK_VERSION_MAJOR};\n\n"
            "__declspec(dllexport) extern const char* D3D12SDKPath;\n"
            "const char* D3D12SDKPath = \"${NRI_AGILITY_SDK_DIR}/\";\n\n"
            "#ifdef __cplusplus\n"
            "}\n"
            "#endif\n"
        )
    endif()
endif()

# VK
if(NRI_ENABLE_VK_SUPPORT)
    if(APPLE)
        find_package(Vulkan REQUIRED)
    endif()

    set(VK_VMA "${vma_SOURCE_DIR}/include/vk_mem_alloc.h")
    source_group("External/Vma"
        FILES
            ${VK_VMA}
    )

    set(VK_SOURCE
        "Source/VK/AccelerationStructureVK.h"
        "Source/VK/AccelerationStructureVK.hpp"
        "Source/VK/BufferVK.h"
        "Source/VK/BufferVK.hpp"
        "Source/VK/CommandAllocatorVK.h"
        "Source/VK/CommandAllocatorVK.hpp"
        "Source/VK/CommandBufferVK.h"
        "Source/VK/CommandBufferVK.hpp"
        "Source/VK/ConversionVK.h"
        "Source/VK/ConversionVK.hpp"
        "Source/VK/DescriptorPoolVK.h"
        "Source/VK/DescriptorPoolVK.hpp"
        "Source/VK/DescriptorSetVK.h"
        "Source/VK/DescriptorSetVK.hpp"
        "Source/VK/DescriptorVK.h"
        "Source/VK/DescriptorVK.hpp"
        "Source/VK/DescriptorHeapVK.h"
        "Source/VK/DescriptorHeapVK.hpp"
        "Source/VK/DeviceVK.h"
        "Source/VK/DeviceVK.hpp"
        "Source/VK/DispatchTable.h"
        "Source/VK/FenceVK.h"
        "Source/VK/FenceVK.hpp"
        "Source/VK/ImplVK.cpp"
        "Source/VK/MemoryAllocatorVK.h"
        "Source/VK/MemoryVK.h"
        "Source/VK/MemoryVK.hpp"
        "Source/VK/MicromapVK.h"
        "Source/VK/MicromapVK.hpp"
        "Source/VK/PipelineCacheVK.h"
        "Source/VK/PipelineCacheVK.hpp"
        "Source/VK/PipelineLayoutVK.h"
        "Source/VK/PipelineLayoutVK.hpp"
        "Source/VK/PipelineVK.h"
        "Source/VK/PipelineVK.hpp"
        "Source/VK/QueryPoolVK.h"
        "Source/VK/QueryPoolVK.hpp"
        "Source/VK/QueueVK.h"
        "Source/VK/QueueVK.hpp"
        "Source/VK/SharedVK.h"
        "Source/VK/SwapChainVK.h"
        "Source/VK/SwapChainVK.hpp"
        "Source/VK/TextureVK.h"
        "Source/VK/TextureVK.hpp"
        "Source/VK/TransferContextVK.h"
        "Source/VK/TransferContextVK.hpp"
        "Source/VK/VideoHelpersVK.h"
        "Source/VK/VideoPictureVK.h"
        "Source/VK/VideoPictureVK.hpp"
        "Source/VK/VideoSessionVK.h"
        "Source/VK/VideoSessionVK.hpp"
        "Source/VK/VideoSessionParametersVK.h"
        "Source/VK/VideoSessionParametersVK.hpp"
    )

    add_library(NRI_VK STATIC)
    target_sources(NRI_VK
        PRIVATE
            ${VK_SOURCE}
            ${VK_VMA}
    )
    target_include_directories(NRI_VK
        PRIVATE
            "${vma_SOURCE_DIR}/include"
            "${vulkan_headers_SOURCE_DIR}/include"
    )
    target_compile_definitions(NRI_VK
        PRIVATE
            $<$<BOOL:${WIN32}>:
                VK_USE_PLATFORM_WIN32_KHR
            >
            $<$<BOOL:${APPLE}>:
                VK_USE_PLATFORM_METAL_EXT;VK_ENABLE_BETA_EXTENSIONS
            >
            $<$<BOOL:${ANDROID}>:
                VK_USE_PLATFORM_ANDROID_KHR
            >
            $<$<BOOL:${NRI_ENABLE_XLIB_SUPPORT}>:
                VK_USE_PLATFORM_XLIB_KHR
            >
            $<$<BOOL:${NRI_ENABLE_WAYLAND_SUPPORT}>:
                VK_USE_PLATFORM_WAYLAND_KHR
            >
    )
    target_link_libraries(NRI_VK
        PRIVATE
            NRI_Shared
            $<$<BOOL:${APPLE}>:
                ${Vulkan_LIBRARIES}
            >
    )
    set_target_properties(NRI_VK
        PROPERTIES
            FOLDER "NRI"
    )
endif()

# WGPU
if(NRI_ENABLE_WGPU_SUPPORT)
    set(WGPU_SOURCE
        "Source/WGPU/BufferWGPU.h"
        "Source/WGPU/BufferWGPU.hpp"
        "Source/WGPU/CommandAllocatorWGPU.h"
        "Source/WGPU/CommandAllocatorWGPU.hpp"
        "Source/WGPU/CommandBufferWGPU.h"
        "Source/WGPU/CommandBufferWGPU.hpp"
        "Source/WGPU/DescriptorPoolWGPU.h"
        "Source/WGPU/DescriptorPoolWGPU.hpp"
        "Source/WGPU/DescriptorSetWGPU.h"
        "Source/WGPU/DescriptorSetWGPU.hpp"
        "Source/WGPU/DescriptorWGPU.h"
        "Source/WGPU/DescriptorWGPU.hpp"
        "Source/WGPU/DeviceWGPU.h"
        "Source/WGPU/DeviceWGPU.hpp"
        "Source/WGPU/FenceWGPU.h"
        "Source/WGPU/FenceWGPU.hpp"
        "Source/WGPU/ImplWGPU.cpp"
        "Source/WGPU/MemoryWGPU.h"
        "Source/WGPU/MemoryWGPU.hpp"
        "Source/WGPU/PipelineCacheWGPU.h"
        "Source/WGPU/PipelineCacheWGPU.hpp"
        "Source/WGPU/PipelineLayoutWGPU.h"
        "Source/WGPU/PipelineLayoutWGPU.hpp"
        "Source/WGPU/PipelineWGPU.h"
        "Source/WGPU/PipelineWGPU.hpp"
        "Source/WGPU/QueryPoolWGPU.h"
        "Source/WGPU/QueryPoolWGPU.hpp"
        "Source/WGPU/QueueWGPU.h"
        "Source/WGPU/QueueWGPU.hpp"
        "Source/WGPU/SharedWGPU.h"
        "Source/WGPU/SharedWGPU.hpp"
        "Source/WGPU/SwapChainWGPU.h"
        "Source/WGPU/SwapChainWGPU.hpp"
        "Source/WGPU/TextureWGPU.h"
        "Source/WGPU/TextureWGPU.hpp"
    )

    add_library(NRI_WGPU STATIC)
    target_sources(NRI_WGPU
        PRIVATE
            ${WGPU_SOURCE}
    )
    target_include_directories(NRI_WGPU
        PRIVATE
            "${wgpu_native_SOURCE_DIR}/include"
    )
    target_link_libraries(NRI_WGPU
        PRIVATE
            NRI_Shared
            "${wgpu_native_SOURCE_DIR}/lib/${WGPU_NATIVE_LIB_NAME}"
    )
    set_target_properties(NRI_WGPU
        PROPERTIES
            FOLDER "NRI"
    )
endif()

# Metal
if(NRI_ENABLE_METAL_SUPPORT)
    if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 17)
        message(FATAL_ERROR "NRI: Metal 4 requires Xcode 26 or newer (AppleClang 17 or newer)")
    endif()

    if(NOT EXISTS "${metal_cpp_SOURCE_DIR}/Metal/Metal.hpp" OR NOT EXISTS "${metal_cpp_SOURCE_DIR}/Metal/MTL4ArgumentTable.hpp")
        message(FATAL_ERROR "NRI: Metal 4 metal-cpp headers were not found at '${metal_cpp_SOURCE_DIR}'")
    endif()

    if(NRI_ENABLE_METAL_SHADER_CONVERTER)
        if(NOT NRI_METAL_SHADER_CONVERTER_INCLUDE_PATH)
            unset(NRI_METAL_SHADER_CONVERTER_INCLUDE_PATH CACHE)
        endif()
        if(NOT NRI_METAL_SHADER_CONVERTER_LIBRARY)
            unset(NRI_METAL_SHADER_CONVERTER_LIBRARY CACHE)
        endif()
        find_path(NRI_METAL_SHADER_CONVERTER_INCLUDE_PATH metal_irconverter/metal_irconverter.h PATHS "/usr/local/include" NO_CMAKE_FIND_ROOT_PATH REQUIRED)
        find_library(NRI_METAL_SHADER_CONVERTER_LIBRARY NAMES metalirconverter ${NRI_METAL_SHADER_CONVERTER_FIND_ARGS} REQUIRED)
        message(STATUS "NRI: Metal Shader Converter headers: ${NRI_METAL_SHADER_CONVERTER_INCLUDE_PATH}")
        message(STATUS "NRI: Metal Shader Converter library: ${NRI_METAL_SHADER_CONVERTER_LIBRARY}")
    endif()

    # MetalFX is not in the iOS simulator SDK (with the Xcode generator "CMAKE_OSX_SYSROOT" must match the SDK used for building)
    if(IOS AND CMAKE_OSX_SYSROOT MATCHES "[Ss]imulator")
        set(NRI_METALFX_FRAMEWORK "")
    else()
        set(NRI_METALFX_FRAMEWORK "-framework MetalFX")
    endif()

    # Precompiles "Shaders/<NAME>.metal" into "<NAME>.metallib.h" ("g_<NAME>_metallib" byte array) and makes "TARGET" depend on it.
    # iOS: device and simulator variants are selected by "TARGET_OS_SIMULATOR", since generators like Xcode pick the SDK at build time
    find_program(NRI_XCRUN xcrun REQUIRED)

    set(NRI_METALLIB_SCRIPT "${CMAKE_CURRENT_BINARY_DIR}/EmbedMetallib.cmake")
    file(CONFIGURE
        OUTPUT "${NRI_METALLIB_SCRIPT}"
        CONTENT [=[
function(to_array IN VAR)
    file(READ "${IN}" DATA HEX)
    string(REGEX REPLACE "([0-9a-f][0-9a-f])" "0x\\1," DATA "${DATA}")
    set(${VAR} "unsigned char g_${NAME}_metallib[] = {${DATA}};\n" PARENT_SCOPE)
endfunction()
to_array("${IN}" DATA)
if(IN_SIMULATOR)
    to_array("${IN_SIMULATOR}" DATA_SIMULATOR)
    set(DATA "#include <TargetConditionals.h>\n#if TARGET_OS_SIMULATOR\n${DATA_SIMULATOR}#else\n${DATA}#endif\n")
endif()
file(WRITE "${OUT}" "${DATA}")
]=]
        @ONLY
    )

    function(nri_embed_metallib NAME TARGET)
        set(SOURCE "${CMAKE_CURRENT_SOURCE_DIR}/Shaders/${NAME}.metal")
        set(HEADER "${CMAKE_CURRENT_BINARY_DIR}/${NAME}.metallib.h")

        if(IOS)
            set(SDKS iphoneos iphonesimulator)
        else()
            set(SDKS macosx)
        endif()

        set(COMMANDS "")
        set(INPUTS "")
        foreach(SDK IN LISTS SDKS)
            set(AIR "${CMAKE_CURRENT_BINARY_DIR}/${NAME}.${SDK}.air")
            set(METALLIB "${CMAKE_CURRENT_BINARY_DIR}/${NAME}.${SDK}.metallib")
            if(SDK STREQUAL "macosx")
                set(VERSION_MIN "-mmacosx-version-min=26.0")
                list(APPEND INPUTS -D "IN=${METALLIB}")
            elseif(SDK STREQUAL "iphonesimulator")
                set(VERSION_MIN "-mios-simulator-version-min=26.0")
                list(APPEND INPUTS -D "IN_SIMULATOR=${METALLIB}")
            else()
                set(VERSION_MIN "-mios-version-min=26.0")
                list(APPEND INPUTS -D "IN=${METALLIB}")
            endif()
            list(APPEND COMMANDS
                COMMAND "${NRI_XCRUN}" -sdk ${SDK} metal -std=metal4.0 ${VERSION_MIN} -c "${SOURCE}" -o "${AIR}"
                COMMAND "${NRI_XCRUN}" -sdk ${SDK} metallib "${AIR}" -o "${METALLIB}"
            )
        endforeach()

        add_custom_command(
            OUTPUT "${HEADER}"
            ${COMMANDS}
            COMMAND "${CMAKE_COMMAND}" ${INPUTS} -D "OUT=${HEADER}" -D "NAME=${NAME}" -P "${NRI_METALLIB_SCRIPT}"
            DEPENDS "${SOURCE}" "${NRI_METALLIB_SCRIPT}"
            VERBATIM
        )
        add_custom_target(NRI_Metal_${NAME}Shader
            DEPENDS "${HEADER}"
        )
        add_dependencies(${TARGET} NRI_Metal_${NAME}Shader)
        target_include_directories(${TARGET}
            PRIVATE
                "${CMAKE_CURRENT_BINARY_DIR}"
        )
    endfunction()

    if(NRI_ENABLE_IMGUI_EXTENSION)
        nri_embed_metallib(Imgui NRI_Shared)
    endif()

    set(METAL_SOURCE
        "Source/Metal/AccelerationStructureMetal.h"
        "Source/Metal/AccelerationStructureMetal.hpp"
        "Source/Metal/BufferMetal.h"
        "Source/Metal/BufferMetal.hpp"
        "Source/Metal/CommandAllocatorMetal.h"
        "Source/Metal/CommandAllocatorMetal.hpp"
        "Source/Metal/CommandBufferMetal.h"
        "Source/Metal/CommandBufferMetal.hpp"
        "Source/Metal/ConversionMetal.h"
        "Source/Metal/ConversionMetal.hpp"
        "Source/Metal/DescriptorMetal.h"
        "Source/Metal/DescriptorMetal.hpp"
        "Source/Metal/DescriptorPoolMetal.h"
        "Source/Metal/DescriptorPoolMetal.hpp"
        "Source/Metal/DescriptorSetMetal.h"
        "Source/Metal/DescriptorSetMetal.hpp"
        "Source/Metal/DeviceMetal.h"
        "Source/Metal/DeviceMetal.hpp"
        "Source/Metal/FenceMetal.h"
        "Source/Metal/FenceMetal.hpp"
        "Source/Metal/ImplMetal.cpp"
        "Source/Metal/InternalShadersMetal.h"
        "Source/Metal/InternalShadersMetal.hpp"
        "Source/Metal/MemoryMetal.h"
        "Source/Metal/MemoryMetal.hpp"
        "Source/Metal/PipelineCacheMetal.h"
        "Source/Metal/PipelineCacheMetal.hpp"
        "Source/Metal/PipelineLayoutMetal.h"
        "Source/Metal/PipelineLayoutMetal.hpp"
        "Source/Metal/PipelineMetal.h"
        "Source/Metal/PipelineMetal.hpp"
        "Source/Metal/QueryPoolMetal.h"
        "Source/Metal/QueryPoolMetal.hpp"
        "Source/Metal/QueueMetal.h"
        "Source/Metal/QueueMetal.hpp"
        "Source/Metal/SharedMetal.h"
        "Source/Metal/SwapChainMetal.h"
        "Source/Metal/SwapChainMetal.hpp"
        "Source/Metal/TextureMetal.h"
        "Source/Metal/TextureMetal.hpp"
    )

    target_include_directories(NRI_Shared PRIVATE "${metal_cpp_SOURCE_DIR}") # MetalFX in "UpscalerInterface.hpp"

    add_library(NRI_Metal STATIC)
    target_sources(NRI_Metal
        PRIVATE
            ${METAL_SOURCE}
    )
    target_include_directories(NRI_Metal
        PRIVATE
            "${metal_cpp_SOURCE_DIR}"
            $<$<BOOL:${NRI_ENABLE_METAL_SHADER_CONVERTER}>:
                "${NRI_METAL_SHADER_CONVERTER_INCLUDE_PATH}"
            >
    )
    target_link_libraries(NRI_Metal
        PRIVATE
            NRI_Shared
            "-framework Foundation"
            "-framework Metal"
            ${NRI_METALFX_FRAMEWORK}
            "-framework QuartzCore"
            "-framework CoreGraphics"
            $<$<BOOL:${NRI_ENABLE_METAL_SHADER_CONVERTER}>:
                "${NRI_METAL_SHADER_CONVERTER_LIBRARY}"
            >
    )
    set_target_properties(NRI_Metal
        PROPERTIES
            FOLDER "NRI"
    )

    nri_embed_metallib(InternalMetal NRI_Metal)
endif()

# Validation
if(NRI_ENABLE_VALIDATION_SUPPORT)
    set(NRI_VALIDATION_SOURCE
        "Source/Validation/AccelerationStructureVal.h"
        "Source/Validation/AccelerationStructureVal.hpp"
        "Source/Validation/BufferVal.h"
        "Source/Validation/BufferVal.hpp"
        "Source/Validation/CommandAllocatorVal.h"
        "Source/Validation/CommandAllocatorVal.hpp"
        "Source/Validation/CommandBufferVal.h"
        "Source/Validation/CommandBufferVal.hpp"
        "Source/Validation/ConversionVal.hpp"
        "Source/Validation/DescriptorPoolVal.h"
        "Source/Validation/DescriptorPoolVal.hpp"
        "Source/Validation/DescriptorHeapVal.h"
        "Source/Validation/DescriptorHeapVal.hpp"
        "Source/Validation/DescriptorSetVal.h"
        "Source/Validation/DescriptorSetVal.hpp"
        "Source/Validation/DescriptorVal.h"
        "Source/Validation/DescriptorVal.hpp"
        "Source/Validation/DeviceVal.h"
        "Source/Validation/DeviceVal.hpp"
        "Source/Validation/FenceVal.h"
        "Source/Validation/FenceVal.hpp"
        "Source/Validation/ImplVal.cpp"
        "Source/Validation/MemoryVal.h"
        "Source/Validation/MemoryVal.hpp"
        "Source/Validation/MicromapVal.h"
        "Source/Validation/MicromapVal.hpp"
        "Source/Validation/PipelineCacheVal.h"
        "Source/Validation/PipelineCacheVal.hpp"
        "Source/Validation/PipelineLayoutVal.h"
        "Source/Validation/PipelineLayoutVal.hpp"
        "Source/Validation/PipelineVal.h"
        "Source/Validation/PipelineVal.hpp"
        "Source/Validation/QueryPoolVal.h"
        "Source/Validation/QueryPoolVal.hpp"
        "Source/Validation/QueueVal.h"
        "Source/Validation/QueueVal.hpp"
        "Source/Validation/SharedVal.h"
        "Source/Validation/SwapChainVal.h"
        "Source/Validation/SwapChainVal.hpp"
        "Source/Validation/TextureVal.h"
        "Source/Validation/TextureVal.hpp"
        "Source/Validation/VideoPictureVal.h"
        "Source/Validation/VideoPictureVal.hpp"
        "Source/Validation/VideoSessionParametersVal.h"
        "Source/Validation/VideoSessionParametersVal.hpp"
        "Source/Validation/VideoSessionVal.h"
        "Source/Validation/VideoSessionVal.hpp"
    )

    add_library(NRI_Validation STATIC)
    target_sources(NRI_Validation
        PRIVATE
            ${NRI_VALIDATION_SOURCE}
    )
    target_link_libraries(NRI_Validation
        PRIVATE
            NRI_Shared
    )
    set_target_properties(NRI_Validation
        PROPERTIES
            FOLDER "NRI"
    )
endif()

# Core headers
set(NRI_HEADERS
    "Include/NRI.h"
    "Include/NRI.hlsl"
    "Include/NRI.metal"
    "Include/NRIDescs.h"
    "Include/NRIMacro.h"
)
source_group("Include"
    FILES
        ${NRI_HEADERS}
)
set_source_files_properties(${NRI_HEADERS}
    PROPERTIES
        VS_SETTINGS "ExcludedFromBuild=true" # do not compile HLSL
)
set_source_files_properties("Include/NRI.metal"
    PROPERTIES
        HEADER_FILE_ONLY TRUE # do not compile MSL
)

# Extensions headers
set(NRI_EXTENSIONS
    "Include/Extensions/NRIDescriptorHeap.h"
    "Include/Extensions/NRIDeviceCreation.h"
    "Include/Extensions/NRIHelper.h"
    "Include/Extensions/NRIImgui.h"
    "Include/Extensions/NRILowLatency.h"
    "Include/Extensions/NRIMeshShader.h"
    "Include/Extensions/NRIRayTracing.h"
    "Include/Extensions/NRIStreamer.h"
    "Include/Extensions/NRISwapChain.h"
    "Include/Extensions/NRIUpscaler.h"
    "Include/Extensions/NRIVideo.h"
    "Include/Extensions/NRIWrapperD3D11.h"
    "Include/Extensions/NRIWrapperD3D12.h"
    "Include/Extensions/NRIWrapperMetal.h"
    "Include/Extensions/NRIWrapperVK.h"
)
source_group("Include/Extensions"
    FILES
        ${NRI_EXTENSIONS}
)

# Resources
set(NRI_RESOURCES
    "Resources/NRI.rc"
    "Resources/Version.h"
)
source_group("Resources"
    FILES
        ${NRI_RESOURCES}
)

# NRI
set(NRI_SOURCE "Source/Creation/Creation.cpp")
source_group("Sources"
    FILES
        ${NRI_SOURCE}
)

if(NRI_STATIC_LIBRARY)
    add_library(NRI STATIC)
else()
    add_library(NRI SHARED)

    if(CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
        target_link_options(NRI
            PRIVATE
                $<$<CONFIG:Release>:/DEBUG> # generate a PDB for Release build
                $<$<CONFIG:Release>:/OPT:ICF> # perform identical COMDAT folding (removes duplicate code/data)
        )
    endif()
endif()

target_sources(NRI
    PRIVATE
        ${NRI_SOURCE}
        ${NRI_HEADERS}
        ${NRI_RESOURCES}
        ${NRI_EXTENSIONS}
        $<$<CXX_COMPILER_FRONTEND_VARIANT:MSVC>:nri.natvis> # debugger markup
)
target_include_directories(NRI
    PRIVATE
        $<$<BOOL:${NRI_ENABLE_NVTX_SUPPORT}>:
            "${nvtx_SOURCE_DIR}/c/include/"
        >
        $<$<BOOL:${NRI_ENABLE_VK_SUPPORT}>:
            "${vulkan_headers_SOURCE_DIR}/include"
        >
        $<$<BOOL:${NRI_ENABLE_WGPU_SUPPORT}>:
            "${wgpu_native_SOURCE_DIR}/include"
        >
    PUBLIC
        "Include"
)
target_compile_definitions(NRI
    PRIVATE
        $<$<NOT:$<BOOL:${NRI_STATIC_LIBRARY}>>:
            $<$<BOOL:${WIN32}>:
                "NRI_API=extern \"C\" __declspec(dllexport)"
            >
            $<$<NOT:$<BOOL:${WIN32}>>:
                "NRI_API=extern \"C\" __attribute__((visibility(\"default\")))"
            >
        >
    PUBLIC
        $<$<BOOL:${NRI_ENABLE_AGILITY_SDK_SUPPORT}>:
            NRI_ENABLE_AGILITY_SDK_SUPPORT=1
        >
)
target_link_libraries(NRI
    PRIVATE
        NRI_Shared
        $<$<NOT:$<BOOL:${WIN32}>>:
            ${CMAKE_DL_LIBS}
        >
        $<$<BOOL:${NRI_ENABLE_NONE_SUPPORT}>:
            NRI_NONE
        >
        $<$<BOOL:${NRI_ENABLE_D3D11_SUPPORT}>:
            NRI_D3D11
        >
        $<$<BOOL:${NRI_ENABLE_D3D12_SUPPORT}>:
            NRI_D3D12
        >
        $<$<BOOL:${NRI_ENABLE_VK_SUPPORT}>:
            NRI_VK
        >
        $<$<BOOL:${NRI_ENABLE_WGPU_SUPPORT}>:
            NRI_WGPU
        >
        $<$<BOOL:${NRI_ENABLE_METAL_SUPPORT}>:
            NRI_Metal
        >
        $<$<BOOL:${NRI_ENABLE_VALIDATION_SUPPORT}>:
            NRI_Validation
        >
)
set_target_properties(NRI
    PROPERTIES
        FOLDER "NRI"
        ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}"
)

message("NRI: output path '${CMAKE_RUNTIME_OUTPUT_DIRECTORY}'")

# Copy to the output folder
if(NRI_ENABLE_AMDAGS)
    find_file(AMD_AGS_DLL
        NAMES
            amd_ags_${BIN_ARCHITECTURE}.dll
        PATHS "${amdags_SOURCE_DIR}/ags_lib/lib"
    )
    add_custom_command(TARGET NRI
        POST_BUILD
            COMMAND ${CMAKE_COMMAND} -E copy_if_different "${AMD_AGS_DLL}" "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
        VERBATIM
    )
endif()

if(NRI_ENABLE_AGILITY_SDK_SUPPORT)
    add_custom_command(TARGET NRI
        POST_BUILD
            COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different "${agilitysdk_SOURCE_DIR}/build/native/bin/${BIN_ARCHITECTURE}" "$<TARGET_FILE_DIR:${PROJECT_NAME}>/${NRI_AGILITY_SDK_DIR}"
        VERBATIM
    )
endif()

# Metal Shader Converter: "@rpath/libmetalirconverter.dylib" is found next to "libNRI" or in the app "Frameworks" folder
if(NRI_ENABLE_METAL_SHADER_CONVERTER AND NOT NRI_STATIC_LIBRARY)
    if(IOS)
        set(NRI_RPATH "@loader_path;@executable_path/Frameworks")
    else()
        set(NRI_RPATH "@loader_path;@executable_path/../Frameworks")
    endif()

    set_target_properties(NRI
        PROPERTIES
            BUILD_RPATH "${NRI_RPATH}"
            INSTALL_RPATH "${NRI_RPATH}"
    )
    add_custom_command(TARGET NRI
        POST_BUILD
            COMMAND ${CMAKE_COMMAND} -E copy_if_different "${NRI_METAL_SHADER_CONVERTER_LIBRARY}" "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
        VERBATIM
    )
endif()

if(NRI_ENABLE_WGPU_SUPPORT)
    add_custom_command(TARGET NRI
        POST_BUILD
            COMMAND ${CMAKE_COMMAND} -E copy_if_different "${wgpu_native_SOURCE_DIR}/lib/${WGPU_NATIVE_RUNTIME_NAME}" "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
        VERBATIM
    )
endif()

if(NRI_ENABLE_NGX_SDK)
    set(NGX_LIB_DIR $<IF:$<CONFIG:Debug>,dev,rel>)

    if(WIN32)
        set(DLSS_SR_DLL "${ngx_SOURCE_DIR}/lib/${NGX_WINDOWS_DIR}/${NGX_LIB_DIR}/nvngx_dlss.dll")
        set(DLSS_RR_DLL "${ngx_SOURCE_DIR}/lib/${NGX_WINDOWS_DIR}/${NGX_LIB_DIR}/nvngx_dlssd.dll")
    else()
        set(DLSS_SR_DLL "${ngx_SOURCE_DIR}/lib/Linux_x86_64/${NGX_LIB_DIR}/libnvidia-ngx-dlss.so.${NGX_VERSION}")
        set(DLSS_RR_DLL "${ngx_SOURCE_DIR}/lib/Linux_x86_64/${NGX_LIB_DIR}/libnvidia-ngx-dlssd.so.${NGX_VERSION}")
    endif()

    add_custom_command(TARGET NRI
        POST_BUILD
            COMMAND ${CMAKE_COMMAND} -E copy_if_different ${DLSS_SR_DLL} "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
            COMMAND ${CMAKE_COMMAND} -E copy_if_different ${DLSS_RR_DLL} "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
        VERBATIM
    )
endif()

if(NRI_ENABLE_FFX_SDK)
    if(NRI_ENABLE_D3D12_SUPPORT)
        find_file(FSR_DX12_LOADER_DLL
            NAMES
                amd_fidelityfx_loader_dx12.dll
            PATHS
                "${fsr_SOURCE_DIR}/Kits/FidelityFX/signedbin"
            NO_DEFAULT_PATH
            NO_CACHE
            REQUIRED
        )
        find_file(FSR_DX12_UPSCALER_DLL
            NAMES
                amd_fidelityfx_upscaler_dx12.dll
            PATHS
                "${fsr_SOURCE_DIR}/Kits/FidelityFX/signedbin"
            NO_DEFAULT_PATH
            NO_CACHE
            REQUIRED
        )
        add_custom_command(TARGET NRI
            POST_BUILD
                COMMAND ${CMAKE_COMMAND} -E copy_if_different ${FSR_DX12_LOADER_DLL} ${FSR_DX12_UPSCALER_DLL} "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
                VERBATIM
        )
    endif()

    if(NRI_ENABLE_VK_SUPPORT AND WIN32)
        find_file(FFX_VK_DLL
            NAMES
                amd_fidelityfx_vk.dll
            PATHS
                "${ffx_SOURCE_DIR}/PrebuiltSignedDLL"
        )
        add_custom_command(TARGET NRI
            POST_BUILD
                COMMAND ${CMAKE_COMMAND} -E copy_if_different ${FFX_VK_DLL} "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
            VERBATIM
        )
    endif()
endif()

if(NRI_ENABLE_XESS_SDK)
    if(NRI_ENABLE_D3D12_SUPPORT)
        find_file(XESS_DX12_DLL
            NAMES
                libxess.dll
            PATHS
                "${xess_SOURCE_DIR}/bin"
        )
        add_custom_command(TARGET NRI
            POST_BUILD
                COMMAND ${CMAKE_COMMAND} -E copy_if_different ${XESS_DX12_DLL} "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
            VERBATIM
        )
    endif()
endif()

# Shaders
if(NRI_ENABLE_SHADERMAKE)
    set(SHADERS
        "Shaders/Imgui.fs.hlsl"
        "Shaders/Imgui.metal"
        "Shaders/Imgui.vs.hlsl"
        "Shaders/InternalMetal.metal"
        "Shaders/NIS.hlsl"
        "Shaders/NIS.cs.hlsl"
    )
    set_source_files_properties(${SHADERS}
        PROPERTIES
            VS_SETTINGS "ExcludedFromBuild=true" # do not compile HLSL
    )
    set_source_files_properties("Shaders/Imgui.metal" "Shaders/InternalMetal.metal"
        PROPERTIES
            HEADER_FILE_ONLY TRUE # precompiled by "nri_embed_metallib"
    )

    set(SHADERMAKE_GENERAL_ARGS
        --project "NRI"
        --compactProgress
        --flatten
        --stripReflection
        --WX
        --sRegShift 0 --tRegShift 0 --bRegShift 0 --uRegShift 0
        --headerBlob
        --sourceDir "Shaders"
        --ignoreConfigDir
        -c "Shaders/Shaders.cfg"
        -o "${NRI_SHADERS_PATH}"
        -I "Shaders"
        -I "Include"
    )

    set(SHADERMAKE_COMMANDS)
    if(NRI_ENABLE_D3D11_SUPPORT)
        list(APPEND SHADERMAKE_COMMANDS COMMAND ${SHADERMAKE_PATH} -p DXBC --compiler "${SHADERMAKE_FXC_PATH}" ${SHADERMAKE_GENERAL_ARGS})
    endif()
    if(NRI_ENABLE_D3D12_SUPPORT OR (NRI_ENABLE_METAL_SUPPORT AND NRI_ENABLE_METAL_SHADER_CONVERTER))
        list(APPEND SHADERMAKE_COMMANDS COMMAND ${SHADERMAKE_PATH} -p DXIL --compiler "${SHADERMAKE_DXC_PATH}" ${SHADERMAKE_GENERAL_ARGS})
    endif()
    if(NRI_ENABLE_VK_SUPPORT OR NRI_ENABLE_WGPU_SUPPORT)
        list(APPEND SHADERMAKE_COMMANDS COMMAND ${SHADERMAKE_PATH} -p SPIRV --compiler "${SHADERMAKE_DXC_VK_PATH}" ${SHADERMAKE_GENERAL_ARGS})
    endif()
    list(APPEND SHADERMAKE_COMMANDS "") # fix for "The system cannot find the batch label specified - VCEnd"

    add_custom_target(NRI_Shaders
        ALL
            ${SHADERMAKE_COMMANDS}
        DEPENDS
            ShaderMake
        WORKING_DIRECTORY
            "${CMAKE_CURRENT_SOURCE_DIR}"
        SOURCES
            ${SHADERS}
        VERBATIM
    )
    set_target_properties(NRI_Shaders
        PROPERTIES
            FOLDER "NRI"
    )
    add_dependencies(NRI_Shared NRI_Shaders)
    target_include_directories(NRI_Shared
        PRIVATE
            "${NRI_SHADERS_PATH}"
    )
    target_link_libraries(NRI_Shared
        PRIVATE
            ShaderMakeBlob
    )

    message("NRI: shaders path '${NRI_SHADERS_PATH}'")
endif()