hyperverse 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/cmake/autodetect/tier4-cuda.cmake

@@ -0,0 +1,42 @@
+if(NOT RL_TOOLS_BACKEND_DISABLE_CUDA AND NOT WIN32) # CUDA Not supported when using MSVC right now
+    cmake_minimum_required(VERSION 3.17)
+    find_package(CUDAToolkit QUIET)
+    if(CUDAToolkit_FOUND)
+        message(VERBOSE "CUDAToolkit version: ${CUDAToolkit_VERSION}")
+        message(VERBOSE "CUDAToolkit include path: ${CUDAToolkit_INCLUDE_DIRS}")
+        message(VERBOSE "CUDAToolkit libraries: ${CUDAToolkit_LIBRARIES}")
+        message(VERBOSE "CUDAToolkit cublas library: ${CUDAToolkit_CUBLAS_LIBRARIES}")
+        set(CMAKE_CUDA_FLAGS_DEBUG "-g -G")
+        if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES AND NOT DEFINED ENV{CUDAARCHS})
+            set(CMAKE_CUDA_ARCHITECTURES "native")
+        endif()
+        if(NOT CMAKE_CUDA_COMPILER)
+            set(CMAKE_CUDA_COMPILER "${CUDAToolkit_NVCC_EXECUTABLE}")
+        endif()
+        include(CheckLanguage)
+        check_language(CUDA)
+        if(NOT CMAKE_CUDA_COMPILER)
+            set(RL_TOOLS_SUMMARY_CUDA_REASON "toolkit ${CUDAToolkit_VERSION} found but the toolchain does not work (check_language(CUDA) failed)")
+        else()
+            target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_BACKEND_ENABLE_CUDA)
+            target_link_libraries(rl_tools_full INTERFACE CUDA::cublas)
+            set(RL_TOOLS_BACKEND_ENABLE_CUDA ON)
+            set(RL_TOOLS_SUMMARY_CUDA_REASON "toolkit ${CUDAToolkit_VERSION} (${CUDAToolkit_NVCC_EXECUTABLE})")
+            if(NOT RL_TOOLS_BACKEND_DISABLE_CUDNN)
+                find_library(CUDNN_LIBRARY cudnn)
+                find_path(CUDNN_INCLUDE_DIR cudnn.h)
+                if(CUDNN_LIBRARY AND CUDNN_INCLUDE_DIR)
+                    target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_BACKEND_ENABLE_CUDNN)
+                    target_link_libraries(rl_tools_full INTERFACE ${CUDNN_LIBRARY})
+                    target_include_directories(rl_tools_full INTERFACE ${CUDNN_INCLUDE_DIR})
+                    set(RL_TOOLS_BACKEND_ENABLE_CUDNN ON)
+                    set(RL_TOOLS_SUMMARY_CUDNN_REASON "${CUDNN_LIBRARY}")
+                else()
+                    set(RL_TOOLS_SUMMARY_CUDNN_REASON "not found")
+                endif()
+            endif()
+        endif()
+    else()
+        set(RL_TOOLS_SUMMARY_CUDA_REASON "toolkit not found")
+    endif()
+endif()

hyperdrone/_vendor/rl-tools/cmake/autodetect/tier5-cli11.cmake

@@ -0,0 +1,24 @@
+if(NOT RL_TOOLS_DISABLE_CLI11)
+    set(CLI11_PRECOMPILED ON)
+    find_package(CLI11 QUIET)
+    if(CLI11_FOUND)
+        message(VERBOSE "Found existing/system CLI11 ${CLI11_VERSION} at ${CLI11_DIR}")
+        target_link_libraries(rl_tools_full INTERFACE CLI11::CLI11)
+        target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_ENABLE_CLI11)
+        set(RL_TOOLS_ENABLE_CLI11 ON)
+        set(RL_TOOLS_SUMMARY_CLI11_REASON "system ${CLI11_VERSION}")
+    elseif(GIT_FOUND)
+        FetchContent_Declare(CLI11
+                GIT_REPOSITORY https://github.com/CLIUtils/CLI11.git
+                GIT_TAG        v2.3.2
+                GIT_SHALLOW    TRUE
+        )
+        rl_tools_fetchcontent_makeavailable_quiet(CLI11)
+        target_link_libraries(rl_tools_full INTERFACE CLI11::CLI11)
+        target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_ENABLE_CLI11)
+        set(RL_TOOLS_ENABLE_CLI11 ON)
+        set(RL_TOOLS_SUMMARY_CLI11_REASON "FetchContent")
+    else()
+        set(RL_TOOLS_SUMMARY_CLI11_REASON "not found and no git")
+    endif()
+endif()

hyperdrone/_vendor/rl-tools/cmake/dependencies/assimp.cmake

@@ -0,0 +1,19 @@
+include(FetchContent)
+if(POLICY CMP0135)
+    cmake_policy(SET CMP0135 NEW)
+endif()
+
+set(RL_TOOLS_ASSIMP_VERSION 6.0.4)
+set(RL_TOOLS_ASSIMP_ARCHIVE "${FETCHCONTENT_BASE_DIR}/assimp-download/assimp-v${RL_TOOLS_ASSIMP_VERSION}.tar.gz")
+if(RL_TOOLS_OFFLINE_BUILD)
+    set(RL_TOOLS_ASSIMP_URL "${RL_TOOLS_ASSIMP_ARCHIVE}")
+else()
+    set(RL_TOOLS_ASSIMP_URL "https://github.com/assimp/assimp/archive/refs/tags/v${RL_TOOLS_ASSIMP_VERSION}.tar.gz")
+endif()
+FetchContent_Declare(assimp
+    URL "${RL_TOOLS_ASSIMP_URL}"
+    URL_HASH SHA256=afa5487efdd285661afa842c85187cd8c541edad92e8d4aa85be4fca7476eccc
+    DOWNLOAD_DIR "${FETCHCONTENT_BASE_DIR}/assimp-download"
+    DOWNLOAD_NAME "assimp-v${RL_TOOLS_ASSIMP_VERSION}.tar.gz"
+    EXCLUDE_FROM_ALL
+)

