hyperdrone 0.1.0__py3-none-any.whl

hyperdrone/_native/render/scene_bindings.cpp

@@ -0,0 +1,279 @@
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/array.h>
+#include <nanobind/stl/vector.h>
+
+#include <rl_tools/operations/cpu_mux.h>
+#include <rl_tools/rendering/raytracing/operations_cpu_common.h>
+
+#include "bindings.h"
+
+#include <cmath>
+#include <stdexcept>
+#include <string>
+
+namespace nb = nanobind;
+namespace rlt = rl_tools;
+namespace rrt = rl_tools::rendering::raytracing;
+
+using hyperdrone::FloatArray;
+using hyperdrone::Transform;
+using hyperdrone::Vec3;
+using hyperdrone::Vec4;
+using hyperdrone::extract_transform;
+using hyperdrone::make_owned_array;
+
+using DEVICE = rlt::devices::DEVICE_FACTORY<>;
+static DEVICE g_device;
+
+template <typename TARGET>
+static bool load_dispatch(TARGET& target, const std::string& path, int shading, bool rgb){
+    switch(shading){
+        case 0: return rgb ? rlt::load<rrt::Low, true>(g_device, target, path) : rlt::load<rrt::Low, false>(g_device, target, path);
+        case 1: return rgb ? rlt::load<rrt::Medium, true>(g_device, target, path) : rlt::load<rrt::Medium, false>(g_device, target, path);
+        case 2: return rgb ? rlt::load<rrt::High, true>(g_device, target, path) : rlt::load<rrt::High, false>(g_device, target, path);
+        case 3: return rgb ? rlt::load<rrt::VeryHigh, true>(g_device, target, path) : rlt::load<rrt::VeryHigh, false>(g_device, target, path);
+    }
+    throw std::invalid_argument("hyperdrone: shading must be in [0, 3]");
+}
+
+static rrt::Mesh make_mesh(FloatArray vertices, nb::ndarray<const int32_t, nb::c_contig, nb::device::cpu> indices,
+                           Vec3 color, nb::object normals, nb::object tex_coords,
+                           float metallic, float roughness, Vec3 emissive){
+    if(vertices.ndim() != 2 || vertices.shape(1) != 3){
+        throw std::invalid_argument("hyperdrone: vertices must have shape (V, 3) and dtype float32");
+    }
+    if(indices.ndim() != 2 || indices.shape(1) != 3){
+        throw std::invalid_argument("hyperdrone: indices must have shape (F, 3) and dtype int32");
+    }
+    rrt::Mesh mesh;
+    const size_t num_vertices = vertices.shape(0);
+    const size_t num_faces = indices.shape(0);
+    mesh.vertices.assign(vertices.data(), vertices.data() + num_vertices * 3);
+    mesh.indices.assign(indices.data(), indices.data() + num_faces * 3);
+    mesh.color[0] = color[0]; mesh.color[1] = color[1]; mesh.color[2] = color[2];
+    mesh.metallic = metallic;
+    mesh.roughness = roughness;
+    mesh.emissive[0] = emissive[0]; mesh.emissive[1] = emissive[1]; mesh.emissive[2] = emissive[2];
+    if(!normals.is_none()){
+        auto normals_array = nb::cast<FloatArray>(normals);
+        if(normals_array.ndim() != 2 || normals_array.shape(0) != num_vertices || normals_array.shape(1) != 3){
+            throw std::invalid_argument("hyperdrone: normals must have shape (V, 3) and dtype float32");
+        }
+        mesh.normals.assign(normals_array.data(), normals_array.data() + num_vertices * 3);
+    }
+    else {
+        // area-weighted vertex normals so meshes shade correctly under normal/PBR tiers
+        mesh.normals.assign(num_vertices * 3, 0.0f);
+        for(size_t face = 0; face < num_faces; face++){
+            const int32_t i0 = mesh.indices[face * 3 + 0], i1 = mesh.indices[face * 3 + 1], i2 = mesh.indices[face * 3 + 2];
+            const float* v0 = &mesh.vertices[(size_t)i0 * 3];
+            const float* v1 = &mesh.vertices[(size_t)i1 * 3];
+            const float* v2 = &mesh.vertices[(size_t)i2 * 3];
+            const float e1[3] = {v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]};
+            const float e2[3] = {v2[0] - v0[0], v2[1] - v0[1], v2[2] - v0[2]};
+            const float n[3] = {
+                e1[1] * e2[2] - e1[2] * e2[1],
+                e1[2] * e2[0] - e1[0] * e2[2],
+                e1[0] * e2[1] - e1[1] * e2[0]
+            };
+            for(int32_t index : {i0, i1, i2}){
+                mesh.normals[(size_t)index * 3 + 0] += n[0];
+                mesh.normals[(size_t)index * 3 + 1] += n[1];
+                mesh.normals[(size_t)index * 3 + 2] += n[2];
+            }
+        }
+        for(size_t vertex = 0; vertex < num_vertices; vertex++){
+            float* n = &mesh.normals[vertex * 3];
+            const float length = std::sqrt(n[0] * n[0] + n[1] * n[1] + n[2] * n[2]);
+            if(length > 0){
+                n[0] /= length; n[1] /= length; n[2] /= length;
+            }
+        }
+    }
+    if(!tex_coords.is_none()){
+        auto uv_array = nb::cast<FloatArray>(tex_coords);
+        if(uv_array.ndim() != 2 || uv_array.shape(0) != num_vertices || uv_array.shape(1) != 2){
+            throw std::invalid_argument("hyperdrone: tex_coords must have shape (V, 2) and dtype float32");
+        }
+        mesh.tex_coords.assign(uv_array.data(), uv_array.data() + num_vertices * 2);
+    }
+    return mesh;
+}
+
+void register_scene_bindings(nb::module_& m){
+    nb::class_<rrt::SceneLight>(m, "SceneLight")
+        .def_static("directional", [](Vec3 direction, Vec3 color){
+            rrt::SceneLight light{};
+            light.type = 0;
+            for(int i = 0; i < 3; i++){ light.direction[i] = direction[i]; light.color[i] = color[i]; }
+            return light;
+        }, nb::arg("direction"), nb::arg("color"))
+        .def_static("point", [](Vec3 position, Vec3 color, Vec3 attenuation){
+            rrt::SceneLight light{};
+            light.type = 1;
+            for(int i = 0; i < 3; i++){ light.position[i] = position[i]; light.color[i] = color[i]; }
+            light.attenuation_constant = attenuation[0];
+            light.attenuation_linear = attenuation[1];
+            light.attenuation_quadratic = attenuation[2];
+            return light;
+        }, nb::arg("position"), nb::arg("color"), nb::arg("attenuation") = Vec3{1.0f, 0.0f, 0.0f})
+        .def_static("spot", [](Vec3 position, Vec3 direction, Vec3 color, float cos_inner_cone, float cos_outer_cone, Vec3 attenuation){
+            rrt::SceneLight light{};
+            light.type = 2;
+            for(int i = 0; i < 3; i++){ light.position[i] = position[i]; light.direction[i] = direction[i]; light.color[i] = color[i]; }
+            light.cos_inner_cone = cos_inner_cone;
+            light.cos_outer_cone = cos_outer_cone;
+            light.attenuation_constant = attenuation[0];
+            light.attenuation_linear = attenuation[1];
+            light.attenuation_quadratic = attenuation[2];
+            return light;
+        }, nb::arg("position"), nb::arg("direction"), nb::arg("color"), nb::arg("cos_inner_cone"), nb::arg("cos_outer_cone"), nb::arg("attenuation") = Vec3{1.0f, 0.0f, 0.0f})
+        .def_prop_ro("type", [](const rrt::SceneLight& light){ return light.type; });
+
+    nb::class_<rrt::Mesh>(m, "Mesh")
+        .def("__init__", [](rrt::Mesh* mesh, FloatArray vertices, nb::ndarray<const int32_t, nb::c_contig, nb::device::cpu> indices,
+                            Vec3 color, nb::object normals, nb::object tex_coords, float metallic, float roughness, Vec3 emissive){
+            new (mesh) rrt::Mesh(make_mesh(vertices, indices, color, normals, tex_coords, metallic, roughness, emissive));
+        }, nb::arg("vertices"), nb::arg("indices"), nb::arg("color") = Vec3{0.8f, 0.8f, 0.8f},
+           nb::arg("normals") = nb::none(), nb::arg("tex_coords") = nb::none(),
+           nb::arg("metallic") = 0.0f, nb::arg("roughness") = 1.0f, nb::arg("emissive") = Vec3{0.0f, 0.0f, 0.0f})
+        .def_prop_ro("num_vertices", [](const rrt::Mesh& mesh){ return mesh.vertices.size() / 3; })
+        .def_prop_ro("num_faces", [](const rrt::Mesh& mesh){ return mesh.indices.size() / 3; });
+
+    nb::class_<rrt::Object>(m, "Object")
+        .def("__init__", [](rrt::Object* object, const std::string& name, uint32_t segmentation_class){
+            new (object) rrt::Object();
+            object->name = name;
+            object->segmentation_class = segmentation_class;
+        }, nb::arg("name") = "", nb::arg("segmentation_class") = 0)
+        .def_rw("name", &rrt::Object::name)
+        .def_rw("segmentation_class", &rrt::Object::segmentation_class)
+        .def("add_mesh", [](rrt::Object& object, const rrt::Mesh& mesh){ object.meshes.push_back(mesh); })
+        .def("add_light", [](rrt::Object& object, const rrt::SceneLight& light){ object.lights.push_back(light); })
+        .def_prop_ro("num_meshes", [](const rrt::Object& object){ return object.meshes.size(); });
+
+    nb::class_<rrt::ObjectAssembly>(m, "ObjectAssembly")
+        .def(nb::init<>())
+        .def_prop_ro("num_objects", [](const rrt::ObjectAssembly& assembly){ return assembly.objects.size(); })
+        .def_prop_ro("num_parts", [](const rrt::ObjectAssembly& assembly){ return assembly.parts.size(); })
+        .def("object_name", [](const rrt::ObjectAssembly& assembly, size_t index){ return assembly.objects.at(index).name; })
+        .def("object_names", [](const rrt::ObjectAssembly& assembly){
+            std::vector<std::string> names;
+            for(const auto& object : assembly.objects){ names.push_back(object.name); }
+            return names;
+        })
+        .def("segmentation_class", [](const rrt::ObjectAssembly& assembly, size_t index){ return assembly.objects.at(index).segmentation_class; })
+        .def("set_segmentation_class", [](rrt::ObjectAssembly& assembly, size_t index, uint32_t segmentation_class){
+            assembly.objects.at(index).segmentation_class = segmentation_class;
+        })
+        .def("part", [](const rrt::ObjectAssembly& assembly, size_t index){
+            const auto& part = assembly.parts.at(index);
+            return nb::make_tuple(part.object, make_owned_array(part.transform, {3, 4}));
+        });
+
+    nb::class_<rrt::AssetPool>(m, "AssetPool")
+        .def(nb::init<>())
+        .def("add_assembly", [](rrt::AssetPool& pool, const rrt::ObjectAssembly& assembly){ return rlt::add(g_device, pool, assembly).index; })
+        .def("add_object", [](rrt::AssetPool& pool, const rrt::Object& object){ return rlt::add(g_device, pool, object).index; })
+        .def("add_mesh", [](rrt::AssetPool& pool, const rrt::Mesh& mesh){ return rlt::add(g_device, pool, mesh).index; })
+        .def_prop_ro("num_assets", [](const rrt::AssetPool& pool){ return pool.assemblies.size(); });
+
+    nb::class_<rrt::Scene>(m, "Scene")
+        .def(nb::init<>())
+        .def("load", [](rrt::Scene& scene, const std::string& path, int shading, bool rgb){
+            bool success;
+            {
+                nb::gil_scoped_release release;
+                success = load_dispatch(scene, path, shading, rgb);
+            }
+            if(!success){
+                throw std::runtime_error("hyperdrone: failed to load scene from " + path);
+            }
+        }, nb::arg("path"), nb::arg("shading") = 2, nb::arg("rgb") = true)
+        .def("add_object", [](rrt::Scene& scene, const rrt::Object& object, nb::object transform){
+            if(transform.is_none()){
+                return rlt::add(g_device, scene, object);
+            }
+            float values[12];
+            extract_transform(nb::cast<Transform>(transform), values);
+            return rlt::add(g_device, scene, object, values);
+        }, nb::arg("object"), nb::arg("transform") = nb::none())
+        .def("add_mesh", [](rrt::Scene& scene, const rrt::Mesh& mesh){ return rlt::add(g_device, scene, mesh); })
+        .def("add_assembly", [](rrt::Scene& scene, const rrt::ObjectAssembly& assembly, nb::object transform){
+            rrt::Placement placement;
+            if(transform.is_none()){
+                placement = rlt::add(g_device, scene, assembly);
+            }
+            else {
+                float values[12];
+                extract_transform(nb::cast<Transform>(transform), values);
+                placement = rlt::add(g_device, scene, assembly, values);
+            }
+            return nb::make_tuple(placement.first_instance, placement.num_instances);
+        }, nb::arg("assembly"), nb::arg("transform") = nb::none())
+        .def("add_light", [](rrt::Scene& scene, const rrt::SceneLight& light){ scene.lights.push_back(light); })
+        .def_prop_ro("num_objects", [](const rrt::Scene& scene){ return scene.objects.size(); })
+        .def_prop_ro("num_instances", [](const rrt::Scene& scene){ return scene.instances.size(); })
+        .def_prop_ro("num_lights", [](const rrt::Scene& scene){ return scene.lights.size(); })
+        .def("object_name", [](const rrt::Scene& scene, size_t index){ return scene.objects.at(index).name; })
+        .def("object_segmentation_class", [](const rrt::Scene& scene, size_t index){ return scene.objects.at(index).segmentation_class; })
+        .def("set_object_segmentation_class", [](rrt::Scene& scene, size_t index, uint32_t segmentation_class){
+            scene.objects.at(index).segmentation_class = segmentation_class;
+        })
+        .def("instance_object", [](const rrt::Scene& scene, size_t index){ return scene.instances.at(index).object; })
+        .def("instance_objects", [](const rrt::Scene& scene){
+            std::vector<size_t> objects;
+            for(const auto& instance : scene.instances){ objects.push_back(instance.object); }
+            return objects;
+        })
+        .def("instance_transform", [](const rrt::Scene& scene, size_t index){
+            return make_owned_array(scene.instances.at(index).transform, {3, 4});
+        });
+
+    m.def("load_object", [](const std::string& path, int shading, bool rgb){
+        rrt::Object object;
+        bool success;
+        {
+            nb::gil_scoped_release release;
+            success = load_dispatch(object, path, shading, rgb);
+        }
+        if(!success){
+            throw std::runtime_error("hyperdrone: failed to load object from " + path);
+        }
+        return object;
+    }, nb::arg("path"), nb::arg("shading") = 2, nb::arg("rgb") = true);
+
+    m.def("load_assembly", [](const std::string& path, int shading, bool rgb){
+        rrt::ObjectAssembly assembly;
+        bool success;
+        {
+            nb::gil_scoped_release release;
+            success = load_dispatch(assembly, path, shading, rgb);
+        }
+        if(!success){
+            throw std::runtime_error("hyperdrone: failed to load assembly from " + path);
+        }
+        return assembly;
+    }, nb::arg("path"), nb::arg("shading") = 2, nb::arg("rgb") = true);
+
+    m.def("make_camera", [](Vec3 position, Vec3 look_at, Vec3 up, float fov, float aspect){
+        rrt::Camera<float> camera = rlt::make_camera_data(position.data(), look_at.data(), up.data(), fov, aspect);
+        return make_owned_array(camera.pos, {4, 3});
+    }, nb::arg("position"), nb::arg("look_at"), nb::arg("up"), nb::arg("fov"), nb::arg("aspect"));
+
+    m.def("make_transform", [](Vec3 position, Vec4 orientation_wxyz){
+        float values[12];
+        rlt::make_transform(position.data(), orientation_wxyz.data(), values);
+        return make_owned_array(values, {3, 4});
+    }, nb::arg("position"), nb::arg("orientation_wxyz") = Vec4{1.0f, 0.0f, 0.0f, 0.0f});
+
+    m.def("compose_transforms", [](Transform a, Transform b){
+        float a_values[12], b_values[12], out[12];
+        extract_transform(a, a_values);
+        extract_transform(b, b_values);
+        rlt::compose_transforms(a_values, b_values, out);
+        return make_owned_array(out, {3, 4});
+    }, nb::arg("a"), nb::arg("b"));
+}

