CMakeLists.txt

# SPDX-FileCopyrightText: 2025 LichtFeld Studio Authors
#
# SPDX-License-Identifier: GPL-3.0-or-later

# windows/linux platform independent
set(RAW_VCPKG_PATH $ENV{VCPKG_ROOT})
file(TO_CMAKE_PATH "${RAW_VCPKG_PATH}" VCPKG_ROOT)

if ("${CMAKE_TOOLCHAIN_FILE}" STREQUAL "")
    message(STATUS "user didn't specify CMAKE_TOOLCHAIN_FILE manually, so let's use default -> ${VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake")
    set(CMAKE_TOOLCHAIN_FILE "${VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake")
endif()

cmake_minimum_required(VERSION 3.30)

option(LFS_ENFORCE_LINUX_GUI_BACKENDS "Fail configure when Linux SDL3 would lack X11 and Wayland support" ON)

include("${CMAKE_CURRENT_SOURCE_DIR}/cmake/LinuxGuiSanity.cmake")
lfs_linux_preflight_gui_backends()

# Suppress CMake developer warnings
set(CMAKE_SUPPRESS_DEVELOPER_WARNINGS ON CACHE BOOL "" FORCE)

set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

# Default to Release build
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
    message(STATUS "No build type specified, defaulting to Release")
    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Build type" FORCE)
    set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
endif()

project(LichtFeld-Studio VERSION 0.5.2 LANGUAGES CUDA CXX C)

# On Windows with a multi-config generator (MSVC/Visual Studio, Ninja Multi-Config),
# route all build outputs to build/<Config>/ so Debug and Release binaries are
# separated. Single-config generators (Ninja, NMake) use a flat binary dir —
# the selected CMAKE_BUILD_TYPE is baked in at configure time, so no subdirectory
# is needed; each target's per-target RUNTIME_OUTPUT_DIRECTORY (set to
# ${CMAKE_BINARY_DIR}) ensures a flat layout under build/.
# Linux: same per-target convention applies; no override needed here.
# The else() branch explicitly sets to "" to override any stale cached value.
get_property(_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
if(WIN32 AND _IS_MULTI_CONFIG)
    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/$<CONFIG>")
    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/$<CONFIG>")
    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/$<CONFIG>")
else()
    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "")
    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "")
    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "")
endif()

# Disable C++20 module scanning
set(CMAKE_CXX_SCAN_FOR_MODULES OFF)

# Get git version info
execute_process(
    COMMAND git rev-parse --short HEAD
    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
    OUTPUT_VARIABLE GIT_COMMIT_HASH_SHORT
    OUTPUT_STRIP_TRAILING_WHITESPACE
    ERROR_QUIET
)
execute_process(
    COMMAND git describe --tags --dirty --always --match "v*"
    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
    OUTPUT_VARIABLE GIT_TAGGED_VERSION
    OUTPUT_STRIP_TRAILING_WHITESPACE
    ERROR_QUIET
)
if(NOT GIT_COMMIT_HASH_SHORT AND DEFINED ENV{GITHUB_SHA} AND NOT "$ENV{GITHUB_SHA}" STREQUAL "")
    string(SUBSTRING "$ENV{GITHUB_SHA}" 0 7 GIT_COMMIT_HASH_SHORT)
endif()
if(NOT GIT_TAGGED_VERSION)
    if(DEFINED ENV{GITHUB_REF_TYPE} AND "$ENV{GITHUB_REF_TYPE}" STREQUAL "tag" AND
       DEFINED ENV{GITHUB_REF_NAME} AND NOT "$ENV{GITHUB_REF_NAME}" STREQUAL "")
        set(GIT_TAGGED_VERSION "$ENV{GITHUB_REF_NAME}")
    elseif(GIT_COMMIT_HASH_SHORT)
        set(GIT_TAGGED_VERSION "${GIT_COMMIT_HASH_SHORT}")
    endif()
endif()
if(NOT GIT_COMMIT_HASH_SHORT)
    set(GIT_COMMIT_HASH_SHORT "unknown")
endif()
if(NOT GIT_TAGGED_VERSION)
    set(GIT_TAGGED_VERSION "unknown")
endif()

# Generate git_version.h at configure time
file(WRITE "${CMAKE_BINARY_DIR}/include/git_version.h"
"#pragma once\n\
#define GIT_COMMIT_HASH_SHORT \"${GIT_COMMIT_HASH_SHORT}\"\n\
#define GIT_TAGGED_VERSION \"${GIT_TAGGED_VERSION}\"\n"
)

# Setup
get_filename_component(PROJ_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}" ABSOLUTE)

option(ENABLE_CUDA_GL_INTEROP "Enable CUDA-OpenGL interoperability" ON)
option(BUILD_TESTS "Build tests" OFF)
option(BUILD_UNICODE_TEST_ONLY "Build only Unicode path test (no CUDA)" OFF)
option(ENABLE_ALLOCATION_PROFILING "Enable tensor allocation profiling" OFF)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)

# Debug options
option(ENABLE_TENSOR_VALIDATION "Enable runtime tensor NaN/Inf validation" OFF)
option(ENABLE_CUDA_DEBUG_SYNC "Enable synchronous CUDA kernel checking (slow)" OFF)
option(ENABLE_TENSOR_OP_TRACING "Enable tensor operation tracing" OFF)

# Add -rdynamic for backtrace symbol resolution
if(UNIX AND NOT APPLE)
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -rdynamic")
endif()

# PTX-only: smaller binary (~66MB vs ~750MB), JIT compiles at runtime
option(BUILD_CUDA_PTX_ONLY "Build PTX-only (JIT at runtime, ~5-15s first startup)" OFF)

# Portable: PTX-only + bundled libs, no tests
option(BUILD_PORTABLE "Build portable distribution" OFF)
if(BUILD_PORTABLE)
    set(BUILD_CUDA_PTX_ONLY ON CACHE BOOL "" FORCE)
    set(BUILD_TESTS OFF CACHE BOOL "" FORCE)
    add_compile_definitions(LFS_BUILD_PORTABLE=1)
    message(STATUS "Portable: PTX-only, tests disabled")
endif()

# Compiler cache is opt-in. Auto-enabling a broken local launcher can silently
# poison object files and make the build non-reproducible.
option(ENABLE_COMPILER_CACHE "Enable sccache/ccache compiler launchers when available" OFF)
if(ENABLE_COMPILER_CACHE)
    # CUDA caching disabled on Windows due to nvcc compatibility issues.
    find_program(SCCACHE_PROGRAM sccache)
    find_program(CCACHE_PROGRAM ccache)
    if(SCCACHE_PROGRAM)
        set(CMAKE_C_COMPILER_LAUNCHER "${SCCACHE_PROGRAM}")
        set(CMAKE_CXX_COMPILER_LAUNCHER "${SCCACHE_PROGRAM}")
        if(WIN32)
            message(STATUS "Compiler cache: sccache (C/C++ only, CUDA uncached)")
        else()
            set(CMAKE_CUDA_COMPILER_LAUNCHER "${SCCACHE_PROGRAM}")
            message(STATUS "Compiler cache: sccache")
        endif()
    elseif(CCACHE_PROGRAM)
        set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
        set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
        if(WIN32)
            message(STATUS "Compiler cache: ccache (C/C++ only, CUDA uncached)")
        else()
            set(CMAKE_CUDA_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
            message(STATUS "Compiler cache: ccache")
        endif()
    else()
        message(STATUS "Compiler cache: requested, but no launcher was found")
    endif()
else()
    message(STATUS "Compiler cache: disabled")
endif()

# Minimum SM for PTX-only (75=Turing, 80=Ampere, 86=GA102, 89=Ada, 90=Hopper)
set(BUILD_CUDA_MIN_SM "75" CACHE STRING "Minimum SM for PTX-only builds")

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CUDA_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CUDA_STANDARD_REQUIRED ON)