hyperdrone/_vendor/rl-tools/cmake/legacy_flags.cmake

@@ -0,0 +1,33 @@
+# Migration from the pre-auto-configure flag surface: features are enabled by default now and
+# opted out via RL_TOOLS_*_DISABLE_* options.
+# - A legacy cache entry that agrees with the new default behavior is scrubbed with a notice.
+# - A BOOL-typed OFF entry whose value is just the old option() default is a stale leftover of a
+#   previous configure (option() types passed-in entries), not an explicit choice: scrubbed too,
+#   so existing build trees keep reconfiguring under the new defaults.
+# - Anything else would silently change behavior: fail with the replacement flag.
+function(rl_tools_legacy_flag LEGACY_NAME OLD_DEFAULT REPLACEMENT_HINT)
+    if(DEFINED CACHE{${LEGACY_NAME}})
+        if(${LEGACY_NAME})
+            message(STATUS "RLtools: legacy flag ${LEGACY_NAME} matches the default behavior now, removing it from the cache")
+            unset(${LEGACY_NAME} CACHE)
+        else()
+            get_property(RL_TOOLS_LEGACY_TYPE CACHE ${LEGACY_NAME} PROPERTY TYPE)
+            if(RL_TOOLS_LEGACY_TYPE STREQUAL "BOOL" AND OLD_DEFAULT STREQUAL "OFF")
+                message(STATUS "RLtools: removing stale legacy cache entry ${LEGACY_NAME} (${REPLACEMENT_HINT})")
+                unset(${LEGACY_NAME} CACHE)
+            else()
+                message(FATAL_ERROR "RLtools: ${LEGACY_NAME} has been replaced: ${REPLACEMENT_HINT}")
+            endif()
+        endif()
+    endif()
+endfunction()
+
+rl_tools_legacy_flag(RL_TOOLS_ENABLE_TARGETS ON "targets are enabled by default, use RL_TOOLS_DISABLE_TARGETS=ON to disable them")
+rl_tools_legacy_flag(RL_TOOLS_ENABLE_TESTS OFF "tests are enabled by default, use RL_TOOLS_DISABLE_TESTS=ON to disable them")
+rl_tools_legacy_flag(RL_TOOLS_ENABLE_GIT_DIFF ON "git diff embedding is enabled by default, use RL_TOOLS_DISABLE_GIT_DIFF=ON to disable it")
+rl_tools_legacy_flag(RL_TOOLS_EXPERIMENTAL "" "experimental targets are enabled by default, use RL_TOOLS_DISABLE_EXPERIMENTAL=ON to disable them")
+rl_tools_legacy_flag(RL_TOOLS_ENABLE_TAR "" "tar support is enabled by default, use RL_TOOLS_DISABLE_TAR=ON to disable it")
+rl_tools_legacy_flag(RL_TOOLS_NUMERIC_TYPES_ENABLE_BF16 "" "bf16 support is auto-detected, use RL_TOOLS_NUMERIC_TYPES_DISABLE_BF16=ON to disable it")
+rl_tools_legacy_flag(RL_TOOLS_TESTS_ENABLE_EIGEN "" "Eigen is auto-detected, use RL_TOOLS_TESTS_DISABLE_EIGEN=ON to disable it")
+rl_tools_legacy_flag(RL_TOOLS_RL_ENVIRONMENTS_ENABLE_MUJOCO OFF "MuJoCo is auto-enabled, use RL_TOOLS_RL_ENVIRONMENTS_DISABLE_MUJOCO=ON to disable it")
+rl_tools_legacy_flag(RL_TOOLS_RENDERING_ENABLE_RAYTRACING OFF "raytracing is auto-enabled, use RL_TOOLS_RENDERING_DISABLE_RAYTRACING=ON to disable it")

hyperdrone/_vendor/rl-tools/cmake/optional/assimp.cmake

@@ -0,0 +1,30 @@
+include(cmake/dependencies/assimp.cmake)
+if(NOT RL_TOOLS_OFFLINE_BUILD OR EXISTS "${RL_TOOLS_ASSIMP_ARCHIVE}" OR FETCHCONTENT_SOURCE_DIR_ASSIMP)
+    function(rl_tools_fetch_assimp)
+        set(BUILD_SHARED_LIBS OFF)
+        set(ASSIMP_BUILD_TESTS OFF)
+        set(ASSIMP_BUILD_ASSIMP_TOOLS OFF)
+        set(ASSIMP_BUILD_SAMPLES OFF)
+        set(ASSIMP_BUILD_USE_CCACHE OFF)
+        set(ASSIMP_INSTALL OFF)
+        set(ASSIMP_WARNINGS_AS_ERRORS OFF)
+        set(ASSIMP_NO_EXPORT ON)
+        set(ASSIMP_BUILD_ALL_IMPORTERS_BY_DEFAULT OFF)
+        set(ASSIMP_BUILD_GLTF_IMPORTER ON)
+        set(ASSIMP_BUILD_ZLIB ON)
+
+        if(RL_TOOLS_ZLIB_TARGET)
+            set(ZLIB_FOUND TRUE)
+            set(ZLIB_LIBRARIES ${RL_TOOLS_ZLIB_TARGET})
+            set(ZLIB_INCLUDE_DIR ${zlib_SOURCE_DIR} ${zlib_BINARY_DIR})
+        else()
+            find_package(ZLIB QUIET)
+        endif()
+
+        if(RL_TOOLS_OFFLINE_BUILD)
+            set(FETCHCONTENT_FULLY_DISCONNECTED OFF)
+        endif()
+        rl_tools_fetchcontent_makeavailable_quiet(assimp)
+    endfunction()
+    rl_tools_fetch_assimp()
+endif()

