hyperdrone 0.1.5__tar.gz → 0.1.7__tar.gz

{hyperdrone-0.1.5 → hyperdrone-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hyperdrone
-Version: 0.1.5
+Version: 0.1.7
 Summary: The fastest drone simulator and renderer (raytracer).
 Author-email: Jonas Eschmann <jonas.eschmann@gmail.com>
 License: MIT
@@ -11,7 +11,7 @@ Provides-Extra: examples
 Requires-Dist: imageio; extra == 'examples'
 Requires-Dist: imageio-ffmpeg; extra == 'examples'
 Requires-Dist: matplotlib; extra == 'examples'
-Requires-Dist: scipy; extra == 'examples'
+Requires-Dist: scipy>=1.15; extra == 'examples'
 Provides-Extra: gym
 Requires-Dist: gymnasium>=1.0; extra == 'gym'
 Description-Content-Type: text/markdown
@@ -66,11 +66,12 @@ Install the dependencies used by the packaged examples with:
 pip install "hyperdrone[examples]"
 ```
 
-Requirements: CMake >= 3.24, a C++17 compiler, and per feature: assimp (system package)
-for GLB loading, CUDA + OptiX driver for the OptiX render backend and cuda dynamics,
+Requirements: CMake >= 3.24, a C++17 compiler, and git for dependency downloads.
+GLB loading uses the Assimp 6.0.4 release archive with a pinned SHA-256, shared by render and env builds. Cached archives are reused offline and verified by CMake before extraction.
+CUDA + OptiX driver is required for the OptiX render backend and cuda dynamics,
 Vulkan dev + glslang for the VULKAN backend. The WEBGPU backend fetches a hash-pinned
 wgpu-native prebuilt at first build (no extra system packages). Nothing beyond the
-compiler for GENERIC + cpu.
+build toolchain for GENERIC + cpu.
 
 ## Environment
 
@@ -121,6 +122,13 @@ swizzled at load time. Procedural scenes (`render.Scene()` + `render.Object` /
 content via `AssetPool` + `spawn`/`attach`), motion blur, and anti-aliasing follow the
 same API as before under `hyperdrone.render.*`.
 
+Converted ProcTHOR scenes carry ambient `(0.6, 0.6, 0.6)` and a black background in
+`scenes[].extras.rl_tools.environment` (`mode: "solid"`, `ambient` and `background`
+are nonnegative linear RGB triples). Scene loading imports these settings; importing
+objects or assemblies leaves the parent environment alone. Ambient affects `high`
+and `veryhigh`, approximating indirect illumination without light bounces. Override
+imported settings with `scene.set_environment(...)` before `renderer.init(scene)`.
+
 `num_probes` sizes the collision-probe pass (`generate_probe_directions()`, `render("collision")`, `collisions()`; one probe per camera by default). `num_probes=0` compiles that pass out entirely, the counterpart of the probe-ray macro the C++ benchmark targets set: no probe buffers are allocated, the default `render()` target runs only the image channels, and the probe methods raise.
 
 ### Zero-copy I/O (DLPack)
@@ -290,3 +298,21 @@ HYPERDRONE_RENDER_BACKEND=GENERIC .venv/bin/python -m pytest interface/python/hy
 `tests/test_architecture.py` enforces the import DAG (render and dynamics never see each
 other); `scripts/test_sdist.sh` is the self-containment rot guard (build sdist → clean
 venv → vendored-tree render).
+
+For labelled ProcTHOR rendering, preserve GLB root instances and select the output meaning:
+
+```python
+scene = render.load_scene(procthor_scene_path(), rgb=False, preserve_instances=True)
+renderer = render.Renderer(width=512, height=512, output="segmentation",
+                           semantic_segmentation=True)  # False selects instance IDs
+renderer.init(scene)
+# Set cameras and render as usual.
+labels = renderer.segmentation()  # uint32; renderer.segmentation_mode identifies the mode
+classes = scene.segmentation_classes  # {class_id: name}, taxonomy: scene.segmentation_taxonomy
+```
+
+Semantic IDs come from AI2THOR-Hab's taxonomy: unknown is `0` (including Ceiling, which has no dataset category); background is `0xFFFFFFFF` in both modes. Instance IDs identify scene instances: use `scene.instance_object(id)` then `scene.object_name(object_index)` for static hits. Overlay instance IDs use the renderer's global slot layout. Semantic IDs must never be used as object indices. Loading remains welded by default for RGB; semantic rendering rejects a welded object containing multiple classes. Assemblies and asset-pool copies retain labels and the taxonomy. Composing conflicting taxonomies requires an explicit remapping before semantic rendering.
+
+Assign labels before `Renderer.init()`: `object.segmentation_class = id`, `scene.set_object_segmentation_class(index, id)`, `assembly.set_segmentation_class(index, id)`, or `pool.set_object_segmentation_class(asset, object_index, id)` retains the current taxonomy and explicitly makes that object's class valid, including welded objects. Assignment rejects IDs absent from that taxonomy. `object.assign_segmentation_class(id, taxonomy="custom", classes={0: "Unknown", 7: "Furniture"})` replaces the taxonomy; omitting taxonomy/classes selects unnamed numeric IDs.
+
+Objects, scenes, assemblies and pools expose `remap_segmentation_classes(mapping, taxonomy="custom", classes={...})`; pools also expose `remap_asset_segmentation_classes(asset, mapping, ...)`. Omitting taxonomy/classes selects unnamed numeric IDs. Mappings must cover every used class, and validation failures leave labels unchanged. Remapping preserves valid class boundaries and rejects mixed-class welded objects; explicitly assign one class first if collapsing their labels is intentional. Remap conflicting sources separately before composition. The C++ equivalents are device-first `assign_segmentation_class` and `remap_segmentation_classes` in `rendering/segmentation_cpu.h`, with a shared immutable target taxonomy (or `nullptr` for unnamed IDs).

{hyperdrone-0.1.5 → hyperdrone-0.1.7}/README.md

@@ -48,11 +48,12 @@ Install the dependencies used by the packaged examples with:
 pip install "hyperdrone[examples]"
 ```
 
-Requirements: CMake >= 3.24, a C++17 compiler, and per feature: assimp (system package)
-for GLB loading, CUDA + OptiX driver for the OptiX render backend and cuda dynamics,
+Requirements: CMake >= 3.24, a C++17 compiler, and git for dependency downloads.
+GLB loading uses the Assimp 6.0.4 release archive with a pinned SHA-256, shared by render and env builds. Cached archives are reused offline and verified by CMake before extraction.
+CUDA + OptiX driver is required for the OptiX render backend and cuda dynamics,
 Vulkan dev + glslang for the VULKAN backend. The WEBGPU backend fetches a hash-pinned
 wgpu-native prebuilt at first build (no extra system packages). Nothing beyond the
-compiler for GENERIC + cpu.
+build toolchain for GENERIC + cpu.
 
 ## Environment
 
@@ -103,6 +104,13 @@ swizzled at load time. Procedural scenes (`render.Scene()` + `render.Object` /
 content via `AssetPool` + `spawn`/`attach`), motion blur, and anti-aliasing follow the
 same API as before under `hyperdrone.render.*`.
 
+Converted ProcTHOR scenes carry ambient `(0.6, 0.6, 0.6)` and a black background in
+`scenes[].extras.rl_tools.environment` (`mode: "solid"`, `ambient` and `background`
+are nonnegative linear RGB triples). Scene loading imports these settings; importing
+objects or assemblies leaves the parent environment alone. Ambient affects `high`
+and `veryhigh`, approximating indirect illumination without light bounces. Override
+imported settings with `scene.set_environment(...)` before `renderer.init(scene)`.
+
 `num_probes` sizes the collision-probe pass (`generate_probe_directions()`, `render("collision")`, `collisions()`; one probe per camera by default). `num_probes=0` compiles that pass out entirely, the counterpart of the probe-ray macro the C++ benchmark targets set: no probe buffers are allocated, the default `render()` target runs only the image channels, and the probe methods raise.
 
 ### Zero-copy I/O (DLPack)
@@ -272,3 +280,21 @@ HYPERDRONE_RENDER_BACKEND=GENERIC .venv/bin/python -m pytest interface/python/hy
 `tests/test_architecture.py` enforces the import DAG (render and dynamics never see each
 other); `scripts/test_sdist.sh` is the self-containment rot guard (build sdist → clean
 venv → vendored-tree render).
+
+For labelled ProcTHOR rendering, preserve GLB root instances and select the output meaning:
+
+```python
+scene = render.load_scene(procthor_scene_path(), rgb=False, preserve_instances=True)
+renderer = render.Renderer(width=512, height=512, output="segmentation",
+                           semantic_segmentation=True)  # False selects instance IDs
+renderer.init(scene)
+# Set cameras and render as usual.
+labels = renderer.segmentation()  # uint32; renderer.segmentation_mode identifies the mode
+classes = scene.segmentation_classes  # {class_id: name}, taxonomy: scene.segmentation_taxonomy
+```
+
+Semantic IDs come from AI2THOR-Hab's taxonomy: unknown is `0` (including Ceiling, which has no dataset category); background is `0xFFFFFFFF` in both modes. Instance IDs identify scene instances: use `scene.instance_object(id)` then `scene.object_name(object_index)` for static hits. Overlay instance IDs use the renderer's global slot layout. Semantic IDs must never be used as object indices. Loading remains welded by default for RGB; semantic rendering rejects a welded object containing multiple classes. Assemblies and asset-pool copies retain labels and the taxonomy. Composing conflicting taxonomies requires an explicit remapping before semantic rendering.
+
+Assign labels before `Renderer.init()`: `object.segmentation_class = id`, `scene.set_object_segmentation_class(index, id)`, `assembly.set_segmentation_class(index, id)`, or `pool.set_object_segmentation_class(asset, object_index, id)` retains the current taxonomy and explicitly makes that object's class valid, including welded objects. Assignment rejects IDs absent from that taxonomy. `object.assign_segmentation_class(id, taxonomy="custom", classes={0: "Unknown", 7: "Furniture"})` replaces the taxonomy; omitting taxonomy/classes selects unnamed numeric IDs.
+
+Objects, scenes, assemblies and pools expose `remap_segmentation_classes(mapping, taxonomy="custom", classes={...})`; pools also expose `remap_asset_segmentation_classes(asset, mapping, ...)`. Omitting taxonomy/classes selects unnamed numeric IDs. Mappings must cover every used class, and validation failures leave labels unchanged. Remapping preserves valid class boundaries and rejects mixed-class welded objects; explicitly assign one class first if collapsing their labels is intentional. Remap conflicting sources separately before composition. The C++ equivalents are device-first `assign_segmentation_class` and `remap_segmentation_classes` in `rendering/segmentation_cpu.h`, with a shared immutable target taxonomy (or `nullptr` for unnamed IDs).

{hyperdrone-0.1.5 → hyperdrone-0.1.7}/hyperdrone/_native/env/CMakeLists.txt

@@ -28,7 +28,7 @@ if(HYPERDRONE_VARIANT STREQUAL "VULKAN")
     find_package(Vulkan REQUIRED COMPONENTS glslangValidator)
 endif()
 
-find_package(assimp REQUIRED)
+unset(FETCHCONTENT_SOURCE_DIR_ASSIMP CACHE)
 add_subdirectory(${RLTOOLS_ROOT} rl_tools EXCLUDE_FROM_ALL)
 set(RL_TOOLS_RENDERING_RAYTRACING_BACKEND_RESOLVED ${HYPERDRONE_VARIANT})
 add_subdirectory(${RLTOOLS_ROOT}/src/rendering/raytracing/backends rl_tools_rt_backends EXCLUDE_FROM_ALL)

{hyperdrone-0.1.5 → hyperdrone-0.1.7}/hyperdrone/_native/render/CMakeLists.txt

@@ -35,9 +35,7 @@ if(HYPERDRONE_VARIANT STREQUAL "VULKAN")
     find_package(Vulkan REQUIRED COMPONENTS glslangValidator)
 endif()
 
-# imported targets are directory-scoped; the backends subtree below needs assimp visible
-# from this scope, not just inside the rl_tools subtree
-find_package(assimp REQUIRED)
+unset(FETCHCONTENT_SOURCE_DIR_ASSIMP CACHE)
 add_subdirectory(${RLTOOLS_ROOT} rl_tools EXCLUDE_FROM_ALL)
 # the resolved-backend variable is directory-scoped inside the rl_tools subtree, so the
 # backends dispatch needs it set again here

{hyperdrone-0.1.5 → hyperdrone-0.1.7}/hyperdrone/_native/render/scene_bindings.cpp

@@ -3,6 +3,7 @@
 #include <nanobind/stl/string.h>
 #include <nanobind/stl/array.h>
 #include <nanobind/stl/vector.h>
+#include <nanobind/stl/map.h>
 
 #include <rl_tools/operations/cpu_mux.h>
 #include <rl_tools/rendering/raytracing/operations_cpu_common.h>
@@ -11,6 +12,8 @@
 #include "bindings.h"
 
 #include <cmath>
+#include <cstdint>
+#include <cstring>
 #include <stdexcept>
 #include <string>
 
@@ -27,22 +30,50 @@ using hyperdrone::make_owned_array;
 
 using DEVICE = rlt::devices::DEVICE_FACTORY<>;
 static DEVICE g_device;
+using rlt::segmentation_taxonomy;
+using rlt::assign_segmentation_class;
+using rlt::remap_segmentation_classes;
 
 // the Python-facing "Scene" is a Bundle: the composed scene plus its loader/computed
 // metadata (bounds, max ray length), which the renderer consumes at init
 using SceneBundle = rlt::rendering::Bundle<float>;
 
-template <typename TARGET>
-static bool load_dispatch(TARGET& target, const std::string& path, int fidelity, bool rgb){
+template <typename TARGET, typename... MODES>
+static bool load_dispatch(TARGET& target, const std::string& path, int fidelity, bool rgb, const MODES&... modes){
+    using rlt::load;
     switch(fidelity){
-        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);
+        case 0: return rgb ? load<rrt::Low, true>(g_device, target, path, modes...) : load<rrt::Low, false>(g_device, target, path, modes...);
+        case 1: return rgb ? load<rrt::Medium, true>(g_device, target, path, modes...) : load<rrt::Medium, false>(g_device, target, path, modes...);
+        case 2: return rgb ? load<rrt::High, true>(g_device, target, path, modes...) : load<rrt::High, false>(g_device, target, path, modes...);
+        case 3: return rgb ? load<rrt::VeryHigh, true>(g_device, target, path, modes...) : load<rrt::VeryHigh, false>(g_device, target, path, modes...);
     }
     throw std::invalid_argument("hyperdrone: fidelity must be in [0, 3]");
 }
 
+template <typename TARGET>
+static std::string taxonomy_name(const TARGET& target){
+    const auto taxonomy = segmentation_taxonomy(g_device, target);
+    return taxonomy ? taxonomy->name : std::string{};
+}
+
+template <typename TARGET>
+static std::map<uint32_t, std::string> class_names(const TARGET& target){
+    const auto taxonomy = segmentation_taxonomy(g_device, target);
+    return taxonomy ? taxonomy->classes : std::map<uint32_t, std::string>{};
+}
+
+static std::shared_ptr<const rlt::rendering::SegmentationTaxonomy> make_taxonomy(const std::string& name, const std::map<uint32_t, std::string>& classes){
+    if(name.empty() && classes.empty()){
+        return nullptr;
+    }
+    return std::make_shared<const rlt::rendering::SegmentationTaxonomy>(rlt::rendering::SegmentationTaxonomy{name, classes});
+}
+
+template <typename TARGET>
+static void remap_labels(TARGET& target, const std::map<uint32_t, uint32_t>& mapping, const std::string& taxonomy, const std::map<uint32_t, std::string>& classes){
+    remap_segmentation_classes(g_device, target, mapping, make_taxonomy(taxonomy, classes));
+}
+
 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){
@@ -149,12 +180,22 @@ void register_scene_bindings(nb::module_& m){
 
     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;
+            rrt::Object value;
+            value.name = name;
+            assign_segmentation_class(g_device, value, segmentation_class);
+            new (object) rrt::Object(std::move(value));
         }, nb::arg("name") = "", nb::arg("segmentation_class") = 0)
         .def_rw("name", &rrt::Object::name)
