hyperdrone 0.1.0__py3-none-any.whl

hyperdrone/_vendor/rl-tools/cmake/autodetect/tier2-json-hdf5-zlib.cmake

@@ -0,0 +1,84 @@
+if(NOT RL_TOOLS_DISABLE_JSON)
+    find_package(nlohmann_json QUIET)
+    if(nlohmann_json_FOUND)
+        get_target_property(nlohmann_json_INCLUDE_DIRS nlohmann_json::nlohmann_json INCLUDE_DIRECTORIES)
+        message(STATUS "Found existing/system nlohmann_json ${nlohmann_json_VERSION} at ${nlohmann_json_DIR}")
+        target_link_libraries(rl_tools_full INTERFACE nlohmann_json::nlohmann_json)
+        target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_ENABLE_JSON)
+        set(RL_TOOLS_ENABLE_JSON ON)
+    else()
+        find_package(Git QUIET)
+        if(GIT_FOUND)
+            message(STATUS "nlohmann_json not found. Using FetchContent.")
+            FetchContent_Declare(nlohmann_json
+                    GIT_REPOSITORY https://github.com/nlohmann/json.git
+                    GIT_TAG        a0c1318830519eac027a31edec1a99ce1ae5670e
+            )
+            rl_tools_fetchcontent_makeavailable_quiet(nlohmann_json)
+            target_include_directories(rl_tools_full INTERFACE ${nlohmann_json_SOURCE_DIR}/include)
+            target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_ENABLE_JSON)
+            set(RL_TOOLS_ENABLE_JSON ON)
+        else()
+            message(STATUS "Git not found - nlohmann_json disabled")
+            return()
+        endif()
+    endif()
+endif()
+
+if(NOT RL_TOOLS_DISABLE_HDF5)
+    find_package(HDF5 QUIET)
+    if(HDF5_FOUND)
+        message(STATUS "Found existing/system HDF5 ${HDF5_VERSION} at ${HDF5_INCLUDE_DIRS}")
+        target_link_libraries(rl_tools_full INTERFACE HDF5::HDF5)
+        target_include_directories(rl_tools_full INTERFACE ${HDF5_INCLUDE_DIRS})
+        target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_ENABLE_HDF5)
+        set(RL_TOOLS_ENABLE_HDF5 ON)
+    else()
+        message(WARNING "HDF5 not found. HDF5 is disabled. Suppress this warning by setting RL_TOOLS_DISABLE_HDF5=ON")
+    endif()
+endif()
+
+
+if(NOT RL_TOOLS_DISABLE_ZLIB)
+    find_package(ZLIB QUIET)
+    if(ZLIB_FOUND)
+        message(STATUS "Found existing/system ZLIB ${ZLIB_VERSION} at ${ZLIB_INCLUDE_DIRS}")
+        target_link_libraries(rl_tools_full INTERFACE ZLIB::ZLIB)
+        target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_ENABLE_ZLIB)
+        set(RL_TOOLS_ENABLE_ZLIB ON)
+    else()
+        find_package(Git QUIET)
+        if(GIT_FOUND)
+            message(STATUS "ZLIB not found. Using FetchContent.")
+            set(ZLIB_BUILD_EXAMPLES OFF)
+            set(ZLIB_ENABLE_TESTS OFF)
+            set(ZLIB_COMPAT ON)
+            FetchContent_Declare(zlib
+                    GIT_REPOSITORY https://github.com/zlib-ng/zlib-ng.git
+                    GIT_TAG   8d10c309d7d468b9b2ecfd8d5f1b063d6396af17
+            )
+            rl_tools_fetchcontent_makeavailable_quiet(zlib)
+
+            # zlib-ng can expose different target names depending on options/platform.
+            # Resolve to an existing CMake target to avoid falling back to a raw -l flag.
+            if(TARGET zlibstatic)
+                set(RL_TOOLS_ZLIB_TARGET zlibstatic)
+            elseif(TARGET zlib)
+                set(RL_TOOLS_ZLIB_TARGET zlib)
+            elseif(TARGET zlib-ng)
+                set(RL_TOOLS_ZLIB_TARGET zlib-ng)
+            elseif(TARGET ZLIB::ZLIB)
+                set(RL_TOOLS_ZLIB_TARGET ZLIB::ZLIB)
+            else()
+                message(FATAL_ERROR "zlib FetchContent completed, but no expected zlib target exists (tried: zlibstatic, zlib, zlib-ng, ZLIB::ZLIB).")
+            endif()
+            message(STATUS "Using zlib target: ${RL_TOOLS_ZLIB_TARGET}")
+            target_link_libraries(rl_tools_full INTERFACE ${RL_TOOLS_ZLIB_TARGET})
+            target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_ENABLE_ZLIB)
+            set(RL_TOOLS_ENABLE_ZLIB ON)
+        else()
+            message(STATUS "Git not found - ZLIB disabled")
+            return()
+        endif()
+    endif()
+endif()