# Parallel build
include(ProcessorCount)
ProcessorCount(total_cores)
if(total_cores GREATER 1)
    math(EXPR used_cores "${total_cores} - 2")
    set(ENV{MAKEFLAGS} "-j${used_cores}")
    message(STATUS "Building with ${used_cores} cores")
endif()

# CUDA setup
# On Windows, nvidia-smi.exe is in System32, but CMake might be running as 32-bit
# which causes WOW64 redirection. Explicitly search in Sysnative to avoid this.
if(WIN32)
    find_program(NVIDIA_SMI nvidia-smi
        PATHS "C:/Windows/Sysnative" "C:/Windows/System32"
        NO_DEFAULT_PATH)
    if(NOT NVIDIA_SMI)
        find_program(NVIDIA_SMI nvidia-smi)
    endif()
else()
    find_program(NVIDIA_SMI nvidia-smi)
endif()
if(NVIDIA_SMI)
    execute_process(
            COMMAND ${NVIDIA_SMI} --query-gpu=compute_cap --format=csv,noheader
            OUTPUT_VARIABLE DETECTED_COMPUTE_CAP
            OUTPUT_STRIP_TRAILING_WHITESPACE
    )
    string(REGEX REPLACE "\n.*" "" DETECTED_COMPUTE_CAP "${DETECTED_COMPUTE_CAP}")

    execute_process(
            COMMAND ${NVIDIA_SMI} --query-gpu=driver_version --format=csv,noheader
            OUTPUT_VARIABLE NVIDIA_DRIVER_VERSION
            OUTPUT_STRIP_TRAILING_WHITESPACE
    )
    string(REGEX REPLACE "\n.*" "" NVIDIA_DRIVER_VERSION "${NVIDIA_DRIVER_VERSION}")
    message(STATUS "Detected NVIDIA driver: ${NVIDIA_DRIVER_VERSION}")
    if(NVIDIA_DRIVER_VERSION VERSION_LESS "570")
        message(FATAL_ERROR "NVIDIA driver ${NVIDIA_DRIVER_VERSION} is too old. "
            "CUDA Toolkit 12.8 requires driver >= 570. "
            "Please update: https://www.nvidia.com/drivers")
    endif()

    message(STATUS "Detected GPU compute capability: ${DETECTED_COMPUTE_CAP}")
    if(CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 13.1)
        string(REPLACE "." "" LichtFeld-Studio_CUDA_ARCH "${DETECTED_COMPUTE_CAP}")
    else()
        set(LichtFeld-Studio_CUDA_ARCH "native")
    endif()
else()
    message(WARNING "nvidia-smi not found! We are likely in CI, default to 8.6.")
    set(DETECTED_COMPUTE_CAP 8.6)
    set(LichtFeld-Studio_CUDA_ARCH "86")
endif()


if(DEFINED TORCH_CUDA_ARCH_LIST)
    unset(TORCH_CUDA_ARCH_LIST CACHE)
endif()

if(BUILD_CUDA_PTX_ONLY)
    # PTX-only: JIT compile at runtime, smaller binary
    if(NOT BUILD_CUDA_MIN_SM MATCHES "^[0-9]+$")
        message(FATAL_ERROR "BUILD_CUDA_MIN_SM must be an integer (70, 75, 86, 90, ...)")
    endif()
    if(BUILD_CUDA_MIN_SM LESS 70)
        message(FATAL_ERROR "BUILD_CUDA_MIN_SM must be >= 70")
    endif()

    set(LichtFeld-Studio_CUDA_ARCH "${BUILD_CUDA_MIN_SM}-virtual")

    math(EXPR _maj "${BUILD_CUDA_MIN_SM}/10")
    math(EXPR _min "${BUILD_CUDA_MIN_SM}%10")
    set(TORCH_CUDA_ARCH_LIST "${_maj}.${_min}+PTX" CACHE STRING "" FORCE)

    message(STATUS "CUDA: PTX-only (SM >= ${BUILD_CUDA_MIN_SM}, JIT at runtime)")
else()
    # Native GPU only
    set(TORCH_CUDA_ARCH_LIST "${DETECTED_COMPUTE_CAP}" CACHE STRING "" FORCE)
    message(STATUS "CUDA: native (${LichtFeld-Studio_CUDA_ARCH})")
endif()

enable_language(CUDA)
find_package(CUDAToolkit 12.8 REQUIRED)
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda --expt-relaxed-constexpr")
if(WIN32)
    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --diag-suppress 221,1394,1388 -Xcompiler=/wd4267")
endif()

# Create nvToolsExt target BEFORE finding Torch (PyTorch expects this)
if(NOT TARGET CUDA::nvToolsExt)
    find_library(NVTOOLSEXT_LIBRARY
            NAMES nvToolsExt
            PATHS
            ${CUDAToolkit_LIBRARY_ROOT}
            ${CUDAToolkit_LIBRARY_DIR}
            ${CUDAToolkit_TARGET_DIR}/lib64
            /usr/local/cuda-12.8/lib64
            PATH_SUFFIXES lib lib64
            NO_DEFAULT_PATH
    )

    if(NVTOOLSEXT_LIBRARY)
        add_library(CUDA::nvToolsExt UNKNOWN IMPORTED)
        set_target_properties(CUDA::nvToolsExt PROPERTIES
                IMPORTED_LOCATION ${NVTOOLSEXT_LIBRARY}
        )
        message(STATUS "Created CUDA::nvToolsExt target: ${NVTOOLSEXT_LIBRARY}")
    else()
        # Create empty interface library (nvToolsExt is deprecated in CUDA 12+)
        add_library(CUDA::nvToolsExt INTERFACE IMPORTED)
        message(STATUS "nvToolsExt not found (normal for CUDA 12+), created empty interface target")
    endif()
endif()

message(STATUS "CUDA Toolkit ${CUDAToolkit_VERSION} found at ${CUDAToolkit_TARGET_DIR}")

# Find packages
find_package(TBB REQUIRED)
find_package(Threads REQUIRED)
find_package(OpenGL REQUIRED)
find_package(glad REQUIRED)
find_package(SDL3 REQUIRED)
lfs_validate_linux_sdl_video_backends()
find_package(glm REQUIRED)
find_package(imgui REQUIRED)
find_package(implot REQUIRED)
find_package(nfd CONFIG REQUIRED)
find_package(nlohmann_json REQUIRED)
find_package(args REQUIRED)
find_package(spdlog REQUIRED)
find_package(Freetype REQUIRED)
find_package(WebP REQUIRED)
find_package(LibArchive REQUIRED)
find_package(OpenImageIO REQUIRED)
find_package(OpenSSL REQUIRED)
find_package(pxr CONFIG REQUIRED)
find_package(assimp REQUIRED)
find_package(RmlUi CONFIG REQUIRED)