-        .def_rw("segmentation_class", &rrt::Object::segmentation_class)
+        .def_prop_rw("segmentation_class", [](const rrt::Object& object){ return object.segmentation_class; },
+                     [](rrt::Object& object, uint32_t id){ assign_segmentation_class(g_device, object, id); })
+        .def("assign_segmentation_class", [](rrt::Object& object, uint32_t id, const std::string& taxonomy, const std::map<uint32_t, std::string>& classes){
+            assign_segmentation_class(g_device, object, id, make_taxonomy(taxonomy, classes));
+        }, nb::arg("id"), nb::arg("taxonomy") = "", nb::arg("classes") = std::map<uint32_t, std::string>{},
+           "Assign one class and its taxonomy before init; omitted taxonomy selects unnamed numeric classes.")
+        .def("remap_segmentation_classes", &remap_labels<rrt::Object>, nb::arg("mapping"), nb::arg("taxonomy") = "", nb::arg("classes") = std::map<uint32_t, std::string>{})
+        .def_prop_ro("segmentation_class_valid", [](const rrt::Object& object){ return object.segmentation_class_valid; })
+        .def_prop_ro("segmentation_taxonomy", [](const rrt::Object& object){ return object.segmentation_taxonomy ? object.segmentation_taxonomy->name : std::string{}; })
+        .def_prop_ro("segmentation_classes", [](const rrt::Object& object){ return object.segmentation_taxonomy ? object.segmentation_taxonomy->classes : std::map<uint32_t, std::string>{}; })
         .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(); });