hyperdrone/_vendor/rl-tools/CMakeLists.txt

@@ -0,0 +1,159 @@
+#cmake_minimum_required(VERSION 3.14)
+#cmake_minimum_required(VERSION 3.18) # for BLAS::BLAS
+cmake_minimum_required(VERSION 3.19) # for HDF5::HDF5
+set(CMAKE_POLICY_VERSION_MINIMUM 3.5) # to prevent warnings about "Compatibility with CMake < 3.5 has been removed from CMake."
+
+project(rl_tools_core)
+
+set(CMAKE_CXX_STANDARD 17)
+
+option(RL_TOOLS_ENABLE_TARGETS "Enable building the main targets" ON)
+option(RL_TOOLS_ENABLE_TESTS "Enable building the tests" OFF)
+option(RL_TOOLS_OFFLINE_BUILD "Use the dependencies in .dependencies without checking for updates (useful after nuking the build directory when offline)" OFF)
+option(RL_TOOLS_WARNINGS_AS_ERRORS "Treat warnings as errors" ON)
+
+option(RL_TOOLS_RL_ENVIRONMENTS_ENABLE_MUJOCO "Enable MuJoCo" OFF)
+option(RL_TOOLS_RENDERING_ENABLE_RAYTRACING "Enable raytracing" OFF)
+
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type")
+endif()
+
+add_library(rl_tools_core INTERFACE)
+add_library(RLtools::Core ALIAS rl_tools_core)
+target_compile_features(rl_tools_core INTERFACE cxx_std_17)
+target_include_directories(rl_tools_core INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+add_library(rl_tools_full INTERFACE)
+add_library(RLtools::RLtools ALIAS rl_tools_full)
+target_link_libraries(rl_tools_full INTERFACE rl_tools_core)
+
+# Compiler optimizations
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+    if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+        target_compile_options(rl_tools_full INTERFACE -O3 -ffast-math -march=native)
+    endif()
+    if(RL_TOOLS_WARNINGS_AS_ERRORS)
+        # Safe (just unused warnings)
+        target_compile_options(rl_tools_full INTERFACE $<$<COMPILE_LANGUAGE:CXX>:-Werror -Wall -Wextra>) # the $<$<COMPILE_LANGUAGE:CXX>: is required for NVCC to not complain about -Wall
+        target_compile_options(rl_tools_full INTERFACE $<$<COMPILE_LANGUAGE:CXX>:-Wno-unused-parameter -Wno-unused-local-typedefs -Wno-unused-variable -Wno-unused-but-set-variable>)
+        if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+            target_compile_options(rl_tools_full INTERFACE -Wno-unused-lambda-capture)
+        endif()
+
+        # todo (put exclusions here)
+        if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+            include(CheckCXXCompilerFlag)
+            check_cxx_compiler_flag("-Wnan-infinity-disabled" HAS_NAN_INF_WARN)
+            if (HAS_NAN_INF_WARN)
+                target_compile_options(rl_tools_full INTERFACE $<$<COMPILE_LANGUAGE:CXX>:-Wno-error=nan-infinity-disabled>) # clang does not like some NaN handling in nlohmann_json when -ffast-math is on
+            endif()
+        endif()
+    endif()
+elseif(MSVC)
+    if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+        target_compile_options(rl_tools_full INTERFACE /O2 /fp:fast)
+    endif()
+    target_compile_options(rl_tools_full INTERFACE /bigobj)
+    target_compile_definitions(rl_tools_full INTERFACE _CRT_SECURE_NO_WARNINGS)
+    if(RL_TOOLS_WARNINGS_AS_ERRORS)
+        target_compile_options(rl_tools_full INTERFACE /W3 /WX)
+        target_compile_options(rl_tools_full INTERFACE
+            /wd4100  # unreferenced formal parameter
+            /wd4101  # unreferenced local variable
+            /wd4146  # unary minus on unsigned type
+            /wd4189  # local variable initialized but not referenced
+            /wd4244  # conversion, possible loss of data
+            /wd4267  # conversion from size_t, possible loss of data
+            /wd4459  # declaration hides global
+            /wd4996  # deprecated functions (getenv etc.)
+            /wd4068  # unknown pragma (e.g. #pragma GCC)
+            /wd4804  # unsafe use of type 'bool' in operation
+        )
+    endif()
+endif()
+
+
+# Configure FetchContent
+get_filename_component(CMAKE_BINARY_DIR_BASENAME ${CMAKE_BINARY_DIR} NAME)
+if(NOT DEFINED FETCHCONTENT_BASE_DIR)
+    set(_test_file "${CMAKE_CURRENT_SOURCE_DIR}/.cmake_write_test")
+    execute_process(
+        COMMAND ${CMAKE_COMMAND} -E touch "${_test_file}"
+        RESULT_VARIABLE _write_test_result
+        ERROR_QUIET
+        OUTPUT_QUIET
+    )
+    if(_write_test_result EQUAL 0)
+        file(REMOVE "${_test_file}")
+        set(_fetchcontent_base_dir_root "${CMAKE_CURRENT_SOURCE_DIR}")
+    else()
+        set(_fetchcontent_base_dir_root "${CMAKE_CURRENT_BINARY_DIR}")
+    endif()
+    set(FETCHCONTENT_BASE_DIR "${_fetchcontent_base_dir_root}/.dependencies/${CMAKE_BINARY_DIR_BASENAME}" CACHE PATH "Base dir for FetchContent downloads" FORCE)
+else()
+    set(FETCHCONTENT_BASE_DIR "${FETCHCONTENT_BASE_DIR}/${CMAKE_BINARY_DIR_BASENAME}" CACHE PATH "Base dir for FetchContent downloads")
+endif()
+if(RL_TOOLS_OFFLINE_BUILD)
+    set(FETCHCONTENT_FULLY_DISCONNECTED ON)
+endif()
+include(FetchContent)
+
+# Suppress STATUS messages from FetchContent subprojects (arch details, feature
+# summaries, proto generation lists, …) while still forwarding WARNING/ERROR.
+# Requires CMake >= 3.25; silently ignored on older versions.
+macro(rl_tools_fetchcontent_makeavailable_quiet)
+    set(_rl_tools_prev_log_level ${CMAKE_MESSAGE_LOG_LEVEL})
+    set(_rl_tools_prev_deprecation_flag ${CMAKE_WARN_DEPRECATED})
+    set(CMAKE_MESSAGE_LOG_LEVEL ERROR)
+    set(CMAKE_WARN_DEPRECATED FALSE)
+    FetchContent_MakeAvailable(${ARGN})
+    set(CMAKE_MESSAGE_LOG_LEVEL ${_rl_tools_prev_log_level})
+    set(CMAKE_WARN_DEPRECATED ${_rl_tools_prev_deprecation_flag})
+endmacro()
+
+include(cmake/autodetect/all.cmake)
+
+if(RL_TOOLS_RL_ENVIRONMENTS_ENABLE_MUJOCO)
+    include(cmake/optional/mujoco.cmake)
+endif()
+
+set(RL_TOOLS_RENDERING_RAYTRACING_BACKEND "AUTO" CACHE STRING "Raytracing backend (AUTO|OPTIX|METAL|VULKAN|GENERIC)")
+if(RL_TOOLS_RENDERING_ENABLE_RAYTRACING)
+    set(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED ${RL_TOOLS_RENDERING_RAYTRACING_BACKEND})
+    if(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED STREQUAL "AUTO")
+        if(APPLE)
+            set(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED "METAL")
+        else()
+            set(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED "OPTIX")
+        endif()
+    endif()
+    message(STATUS "RLtools raytracing backend: ${RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED}")
+    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 "GENERIC")
+        include(cmake/optional/raytracing_generic.cmake)
+    else()
+        message(FATAL_ERROR "Invalid RL_TOOLS_RENDERING_RAYTRACING_BACKEND: ${RL_TOOLS_RENDERING_RAYTRACING_BACKEND}")
+    endif()
+endif()
+
+if(RL_TOOLS_ENABLE_TARGETS)
+    add_subdirectory(src)
+endif()
+
+if (RL_TOOLS_ENABLE_TESTS)
+    include(cmake/optional/googletest.cmake)
+    if(RL_TOOLS_ENABLE_GTEST)
+        if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/tests/data)
+            set(RL_TOOLS_TEST_DATA_PATH "${CMAKE_CURRENT_SOURCE_DIR}/tests/data" CACHE PATH "Path to test data")
+            target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_TEST_DATA_PATH=${RL_TOOLS_TEST_DATA_PATH})
+        endif()
+        include(CTest)
+        add_subdirectory(tests)
+    endif()
+endif()