# TORCH_CUDA_ARCH_LIST is already defined by Torch
# use it here as the global default CUDA architecture list too
if(LichtFeld-Studio_CUDA_ARCH)
    set(CMAKE_CUDA_ARCHITECTURES "${LichtFeld-Studio_CUDA_ARCH}" CACHE STRING "CUDA architectures" FORCE)
endif()

if(WIN32)
    set(CMAKE_CUDA_RUNTIME_LIBRARY "Shared") # when using INTEROP in windows static and dynamic symbols are mixed
endif()

# Check for CUDA-OpenGL interop capability (only if enabled)
if(ENABLE_CUDA_GL_INTEROP)
    include(CheckCXXSourceCompiles)
    set(CMAKE_REQUIRED_INCLUDES ${CUDAToolkit_INCLUDE_DIRS} ${OPENGL_INCLUDE_DIRS})
    set(CMAKE_REQUIRED_LIBRARIES ${CUDA_LIBRARIES} ${OPENGL_LIBRARIES})
    check_cxx_source_compiles("
        #ifdef _WIN32
        #include <windows.h>
        #endif
        #include <cuda_runtime.h>

        // On ARM machines, you must include the gl headers before including cuda_gl_interop.h
        // Please refer to /usr/local/cuda/include/cuda_gl_interop.h
        #if defined(__arm__) || defined(__aarch64__)
        #include <GL/gl.h>
        #endif

        #include <cuda_gl_interop.h>
        int main() {
            cudaGraphicsResource_t resource;
            return 0;
        }
    " CUDA_GL_INTEROP_FOUND)

    if(CUDA_GL_INTEROP_FOUND)
        message(STATUS "CUDA-OpenGL interop support: ENABLED")
        set(CUDA_GL_INTEROP_ENABLED 1)
    else()
        message(WARNING "CUDA-OpenGL interop support: DISABLED (headers not found)")
        set(CUDA_GL_INTEROP_ENABLED 0)
    endif()
else()
    message(STATUS "CUDA-OpenGL interop support: DISABLED (by user option)")
    set(CUDA_GL_INTEROP_FOUND FALSE)
    set(CUDA_GL_INTEROP_ENABLED 0)
endif()

# Create configuration header (static options)
configure_file(
        "${CMAKE_CURRENT_SOURCE_DIR}/cmake/config.h.in"
        "${CMAKE_CURRENT_BINARY_DIR}/include/config.h"
        @ONLY
)


# Project-wide definitions
add_definitions(-DPROJECT_ROOT_PATH="${PROJ_ROOT_DIR}")

# CUDA device debugging (-G flag) generates huge object files. Disable in CI.
option(CUDA_DEVICE_DEBUG "Enable CUDA device debugging (-G flag)" ON)

if(CUDA_DEVICE_DEBUG)
    set(LFS_CUDA_DEVICE_DEBUG_FLAGS "-G" CACHE INTERNAL "")
else()
    set(LFS_CUDA_DEVICE_DEBUG_FLAGS "" CACHE INTERNAL "")
endif()

if(CMAKE_BUILD_TYPE STREQUAL "Debug")
    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -O0")
    if(CUDA_DEVICE_DEBUG)
        set(CMAKE_CUDA_FLAGS_DEBUG "${CMAKE_CUDA_FLAGS_DEBUG} -g -G -O0")
    else()
        set(CMAKE_CUDA_FLAGS_DEBUG "${CMAKE_CUDA_FLAGS_DEBUG} -g -O0")
    endif()
endif()

# External dependencies (EXCLUDE_FROM_ALL to handle install ourselves)
add_subdirectory(external EXCLUDE_FROM_ALL)

# =============================================================================
# LIBRARY MODULES
# =============================================================================
add_subdirectory(src/core)       # Core module (lfs::core namespace)
add_subdirectory(src/training)   # Training module (lfs::training namespace)
add_subdirectory(src/io)         # I/O module (lfs::io namespace)
add_subdirectory(src/rendering)  # Rendering module (lfs::rendering namespace)
add_subdirectory(src/sequencer)  # Sequencer module (lfs::sequencer namespace)
add_subdirectory(src/visualizer) # Visualizer module (lfs::vis namespace)
add_subdirectory(src/geometry)   # Geometry utilities
add_subdirectory(src/mcp)        # MCP server (AI agent integration)
add_subdirectory(src/python)

# =============================================================================
# MAIN EXECUTABLES
# =============================================================================

# -----------------------------------------------------------------------------
# LichtFeld-Studio
# -----------------------------------------------------------------------------

add_executable(${PROJECT_NAME}
    src/app/main.cpp
    src/app/application.cpp
    src/app/mcp_gui_tools.cpp
    src/app/mcp_operator_tools.cpp
    src/app/mcp_runtime_tools.cpp
    src/app/mcp_sequencer_tools.cpp
    src/app/mcp_ui_registry_tools.cpp
    src/app/converter.cpp
    src/app/splash_screen.cpp
    resources/lichtfeld-studio.rc
)


set_target_properties(${PROJECT_NAME} PROPERTIES
        CUDA_ARCHITECTURES "${LichtFeld-Studio_CUDA_ARCH}"
        CUDA_SEPARABLE_COMPILATION OFF
)

target_include_directories(${PROJECT_NAME}
        PRIVATE
        ${CMAKE_CURRENT_SOURCE_DIR}/include
        ${CMAKE_CURRENT_BINARY_DIR}/include
        ${CMAKE_CURRENT_SOURCE_DIR}/src/app/include  # For app headers
        ${CMAKE_CURRENT_SOURCE_DIR}/src              # For training/, visualizer/, etc.
        ${CMAKE_CURRENT_SOURCE_DIR}/src/visualizer   # For internal visualizer headers used by GUI MCP
        ${CMAKE_CURRENT_SOURCE_DIR}/src/rendering/include  # For rendering headers (MCP GUI tools)
        ${CMAKE_CURRENT_SOURCE_DIR}/external         # For external headers

        ${CUDAToolkit_INCLUDE_DIRS}
        ${OPENGL_INCLUDE_DIRS}
)

if(CMAKE_CXX_LINK_GROUP_USING_RESCAN_SUPPORTED)
    set(LFS_APP_INTERNAL_LINK_LIBS
        "$<LINK_GROUP:RESCAN,lfs_visualizer,lfs_mcp,lfs_sequencer,lfs_rendering,lfs_training,lfs_geometry,lfs_core,lfs_io,lfs_video,fastlfs_backend,lfs_python_utils>"
    )
else()
    set(LFS_APP_INTERNAL_LINK_LIBS
        lfs_visualizer
        lfs_mcp
        lfs_sequencer
        lfs_rendering
        lfs_training
        lfs_geometry
        lfs_core
        lfs_io
        lfs_video
        fastlfs_backend
        lfs_python_utils
    )
endif()

target_link_libraries(${PROJECT_NAME}
        PRIVATE
        ${LFS_APP_INTERNAL_LINK_LIBS}

        ${OPENGL_LIBRARIES}
        CUDA::cudart
        spdlog::spdlog
        taywee::args
        OpenImageIO::OpenImageIO
        glad::glad
        SDL3::SDL3
)

# The app embeds Python and loads the nanobind module at runtime for panels,
# menus, and operators. Keep the runtime artifact in lockstep with the app.
add_dependencies(${PROJECT_NAME} lfs_py)

# Copy nvImageCodec shared libraries next to executable for easy deployment
if(TARGET nvimgcodec)
    # Force build of nvimgcodec even with EXCLUDE_FROM_ALL
    add_dependencies(${PROJECT_NAME} nvimgcodec)

    # Add post-build command to copy libraries and create symlinks (Unix only)
    add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E copy_if_different
            "$<TARGET_FILE:nvimgcodec>"
            "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
        COMMENT "Copying nvImageCodec library"
    )

    # Create symlinks only on Unix-like systems (not Windows)
    if(UNIX)
        add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
            COMMAND ${CMAKE_COMMAND} -E create_symlink
                "$<TARGET_FILE_NAME:nvimgcodec>"
                "$<TARGET_FILE_DIR:${PROJECT_NAME}>/libnvimgcodec.so.0"
            COMMAND ${CMAKE_COMMAND} -E create_symlink
                "libnvimgcodec.so.0"
                "$<TARGET_FILE_DIR:${PROJECT_NAME}>/libnvimgcodec.so"
            COMMENT "Creating nvImageCodec symlinks"
        )
    endif()

    message(STATUS "Post-build: nvImageCodec libraries will be copied to executable directory")