@@ -162,6 +203,8 @@ void register_scene_bindings(nb::module_& m){
     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("segmentation_taxonomy", &taxonomy_name<rrt::ObjectAssembly>)
+        .def_prop_ro("segmentation_classes", &class_names<rrt::ObjectAssembly>)
         .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){
@@ -171,8 +214,9 @@ void register_scene_bindings(nb::module_& m){
         })
         .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;
+            assign_segmentation_class(g_device, assembly, index, segmentation_class);
         })
+        .def("remap_segmentation_classes", &remap_labels<rrt::ObjectAssembly>, nb::arg("mapping"), nb::arg("taxonomy") = "", nb::arg("classes") = std::map<uint32_t, std::string>{})
         .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}));
@@ -183,20 +227,34 @@ void register_scene_bindings(nb::module_& m){
         .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(); });
+        .def_prop_ro("num_assets", [](const rrt::AssetPool& pool){ return pool.assemblies.size(); })
+        .def_prop_ro("segmentation_taxonomy", &taxonomy_name<rrt::AssetPool>)
+        .def_prop_ro("segmentation_classes", &class_names<rrt::AssetPool>)
+        .def("object_segmentation_class", [](const rrt::AssetPool& pool, size_t asset, size_t object){
+            return pool.assemblies.at(asset).objects.at(object).segmentation_class;
+        })
+        .def("set_object_segmentation_class", [](rrt::AssetPool& pool, size_t asset, size_t object, uint32_t id){
+            assign_segmentation_class(g_device, pool, asset, object, id);
+        })
+        .def("remap_segmentation_classes", &remap_labels<rrt::AssetPool>, nb::arg("mapping"), nb::arg("taxonomy") = "", nb::arg("classes") = std::map<uint32_t, std::string>{})
+        .def("remap_asset_segmentation_classes", [](rrt::AssetPool& pool, size_t asset, const std::map<uint32_t, uint32_t>& mapping, const std::string& taxonomy, const std::map<uint32_t, std::string>& classes){
+            remap_labels(pool.assemblies.at(asset), mapping, taxonomy, classes);
+        }, nb::arg("asset"), nb::arg("mapping"), nb::arg("taxonomy") = "", nb::arg("classes") = std::map<uint32_t, std::string>{});
 
     nb::class_<SceneBundle>(m, "Scene")
         .def(nb::init<>())