hyperdrone/_vendor/rl-tools/cmake/autodetect/tier3-tensorboard.cmake

@@ -0,0 +1,29 @@
+if(NOT RL_TOOLS_DISABLE_TENSORBOARD)
+    find_package(Protobuf CONFIG QUIET)
+    if(NOT Protobuf_FOUND)
+        message(STATUS "Protobuf not found in config mode, trying to find it with CMake config.")
+        find_package(Protobuf QUIET)
+        set(RL_TOOLS_PROTOBUF_NO_CONFIG_PACKAGE ON)
+    endif()
+    find_package(Git QUIET)
+    if(Protobuf_FOUND)
+        if(GIT_FOUND)
+            FetchContent_Declare(tensorboard
+                    GIT_REPOSITORY https://github.com/rl-tools/tensorboard_logger.git
+                    GIT_TAG   6405cc19eae874ed51ac876f4ab530205f1c0147
+            )
+            set(_RL_TOOLS_SAVED_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
+            set(BUILD_SHARED_LIBS OFF)
+            rl_tools_fetchcontent_makeavailable_quiet(tensorboard)
+            set(BUILD_SHARED_LIBS ${_RL_TOOLS_SAVED_BUILD_SHARED_LIBS})
+            target_link_libraries(rl_tools_full INTERFACE tensorboard_logger)
+            target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_ENABLE_TENSORBOARD)
+            set(RL_TOOLS_ENABLE_TENSORBOARD ON)
+        else()
+            message(STATUS "Git not found, TensorBoard disabled.")
+            return()
+        endif()
+    else()
+        message(STATUS "Protobuf not found, TensorBoard disabled.")
+    endif()
+endif()

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