endif()

# Copy Python DLLs for Windows runtime (Python is embedded in the application)
if(WIN32)
    get_filename_component(VCPKG_PYTHON_DIR "${Python_EXECUTABLE}" DIRECTORY)

    # Glob python*.dll - check both tools/python3/ and parent bin/ (vcpkg layout varies)
    file(GLOB PYTHON_RUNTIME_DLLS
        "${VCPKG_PYTHON_DIR}/python*.dll"
        "${VCPKG_PYTHON_DIR}/../bin/python*.dll"
    )
    if(PYTHON_RUNTIME_DLLS)
        add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
            COMMAND ${CMAKE_COMMAND} -E copy_if_different
                ${PYTHON_RUNTIME_DLLS}
                "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
            COMMENT "Copying Python DLLs to executable directory"
        )
        message(STATUS "Post-build: Python DLLs will be copied: ${PYTHON_RUNTIME_DLLS}")
    endif()
endif()

# Copy CUDA runtime DLLs for Windows (needed for Python module loading)
if(WIN32 AND CUDAToolkit_FOUND)
    file(GLOB CUDA_DLLS_1 "${CUDAToolkit_BIN_DIR}/cudart64*.dll" "${CUDAToolkit_BIN_DIR}/curand64*.dll")
    file(GLOB CUDA_DLLS_2 "${CUDAToolkit_BIN_DIR}/x64/cudart64*.dll" "${CUDAToolkit_BIN_DIR}/x64/curand64*.dll")
    set(CUDA_RUNTIME_DLLS ${CUDA_DLLS_1} ${CUDA_DLLS_2})
    foreach(CUDA_DLL ${CUDA_RUNTIME_DLLS})
        if(EXISTS "${CUDA_DLL}")
            add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
                COMMAND ${CMAKE_COMMAND} -E copy_if_different
                    "${CUDA_DLL}"
                    "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
                COMMENT "Copying ${CUDA_DLL} to executable directory"
            )
        endif()
    endforeach()
    message(STATUS "Post-build: CUDA DLLs will be copied from ${CUDAToolkit_BIN_DIR}")
endif()

# =============================================================================
# VCPKG DLL COPYING - Ensure all vcpkg DLLs are available at runtime
# =============================================================================
# vcpkg's VCPKG_APPLOCAL_DEPS feature may not copy all needed DLLs.
# This explicitly copies vcpkg DLLs to ensure they're available at runtime.
# 
# IMPORTANT: For Release builds, copy ONLY release DLLs to avoid loading debug CRT.
# For Debug builds, copy both because some vcpkg packages (e.g., zlib) are release-only.
if(WIN32 AND DEFINED VCPKG_TARGET_TRIPLET)
    set(_vcpkg_debug_bin_dir "${CMAKE_BINARY_DIR}/vcpkg_installed/${VCPKG_TARGET_TRIPLET}/debug/bin")
    set(_vcpkg_release_bin_dir "${CMAKE_BINARY_DIR}/vcpkg_installed/${VCPKG_TARGET_TRIPLET}/bin")
    file(GLOB _vcpkg_release_dlls CONFIGURE_DEPENDS "${_vcpkg_release_bin_dir}/*.dll")
    file(GLOB _vcpkg_debug_dlls CONFIGURE_DEPENDS "${_vcpkg_debug_bin_dir}/*.dll")
    
    # Always copy release DLLs - needed for both Release and Debug builds
    if(_vcpkg_release_dlls)
        add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
            COMMAND ${CMAKE_COMMAND} -E copy_if_different
                ${_vcpkg_release_dlls}
                "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
            COMMENT "Copying vcpkg release DLLs"
        )
    endif()
    
    # Only copy debug DLLs for Debug builds (they link to debug CRT which breaks Release)
    # For single-config generators (Ninja, Makefiles): check CMAKE_BUILD_TYPE
    # For multi-config generators (VS, Xcode): use generator expression
    get_property(_is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
    if(_is_multi_config)
        # Multi-config: use generator expression to conditionally copy
        if(_vcpkg_debug_dlls)
            add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
                COMMAND ${CMAKE_COMMAND} -E $<IF:$<CONFIG:Debug>,copy_if_different,true>
                    ${_vcpkg_debug_dlls}
                    "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
                COMMENT "Copying vcpkg debug DLLs (Debug config only)"
            )
        endif()
        message(STATUS "Post-build: vcpkg DLLs - release always, debug for Debug config only (multi-config)")
    else()
        # Single-config: check CMAKE_BUILD_TYPE at configure time
        if(CMAKE_BUILD_TYPE STREQUAL "Debug" AND _vcpkg_debug_dlls)
            add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
                COMMAND ${CMAKE_COMMAND} -E copy_if_different
                    ${_vcpkg_debug_dlls}
                    "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
                COMMENT "Copying vcpkg debug DLLs"
            )
            message(STATUS "Post-build: vcpkg DLLs - copying both release and debug (Debug build)")
        else()
            message(STATUS "Post-build: vcpkg DLLs - copying release only (${CMAKE_BUILD_TYPE} build)")
        endif()
    endif()
endif()

# Before extension post-build copying: remove stale 'extensions' file if present (prevent mkdir failure)
set(_target_extensions_dir "${CMAKE_BINARY_DIR}/extensions")
if(EXISTS "${_target_extensions_dir}" AND NOT IS_DIRECTORY "${_target_extensions_dir}")
    file(REMOVE "${_target_extensions_dir}")
    message(STATUS "Removed stale file '${_target_extensions_dir}' to make way for extensions/ directory")
endif()