hyperdrone/_vendor/rl-tools/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Jonas Eschmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hyperdrone/_vendor/rl-tools/cmake/autodetect/all.cmake

@@ -0,0 +1,14 @@
+# tiers of optional dependencies
+# tier 0: none
+# tier 1: backend (MKL, OpenBLAS, Accelerate)
+# tier 2: json, hdf5
+# tier 3: tensorboard
+# tier 4: cuda
+# tier 5: cli11
+include(cmake/autodetect/tier1-blas.cmake)
+include(cmake/autodetect/tier2-json-hdf5-zlib.cmake)
+include(cmake/autodetect/tier3-tensorboard.cmake)
+include(cmake/autodetect/tier4-cuda.cmake)
+include(cmake/autodetect/tier5-cli11.cmake)
+include(cmake/autodetect/git-hash.cmake)
+include(cmake/autodetect/git-diff.cmake)

hyperdrone/_vendor/rl-tools/cmake/autodetect/git-diff.cmake

@@ -0,0 +1,103 @@
+# ==============================================================================
+# Git snapshot tracking for ExTrack
+# ==============================================================================
+
+option(RL_TOOLS_ENABLE_GIT_DIFF "Enable embedding git state into ExTrack runs" ON)
+
+if(NOT RL_TOOLS_ENABLE_GIT_DIFF)
+    return()
+endif()
+
+find_package(Git QUIET)
+if(NOT GIT_FOUND)
+    message(STATUS "Git not found - git snapshot tracking disabled")
+    return()
+endif()
+
+function(rl_tools_git_toplevel OUT_IS_REPO OUT_TOPLEVEL REPO_DIR)
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} rev-parse --show-toplevel
+        WORKING_DIRECTORY "${REPO_DIR}"
+        RESULT_VARIABLE GIT_TOPLEVEL_RESULT
+        OUTPUT_VARIABLE GIT_TOPLEVEL_OUTPUT
+        ERROR_QUIET
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    if(GIT_TOPLEVEL_RESULT EQUAL 0)
+        file(REAL_PATH "${GIT_TOPLEVEL_OUTPUT}" GIT_TOPLEVEL_NORMALIZED)
+        set(${OUT_IS_REPO} TRUE PARENT_SCOPE)
+        set(${OUT_TOPLEVEL} "${GIT_TOPLEVEL_NORMALIZED}" PARENT_SCOPE)
+    else()
+        set(${OUT_IS_REPO} FALSE PARENT_SCOPE)
+        set(${OUT_TOPLEVEL} "" PARENT_SCOPE)
+    endif()
+endfunction()
+
+file(REAL_PATH "${CMAKE_CURRENT_SOURCE_DIR}" RL_TOOLS_ROOT_DIR)
+file(REAL_PATH "${CMAKE_SOURCE_DIR}" CMAKE_SOURCE_DIR_NORMALIZED)
+
+if(NOT CMAKE_SOURCE_DIR_NORMALIZED STREQUAL RL_TOOLS_ROOT_DIR)
+    set(RL_TOOLS_PARENT_DIR "${CMAKE_SOURCE_DIR_NORMALIZED}")
+    set(RL_TOOLS_HAS_PARENT TRUE)
+else()
+    set(RL_TOOLS_PARENT_DIR "")
+    set(RL_TOOLS_HAS_PARENT FALSE)
+endif()
+
+rl_tools_git_toplevel(RL_TOOLS_IS_INSIDE_GIT_REPO RL_TOOLS_GIT_TOPLEVEL "${RL_TOOLS_ROOT_DIR}")
+if(RL_TOOLS_IS_INSIDE_GIT_REPO AND RL_TOOLS_GIT_TOPLEVEL STREQUAL RL_TOOLS_ROOT_DIR)
+    set(RL_TOOLS_IS_GIT_REPO TRUE)
+else()
+    set(RL_TOOLS_IS_GIT_REPO FALSE)
+endif()
+
+set(RL_TOOLS_PARENT_IS_GIT_REPO FALSE)
+if(RL_TOOLS_HAS_PARENT)
+    rl_tools_git_toplevel(RL_TOOLS_PARENT_IS_INSIDE_GIT_REPO RL_TOOLS_PARENT_GIT_TOPLEVEL "${RL_TOOLS_PARENT_DIR}")
+    if(RL_TOOLS_PARENT_IS_INSIDE_GIT_REPO AND RL_TOOLS_PARENT_GIT_TOPLEVEL STREQUAL RL_TOOLS_PARENT_DIR)
+        set(RL_TOOLS_PARENT_IS_GIT_REPO TRUE)
+    endif()
+endif()
+
+if(NOT RL_TOOLS_IS_GIT_REPO AND NOT RL_TOOLS_PARENT_IS_GIT_REPO)
+    message(STATUS "No git repositories detected - git snapshot tracking disabled")
+    return()
+endif()
+
+message(STATUS "Git snapshot tracking enabled:")
+message(STATUS "  Library: ${RL_TOOLS_ROOT_DIR} [git: ${RL_TOOLS_IS_GIT_REPO}]")
+if(RL_TOOLS_HAS_PARENT)
+    message(STATUS "  Project: ${RL_TOOLS_PARENT_DIR} [git: ${RL_TOOLS_PARENT_IS_GIT_REPO}]")
+endif()
+
+set(GIT_SNAPSHOT_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/rl_tools/extrack/git_snapshot.cpp")
+set(GIT_SNAPSHOT_GENERATOR "${CMAKE_CURRENT_SOURCE_DIR}/cmake/scripts/generate-git-snapshot.cmake")
+
+set(GIT_SNAPSHOT_PARENT_ARGS "")
+if(RL_TOOLS_HAS_PARENT)
+    set(GIT_SNAPSHOT_PARENT_ARGS -DPARENT_ROOT=${RL_TOOLS_PARENT_DIR})
+endif()
+
+add_custom_target(rl_tools_git_snapshot_update
+    COMMAND ${CMAKE_COMMAND}
+        -DGIT_EXECUTABLE=${GIT_EXECUTABLE}
+        -DOUTPUT_FILE=${GIT_SNAPSHOT_OUTPUT}
+        -DRL_TOOLS_ROOT=${RL_TOOLS_ROOT_DIR}
+        -DRL_TOOLS_IS_REPO=${RL_TOOLS_IS_GIT_REPO}
+        -DPARENT_IS_REPO=${RL_TOOLS_PARENT_IS_GIT_REPO}
+        ${GIT_SNAPSHOT_PARENT_ARGS}
+        -P "${GIT_SNAPSHOT_GENERATOR}"
+    BYPRODUCTS ${GIT_SNAPSHOT_OUTPUT}
+    COMMENT "Updating git snapshot for ExTrack"
+    VERBATIM
+)
+
+set_source_files_properties(${GIT_SNAPSHOT_OUTPUT} PROPERTIES GENERATED TRUE)
+add_library(rl_tools_git_snapshot STATIC ${GIT_SNAPSHOT_OUTPUT})
+add_dependencies(rl_tools_git_snapshot rl_tools_git_snapshot_update)
+target_compile_features(rl_tools_git_snapshot PRIVATE cxx_std_11)
+target_compile_definitions(rl_tools_git_snapshot PUBLIC RL_TOOLS_EXTRACK_GIT_DIFF)
+
+if(TARGET rl_tools_full)
+    target_link_libraries(rl_tools_full INTERFACE rl_tools_git_snapshot)
+endif()

hyperdrone/_vendor/rl-tools/cmake/autodetect/git-hash.cmake

@@ -0,0 +1,13 @@
+find_package(Git)
+if(GIT_FOUND)
+    execute_process(
+            COMMAND ${GIT_EXECUTABLE} rev-parse HEAD
+            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+            OUTPUT_VARIABLE RL_TOOLS_COMMIT_HASH
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    message("Commit hash: ${RL_TOOLS_COMMIT_HASH}")
+endif()
+if(RL_TOOLS_COMMIT_HASH)
+    target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_COMMIT_HASH_EXTERNAL=${RL_TOOLS_COMMIT_HASH})
+endif()

hyperdrone/_vendor/rl-tools/cmake/autodetect/tier1-blas.cmake

@@ -0,0 +1,43 @@
+if(NOT MKL_ROOT)
+    if(DEFINED ENV{MKL_ROOT})
+        set(MKL_ROOT $ENV{MKL_ROOT})
+    else()
+        set(MKL_ROOT /opt/intel/oneapi/mkl/latest)
+        message(STATUS "MKL_ROOT is not set. Using default: ${MKL_ROOT}")
+    endif()
+endif()
+find_package(MKL QUIET)
+if(MKL_FOUND)
+    message(STATUS "Found MKL ${MKL_VERSION}")
+    target_link_libraries(rl_tools_full INTERFACE MKL::MKL)
+    target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_BACKEND_ENABLE_MKL)
+    target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_BACKEND_ENABLE_BLAS)
+    set(RL_TOOLS_BACKEND_ENABLE_MKL ON)
+    set(RL_TOOLS_BACKEND_ENABLE_BLAS ON)
+    find_package(dnnl QUIET)
+    if(dnnl_FOUND)
+        message(STATUS "Found oneDNN (DNNL)")
+        target_link_libraries(rl_tools_full INTERFACE DNNL::dnnl)
+        target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_BACKEND_ENABLE_DNNL)
+        set(RL_TOOLS_BACKEND_ENABLE_DNNL ON)
+    endif()
+else()
+    find_package(BLAS QUIET)
+    if(BLAS_FOUND)
+        message(STATUS "Found BLAS library ${BLAS_VENDOR} at ${BLAS_LIBRARIES}")
+        target_link_libraries(rl_tools_full INTERFACE BLAS::BLAS)
+        if(NOT APPLE)
+            target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_BACKEND_ENABLE_OPENBLAS)
+            target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_BACKEND_ENABLE_BLAS)
+            set(RL_TOOLS_BACKEND_ENABLE_OPENBLAS ON)
+            set(RL_TOOLS_BACKEND_ENABLE_BLAS ON)
+        else()
+            target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_BACKEND_ENABLE_ACCELERATE)
+            target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_BACKEND_ENABLE_BLAS)
+            set(RL_TOOLS_BACKEND_ENABLE_ACCELERATE ON)
+            set(RL_TOOLS_BACKEND_ENABLE_BLAS ON)
+        endif()
+    else()
+        message(WARNING "BLAS no BLAS library found, defaulting to naive backend. Performance will be suboptimal.")
+    endif()
+endif()