hyperdrone/_vendor/rl-tools/cmake/optional/googletest.cmake

@@ -0,0 +1,20 @@
+find_package(GTest QUIET)
+if(GTest_FOUND)
+    message(VERBOSE "Found existing/system GTest ${GTest_VERSION} at ${GTest_DIR}")
+    set(RL_TOOLS_ENABLE_GTEST ON)
+    set(RL_TOOLS_SUMMARY_TESTS_REASON "system gtest ${GTest_VERSION}")
+else()
+    find_package(Git QUIET)
+    if(GIT_FOUND)
+        FetchContent_Declare(googletest
+                GIT_REPOSITORY https://github.com/google/googletest.git
+                GIT_TAG        v1.17.0
+                GIT_SHALLOW    TRUE
+        )
+        rl_tools_fetchcontent_makeavailable_quiet(googletest)
+        set(RL_TOOLS_ENABLE_GTEST ON)
+        set(RL_TOOLS_SUMMARY_TESTS_REASON "gtest via FetchContent")
+    else()
+        message(VERBOSE "Git not found - GTest disabled")
+    endif()
+endif()

hyperdrone/_vendor/rl-tools/cmake/optional/metal.cmake

@@ -0,0 +1,25 @@
+set(RL_TOOLS_METAL_CPP_PATH "" CACHE PATH "Path to a local metal-cpp checkout (skips the FetchContent download)")
+
+add_library(rendering_raytracing_metal_cpp INTERFACE)
+if(RL_TOOLS_METAL_CPP_PATH)
+    target_include_directories(rendering_raytracing_metal_cpp SYSTEM INTERFACE ${RL_TOOLS_METAL_CPP_PATH})
+else()
+    include(FetchContent)
+    FetchContent_Declare(
+        metal_cpp
+        URL https://developer.apple.com/metal/cpp/files/metal-cpp_macOS15.2_iOS18.2.zip
+        URL_HASH SHA256=3437e4abfbd3d45217f34772ef3502f31ba3358e5fb6ac9d0ca952a047bcfe25
+        DOWNLOAD_EXTRACT_TIMESTAMP TRUE
+        EXCLUDE_FROM_ALL
+    )
+    rl_tools_fetchcontent_makeavailable_quiet(metal_cpp)
+    target_include_directories(rendering_raytracing_metal_cpp SYSTEM INTERFACE ${metal_cpp_SOURCE_DIR})
+endif()
+
+find_library(RL_TOOLS_METAL_FRAMEWORK Metal REQUIRED)
+find_library(RL_TOOLS_FOUNDATION_FRAMEWORK Foundation REQUIRED)
+find_library(RL_TOOLS_QUARTZCORE_FRAMEWORK QuartzCore REQUIRED)
+target_link_libraries(rendering_raytracing_metal_cpp INTERFACE ${RL_TOOLS_METAL_FRAMEWORK} ${RL_TOOLS_FOUNDATION_FRAMEWORK} ${RL_TOOLS_QUARTZCORE_FRAMEWORK})
+
+target_link_libraries(rl_tools_full INTERFACE assimp::assimp)
+target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_RENDERING_ENABLE_RAYTRACING RL_TOOLS_RENDERING_RAYTRACING_BACKEND_METAL)

hyperdrone/_vendor/rl-tools/cmake/optional/mujoco.cmake