# =============================================================================
# EXTENSIONS COPYING - Copy nvImageCodec extensions to build/extensions
# =============================================================================
if(TARGET nvjpeg_ext)
    # Force build of nvjpeg_ext even with EXCLUDE_FROM_ALL
    add_dependencies(${PROJECT_NAME} nvjpeg_ext)

    add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E make_directory "$<TARGET_FILE_DIR:${PROJECT_NAME}>/extensions"
        COMMAND ${CMAKE_COMMAND} -E copy_if_different
            "$<TARGET_FILE:nvjpeg_ext>"
            "$<TARGET_FILE_DIR:${PROJECT_NAME}>/extensions/"
        COMMENT "Copying nvjpeg extension binary only"
    )
endif()

if(TARGET nvjpeg2k_ext)
    # Force build of nvjpeg2k_ext even with EXCLUDE_FROM_ALL
    add_dependencies(${PROJECT_NAME} nvjpeg2k_ext)

    add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E make_directory "$<TARGET_FILE_DIR:${PROJECT_NAME}>/extensions"
        COMMAND ${CMAKE_COMMAND} -E copy_if_different
            "$<TARGET_FILE:nvjpeg2k_ext>"
            "$<TARGET_FILE_DIR:${PROJECT_NAME}>/extensions/"
        COMMENT "Copying nvjpeg2k extension binary only"
    )
endif()

# =============================================================================
# RESOURCE COPYING - Copy all resources to build/resources for runtime access
# =============================================================================
set(RESOURCE_DIR "$<TARGET_FILE_DIR:${PROJECT_NAME}>/resources")

# Create resource directory structure
add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E make_directory "${RESOURCE_DIR}/shaders"
    COMMAND ${CMAKE_COMMAND} -E make_directory "${RESOURCE_DIR}/assets/icon"
    COMMAND ${CMAKE_COMMAND} -E make_directory "${RESOURCE_DIR}/assets/icon/scene"
    COMMAND ${CMAKE_COMMAND} -E make_directory "${RESOURCE_DIR}/assets/fonts"
    COMMAND ${CMAKE_COMMAND} -E make_directory "${RESOURCE_DIR}/assets/themes"
    COMMENT "Creating resource directory structure"
)

# Copy rendering shaders
add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different
        "${CMAKE_SOURCE_DIR}/src/rendering/resources/shaders"
        "${RESOURCE_DIR}/shaders"
    COMMENT "Copying rendering shaders"
)

# Copy visualizer icons
add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different
        "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/icon"
        "${RESOURCE_DIR}/assets/icon"
    COMMENT "Copying visualizer icons"
)

# Copy fonts (from visualizer)
add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different
        "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/fonts"
        "${RESOURCE_DIR}/assets/fonts"
    COMMENT "Copying visualizer fonts"
)

# Copy fonts (from rendering - JetBrainsMono for viewport gizmo)
add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${CMAKE_SOURCE_DIR}/src/rendering/resources/assets/JetBrainsMono-Regular.ttf"
        "${RESOURCE_DIR}/assets/fonts/"
    COMMENT "Copying rendering fonts"
)

# Copy themes
add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different
        "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/themes"
        "${RESOURCE_DIR}/assets/themes"
    COMMENT "Copying themes"
)

# Copy additional assets (logo, splash images, etc.)
add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/lichtfeld-icon.png"
        "${RESOURCE_DIR}/assets/"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/lichtfeld-splash-logo.png"
        "${RESOURCE_DIR}/assets/"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/lichtfeld-splash-logo-dark.png"
        "${RESOURCE_DIR}/assets/"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/lichtfeld-splash-loading.png"
        "${RESOURCE_DIR}/assets/"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/lichtfeld-splash-loading-dark.png"
        "${RESOURCE_DIR}/assets/"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/core11-logo.png"
        "${RESOURCE_DIR}/assets/"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/core11-logo-dark.png"
        "${RESOURCE_DIR}/assets/"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/volinga-logo.png"
        "${RESOURCE_DIR}/assets/"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/volinga-logo-dark.png"
        "${RESOURCE_DIR}/assets/"
    COMMENT "Copying application assets"
)

# Copy locale files (named target so it can be run without rebuilding the exe)
add_custom_target(copy_locale_files
    COMMAND ${CMAKE_COMMAND} -E make_directory "${RESOURCE_DIR}/locales"
    COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different
        "${CMAKE_SOURCE_DIR}/src/visualizer/gui/resources/locales"
        "${RESOURCE_DIR}/locales"
    COMMENT "Syncing locale files"
)
add_dependencies(${PROJECT_NAME} copy_locale_files)

# OpenUSD runtime resources (schema/file-format plugin metadata).
# On Windows: copy to <exe>/usd/ so that relative LibraryPaths resolve to the
# DLL copies already loaded from the exe directory.
# On Linux: copy to <exe>/../lib/usd/ (conventional layout).
set(_USD_PLUGIN_SOURCE_DIR "")
foreach(_candidate
    "${CMAKE_BINARY_DIR}/vcpkg_installed/${VCPKG_TARGET_TRIPLET}/lib/usd"
    "${CMAKE_BINARY_DIR}/vcpkg_installed/${VCPKG_TARGET_TRIPLET}/bin/usd"
    "${CMAKE_BINARY_DIR}/src/python/usd")
    # Require an actual plugin sub-directory (not just the root index).
    if(NOT _USD_PLUGIN_SOURCE_DIR AND EXISTS "${_candidate}/ar/resources/plugInfo.json")
        set(_USD_PLUGIN_SOURCE_DIR "${_candidate}")
    endif()
endforeach()

set(_USD_ROOT_INDEX "")
foreach(_candidate
    "${CMAKE_BINARY_DIR}/vcpkg_installed/${VCPKG_TARGET_TRIPLET}/lib/usd/plugInfo.json"
    "${CMAKE_BINARY_DIR}/vcpkg_installed/${VCPKG_TARGET_TRIPLET}/bin/usd/plugInfo.json"
    "${CMAKE_BINARY_DIR}/src/python/usd/plugInfo.json")
    if(NOT _USD_ROOT_INDEX AND EXISTS "${_candidate}")
        set(_USD_ROOT_INDEX "${_candidate}")
    endif()
endforeach()

if(WIN32)
    set(_USD_PLUGIN_DEST "$<TARGET_FILE_DIR:${PROJECT_NAME}>/usd")
else()
    set(_USD_PLUGIN_DEST "$<TARGET_FILE_DIR:${PROJECT_NAME}>/../lib/usd")
endif()

if(EXISTS "${_USD_PLUGIN_SOURCE_DIR}")
    add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E make_directory "${_USD_PLUGIN_DEST}"
        COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different
            "${_USD_PLUGIN_SOURCE_DIR}"
            "${_USD_PLUGIN_DEST}"
        COMMENT "Copying OpenUSD plugin resources (per-module)"
    )
    message(STATUS "Post-build: OpenUSD plugin resources will be copied from ${_USD_PLUGIN_SOURCE_DIR}")
endif()

if(EXISTS "${_USD_ROOT_INDEX}")
    add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E copy_if_different
            "${_USD_ROOT_INDEX}"
            "${_USD_PLUGIN_DEST}/plugInfo.json"
        COMMENT "Copying OpenUSD root plugin index"
    )