-        .def("load", [](SceneBundle& bundle, const std::string& path, int fidelity, bool rgb){
+        .def("load", [](SceneBundle& bundle, const std::string& path, int fidelity, bool rgb, bool preserve_instances){
             bool success;
             {
                 nb::gil_scoped_release release;
-                success = load_dispatch(bundle, path, fidelity, rgb);
+                success = preserve_instances
+                    ? load_dispatch(bundle, path, fidelity, rgb, rlt::Mode<rlt::mode::rendering::SceneRoots<>>{})
+                    : load_dispatch(bundle, path, fidelity, rgb);
             }
             if(!success){
                 throw std::runtime_error("hyperdrone: failed to load scene from " + path);
             }
-        }, nb::arg("path"), nb::arg("fidelity") = 2, nb::arg("rgb") = true)
+        }, nb::arg("path"), nb::arg("fidelity") = 2, nb::arg("rgb") = true, nb::arg("preserve_instances") = false)
         .def("add_object", [](SceneBundle& bundle, const rrt::Object& object, nb::object transform){
             if(transform.is_none()){
                 return rlt::add(g_device, bundle.scene, object);
@@ -219,14 +277,41 @@ void register_scene_bindings(nb::module_& m){
             return nb::make_tuple(placement.first_instance, placement.num_instances);
         }, nb::arg("assembly"), nb::arg("transform") = nb::none())
         .def("add_light", [](SceneBundle& bundle, const rrt::SceneLight& light){ bundle.scene.lights.push_back(light); })
+        .def("set_environment", [](SceneBundle& bundle, Vec3 ambient, Vec3 background){
+            const auto valid_component = [](float value){
+                // Bit inspection keeps NaN/Inf validation effective under -ffast-math.
+                uint32_t bits;
+                static_assert(sizeof(bits) == sizeof(value));
+                std::memcpy(&bits, &value, sizeof(bits));
+                volatile uint32_t representation = bits;
+                return (representation & 0x7f800000u) != 0x7f800000u && value >= 0.0f;
+            };
+            for(int component = 0; component < 3; component++){
+                if(!valid_component(ambient[component]) || !valid_component(background[component])){
+                    throw std::invalid_argument("hyperdrone: environment colors must be finite and nonnegative");
+                }
+            }
+            auto& environment = bundle.scene.environment;
+            environment.mode = rrt::Scene::Environment::Mode::SOLID;
+            for(int component = 0; component < 3; component++){
+                environment.ambient[component] = ambient[component];
+                environment.horizon[component] = background[component];
+            }
+        }, nb::arg("ambient") = Vec3{0.1f, 0.1f, 0.1f}, nb::arg("background") = Vec3{0.0f, 0.0f, 0.0f},
+           "Set linear RGB ambient illumination (high/veryhigh) and a solid background before Renderer.init().")
         .def_prop_ro("num_objects", [](const SceneBundle& bundle){ return bundle.scene.objects.size(); })
         .def_prop_ro("num_instances", [](const SceneBundle& bundle){ return bundle.scene.instances.size(); })
         .def_prop_ro("num_lights", [](const SceneBundle& bundle){ return bundle.scene.lights.size(); })
+        .def_prop_ro("segmentation_taxonomy", [](const SceneBundle& bundle){ return taxonomy_name(bundle.scene); })
+        .def_prop_ro("segmentation_classes", [](const SceneBundle& bundle){ return class_names(bundle.scene); })
         .def("object_name", [](const SceneBundle& bundle, size_t index){ return bundle.scene.objects.at(index).name; })
         .def("object_segmentation_class", [](const SceneBundle& bundle, size_t index){ return bundle.scene.objects.at(index).segmentation_class; })
         .def("set_object_segmentation_class", [](SceneBundle& bundle, size_t index, uint32_t segmentation_class){
-            bundle.scene.objects.at(index).segmentation_class = segmentation_class;
+            assign_segmentation_class(g_device, bundle.scene, index, segmentation_class);
         })
+        .def("remap_segmentation_classes", [](SceneBundle& bundle, const std::map<uint32_t, uint32_t>& mapping, const std::string& taxonomy, const std::map<uint32_t, std::string>& classes){
+            remap_labels(bundle.scene, mapping, taxonomy, classes);
+        }, nb::arg("mapping"), nb::arg("taxonomy") = "", nb::arg("classes") = std::map<uint32_t, std::string>{})
         .def("instance_object", [](const SceneBundle& bundle, size_t index){ return bundle.scene.instances.at(index).object; })
         .def("instance_objects", [](const SceneBundle& bundle){
             std::vector<size_t> objects;

{hyperdrone-0.1.5 → hyperdrone-0.1.7}/hyperdrone/_vendor/rl-tools/cmake/autodetect/summary.cmake

@@ -42,6 +42,11 @@ rl_tools_summary_feature("CLI11" RL_TOOLS_ENABLE_CLI11 RL_TOOLS_SUMMARY_CLI11_RE
 rl_tools_summary_feature("bf16" RL_TOOLS_NUMERIC_TYPES_ENABLE_BF16 RL_TOOLS_SUMMARY_BF16_REASON RL_TOOLS_NUMERIC_TYPES_DISABLE_BF16)
 rl_tools_summary_feature("MuJoCo" RL_TOOLS_RL_ENVIRONMENTS_ENABLE_MUJOCO RL_TOOLS_SUMMARY_MUJOCO_REASON RL_TOOLS_RL_ENVIRONMENTS_DISABLE_MUJOCO)
 rl_tools_summary_feature("Raytracing" RL_TOOLS_RENDERING_ENABLE_RAYTRACING RL_TOOLS_SUMMARY_RAYTRACING_REASON RL_TOOLS_RENDERING_DISABLE_RAYTRACING)
+if(TARGET rendering_raytracing_interactive_gamepad)
+    rl_tools_summary_line("Gamepad" ON "gamepad-mapper + SDL3")
+elseif(TARGET rendering_raytracing_interactive)
+    rl_tools_summary_line("Gamepad" OFF "requires RL_TOOLS_GAMEPAD_MAPPER_SOURCE_DIR, SDL3 and JSON")
+endif()
 
 if(RL_TOOLS_DISABLE_TARGETS)
     rl_tools_summary_line("Targets" OFF "disabled by RL_TOOLS_DISABLE_TARGETS")

{hyperdrone-0.1.5 → hyperdrone-0.1.7}/hyperdrone/_vendor/rl-tools/cmake/autodetect/tier2-json-hdf5-zlib.cmake

@@ -7,18 +7,19 @@ if(NOT RL_TOOLS_DISABLE_JSON)
         target_compile_definitions(rl_tools_full INTERFACE RL_TOOLS_ENABLE_JSON)
         set(RL_TOOLS_ENABLE_JSON ON)
         set(RL_TOOLS_SUMMARY_JSON_REASON "system ${nlohmann_json_VERSION}")
-    elseif(GIT_FOUND)
+    else()
+        if(POLICY CMP0135)
+            cmake_policy(SET CMP0135 NEW)
+        endif()
         FetchContent_Declare(nlohmann_json
-                GIT_REPOSITORY https://github.com/nlohmann/json.git
-                GIT_TAG        a0c1318830519eac027a31edec1a99ce1ae5670e
+                URL https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz
+                URL_HASH SHA256=d6c65aca6b1ed68e7a182f4757257b107ae403032760ed6ef121c9d55e81757d
         )
         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)
-        set(RL_TOOLS_SUMMARY_JSON_REASON "FetchContent")
-    else()
-        set(RL_TOOLS_SUMMARY_JSON_REASON "not found and no git")
+        set(RL_TOOLS_SUMMARY_JSON_REASON "FetchContent 3.11.3")
     endif()
 endif()
 
@@ -51,7 +52,8 @@ if(NOT RL_TOOLS_DISABLE_ZLIB)
         set(ZLIB_COMPAT ON)
         FetchContent_Declare(zlib
                 GIT_REPOSITORY https://github.com/zlib-ng/zlib-ng.git
-                GIT_TAG   8d10c309d7d468b9b2ecfd8d5f1b063d6396af17
+                GIT_TAG        2.2.3
+                GIT_SHALLOW    TRUE
         )
         rl_tools_fetchcontent_makeavailable_quiet(zlib)
 

{hyperdrone-0.1.5 → hyperdrone-0.1.7}/hyperdrone/_vendor/rl-tools/cmake/autodetect/tier5-cli11.cmake

@@ -10,7 +10,8 @@ if(NOT RL_TOOLS_DISABLE_CLI11)
     elseif(GIT_FOUND)
         FetchContent_Declare(CLI11
                 GIT_REPOSITORY https://github.com/CLIUtils/CLI11.git
-                GIT_TAG   291c58789c031208f08f4f261a858b5b7083e8e2
+                GIT_TAG        v2.3.2
+                GIT_SHALLOW    TRUE
         )
         rl_tools_fetchcontent_makeavailable_quiet(CLI11)
         target_link_libraries(rl_tools_full INTERFACE CLI11::CLI11)

hyperdrone-0.1.7/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-0.1.7/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-0.1.5 → hyperdrone-0.1.7}/hyperdrone/_vendor/rl-tools/cmake/optional/googletest.cmake

@@ -8,7 +8,8 @@ else()
     if(GIT_FOUND)
         FetchContent_Declare(googletest
                 GIT_REPOSITORY https://github.com/google/googletest.git
-                GIT_TAG   52eb8108c5bdec04579160ae17225d66034bd723
+                GIT_TAG        v1.17.0
+                GIT_SHALLOW    TRUE
         )
         rl_tools_fetchcontent_makeavailable_quiet(googletest)
         set(RL_TOOLS_ENABLE_GTEST ON)
@@ -16,4 +17,4 @@ else()
     else()
         message(VERBOSE "Git not found - GTest disabled")
     endif()
-endif()
+endif()

{hyperdrone-0.1.5 → hyperdrone-0.1.7}/hyperdrone/_vendor/rl-tools/cmake/optional/metal.cmake

@@ -21,7 +21,5 @@ 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-0.1.5 → hyperdrone-0.1.7}/hyperdrone/_vendor/rl-tools/cmake/optional/mujoco.cmake

@@ -8,9 +8,12 @@ if(NOT RL_TOOLS_RL_ENVIRONMENTS_DISABLE_MUJOCO)
         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
-                GIT_REPOSITORY https://github.com/google-deepmind/mujoco.git
-                GIT_TAG   2.3.5
+                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)
@@ -43,18 +46,33 @@ if(NOT RL_TOOLS_RL_ENVIRONMENTS_DISABLE_MUJOCO)
             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)