@@ -0,0 +1,89 @@
+if(NOT RL_TOOLS_RL_ENVIRONMENTS_DISABLE_MUJOCO)
+    set(MUJOCO_BUILD_EXAMPLES OFF)
+    set(MUJOCO_BUILD_SIMULATE OFF)
+    set(MUJOCO_BUILD_TESTS OFF)
+    set(MUJOCO_TEST_PYTHON_UTIL OFF)
+    find_package(mujoco QUIET)
+    if(mujoco_FOUND)
+        message(VERBOSE "Found existing/system mujoco ${mujoco_VERSION} at ${mujoco_DIR}")
+        set(RL_TOOLS_SUMMARY_MUJOCO_REASON "system ${mujoco_VERSION}")
+    elseif(GIT_FOUND)
+        if(POLICY CMP0135)
+            cmake_policy(SET CMP0135 NEW)
+        endif()
+        FetchContent_Declare(mujoco
+                URL https://github.com/google-deepmind/mujoco/archive/refs/tags/2.3.5.tar.gz
+                URL_HASH SHA256=882d855d833375ad27adfa2d9cf4ec2381a1069ebe8fbc4578d876deb4e0b33f
+        )
+        rl_tools_fetchcontent_makeavailable_quiet(mujoco)
+        # MuJoCo 2.3.5 hardcodes -Werror; its warning set predates current compilers (e.g. GCC 15)
+        function(rl_tools_mujoco_strip_werror STRIP_DIRECTORY)
+            get_property(RL_TOOLS_STRIP_TARGETS DIRECTORY ${STRIP_DIRECTORY} PROPERTY BUILDSYSTEM_TARGETS)
+            foreach(RL_TOOLS_STRIP_TARGET IN LISTS RL_TOOLS_STRIP_TARGETS)
+                get_target_property(RL_TOOLS_STRIP_OPTIONS ${RL_TOOLS_STRIP_TARGET} COMPILE_OPTIONS)
+                if(RL_TOOLS_STRIP_OPTIONS AND "-Werror" IN_LIST RL_TOOLS_STRIP_OPTIONS)
+                    list(REMOVE_ITEM RL_TOOLS_STRIP_OPTIONS "-Werror")
+                    set_target_properties(${RL_TOOLS_STRIP_TARGET} PROPERTIES COMPILE_OPTIONS "${RL_TOOLS_STRIP_OPTIONS}")
+                endif()
+            endforeach()
+            get_property(RL_TOOLS_STRIP_SUBDIRECTORIES DIRECTORY ${STRIP_DIRECTORY} PROPERTY SUBDIRECTORIES)
+            foreach(RL_TOOLS_STRIP_SUBDIRECTORY IN LISTS RL_TOOLS_STRIP_SUBDIRECTORIES)
+                rl_tools_mujoco_strip_werror(${RL_TOOLS_STRIP_SUBDIRECTORY})
+            endforeach()
+        endfunction()
+        rl_tools_mujoco_strip_werror(${mujoco_SOURCE_DIR})
+        set(RL_TOOLS_SUMMARY_MUJOCO_REASON "FetchContent 2.3.5")
+    else()
+        set(RL_TOOLS_SUMMARY_MUJOCO_REASON "not found and no git")
+    endif()
+    if(mujoco_FOUND OR TARGET mujoco::mujoco OR TARGET mujoco)
+        set(RL_TOOLS_RL_ENVIRONMENTS_ENABLE_MUJOCO ON)
+        target_link_libraries(rl_tools_full INTERFACE mujoco::mujoco)
+        target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_RL_ENVIRONMENTS_ENABLE_MUJOCO)
+
+        find_package(glfw3 QUIET)
+        if(glfw3_FOUND)
+            message(VERBOSE "Found existing/system glfw3 ${glfw3_VERSION} at ${glfw3_DIR}")
+        elseif(GIT_FOUND)
+            set(RL_TOOLS_MUJOCO_UI_BUILDABLE ON)
+            if(UNIX AND NOT APPLE AND (NOT DEFINED GLFW_BUILD_X11 OR GLFW_BUILD_X11))
+                find_package(X11 QUIET)
+                if(NOT X11_FOUND)
+                    set(RL_TOOLS_MUJOCO_UI_BUILDABLE OFF)
+                    string(APPEND RL_TOOLS_SUMMARY_MUJOCO_REASON ", UI off (no X11 dev headers for glfw)")
+                else()
+                    set(RL_TOOLS_GLFW_MISSING_X11_HEADERS "")
+                    foreach(RL_TOOLS_GLFW_X11_COMPONENT Xrandr Xinerama Xkb Xcursor Xi Xshape)
+                        if(NOT X11_${RL_TOOLS_GLFW_X11_COMPONENT}_INCLUDE_PATH)
+                            list(APPEND RL_TOOLS_GLFW_MISSING_X11_HEADERS ${RL_TOOLS_GLFW_X11_COMPONENT})
+                        endif()
+                    endforeach()
+                    if(RL_TOOLS_GLFW_MISSING_X11_HEADERS)
+                        set(RL_TOOLS_MUJOCO_UI_BUILDABLE OFF)
+                        list(JOIN RL_TOOLS_GLFW_MISSING_X11_HEADERS ", " RL_TOOLS_GLFW_MISSING_X11_HEADERS)
+                        string(APPEND RL_TOOLS_SUMMARY_MUJOCO_REASON ", UI off (missing glfw X11 headers: ${RL_TOOLS_GLFW_MISSING_X11_HEADERS})")
+                    endif()
+                endif()
+            endif()
+            if(RL_TOOLS_MUJOCO_UI_BUILDABLE)
+                if(NOT DEFINED GLFW_BUILD_WAYLAND)
+                    set(GLFW_BUILD_WAYLAND OFF)
+                endif()
+                FetchContent_Declare(glfw3
+                        GIT_REPOSITORY https://github.com/glfw/glfw.git
+                        GIT_TAG        3.4
+                        GIT_SHALLOW    TRUE
+                )
+                rl_tools_fetchcontent_makeavailable_quiet(glfw3)
+            endif()
+        endif()
+        if(glfw3_FOUND OR TARGET glfw)
+            target_link_libraries(rl_tools_full INTERFACE glfw)
+            set(RL_TOOLS_RL_ENVIRONMENTS_MUJOCO_ENABLE_UI ON)
+            target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_RL_ENVIRONMENTS_MUJOCO_ENABLE_UI)
+            string(APPEND RL_TOOLS_SUMMARY_MUJOCO_REASON ", UI on")
+        elseif(NOT GIT_FOUND)
+            string(APPEND RL_TOOLS_SUMMARY_MUJOCO_REASON ", UI off (glfw not found and no git)")
+        endif()
+    endif()
+endif()

hyperdrone/_vendor/rl-tools/cmake/optional/optix.cmake

@@ -0,0 +1,25 @@
+enable_language(CUDA)
+set(CMAKE_CUDA_STANDARD 17)
+set(CMAKE_CUDA_STANDARD_REQUIRED ON)
+
+# OWL's embed_ptx resolves bin2c with find_program, which searches PATH before the CMAKE_CUDA_COMPILER directory, so an nvcc from a different toolkit on PATH mixes two toolkits into the OptiX build
+find_program(RL_TOOLS_OPTIX_NVCC_ON_PATH nvcc PATHS ENV PATH NO_DEFAULT_PATH NO_CACHE)
+if(RL_TOOLS_OPTIX_NVCC_ON_PATH)
+    file(REAL_PATH "${RL_TOOLS_OPTIX_NVCC_ON_PATH}" RL_TOOLS_OPTIX_NVCC_ON_PATH_REAL)
+    file(REAL_PATH "${CMAKE_CUDA_COMPILER}" RL_TOOLS_OPTIX_CUDA_COMPILER_REAL)
+    if(NOT RL_TOOLS_OPTIX_NVCC_ON_PATH_REAL STREQUAL RL_TOOLS_OPTIX_CUDA_COMPILER_REAL)
+        message(WARNING "RLtools OptiX backend: the CUDA compiler ${CMAKE_CUDA_COMPILER} (CUDACXX/CMAKE_CUDA_COMPILER) is not the nvcc found on PATH (${RL_TOOLS_OPTIX_NVCC_ON_PATH}). OWL looks up bin2c on PATH before the compiler's directory, so the OptiX build mixes two CUDA toolkits; put the bin directory of ${CMAKE_CUDA_COMPILER} first on PATH or point CUDACXX at the PATH toolkit")
+    endif()
+endif()
+
+include(FetchContent)
+FetchContent_Declare(
+    OWL
+    GIT_REPOSITORY https://github.com/NVIDIA/OWL.git
+    GIT_TAG        e5db326767ff759854477f892ba7a2936ad8406d
+    EXCLUDE_FROM_ALL
+)
+rl_tools_fetchcontent_makeavailable_quiet(OWL)
+
+target_link_libraries(rl_tools_full INTERFACE owl::owl assimp::assimp)
+target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_RENDERING_ENABLE_RAYTRACING RL_TOOLS_RENDERING_RAYTRACING_BACKEND_OPTIX)