endif()

message(STATUS "Post-build: Resources will be copied to \${BUILD_DIR}/resources/")

# Per-config output directory variants for the exe: multi-config only.
# Single-config Ninja on Windows uses the flat binary dir (build/).
get_property(_exe_is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
if(WIN32 AND _exe_is_multi_config)
    set_target_properties(${PROJECT_NAME} PROPERTIES
        RUNTIME_OUTPUT_DIRECTORY_DEBUG        "${CMAKE_BINARY_DIR}/Debug"
        RUNTIME_OUTPUT_DIRECTORY_RELEASE      "${CMAKE_BINARY_DIR}/Release"
        RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}/RelWithDebInfo"
        RUNTIME_OUTPUT_DIRECTORY_MINSIZEREL   "${CMAKE_BINARY_DIR}/MinSizeRel"
    )
endif()

# Platform-specific settings
if(UNIX)
    target_link_libraries(${PROJECT_NAME} PRIVATE GL GLU)

    if(BUILD_PORTABLE)
        set_target_properties(${PROJECT_NAME} PROPERTIES
                INSTALL_RPATH "$ORIGIN:$ORIGIN/lib"
                BUILD_WITH_INSTALL_RPATH TRUE
                INSTALL_RPATH_USE_LINK_PATH FALSE
        )
    else()
        set(_lichtfeld_runtime_rpath_common
                "$ORIGIN"
                "$ORIGIN/lib"
                "${CUDAToolkit_LIBRARY_DIR}"
        )
        set(_lichtfeld_runtime_rpath_release "${_lichtfeld_runtime_rpath_common}")
        set(_lichtfeld_runtime_rpath_debug "${_lichtfeld_runtime_rpath_common}")
        if(DEFINED VCPKG_TARGET_TRIPLET)
            set(_vcpkg_release_runtime_dir "${CMAKE_BINARY_DIR}/vcpkg_installed/${VCPKG_TARGET_TRIPLET}/lib")
            if(EXISTS "${_vcpkg_release_runtime_dir}")
                list(APPEND _lichtfeld_runtime_rpath_release "${_vcpkg_release_runtime_dir}")
                list(APPEND _lichtfeld_runtime_rpath_debug "${_vcpkg_release_runtime_dir}")
            endif()

            set(_vcpkg_debug_runtime_dir "${CMAKE_BINARY_DIR}/vcpkg_installed/${VCPKG_TARGET_TRIPLET}/debug/lib")
            if(EXISTS "${_vcpkg_debug_runtime_dir}")
                list(APPEND _lichtfeld_runtime_rpath_debug "${_vcpkg_debug_runtime_dir}")
            endif()
        endif()

        list(REMOVE_DUPLICATES _lichtfeld_runtime_rpath_release)
        list(REMOVE_DUPLICATES _lichtfeld_runtime_rpath_debug)
        list(JOIN _lichtfeld_runtime_rpath_release ":" _lichtfeld_runtime_rpath_release_string)
        list(JOIN _lichtfeld_runtime_rpath_debug ":" _lichtfeld_runtime_rpath_debug_string)

        if(CMAKE_CONFIGURATION_TYPES)
            set(_lichtfeld_runtime_rpath_string
                    "$<$<CONFIG:Debug>:${_lichtfeld_runtime_rpath_debug_string}>$<$<NOT:$<CONFIG:Debug>>:${_lichtfeld_runtime_rpath_release_string}>")
        elseif(CMAKE_BUILD_TYPE STREQUAL "Debug")
            set(_lichtfeld_runtime_rpath_string "${_lichtfeld_runtime_rpath_debug_string}")
        else()
            set(_lichtfeld_runtime_rpath_string "${_lichtfeld_runtime_rpath_release_string}")
        endif()

        set_target_properties(${PROJECT_NAME} PROPERTIES
                INSTALL_RPATH "${_lichtfeld_runtime_rpath_string}"
                BUILD_WITH_INSTALL_RPATH TRUE
                INSTALL_RPATH_USE_LINK_PATH TRUE
        )
    endif()

elseif(WIN32)
    # On Windows, DLLs in the same directory as the .exe are automatically found.
    # Multi-config generators use $<CONFIG> subdir; single-config (Ninja) uses
    # the flat binary dir (build/) set via the global CMAKE_RUNTIME_OUTPUT_DIRECTORY.
    if(_exe_is_multi_config)
        set_target_properties(${PROJECT_NAME} PROPERTIES
            RUNTIME_OUTPUT_DIRECTORY              "${CMAKE_BINARY_DIR}/$<CONFIG>"
        )
    endif()
    if(MSVC)
        target_compile_options(${PROJECT_NAME} PRIVATE /bigobj)
    endif()
endif()

# Build type configuration function
function(configure_build_type target)
    get_target_property(target_type ${target} TYPE)

    if(target_type STREQUAL "INTERFACE_LIBRARY")
        if(CMAKE_BUILD_TYPE STREQUAL "Debug")
            target_compile_definitions(${target} INTERFACE DEBUG_BUILD)
        elseif(CMAKE_BUILD_TYPE STREQUAL "Release|RelWithDebInfo|MinSizeRel")
            target_compile_definitions(${target} INTERFACE RELEASE_BUILD)
        endif()
        # Debug options for interface libraries
        if(ENABLE_TENSOR_VALIDATION)
            target_compile_definitions(${target} INTERFACE TENSOR_VALIDATION_ENABLED)
        endif()
        if(ENABLE_CUDA_DEBUG_SYNC)
            target_compile_definitions(${target} INTERFACE CUDA_DEBUG_SYNC)
        endif()
        if(ENABLE_TENSOR_OP_TRACING)
            target_compile_definitions(${target} INTERFACE TENSOR_OP_TRACING)
        endif()
    else()
        if(CMAKE_BUILD_TYPE STREQUAL "Debug")
            target_compile_definitions(${target} PRIVATE DEBUG_BUILD)
        elseif(CMAKE_BUILD_TYPE STREQUAL "Release|RelWithDebInfo|MinSizeRel")
            target_compile_definitions(${target} PRIVATE RELEASE_BUILD)
        endif()
        # Debug options for regular libraries
        if(ENABLE_TENSOR_VALIDATION)
            target_compile_definitions(${target} PRIVATE TENSOR_VALIDATION_ENABLED)
        endif()
        if(ENABLE_CUDA_DEBUG_SYNC)
            target_compile_definitions(${target} PRIVATE CUDA_DEBUG_SYNC)
        endif()
        if(ENABLE_TENSOR_OP_TRACING)
            target_compile_definitions(${target} PRIVATE TENSOR_OP_TRACING)
        endif()
    endif()
endfunction()

# Apply build configuration to all targets
configure_build_type(fastlfs_backend)
configure_build_type(lfs_core)
configure_build_type(lfs_core_cuda)
configure_build_type(lfs_training)
configure_build_type(lfs_rendering)
configure_build_type(lfs_visualizer)
configure_build_type(lfs_io)
configure_build_type(lfs_geometry)
configure_build_type(${PROJECT_NAME})