-                # building glfw from source hard-requires the X11 dev headers on Linux
+            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   3fa2360720eeba1964df3c0ecf4b5df8648a8e52
+                        GIT_TAG        3.4
+                        GIT_SHALLOW    TRUE
                 )
                 rl_tools_fetchcontent_makeavailable_quiet(glfw3)
             endif()

{hyperdrone-0.1.5 → hyperdrone-0.1.7}/hyperdrone/_vendor/rl-tools/cmake/optional/optix.cmake

@@ -21,7 +21,5 @@ FetchContent_Declare(
 )
 rl_tools_fetchcontent_makeavailable_quiet(OWL)
 
-include(cmake/optional/assimp_fixup.cmake)
-
 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-0.1.5 → hyperdrone-0.1.7}/hyperdrone/_vendor/rl-tools/cmake/optional/raytracing.cmake

@@ -1,17 +1,17 @@
 # Raytracing backend dispatch. AUTO probes availability in preference order
 # OPTIX > METAL > VULKAN > WEBGPU > GENERIC; an explicitly selected backend is hard-required.
-# All backends need assimp, so without it raytracing auto-disables entirely.
+# 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()
-    find_package(assimp QUIET)
-    if(NOT assimp_FOUND)
+    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 not found (e.g. apt install libassimp-dev)")
+            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 was not found (e.g. apt install libassimp-dev)")
+            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})
@@ -97,6 +97,7 @@ if(NOT RL_TOOLS_RENDERING_DISABLE_RAYTRACING)
         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()

{hyperdrone-0.1.5 → hyperdrone-0.1.7}/hyperdrone/_vendor/rl-tools/cmake/optional/raytracing_generic.cmake

@@ -1,4 +1,2 @@
-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-0.1.5 → hyperdrone-0.1.7}/hyperdrone/_vendor/rl-tools/cmake/optional/vulkan.cmake

@@ -1,6 +1,4 @@
 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-0.1.5 → hyperdrone-0.1.7}/hyperdrone/_vendor/rl-tools/cmake/optional/webgpu.cmake

@@ -20,7 +20,5 @@ set_target_properties(rl_tools_wgpu_native PROPERTIES
     INTERFACE_LINK_LIBRARIES "${CMAKE_DL_LIBS};pthread;m"
 )
 
-include(cmake/optional/assimp_fixup.cmake)
-
 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)