hyperdrone/_vendor/rl-tools/cmake/optional/raytracing.cmake

@@ -0,0 +1,105 @@
+# Raytracing backend dispatch. AUTO probes availability in preference order
+# OPTIX > METAL > VULKAN > WEBGPU > GENERIC; an explicitly selected backend is hard-required.
+# All backends need the fetched Assimp sources.
+if(NOT RL_TOOLS_RENDERING_DISABLE_RAYTRACING)
+    set(RL_TOOLS_RENDERING_RAYTRACING_BACKENDS OPTIX METAL VULKAN WEBGPU GENERIC)
+    if(NOT RL_TOOLS_RENDERING_RAYTRACING_BACKEND STREQUAL "AUTO" AND NOT RL_TOOLS_RENDERING_RAYTRACING_BACKEND IN_LIST RL_TOOLS_RENDERING_RAYTRACING_BACKENDS)
+        message(FATAL_ERROR "Invalid RL_TOOLS_RENDERING_RAYTRACING_BACKEND: ${RL_TOOLS_RENDERING_RAYTRACING_BACKEND} (AUTO|OPTIX|METAL|VULKAN|WEBGPU|GENERIC)")
+    endif()
+    include(cmake/optional/assimp.cmake)
+    if(NOT TARGET assimp::assimp)
+        if(RL_TOOLS_RENDERING_RAYTRACING_BACKEND STREQUAL "AUTO")
+            set(RL_TOOLS_SUMMARY_RAYTRACING_REASON "Assimp archive not cached (offline)")
+        else()
+            message(FATAL_ERROR "RLtools raytracing backend ${RL_TOOLS_RENDERING_RAYTRACING_BACKEND} requested but Assimp archive is not cached (offline)")
+        endif()
+    else()
+        set(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED ${RL_TOOLS_RENDERING_RAYTRACING_BACKEND})
+        if(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED STREQUAL "AUTO")
+            set(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED "GENERIC")
+            set(RL_TOOLS_RAYTRACING_OPTIX_UNAVAILABLE_REASON "")
+            if(RL_TOOLS_RENDERING_RAYTRACING_DISABLE_OPTIX)
+                set(RL_TOOLS_RAYTRACING_OPTIX_UNAVAILABLE_REASON "disabled by RL_TOOLS_RENDERING_RAYTRACING_DISABLE_OPTIX")
+            elseif(WIN32)
+                set(RL_TOOLS_RAYTRACING_OPTIX_UNAVAILABLE_REASON "not supported on Windows")
+            elseif(NOT RL_TOOLS_BACKEND_ENABLE_CUDA)
+                set(RL_TOOLS_RAYTRACING_OPTIX_UNAVAILABLE_REASON "CUDA unavailable")
+            elseif(NOT ((GIT_FOUND AND NOT RL_TOOLS_OFFLINE_BUILD) OR EXISTS "${FETCHCONTENT_BASE_DIR}/owl-src"))
+                set(RL_TOOLS_RAYTRACING_OPTIX_UNAVAILABLE_REASON "cannot fetch OWL (offline/no git)")
+            endif()
+
+            set(RL_TOOLS_RAYTRACING_METAL_UNAVAILABLE_REASON "")
+            if(RL_TOOLS_RENDERING_RAYTRACING_DISABLE_METAL)
+                set(RL_TOOLS_RAYTRACING_METAL_UNAVAILABLE_REASON "disabled by RL_TOOLS_RENDERING_RAYTRACING_DISABLE_METAL")
+            elseif(NOT APPLE)
+                set(RL_TOOLS_RAYTRACING_METAL_UNAVAILABLE_REASON "not on macOS")
+            else()
+                find_library(RL_TOOLS_METAL_FRAMEWORK Metal)
+                find_library(RL_TOOLS_FOUNDATION_FRAMEWORK Foundation)
+                find_library(RL_TOOLS_QUARTZCORE_FRAMEWORK QuartzCore)
+                if(NOT (RL_TOOLS_METAL_FRAMEWORK AND RL_TOOLS_FOUNDATION_FRAMEWORK AND RL_TOOLS_QUARTZCORE_FRAMEWORK))
+                    set(RL_TOOLS_RAYTRACING_METAL_UNAVAILABLE_REASON "Metal/Foundation/QuartzCore frameworks not found")
+                endif()
+            endif()
+
+            set(RL_TOOLS_RAYTRACING_VULKAN_UNAVAILABLE_REASON "")
+            if(RL_TOOLS_RENDERING_RAYTRACING_DISABLE_VULKAN)
+                set(RL_TOOLS_RAYTRACING_VULKAN_UNAVAILABLE_REASON "disabled by RL_TOOLS_RENDERING_RAYTRACING_DISABLE_VULKAN")
+            else()
+                find_package(Vulkan QUIET COMPONENTS glslangValidator)
+                if(NOT Vulkan_FOUND OR NOT Vulkan_glslangValidator_FOUND)
+                    set(RL_TOOLS_RAYTRACING_VULKAN_UNAVAILABLE_REASON "Vulkan/glslangValidator not found (e.g. apt install libvulkan-dev glslang-tools)")
+                endif()
+            endif()
+
+            set(RL_TOOLS_RAYTRACING_WEBGPU_UNAVAILABLE_REASON "")
+            if(RL_TOOLS_RENDERING_RAYTRACING_DISABLE_WEBGPU)
+                set(RL_TOOLS_RAYTRACING_WEBGPU_UNAVAILABLE_REASON "disabled by RL_TOOLS_RENDERING_RAYTRACING_DISABLE_WEBGPU")
+            elseif(NOT (CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64"))
+                set(RL_TOOLS_RAYTRACING_WEBGPU_UNAVAILABLE_REASON "only wired up on linux-x86_64")
+            elseif(RL_TOOLS_OFFLINE_BUILD AND NOT EXISTS "${FETCHCONTENT_BASE_DIR}/wgpu_native-src")
+                set(RL_TOOLS_RAYTRACING_WEBGPU_UNAVAILABLE_REASON "cannot fetch wgpu-native (offline)")
+            endif()
+
+            # platform-inapplicable candidates are not worth reporting in the summary
+            set(RL_TOOLS_RAYTRACING_PLATFORM_REASONS "not supported on Windows" "not on macOS" "only wired up on linux-x86_64")
+            set(RL_TOOLS_RAYTRACING_SKIP_NOTES "")
+            foreach(RL_TOOLS_RAYTRACING_CANDIDATE OPTIX METAL VULKAN WEBGPU)
+                if(RL_TOOLS_RAYTRACING_${RL_TOOLS_RAYTRACING_CANDIDATE}_UNAVAILABLE_REASON STREQUAL "")
+                    set(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED ${RL_TOOLS_RAYTRACING_CANDIDATE})
+                    break()
+                else()
+                    message(VERBOSE "RLtools raytracing backend candidate ${RL_TOOLS_RAYTRACING_CANDIDATE} skipped: ${RL_TOOLS_RAYTRACING_${RL_TOOLS_RAYTRACING_CANDIDATE}_UNAVAILABLE_REASON}")
+                    if(NOT RL_TOOLS_RAYTRACING_${RL_TOOLS_RAYTRACING_CANDIDATE}_UNAVAILABLE_REASON IN_LIST RL_TOOLS_RAYTRACING_PLATFORM_REASONS)
+                        list(APPEND RL_TOOLS_RAYTRACING_SKIP_NOTES "${RL_TOOLS_RAYTRACING_CANDIDATE}: ${RL_TOOLS_RAYTRACING_${RL_TOOLS_RAYTRACING_CANDIDATE}_UNAVAILABLE_REASON}")
+                    endif()
+                endif()
+            endforeach()
+            set(RL_TOOLS_SUMMARY_RAYTRACING_REASON "${RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED}, auto-selected")
+            if(RL_TOOLS_RAYTRACING_SKIP_NOTES)
+                list(JOIN RL_TOOLS_RAYTRACING_SKIP_NOTES "; " RL_TOOLS_RAYTRACING_SKIP_NOTES_JOINED)
+                string(APPEND RL_TOOLS_SUMMARY_RAYTRACING_REASON " (skipped ${RL_TOOLS_RAYTRACING_SKIP_NOTES_JOINED})")
+            endif()
+        else()
+            if(RL_TOOLS_RENDERING_RAYTRACING_DISABLE_${RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED})
+                message(FATAL_ERROR "RL_TOOLS_RENDERING_RAYTRACING_BACKEND=${RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED} conflicts with RL_TOOLS_RENDERING_RAYTRACING_DISABLE_${RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED}=ON")
+            endif()
+            set(RL_TOOLS_SUMMARY_RAYTRACING_REASON "${RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED}, explicitly selected")
+        endif()
+        if(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED STREQUAL "METAL")
+            include(cmake/optional/metal.cmake)
+        elseif(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED STREQUAL "OPTIX")
+            include(cmake/optional/optix.cmake)
+        elseif(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED STREQUAL "VULKAN")
+            include(cmake/optional/vulkan.cmake)
+        elseif(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED STREQUAL "WEBGPU")
+            include(cmake/optional/webgpu.cmake)
+        elseif(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED STREQUAL "GENERIC")
+            include(cmake/optional/raytracing_generic.cmake)
+        endif()
+        string(APPEND RL_TOOLS_SUMMARY_RAYTRACING_REASON ", Assimp FetchContent ${RL_TOOLS_ASSIMP_VERSION} (SHA256)")
+        set(RL_TOOLS_RENDERING_ENABLE_RAYTRACING ON)
+    endif()
+else()
+    set(RL_TOOLS_SUMMARY_RAYTRACING_REASON "disabled by RL_TOOLS_RENDERING_DISABLE_RAYTRACING")
+endif()

hyperdrone/_vendor/rl-tools/cmake/optional/raytracing_generic.cmake

@@ -0,0 +1,2 @@
+target_link_libraries(rl_tools_full INTERFACE assimp::assimp)
+target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_RENDERING_ENABLE_RAYTRACING RL_TOOLS_RENDERING_RAYTRACING_BACKEND_GENERIC)

hyperdrone/_vendor/rl-tools/cmake/optional/vulkan.cmake

@@ -0,0 +1,4 @@
+find_package(Vulkan REQUIRED COMPONENTS glslangValidator)
+
+target_link_libraries(rl_tools_full INTERFACE assimp::assimp Vulkan::Vulkan)
+target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_RENDERING_ENABLE_RAYTRACING RL_TOOLS_RENDERING_RAYTRACING_BACKEND_VULKAN)

hyperdrone/_vendor/rl-tools/cmake/optional/webgpu.cmake

@@ -0,0 +1,24 @@
+# WebGPU backend runtime: wgpu-native prebuilt release, pinned by hash (no Rust toolchain).
+# The backend codes against the standard webgpu.h; wgpu-native is the reference runtime and
+# Dawn/emscripten remain drop-in alternatives. Linux-only for now: add the macos/windows
+# archives (and their link libraries) here when those platforms are wired up.
+if(NOT (CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64"))
+    message(FATAL_ERROR "RLtools WEBGPU backend: only linux-x86_64 is wired up so far (cmake/optional/webgpu.cmake)")
+endif()
+
+FetchContent_Declare(wgpu_native
+    URL https://github.com/gfx-rs/wgpu-native/releases/download/v29.0.1.1/wgpu-linux-x86_64-release.zip
+    URL_HASH SHA256=95a4d90c071005a98d03eab348beaa6b07e16eb00d1dcdb9f8348f75eb97ec5a
+    DOWNLOAD_EXTRACT_TIMESTAMP TRUE
+)
+rl_tools_fetchcontent_makeavailable_quiet(wgpu_native)
+
+add_library(rl_tools_wgpu_native STATIC IMPORTED GLOBAL)
+set_target_properties(rl_tools_wgpu_native PROPERTIES
+    IMPORTED_LOCATION ${wgpu_native_SOURCE_DIR}/lib/libwgpu_native.a
+    INTERFACE_INCLUDE_DIRECTORIES ${wgpu_native_SOURCE_DIR}/include
+    INTERFACE_LINK_LIBRARIES "${CMAKE_DL_LIBS};pthread;m"
+)
+
+target_link_libraries(rl_tools_full INTERFACE assimp::assimp rl_tools_wgpu_native)
+target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_RENDERING_ENABLE_RAYTRACING RL_TOOLS_RENDERING_RAYTRACING_BACKEND_WEBGPU)

hyperdrone/_vendor/rl-tools/cmake/scripts/embed_text.cmake

@@ -0,0 +1,7 @@
+# Embeds a text file as a C string with a project-unique symbol.
+# Usage: cmake -DINPUT_FILE=<in> -DOUTPUT_FILE=<out.cpp> -DSYMBOL_NAME=<symbol> -P embed_text.cmake
+file(READ ${INPUT_FILE} RL_TOOLS_EMBED_CONTENT)
+if(RL_TOOLS_EMBED_CONTENT MATCHES "\\)RL_TOOLS_EMBED\"")
+    message(FATAL_ERROR "embed_text.cmake: input contains the raw-string delimiter )RL_TOOLS_EMBED\"")
+endif()
+file(WRITE ${OUTPUT_FILE} "extern \"C\" const char ${SYMBOL_NAME}[] = R\"RL_TOOLS_EMBED(${RL_TOOLS_EMBED_CONTENT})RL_TOOLS_EMBED\";\n")

hyperdrone/_vendor/rl-tools/cmake/scripts/generate-git-snapshot.cmake

@@ -0,0 +1,138 @@
+if(NOT DEFINED OUTPUT_FILE)
+    message(FATAL_ERROR "OUTPUT_FILE is required")
+endif()
+if(POLICY CMP0012)
+    cmake_policy(SET CMP0012 NEW)
+endif()
+if(NOT DEFINED GIT_EXECUTABLE)
+    message(FATAL_ERROR "GIT_EXECUTABLE is required")
+endif()
+if(NOT DEFINED RL_TOOLS_ROOT)
+    message(FATAL_ERROR "RL_TOOLS_ROOT is required")
+endif()
+if(NOT DEFINED RL_TOOLS_IS_REPO)
+    set(RL_TOOLS_IS_REPO FALSE)
+endif()
+if(NOT DEFINED PARENT_IS_REPO)
+    set(PARENT_IS_REPO FALSE)
+endif()
+if(NOT DEFINED PARENT_ROOT)
+    set(PARENT_ROOT "")
+endif()
+
+function(git_capture VAR REPO_DIR)
+    execute_process(
+        COMMAND "${GIT_EXECUTABLE}" ${ARGN}
+        WORKING_DIRECTORY "${REPO_DIR}"
+        RESULT_VARIABLE GIT_CAPTURE_RESULT
+        OUTPUT_VARIABLE GIT_CAPTURE_OUTPUT
+        ERROR_QUIET
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    if(NOT GIT_CAPTURE_RESULT EQUAL 0)
+        set(GIT_CAPTURE_OUTPUT "")
+    endif()
+    set(${VAR} "${GIT_CAPTURE_OUTPUT}" PARENT_SCOPE)
+endfunction()
+
+function(hex_encode_bytes INPUT OUT_BYTES OUT_SIZE)
+    string(HEX "${INPUT}" HEX_STR)
+    string(LENGTH "${HEX_STR}" HEX_LEN)
+    math(EXPR BYTE_COUNT "${HEX_LEN} / 2")
+    set(BYTES "")
+    set(I 0)
+    while(I LESS HEX_LEN)
+        string(SUBSTRING "${HEX_STR}" ${I} 2 BYTE)
+        math(EXPR BYTE_INDEX "${I} / 2")
+        math(EXPR BYTE_MOD "${BYTE_INDEX} % 16")
+        if(BYTE_MOD EQUAL 0)
+            string(APPEND BYTES "\n        ")
+        endif()
+        string(APPEND BYTES "0x${BYTE},")
+        math(EXPR I "${I} + 2")
+    endwhile()
+    set(${OUT_BYTES} "${BYTES}" PARENT_SCOPE)
+    set(${OUT_SIZE} "${BYTE_COUNT}" PARENT_SCOPE)
+endfunction()
+
+function(append_string_var OUT_VAR NAME VALUE)
+    hex_encode_bytes("${VALUE}" BYTES SIZE)
+    set(CONTENT "${${OUT_VAR}}    namespace { const unsigned char ${NAME}_storage[] = {${BYTES}0x00}; }\n")
+    set(CONTENT "${CONTENT}    extern const char* const ${NAME} = reinterpret_cast<const char*>(${NAME}_storage);\n")
+    set(${OUT_VAR} "${CONTENT}" PARENT_SCOPE)
+endfunction()
+
+function(append_commit_message OUT_VAR VALUE)
+    hex_encode_bytes("${VALUE}" BYTES SIZE)
+    set(CONTENT "${${OUT_VAR}}    extern const unsigned char commit_message_bytes[] = {${BYTES}0x00};\n")
+    set(CONTENT "${CONTENT}    extern const std::size_t commit_message_size = ${SIZE};\n")
+    set(${OUT_VAR} "${CONTENT}" PARENT_SCOPE)
+endfunction()
+
+function(append_repo_snapshot OUT_VAR NAMESPACE_NAME IS_REPO REPO_ROOT AVAILABLE_FLAG)
+    set(CONTENT "${${OUT_VAR}}namespace ${NAMESPACE_NAME} {\n")
+    if(NOT AVAILABLE_FLAG STREQUAL "none")
+        if(AVAILABLE_FLAG)
+            set(CONTENT "${CONTENT}    extern const bool available = true;\n")
+        else()
+            set(CONTENT "${CONTENT}    extern const bool available = false;\n")
+        endif()
+    endif()
+
+    if(IS_REPO)
+        git_capture(COMMIT "${REPO_ROOT}" rev-parse HEAD)
+        git_capture(COMMIT_MESSAGE "${REPO_ROOT}" log -1 --pretty=%B)
+        git_capture(DIFF "${REPO_ROOT}" diff --no-ext-diff)
+        git_capture(DIFF_COLOR "${REPO_ROOT}" diff --no-ext-diff --color=always)
+        git_capture(WORD_DIFF "${REPO_ROOT}" diff --no-ext-diff --word-diff)
+        git_capture(WORD_DIFF_COLOR "${REPO_ROOT}" diff --no-ext-diff --word-diff --color=always)
+        git_capture(DIFF_STAGED "${REPO_ROOT}" diff --cached --no-ext-diff)
+        git_capture(DIFF_STAGED_COLOR "${REPO_ROOT}" diff --cached --no-ext-diff --color=always)
+        git_capture(WORD_DIFF_STAGED "${REPO_ROOT}" diff --cached --no-ext-diff --word-diff)
+        git_capture(WORD_DIFF_STAGED_COLOR "${REPO_ROOT}" diff --cached --no-ext-diff --word-diff --color=always)
+        set(PATH_VAR "${REPO_ROOT}")
+        if(NOT COMMIT)
+            set(COMMIT "unknown")
+        endif()
+    else()
+        set(COMMIT "not_a_repository")
+        set(COMMIT_MESSAGE "")
+        set(DIFF "")
+        set(DIFF_COLOR "")
+        set(WORD_DIFF "")
+        set(WORD_DIFF_COLOR "")
+        set(DIFF_STAGED "")
+        set(DIFF_STAGED_COLOR "")
+        set(WORD_DIFF_STAGED "")
+        set(WORD_DIFF_STAGED_COLOR "")
+        set(PATH_VAR "")
+    endif()
+
+    append_string_var(CONTENT commit "${COMMIT}")
+    append_commit_message(CONTENT "${COMMIT_MESSAGE}")
+    append_string_var(CONTENT diff "${DIFF}")
+    append_string_var(CONTENT diff_color "${DIFF_COLOR}")
+    append_string_var(CONTENT word_diff "${WORD_DIFF}")
+    append_string_var(CONTENT word_diff_color "${WORD_DIFF_COLOR}")
+    append_string_var(CONTENT diff_staged "${DIFF_STAGED}")
+    append_string_var(CONTENT diff_staged_color "${DIFF_STAGED_COLOR}")
+    append_string_var(CONTENT word_diff_staged "${WORD_DIFF_STAGED}")
+    append_string_var(CONTENT word_diff_staged_color "${WORD_DIFF_STAGED_COLOR}")
+    append_string_var(CONTENT path "${PATH_VAR}")
+    set(CONTENT "${CONTENT}} // namespace ${NAMESPACE_NAME}\n\n")
+
+    set(${OUT_VAR} "${CONTENT}" PARENT_SCOPE)
+endfunction()
+
+set(CONTENT "#include <cstddef>\n")
+set(CONTENT "${CONTENT}namespace rl_tools { namespace utils { namespace extrack { namespace git {\n")
+append_repo_snapshot(CONTENT rl_tools ${RL_TOOLS_IS_REPO} "${RL_TOOLS_ROOT}" none)
+append_repo_snapshot(CONTENT project ${PARENT_IS_REPO} "${PARENT_ROOT}" ${PARENT_IS_REPO})
+set(CONTENT "${CONTENT}}}}}\n")
+
+set(TMP_FILE "${OUTPUT_FILE}.tmp")
+get_filename_component(OUTPUT_DIR "${OUTPUT_FILE}" DIRECTORY)
+file(MAKE_DIRECTORY "${OUTPUT_DIR}")
+file(WRITE "${TMP_FILE}" "${CONTENT}")
+execute_process(COMMAND "${CMAKE_COMMAND}" -E copy_if_different "${TMP_FILE}" "${OUTPUT_FILE}")
+file(REMOVE "${TMP_FILE}")