# Set the default startup project in Visual Studio to LichtFeld-Studio
# (without this, VS defaults to ALL_BUILD when opening the solution)
if(MSVC)
    set_property(DIRECTORY ${CMAKE_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT ${PROJECT_NAME})
endif()

# =============================================================================
# TESTING (Optional)
# =============================================================================
if(BUILD_TESTS OR BUILD_UNICODE_TEST_ONLY)
    enable_testing()
    add_subdirectory(tests)
    if(BUILD_UNICODE_TEST_ONLY)
        message(STATUS "Unicode path test enabled. Build with 'ninja unicode_path_test' and run with 'ctest -R UnicodePathTest'")
    else()
        message(STATUS "Tests enabled. Build with 'ninja lichtfeld_tests' and run with 'ninja run_tests' or 'ctest'")
    endif()
endif()

# =============================================================================
# BUILD INFO & OPTIMIZATIONS
# =============================================================================
message(STATUS "===========================================")
message(STATUS "Build Configuration:")
message(STATUS "  CUDA Version: ${CUDAToolkit_VERSION}")
message(STATUS "  CUDA Archs: ${CMAKE_CUDA_ARCHITECTURES}")
message(STATUS "  OpenGL Found: ${OPENGL_FOUND}")
message(STATUS "  FreeType Found: ${FREETYPE_FOUND}")
message(STATUS "  WebP Found: ${WebP_FOUND}")
message(STATUS "  LibArchive Found: ${LibArchive_FOUND}")
message(STATUS "  CUDA-GL Interop Option: ${ENABLE_CUDA_GL_INTEROP}")
message(STATUS "  CUDA-GL Interop Available: ${CUDA_GL_INTEROP_FOUND}")
message(STATUS "  Build Type: ${CMAKE_BUILD_TYPE}")
message(STATUS "  C++ Standard: ${CMAKE_CXX_STANDARD}")
message(STATUS "  CUDA Standard: ${CMAKE_CUDA_STANDARD}")
message(STATUS "  OpenImageIO Found: ${OpenImageIO_FOUND}")
message(STATUS "  Tests: ${BUILD_TESTS}")
message(STATUS "  Unicode Test Only: ${BUILD_UNICODE_TEST_ONLY}")
message(STATUS "  Portable Build: ${BUILD_PORTABLE}")
if(BUILD_PORTABLE)
    message(STATUS "  -> PTX-only: ON (SM >= ${BUILD_CUDA_MIN_SM}, JIT at runtime)")
    message(STATUS "  -> Use: cmake --install build --prefix ./dist")
endif()
message(STATUS "===========================================")

# =============================================================================
# INSTALLATION (cmake --install build --prefix ./dist)
# =============================================================================
if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
    set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "" FORCE)
endif()

set(CMAKE_INSTALL_UCRT_LIBRARIES TRUE)
set(CMAKE_INSTALL_OPENMP_LIBRARIES TRUE)

include(GNUInstallDirs)
include(InstallRequiredSystemLibraries)

install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
install(TARGETS lfs_core
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
install(TARGETS lfs_logger
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
install(TARGETS lfs_event_bridge
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
install(TARGETS lfs_visualizer
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
install(TARGETS lfs_mcp
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
install(FILES "${CMAKE_SOURCE_DIR}/LICENSE" DESTINATION ".")

set(INSTALL_RESOURCE_DIR "${CMAKE_INSTALL_DATADIR}/LichtFeld-Studio")
install(DIRECTORY "${CMAKE_SOURCE_DIR}/src/rendering/resources/shaders" DESTINATION "${INSTALL_RESOURCE_DIR}")
install(DIRECTORY "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/icon" DESTINATION "${INSTALL_RESOURCE_DIR}/assets")
install(DIRECTORY "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/fonts" DESTINATION "${INSTALL_RESOURCE_DIR}/assets")
install(FILES "${CMAKE_SOURCE_DIR}/src/rendering/resources/assets/JetBrainsMono-Regular.ttf" DESTINATION "${INSTALL_RESOURCE_DIR}/assets/fonts")
install(DIRECTORY "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/themes" DESTINATION "${INSTALL_RESOURCE_DIR}/assets")
install(DIRECTORY "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/environments" DESTINATION "${INSTALL_RESOURCE_DIR}/assets")
install(FILES "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/lichtfeld-icon.png" DESTINATION "${INSTALL_RESOURCE_DIR}/assets")
install(FILES "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/lichtfeld-splash-logo.png" DESTINATION "${INSTALL_RESOURCE_DIR}/assets")
install(FILES "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/lichtfeld-splash-logo-dark.png" DESTINATION "${INSTALL_RESOURCE_DIR}/assets")
install(FILES "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/lichtfeld-splash-loading.png" DESTINATION "${INSTALL_RESOURCE_DIR}/assets")
install(FILES "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/lichtfeld-splash-loading-dark.png" DESTINATION "${INSTALL_RESOURCE_DIR}/assets")
install(FILES "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/core11-logo.png" DESTINATION "${INSTALL_RESOURCE_DIR}/assets")
install(FILES "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/core11-logo-dark.png" DESTINATION "${INSTALL_RESOURCE_DIR}/assets")
install(FILES "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/volinga-logo.png" DESTINATION "${INSTALL_RESOURCE_DIR}/assets")
install(FILES "${CMAKE_SOURCE_DIR}/src/visualizer/gui/assets/volinga-logo-dark.png" DESTINATION "${INSTALL_RESOURCE_DIR}/assets")
install(DIRECTORY "${CMAKE_SOURCE_DIR}/src/visualizer/gui/rmlui/resources/" DESTINATION "${INSTALL_RESOURCE_DIR}/assets/rmlui")
install(DIRECTORY "${CMAKE_SOURCE_DIR}/src/visualizer/gui/resources/locales" DESTINATION "${INSTALL_RESOURCE_DIR}")

# OpenUSD plugin resources (schema definitions + plugInfo.json files)
# On Windows configure_usd_plugins() looks for <exe_dir>/usd → install next to the exe (bin/usd).
# On Linux it looks for <exe_dir>/../lib/usd → install in lib/usd (unchanged).
if(WIN32)
    set(_USD_INSTALL_DEST "${CMAKE_INSTALL_BINDIR}/usd")
else()
    set(_USD_INSTALL_DEST "${CMAKE_INSTALL_LIBDIR}/usd")
endif()
if(EXISTS "${_USD_PLUGIN_SOURCE_DIR}")
    install(DIRECTORY "${_USD_PLUGIN_SOURCE_DIR}/" DESTINATION "${_USD_INSTALL_DEST}"
            PATTERN "__pycache__" EXCLUDE
            PATTERN "*.pyc" EXCLUDE)
endif()
if(EXISTS "${_USD_ROOT_INDEX}")
    install(FILES "${_USD_ROOT_INDEX}" DESTINATION "${_USD_INSTALL_DEST}")
endif()

# Plugin development documentation
set(DOC_INSTALL_DIR "${CMAKE_INSTALL_DATADIR}/doc/LichtFeld-Studio")
install(FILES
    "${CMAKE_SOURCE_DIR}/docs/PYTHON_API.md"
    "${CMAKE_SOURCE_DIR}/docs/plugin-system.md"
    "${CMAKE_SOURCE_DIR}/docs/plugin-use-cases.md"
    "${CMAKE_SOURCE_DIR}/docs/plugin-dev-workflow.md"
    DESTINATION "${DOC_INSTALL_DIR}"
    OPTIONAL
)

if(TARGET nvimgcodec)
    install(TARGETS nvimgcodec
        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    )
    if(TARGET nvjpeg_ext)
        install(TARGETS nvjpeg_ext
            LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}/extensions"
            RUNTIME DESTINATION "extensions"
        )
    endif()
    if(TARGET nvjpeg2k_ext)
        install(TARGETS nvjpeg2k_ext
            LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}/extensions"
            RUNTIME DESTINATION "extensions"
        )
    endif()
endif()

# Portable build: bundle runtime dependencies via GET_RUNTIME_DEPENDENCIES
if(BUILD_PORTABLE)
    # Exclusion patterns for system libraries
    # nvcuda.dll is provided by the NVIDIA GPU driver, not the CUDA Toolkit
    set(_PRE_EXCLUDE [[api-ms-.*]] [[ext-ms-.*]] [[API-MS-.*]] [[EXT-MS-.*]] [[nvcuda[.]dll]])
    set(_POST_EXCLUDE
            [[.*[Ss]ystem32.*]] [[.*[Ww]indows.*]]
            [[/lib/x86_64-linux-gnu/.*]] [[/lib64/ld-linux.*]] [[/usr/lib.*]]
            [[.*ld-linux.*]] [[.*libc[.]so[.].*]] [[.*libpthread.*]]
            [[.*libdl[.]so.*]] [[.*libm[.]so[.].*]] [[.*librt[.]so.*]]
            [[.*libstdc[+][+].*]] [[.*libgcc_s.*]]
            [[.*libnvimgcodec.*]] [[.*libnvjpeg_ext.*]])

    # Search directories for runtime dependencies (quoted for paths with spaces on Windows)
    set(_SEARCH_DIRS_STR "\"${CMAKE_BINARY_DIR}\" \"${CMAKE_BINARY_DIR}/Release\" \"${CMAKE_BINARY_DIR}/external/nvImageCodec\" \"${CUDAToolkit_BIN_DIR}\" \"${CUDAToolkit_LIBRARY_DIR}\"")

    # Helper: bundle runtime dependencies for a target.
    # On Windows DLLs must live beside the exe (bin/); on Linux they go in lib/.
    if(WIN32)
        set(_BUNDLE_DEST "${CMAKE_INSTALL_BINDIR}")
    else()
        set(_BUNDLE_DEST "${CMAKE_INSTALL_LIBDIR}")
    endif()
    function(bundle_runtime_deps TARGET_FILE IS_LIBRARY)
        if(IS_LIBRARY)
            set(_type "LIBRARIES")
        else()
            set(_type "EXECUTABLES")
        endif()
        install(CODE "
            file(GET_RUNTIME_DEPENDENCIES
                ${_type} \"${TARGET_FILE}\"
                RESOLVED_DEPENDENCIES_VAR _deps
                DIRECTORIES ${_SEARCH_DIRS_STR}
                PRE_EXCLUDE_REGEXES ${_PRE_EXCLUDE}
                POST_EXCLUDE_REGEXES ${_POST_EXCLUDE})
            foreach(_d IN LISTS _deps)
                file(INSTALL \"\${_d}\" DESTINATION \"\${CMAKE_INSTALL_PREFIX}/${_BUNDLE_DEST}\" FOLLOW_SYMLINK_CHAIN)
            endforeach()
        " COMPONENT runtime)
    endfunction()

    bundle_runtime_deps("$<TARGET_FILE:${PROJECT_NAME}>" FALSE)
    if(TARGET nvjpeg_ext)
        bundle_runtime_deps("$<TARGET_FILE:nvjpeg_ext>" TRUE)
    endif()

    if(UNIX AND NOT APPLE)
        configure_file(
                "${CMAKE_SOURCE_DIR}/cmake/templates/run_lichtfeld.sh.in"
                "${CMAKE_BINARY_DIR}/run_lichtfeld.sh"
                @ONLY)
        install(PROGRAMS "${CMAKE_BINARY_DIR}/run_lichtfeld.sh" DESTINATION ${CMAKE_INSTALL_BINDIR})
    elseif(WIN32)
        install(CODE "
            # Copy extensions/ from build to dist/extensions/
            # Handle both single-config (Ninja) and multi-config (VS) generators
            foreach(_cfg IN ITEMS \"\" \"Release\" \"Debug\" \"RelWithDebInfo\" \"MinSizeRel\")
                if(_cfg)
                    set(_ext_dir \"${CMAKE_BINARY_DIR}/\${_cfg}/extensions\")
                else()
                    set(_ext_dir \"${CMAKE_BINARY_DIR}/extensions\")
                endif()
                if(EXISTS \"\${_ext_dir}\")
                    # Install only DLLs from the build extensions directory to avoid non-binary files
                    file(GLOB _ext_dlls \"\${_ext_dir}/*.dll\")
                    if(_ext_dlls)
                        foreach(_e IN LISTS _ext_dlls)
                            file(INSTALL \"\${_e}\" DESTINATION \"\${CMAKE_INSTALL_PREFIX}/extensions\")
                        endforeach()
                    endif()
                    break()
                endif()
            endforeach()
            # Copy vcpkg DLLs
            if(EXISTS \"${CMAKE_BINARY_DIR}/vcpkg_installed/${VCPKG_TARGET_TRIPLET}/bin\")
                file(GLOB _vcpkg \"${CMAKE_BINARY_DIR}/vcpkg_installed/${VCPKG_TARGET_TRIPLET}/bin/*.dll\")
                foreach(_v IN LISTS _vcpkg)
                    file(INSTALL \"\${_v}\" DESTINATION \"\${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}\")
                endforeach()
            endif()
        " COMPONENT runtime)
    endif()
endif()

# Build statistics (parses .ninja_log, no Python required)
if(CMAKE_GENERATOR MATCHES "Ninja")
    # Manual target: ninja build_stats
    add_custom_target(build_stats
        COMMAND ${CMAKE_COMMAND} -P ${CMAKE_SOURCE_DIR}/cmake/BuildStats.cmake
        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
        COMMENT "Build time statistics by module"
    )

    # Auto-show after build: cmake -DSHOW_BUILD_STATS=ON ..
    option(SHOW_BUILD_STATS "Show build stats after every build" OFF)
    if(SHOW_BUILD_STATS)
        add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
            COMMAND ${CMAKE_COMMAND} -P ${CMAKE_SOURCE_DIR}/cmake/BuildStats.cmake
            WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
        )
    endif()
endif()

# Clean build target: ninja clean_all (clears build + compiler cache)
if(CCACHE_PROGRAM)
    add_custom_target(clean_all
        COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR} --target clean
        COMMAND ${CCACHE_PROGRAM} --clear
        COMMENT "Cleaning build and compiler cache (ccache)"
    )
elseif(SCCACHE_PROGRAM)
    add_custom_target(clean_all
        COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR} --target clean
        COMMAND ${SCCACHE_PROGRAM} --zero-stats
        COMMENT "Cleaning build and resetting sccache stats"
    )
endif()