@@ -0,0 +1,33 @@
+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(STATUS "CUDAToolkit version: ${CUDAToolkit_VERSION}")
+        message(STATUS "CUDAToolkit include path: ${CUDAToolkit_INCLUDE_DIRS}")
+        message(STATUS "CUDAToolkit libraries: ${CUDAToolkit_LIBRARIES}")
+        message(STATUS "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()
+        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)
+        find_library(CUDNN_LIBRARY cudnn)
+        find_path(CUDNN_INCLUDE_DIR cudnn.h)
+        if(CUDNN_LIBRARY AND CUDNN_INCLUDE_DIR)
+            message(STATUS "cuDNN found: ${CUDNN_LIBRARY} (include: ${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)
+        else()
+            message(STATUS "cuDNN not found, cuDNN-accelerated layers disabled.")
+        endif()
+    else()
+        message(STATUS "CUDAToolkit not found, CUDA disabled.")
+    endif()
+endif()

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

@@ -0,0 +1,26 @@
+if(NOT RL_TOOLS_DISABLE_CLI11)
+    set(CLI11_PRECOMPILED ON)
+    find_package(CLI11 QUIET)
+    if(CLI11_FOUND)
+        message(STATUS "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)
+    else()
+        find_package(Git QUIET)
+        if(GIT_FOUND)
+            message(STATUS "CLI11 not found. Using FetchContent.")
+            FetchContent_Declare(CLI11
+                    GIT_REPOSITORY https://github.com/CLIUtils/CLI11.git
+                    GIT_TAG   291c58789c031208f08f4f261a858b5b7083e8e2
+            )
+            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)
+        else()
+            message(STATUS "Git not found - CLI11 disabled")
+            return()
+        endif()
+    endif()
+endif()

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

@@ -0,0 +1,16 @@
+find_package(assimp REQUIRED)
+# Homebrew's assimp config hardcodes the libz.tbd path of the SDK it was built against, which may
+# not exist locally; rewrite such entries to plain `z`.
+get_target_property(RL_TOOLS_ASSIMP_LINK_LIBRARIES assimp::assimp INTERFACE_LINK_LIBRARIES)
+if(RL_TOOLS_ASSIMP_LINK_LIBRARIES)
+    set(RL_TOOLS_ASSIMP_LINK_LIBRARIES_FIXED "")
+    foreach(RL_TOOLS_ASSIMP_LINK_ENTRY IN LISTS RL_TOOLS_ASSIMP_LINK_LIBRARIES)
+        if(RL_TOOLS_ASSIMP_LINK_ENTRY MATCHES "libz\\.tbd")
+            list(APPEND RL_TOOLS_ASSIMP_LINK_LIBRARIES_FIXED "z")
+        else()
+            list(APPEND RL_TOOLS_ASSIMP_LINK_LIBRARIES_FIXED "${RL_TOOLS_ASSIMP_LINK_ENTRY}")
+        endif()
+    endforeach()
+    list(REMOVE_DUPLICATES RL_TOOLS_ASSIMP_LINK_LIBRARIES_FIXED)
+    set_target_properties(assimp::assimp PROPERTIES INTERFACE_LINK_LIBRARIES "${RL_TOOLS_ASSIMP_LINK_LIBRARIES_FIXED}")
+endif()

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

@@ -0,0 +1,17 @@
+find_package(GTest QUIET)
+if(GTest_FOUND)
+    message(STATUS "Found existing/system GTest ${GTest_VERSION} at ${GTest_DIR}")
+    set(RL_TOOLS_ENABLE_GTEST ON)
+else()
+    find_package(Git QUIET)
+    if(GIT_FOUND)
+        FetchContent_Declare(googletest
+                GIT_REPOSITORY https://github.com/google/googletest.git
+                GIT_TAG   52eb8108c5bdec04579160ae17225d66034bd723
+        )
+        rl_tools_fetchcontent_makeavailable_quiet(googletest)
+        set(RL_TOOLS_ENABLE_GTEST ON)
+    else()
+        message(STATUS "Git not found - GTest disabled")
+    endif()
+endif()

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

@@ -0,0 +1,27 @@
+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})
+
+include(cmake/optional/assimp_fixup.cmake)
+
+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,32 @@
+if(RL_TOOLS_RL_ENVIRONMENTS_ENABLE_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(STATUS "Found existing/system mujoco ${mujoco_VERSION} at ${mujoco_DIR}")
+    else()
+        FetchContent_Declare(mujoco
+                GIT_REPOSITORY https://github.com/google-deepmind/mujoco.git
+                GIT_TAG   2.3.5
+        )
+        rl_tools_fetchcontent_makeavailable_quiet(mujoco)
+    endif()
+    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(STATUS "Found existing/system glfw3 ${glfw3_VERSION} at ${glfw3_DIR}")
+    else()
+        FetchContent_Declare(glfw3
+                GIT_REPOSITORY https://github.com/glfw/glfw.git
+                GIT_TAG   3fa2360720eeba1964df3c0ecf4b5df8648a8e52
+        )
+        rl_tools_fetchcontent_makeavailable_quiet(glfw3)
+    endif()
+    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)
+endif()

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

@@ -0,0 +1,17 @@
+enable_language(CUDA)
+set(CMAKE_CUDA_STANDARD 17)
+set(CMAKE_CUDA_STANDARD_REQUIRED ON)
+
+include(FetchContent)
+FetchContent_Declare(
+    OWL
+    GIT_REPOSITORY https://github.com/NVIDIA/OWL.git
+    GIT_TAG        978a66642ad00759ae24920afe02775f20b979b6
+    EXCLUDE_FROM_ALL
+)
+rl_tools_fetchcontent_makeavailable_quiet(OWL)
+
+find_package(assimp REQUIRED)
+
+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_generic.cmake

@@ -0,0 +1,4 @@
+include(cmake/optional/assimp_fixup.cmake)
+
+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,6 @@
+find_package(Vulkan REQUIRED COMPONENTS glslangValidator)
+
+include(cmake/optional/assimp_fixup.cmake)
+
+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/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}")

hyperdrone/_vendor/rl-tools/include/rl_tools/containers/matrix/matrix.h

@@ -0,0 +1,143 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_CONTAINERS_MATRIX_MATRIX_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_CONTAINERS_MATRIX_MATRIX_H
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace matrix{
+        namespace layouts{
+
+            template <typename TI, TI ALIGNMENT = 1>
+            struct RowMajorAlignment{
+                template <TI ROWS, TI COLS>
+                static constexpr TI ROW_PITCH = ((COLS + ALIGNMENT - 1) / ALIGNMENT) * ALIGNMENT;
+                template <TI ROWS, TI COLS>
+                static constexpr TI COL_PITCH = 1;
+            };
+
+            template <typename TI, TI ALIGNMENT = 1>
+            using RowMajorAlignmentOptimized = RowMajorAlignment<TI, ALIGNMENT>;
+
+            template <typename TI, TI T_ROW_PITCH, TI T_COL_PITCH>
+            struct Fixed{
+                template <TI ROWS, TI COLS>
+                static constexpr TI ROW_PITCH = T_ROW_PITCH;
+                template <TI ROWS, TI COLS>
+                static constexpr TI COL_PITCH = T_COL_PITCH;
+            };
+
+            template <typename TI>
+            using DEFAULT = layouts::RowMajorAlignmentOptimized<TI>; // row-major by default
+
+        }
+        template <typename T_T, typename T_TI, T_TI T_ROWS, T_TI T_COLS, bool T_DYNAMIC_ALLOCATION = true, typename LAYOUT_FACTORY = matrix::layouts::DEFAULT<T_TI>, bool T_CONST = false>
+        struct Specification{
+            using T = T_T;
+            using TI = T_TI;
+            static constexpr TI ROWS = T_ROWS;
+            static constexpr TI COLS = T_COLS;
+            static constexpr TI ROW_PITCH = LAYOUT_FACTORY::template ROW_PITCH<ROWS, COLS>;
+            static constexpr TI COL_PITCH = LAYOUT_FACTORY::template COL_PITCH<ROWS, COLS>;
+            static constexpr bool DYNAMIC_ALLOCATION = T_DYNAMIC_ALLOCATION;
+            using LAYOUT = layouts::Fixed<TI, ROW_PITCH, COL_PITCH>;
+            static constexpr bool CONST = T_CONST;
+
+            static_assert(COL_PITCH * T_COLS <= ROW_PITCH || ROW_PITCH * T_ROWS <= COL_PITCH, "Pitches of the matrix dimensions are not compatible");
+            static constexpr bool ROW_MAJOR = ROWS * ROW_PITCH >= COL_PITCH * COLS;
+            static constexpr TI SIZE = ROW_MAJOR ? ROWS * ROW_PITCH : COLS * COL_PITCH;
+            static constexpr TI SIZE_BYTES = SIZE * sizeof(T); // todo: discount size for views
+        };
+        template <auto T_ROWS, auto T_COLS> // todo: replace old view() calling convention by new ViewSpec based one
+        struct ViewSpec{
+            static constexpr auto ROWS = T_ROWS;
+            static constexpr auto COLS = T_COLS;
+        };
+    }
+    namespace matrix{
+        template <typename T, typename TI, TI SIZE>
+        struct MatrixStatic{
+            static constexpr bool DYNAMIC_ALLOCATION = false;
+            T _data[SIZE];
+        };
+        template <typename T, typename TI, TI SIZE_BYTES, bool CONST = false>
+        struct MatrixDynamic{
+            static constexpr bool DYNAMIC_ALLOCATION = true;
+            T* RL_TOOLS_RESTRICT _data = nullptr;
+        };
+        template <typename T, typename TI, TI SIZE_BYTES>
+        struct MatrixDynamic<T, TI, SIZE_BYTES, true>{
+            static constexpr bool DYNAMIC_ALLOCATION = true;
+            const T* RL_TOOLS_RESTRICT _data = nullptr;
+        };
+    }
+
+    template <typename T_SPEC>
+    struct Matrix: utils::typing::conditional_t<T_SPEC::DYNAMIC_ALLOCATION, matrix::MatrixDynamic<typename T_SPEC::T, typename T_SPEC::TI, T_SPEC::SIZE_BYTES, T_SPEC::CONST>, matrix::MatrixStatic<typename T_SPEC::T, typename T_SPEC::TI, T_SPEC::SIZE>>{
+        using SPEC = T_SPEC;
+        using T = typename SPEC::T;
+        using TI = typename SPEC::TI;
+        static constexpr TI ROWS = SPEC::ROWS;
+        static constexpr TI COLS = SPEC::COLS;
+        static constexpr TI ROW_PITCH = SPEC::ROW_PITCH;
+        static constexpr TI COL_PITCH = SPEC::COL_PITCH;
+
+        using VIEW_LAYOUT = matrix::layouts::Fixed<typename SPEC::TI, SPEC::ROW_PITCH, SPEC::COL_PITCH>;
+
+        template<typename SPEC::TI ROWS = SPEC::ROWS, typename SPEC::TI COLS = SPEC::COLS>
+        using VIEW = Matrix<matrix::Specification<T, TI, ROWS, COLS, true, VIEW_LAYOUT>>;
+//        virtual void _abstract_tag(){};
+//        // pure virtual function to make this class abstract (should be instantiated by either the MatrixStatic or MatrixDynamic subclasses class)
+//        virtual void _abstract_tag() = 0;
+        // Matrix() = default;
+//        T* _data = nullptr;
+//        Matrix() = default;
+//        Matrix(T* data): _data(data){};
+    };
+//    template<typename T_SPEC>
+//    struct MatrixDynamic: Matrix<T_SPEC>{
+//        using T = typename MatrixDynamic::T;
+//        using TI = typename MatrixDynamic::TI;
+//        using SPEC = T_SPEC;
+//
+//        template<typename SPEC::TI ROWS, typename SPEC::TI COLS>
+//        using VIEW = MatrixDynamic<matrix::Specification<T, TI, ROWS, COLS, typename MatrixDynamic::VIEW_LAYOUT, true>>;
+////        virtual void _abstract_tag(){};
+//    };
+//    struct MatrixDynamicTag{
+//        template<typename T_SPEC>
+//        using type = MatrixDynamic<T_SPEC>;
+//    };
+//    template<typename T_SPEC>
+//    struct MatrixStatic: Matrix<T_SPEC>{
+//        using T = typename MatrixStatic::T;
+//        using TI = typename MatrixStatic::TI;
+//        using SPEC = T_SPEC;
+//
+//        template<typename SPEC::TI ROWS, typename SPEC::TI COLS>
+//        using VIEW = MatrixDynamic<matrix::Specification<T, TI, ROWS, COLS, typename MatrixStatic::VIEW_LAYOUT, true>>;
+////        virtual void _abstract_tag(){};
+//
+//        alignas(T) unsigned char _data_memory[SPEC::SIZE_BYTES];
+//        MatrixStatic(): Matrix<T_SPEC>((T*)_data_memory){};
+//    };
+//    struct MatrixStaticTag{
+//        template<typename T_SPEC>
+//        using type = MatrixStatic<T_SPEC>;
+//    };
+//    namespace matrix{
+//        template <typename T, typename TI>
+//        using Empty = Matrix<matrix::Specification<T, TI, 0, 0>>;
+//    }
+
+
+    namespace containers{
+        template<typename SPEC_1, typename SPEC_2>
+        constexpr bool check_structure = SPEC_1::ROWS == SPEC_2::ROWS && SPEC_1::COLS == SPEC_2::COLS;
+        template<typename SPEC_1, typename SPEC_2>
+        constexpr bool check_memory_layout = check_structure<SPEC_1, SPEC_2> && SPEC_1::ROW_PITCH == SPEC_2::ROW_PITCH && SPEC_1::COL_PITCH == SPEC_2::COL_PITCH && utils::typing::is_same_v<typename SPEC_1::T, typename SPEC_2::T> && SPEC_1::SIZE_BYTES == SPEC_2::SIZE_BYTES; // check if e.g. direct memory copy is possible
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/containers/matrix/operations_arm.h

@@ -0,0 +1,33 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_CONTAINERS_MATRIX_OPERATIONS_ARM_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_CONTAINERS_MATRIX_OPERATIONS_ARM_H
+
+#include "operations_generic.h"
+// #include <cstring> // formemcpy
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template<typename SOURCE_DEV_SPEC, typename TARGET_DEV_SPEC, typename SOURCE_SPEC, typename TARGET_SPEC>
+    void copy_view(devices::ARM<SOURCE_DEV_SPEC>& source_device, devices::ARM<TARGET_DEV_SPEC>& target_device, const Matrix<SOURCE_SPEC>& source, Matrix<TARGET_SPEC>& target){
+        using SOURCE_DEVICE = devices::ARM<SOURCE_DEV_SPEC>;
+        static_assert(containers::check_structure<SOURCE_SPEC, TARGET_SPEC>);
+        using SPEC = SOURCE_SPEC;
+        vectorize_unary<SOURCE_DEVICE, SOURCE_SPEC, TARGET_SPEC, containers::vectorization::operators::copy<typename SOURCE_DEVICE::SPEC::MATH, typename SPEC::T>>(source_device, source, target);
+    }
+    template<typename SOURCE_DEV_SPEC, typename TARGET_DEV_SPEC, typename SPEC_1, typename SPEC_2>
+    void copy(devices::ARM<SOURCE_DEV_SPEC>& source_device, devices::ARM<TARGET_DEV_SPEC>& target_device, const Matrix<SPEC_1>& source, Matrix<SPEC_2>& target){
+        static_assert(containers::check_structure<SPEC_1, SPEC_2>);
+        using DEVICE = devices::ARM<SOURCE_DEV_SPEC>;
+        using TI = typename DEVICE::index_t;
+        if constexpr(containers::check_memory_layout<SPEC_1, SPEC_2>){
+            for(TI i = 0; i < SPEC_1::SIZE; i++){
+                target._data[i] = source._data[i];
+            }
+        }
+        else{
+            copy_view(source_device, target_device, source, target);
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif