hyperdrone 0.1.0__tar.gz → 0.1.2__tar.gz

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/.gitignore

@@ -70,6 +70,7 @@
 /.venv*
 /**/.ipynb_checkpoints
 /**/*.ipynb
+!/interface/python/hyperdrone/hyperdrone/examples/simulation.ipynb
 /**/*.pth
 /foundation-model-experiments
 /1k-experiments

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperdrone
-Version: 0.1.0
+Version: 0.1.2
 Summary: The fastest drone simulator and renderer (raytracer).
 Author-email: Jonas Eschmann <jonas.eschmann@gmail.com>
 License: MIT

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/README.md

@@ -48,7 +48,7 @@ GENERIC + cpu.
 |---|---|
 | `HYPERDRONE_RENDER_BACKEND` | `OPTIX` \| `METAL` \| `VULKAN` \| `GENERIC` \| `AUTO` (default: Metal on macOS, OptiX elsewhere) |
 | `HYPERDRONE_DYNAMICS_DEVICE` | `CPU` \| `CUDA` \| `AUTO` (default: cuda when available) |
-| `HYPERDRONE_CACHE_DIR` | cache root (default `~/.cache/hyperdrone`) |
+| `HYPERDRONE_CACHE_DIR` | root for CMake build trees and downloaded build dependencies (default `~/.cache/hyperdrone`) |
 | `HYPERDRONE_RLTOOLS_ROOT` | rl-tools source root override (default: enclosing checkout, else the vendored tree) |
 | `HYPERDRONE_PROCTHOR_PATH` | local ProcTHOR example scene override (otherwise downloaded and cached) |
 | `HYPERDRONE_SKIP_BUILD` | skip the CMake staleness check when the artifacts already exist |
@@ -57,7 +57,9 @@ GENERIC + cpu.
 
 Each component and variant gets its own build tree (`render-optix-*`, `dynamics-cuda-*`,
 ...); switching never invalidates another's cache. All configure/build steps run under a
-per-tree file lock, so many worker processes can share one cache safely.
+per-tree file lock, so many worker processes can share one cache safely. CMake
+FetchContent sources and native build state live in `<cache>/.dependencies`; the native
+build does not write generated files into an editable checkout or installed package.
 
 Whenever a renderer is successfully allocated, RLtools reports the selected backend on
 stderr, for example `#rl_tools::rendering::raytracing: backend=metal`. The
@@ -70,9 +72,9 @@ import math, numpy as np
 from hyperdrone import render
 from hyperdrone.examples.data import procthor_scene_path
 
-scene = render.load_scene(procthor_scene_path(), shading="high")
+scene = render.load_scene(procthor_scene_path(), fidelity="high")
 
-renderer = render.Renderer(width=320, height=240, num_cameras=4, output="rgbd", shading="high")
+renderer = render.Renderer(width=320, height=240, num_cameras=4, output="rgbd", fidelity="high")
 renderer.init(scene)
 
 camera = renderer.camera(position=(0, 0, 1.5), look_at=(1, 0, 1.5), fov=math.radians(80))
@@ -94,9 +96,10 @@ same API as before under `hyperdrone.render.*`.
 ```python
 renderer.frame()                  # snapshot copy (safe to keep)
 renderer.frame(copy=False)        # numpy view of the staging buffer (refreshed in place)
-renderer.frame_dlpack()           # DLPack producer over the LIVE buffer where rendering
-                                  # writes: CUDA device memory on OptiX, CPU elsewhere
-torch.from_dlpack(renderer.frame_dlpack())   # zero-copy GPU tensor on OptiX
+rgba = torch.from_dlpack(renderer.frame_dlpack())
+# live uint8 (num_cameras, height, width, 4), zero-copy GPU tensor on OptiX
+packed = torch.from_dlpack(renderer.frame_raw_dlpack())
+# same memory as packed uint32 (num_cameras, height, width)
 ```
 
 Inputs accept any DLPack producer. CUDA-resident camera input (OptiX):
@@ -133,11 +136,11 @@ variant (cpu or cuda).
 ```python
 from hyperdrone import dynamics, env, render
 
-scene = render.load_scene("warehouse.glb", shading="medium")
+scene = render.load_scene("warehouse.glb", fidelity="medium")
 positions = env.FreeSpaceSampler(scene, clearance=0.5).sample(4096, seed=0)
 
 sim = dynamics.Sim(num_drones=4096, model="crazyflie")
-renderer = render.Renderer(width=64, height=64, num_cameras=4096, output="rgb", shading="medium")
+renderer = render.Renderer(width=64, height=64, num_cameras=4096, output="rgb", fidelity="medium")
 world = env.World(scene, sim, renderer)
 world.spawn(positions)
 frames = world.step(actions).frame()

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/hyperdrone/_native/render/host.cpp

@@ -165,6 +165,12 @@ NB_MODULE(hyperdrone_render_core, m){
             return nb::ndarray<nb::numpy, uint32_t>(pointer, {c.num_cameras, c.height, c.width}, nb::find(&jit));
         }, nb::arg("refresh") = true)
         .def("frame_dlpack", [](JitRenderer& jit){
+            const hdr::Config c = jit->config();
+            uint8_t* pointer = reinterpret_cast<uint8_t*>(jit->frame_buffer_live());
+            return nb::ndarray<>(pointer, {c.num_cameras, c.height, c.width, 4}, nb::find(&jit), {},
+                                 nb::dtype<uint8_t>(), jit->buffer_device_type(), 0);
+        })
+        .def("frame_raw_dlpack", [](JitRenderer& jit){
             const hdr::Config c = jit->config();
             uint32_t* pointer = jit->frame_buffer_live();
             return nb::ndarray<>(pointer, {c.num_cameras, c.height, c.width}, nb::find(&jit), {},

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/hyperdrone/_native/render/scene_bindings.cpp

@@ -28,14 +28,14 @@ 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){
+static bool load_dispatch(TARGET& target, const std::string& path, int fidelity, bool rgb){
+    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);
     }
-    throw std::invalid_argument("hyperdrone: shading must be in [0, 3]");
+    throw std::invalid_argument("hyperdrone: fidelity must be in [0, 3]");
 }
 
 static rrt::Mesh make_mesh(FloatArray vertices, nb::ndarray<const int32_t, nb::c_contig, nb::device::cpu> indices,
@@ -182,16 +182,16 @@ void register_scene_bindings(nb::module_& m){
 
     nb::class_<rrt::Scene>(m, "Scene")
         .def(nb::init<>())
-        .def("load", [](rrt::Scene& scene, const std::string& path, int shading, bool rgb){
+        .def("load", [](rrt::Scene& scene, const std::string& path, int fidelity, bool rgb){
             bool success;
             {
                 nb::gil_scoped_release release;
-                success = load_dispatch(scene, path, shading, rgb);
+                success = load_dispatch(scene, path, fidelity, 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)
+        }, nb::arg("path"), nb::arg("fidelity") = 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);
@@ -232,31 +232,31 @@ void register_scene_bindings(nb::module_& m){
             return make_owned_array(scene.instances.at(index).transform, {3, 4});
         });
 
-    m.def("load_object", [](const std::string& path, int shading, bool rgb){
+    m.def("load_object", [](const std::string& path, int fidelity, bool rgb){
         rrt::Object object;
         bool success;
         {
             nb::gil_scoped_release release;
-            success = load_dispatch(object, path, shading, rgb);
+            success = load_dispatch(object, path, fidelity, 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);
+    }, nb::arg("path"), nb::arg("fidelity") = 2, nb::arg("rgb") = true);
 
-    m.def("load_assembly", [](const std::string& path, int shading, bool rgb){
+    m.def("load_assembly", [](const std::string& path, int fidelity, bool rgb){
         rrt::ObjectAssembly assembly;
         bool success;
         {
             nb::gil_scoped_release release;
-            success = load_dispatch(assembly, path, shading, rgb);
+            success = load_dispatch(assembly, path, fidelity, 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);
+    }, nb::arg("path"), nb::arg("fidelity") = 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);

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/hyperdrone/env/_sampling.py

@@ -18,7 +18,7 @@ class FreeSpaceSampler:
         self._margin = float(margin)
         self._renderer = render.Renderer(
             width=1, height=1, num_cameras=self._batch, num_probes=int(probes),
-            output="depth", shading="low",
+            output="depth", fidelity="low",
         )
         self._renderer.init(scene)
         self._renderer.generate_probe_directions()

hyperdrone-0.1.2/hyperdrone/examples/.gitignore

@@ -0,0 +1 @@
+*.gif

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/hyperdrone/examples/__init__.py

@@ -3,9 +3,14 @@
 Invoke a module with ``python -m hyperdrone.examples.<name>``.
 """
 
-__all__ = ["procthor_scene_path"]
+__all__ = ["procthor_scene_path", "x500_model_path"]
 
 
 def procthor_scene_path():
     from .data import procthor_scene_path as resolve
     return resolve()
+
+
+def x500_model_path():
+    from .data import x500_model_path as resolve
+    return resolve()

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/hyperdrone/examples/benchmark.py

@@ -2,7 +2,7 @@
 (src/rendering/raytracing/benchmark/simulator_matrix.cpp), matching the configuration of
 `rendering_raytracing_sim_benchmark_medium --scene procthor` (render_only cell):
 
-  4096 cameras @ 64x64, medium shading, RGB output, 1 probe, AA/MB off, fov 80 degrees,
+  4096 cameras @ 64x64, medium fidelity, RGB output, 1 probe, AA/MB off, fov 80 degrees,
   all cameras at the fixed FLU eye position [-3.92, -5.67, 1.0] inside the ProcTHOR
   house, per-camera orientations sampled once from a seeded distribution
   (uniform_so3 default), 2s untimed warmup, then a timed async render_launch loop with a
@@ -36,7 +36,7 @@ parser.add_argument("--width", type=int, default=64)
 parser.add_argument("--height", type=int, default=64)
 parser.add_argument("--cameras", type=int, default=4096)
 parser.add_argument("--output", choices=("rgb", "depth"), default="rgb")
-parser.add_argument("--shading", default="medium")
+parser.add_argument("--fidelity", default="medium")
 parser.add_argument("--orientation-mode", choices=("uniform_so3", "random_yaw_pitch", "look_at_scene_jitter"), default="uniform_so3")
 parser.add_argument("--seconds", type=float, default=10.0)
 parser.add_argument("--iterations", type=int, default=0, help="fixed timed iterations; overrides --seconds when > 0")
@@ -121,7 +121,7 @@ def camera_bases(positions, forwards, ups, fov, aspect):
 model = Path(arguments.model) if arguments.model else procthor_scene_path()
 scene_source = str(model)
 if model.exists():
-    scene = render.load_scene(model, shading=arguments.shading)
+    scene = render.load_scene(model, fidelity=arguments.fidelity)
     eye = PROCTHOR_EYE
 else:
     scene_source = "procedural room (GLB not found)"
@@ -129,7 +129,7 @@ else:
     eye = None
 
 renderer = render.Renderer(width=WIDTH, height=HEIGHT, num_cameras=NUM_CAMERAS, num_probes=1,
-                           output=arguments.output, shading=arguments.shading)
+                           output=arguments.output, fidelity=arguments.fidelity)
 renderer.init(scene)
 if eye is None:
     eye = np.asarray(renderer.scene_bounds["center"], dtype=np.float64)
@@ -217,7 +217,7 @@ print("=== BENCHMARK RESULTS (simulator-matrix config, python) ===")
 print(f"  Backend:             {renderer.backend}")
 print(f"  Scene:               {scene_source}")
 print(f"  Output:              {arguments.output}")
-print(f"  Shading:             {arguments.shading}")
+print(f"  Fidelity:             {arguments.fidelity}")
 print(f"  Cameras per batch:   {NUM_CAMERAS}")
 print(f"  Resolution per cam:  {WIDTH}x{HEIGHT}")
 print(f"  FOV:                 {math.degrees(FOV):.1f} deg")

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/hyperdrone/examples/benchmark_minimal.py

@@ -1,6 +1,6 @@
 """Minimal form of benchmark.py's default run — the configuration of
 `rendering_raytracing_sim_benchmark_medium --scene procthor` (render_only, rgb cell):
-4096 static cameras @ 64x64, medium shading, fov 80 degrees, all at one eye position
+4096 static cameras @ 64x64, medium fidelity, fov 80 degrees, all at one eye position
 inside the ProcTHOR house, uniform-SO3 orientations (seed 0), 2s untimed warmup, then a
 timed async render_launch loop with a sync every 10 iterations for ~10 seconds."""
 import math
@@ -18,9 +18,9 @@ FOV = 1.3962634015954636  # 80 degrees, the renderer config default
 EYE = np.array([-3.92, -5.67, 1.0])
 WARMUP_SECONDS, SECONDS, SYNC_INTERVAL = 2.0, 10.0, 10
 
-scene = render.load_scene(procthor_scene_path(), shading="medium")
+scene = render.load_scene(procthor_scene_path(), fidelity="medium")
 renderer = render.Renderer(width=WIDTH, height=HEIGHT, num_cameras=NUM_CAMERAS, num_probes=1,
-                           output="rgb", shading="medium")
+                           output="rgb", fidelity="medium")
 renderer.init(scene)
 
 

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/hyperdrone/examples/data.py

@@ -10,33 +10,56 @@ from hyperdrone import jit
 
 PROCTHOR_FILENAME = "ProcTHOR-Train-1.glb"
 PROCTHOR_REVISION = "db1af73cfd47318df311ed8821caa8e4e0ffeb00"
+X500_FILENAME = "x500.glb"
+X500_REVISION = PROCTHOR_REVISION
 
 
-def procthor_scene_path():
-    """Return the local ProcTHOR scene, downloading and caching it when necessary.
-
-    Resolution order: HYPERDRONE_PROCTHOR_PATH, an rl-tools checkout's tests/data,
-    then Hugging Face's versioned cache under <hyperdrone cache>/huggingface.
-    """
-    override = os.environ.get("HYPERDRONE_PROCTHOR_PATH")
+def _test_data_path(filename, revision, override_variable):
+    override = os.environ.get(override_variable)
     if override:
         path = Path(override).expanduser().resolve()
         if not path.is_file():
             raise FileNotFoundError(
-                f"hyperdrone: HYPERDRONE_PROCTHOR_PATH does not exist: {path}"
+                f"hyperdrone: {override_variable} does not exist: {path}"
             )
         return path
 
-    checkout_path = jit.source_root() / "tests" / "data" / PROCTHOR_FILENAME
+    checkout_path = jit.source_root() / "tests" / "data" / filename
     if checkout_path.is_file():
         return checkout_path
 
     return Path(hf_hub_download(
         repo_id="rl-tools/test-data",
         repo_type="dataset",
-        filename=PROCTHOR_FILENAME,
-        revision=PROCTHOR_REVISION,
+        filename=filename,
+        revision=revision,
         cache_dir=jit.cache_root() / "huggingface",
         local_files_only=bool(os.environ.get("HYPERDRONE_OFFLINE")),
         library_name="hyperdrone",
     ))
+
+
+def procthor_scene_path():
+    """Return the local ProcTHOR scene, downloading and caching it when necessary.
+
+    Resolution order: HYPERDRONE_PROCTHOR_PATH, an rl-tools checkout's tests/data,
+    then Hugging Face's versioned cache under <hyperdrone cache>/huggingface.
+    """
+    return _test_data_path(
+        PROCTHOR_FILENAME,
+        PROCTHOR_REVISION,
+        "HYPERDRONE_PROCTHOR_PATH",
+    )
+
+
+def x500_model_path():
+    """Return the local x500 GLB, downloading and caching it when necessary.
+
+    Resolution order: HYPERDRONE_X500_PATH, an rl-tools checkout's tests/data,
+    then Hugging Face's versioned cache under <hyperdrone cache>/huggingface.
+    """
+    return _test_data_path(
+        X500_FILENAME,
+        X500_REVISION,
+        "HYPERDRONE_X500_PATH",
+    )

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/hyperdrone/examples/drone_flythrough.py

@@ -60,13 +60,13 @@ def build_room(rng, num_pillars=32, half=8.0, height=4.0):
 
 
 if arguments.model and Path(arguments.model).exists():
-    scene = render.load_scene(arguments.model, shading="medium")
+    scene = render.load_scene(arguments.model, fidelity="medium")
 else:
     scene = build_room(np.random.default_rng(0))
 
 sim = dynamics.Sim(num_drones=arguments.drones, model=arguments.drone_model, device=arguments.device)
 renderer = render.Renderer(width=arguments.width, height=arguments.height,
-                           num_cameras=arguments.drones, output="rgb", shading="medium")
+                           num_cameras=arguments.drones, output="rgb", fidelity="medium")
 world = env.World(scene, sim, renderer)
 
 print(f"backend={renderer.backend} dynamics={sim.device} drones={arguments.drones} "

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/hyperdrone/examples/render_procthor.py

@@ -13,8 +13,8 @@ GLB = procthor_scene_path()
 POSITION = np.array([-0.97, -4.42, 1.5])
 YAWS_DEGREES = (150.0, 195.0, 240.0, 285.0)
 
-scene = render.load_scene(GLB, shading="high")
-renderer = render.Renderer(width=320, height=240, num_cameras=len(YAWS_DEGREES), output="rgbd", shading="high")
+scene = render.load_scene(GLB, fidelity="high")
+renderer = render.Renderer(width=320, height=240, num_cameras=len(YAWS_DEGREES), output="rgbd", fidelity="high")
 renderer.init(scene)
 
 cameras = []

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/hyperdrone/jit/_build.py

@@ -1,5 +1,6 @@
 import os
 import subprocess
+from pathlib import Path
 
 from ._lock import FileLock
 from ._patches import seed_dependencies
@@ -34,6 +35,21 @@ def source_dir(component):
     return native_root() / component.name
 
 
+def fetchcontent_base(directory):
+    return (dependencies_root() / directory.name).resolve()
+
+
+def configured_fetchcontent_base(directory):
+    cache_file = directory / "CMakeCache.txt"
+    if not cache_file.exists():
+        return None
+    prefix = "FETCHCONTENT_BASE_DIR:"
+    for line in cache_file.read_text().splitlines():
+        if line.startswith(prefix):
+            return Path(line.split("=", 1)[1]).resolve()
+    return None
+
+
 def configure(component, directory):
     import sys
     seeded = seed_dependencies(directory.name)
@@ -48,7 +64,7 @@ def configure(component, directory):
         f"-DPython_EXECUTABLE={sys.executable}",
         # fully qualified: the rl_tools root CMakeLists cannot append the build-dir
         # basename to an externally-passed value (non-FORCE cache set)
-        f"-DFETCHCONTENT_BASE_DIR={dependencies_root() / directory.name}",
+        f"-DFETCHCONTENT_BASE_DIR={fetchcontent_base(directory)}",
     ]
     for fetch_name, path in sorted(seeded.items()):
         arguments.append(f"-DFETCHCONTENT_SOURCE_DIR_{fetch_name}={path}")
@@ -61,18 +77,21 @@ def configure(component, directory):
 
 def ensure_configured(component):
     directory = build_dir(component)
-    if (directory / "CMakeCache.txt").exists():
+    expected_fetchcontent_base = fetchcontent_base(directory)
+    if configured_fetchcontent_base(directory) == expected_fetchcontent_base:
         return directory
     with lock(component):
-        if not (directory / "CMakeCache.txt").exists():
+        if configured_fetchcontent_base(directory) != expected_fetchcontent_base:
+            fresh = not (directory / "CMakeCache.txt").exists()
             directory.mkdir(parents=True, exist_ok=True)
             try:
                 configure(component, directory)
             except BaseException:
                 # a failed configure must not leave a tree that looks configured; the
                 # FetchContent state lives in .dependencies/ and survives for the retry
-                import shutil
-                shutil.rmtree(directory, ignore_errors=True)
+                if fresh:
+                    import shutil
+                    shutil.rmtree(directory, ignore_errors=True)
                 raise
     return directory
 

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/hyperdrone/jit/_patches.py

@@ -1,6 +1,6 @@
 """Quarantine for third-party dependency workarounds.
 
-Seeding: FetchContent sources land in <source_root>/.dependencies/<build-dir-basename>.
+Seeding: FetchContent sources land in <cache_root>/.dependencies/<build-dir-basename>.
 New build trees are seeded from any already-populated sibling so offline machines work and
 locally patched trees are not silently re-cloned. Seeded sources are handed to CMake via
 FETCHCONTENT_SOURCE_DIR_<NAME> overrides (per-dependency, so everything else still fetches

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/hyperdrone/jit/_workspace.py

@@ -49,15 +49,13 @@ def source_root():
 
 
 def dependencies_root():
-    """FetchContent sources live next to the checkout for repo builds (shared with other
-    build dirs, seedable); for vendored installs they go to the cache — site-packages may
-    be read-only and must never accumulate build state."""
-    root = source_root()
-    try:
-        root.relative_to(package_root())
-        return cache_root() / ".dependencies"
-    except ValueError:
-        return root / ".dependencies"
+    """FetchContent sources and build state live under the configured cache root.
+
+    Source checkouts and installed packages may be read-only; neither should accumulate
+    generated files. Keeping dependencies beside the component build trees also makes
+    HYPERDRONE_CACHE_DIR a complete, relocatable build cache.
+    """
+    return cache_root() / ".dependencies"
 
 
 def workspace_tag():

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/hyperdrone/render/__init__.py

@@ -8,7 +8,7 @@ AUTO default: Metal on macOS, OptiX elsewhere).
 """
 from .. import cuda as _cuda
 from ._component import backend, component, load_core
-from ._config import OUTPUT_MODE, SHADING, RendererConfig
+from ._config import FIDELITY, OUTPUT_MODE, RendererConfig
 from ._renderer import Renderer
 from ._scene import (
     compose_transforms,
@@ -21,6 +21,7 @@ from ._scene import (
 
 __all__ = [
     "AssetPool",
+    "FIDELITY",
     "Mesh",
     "Object",
     "ObjectAssembly",

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/hyperdrone/render/_config.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass
 
 from .. import jit
 
-SHADING = {"low": 0, "medium": 1, "high": 2, "veryhigh": 3}
+FIDELITY = {"low": 0, "medium": 1, "high": 2, "veryhigh": 3}
 OUTPUT_MODE = {"rgb": 0, "rgbd": 1, "depth": 2, "segmentation": 3, "rgbd_segmentation": 4}
 
 RENDER_TARGET = {"all": 0, "rgb": 1, "depth": 2, "segmentation": 3, "rgb_depth": 4, "collision": 5}
@@ -19,7 +19,7 @@ class RendererConfig:
     height: int
     num_cameras: int
     num_probes: int
-    shading: int
+    fidelity: int
     output_mode: int
     motion_blur_samples: int
     anti_aliasing_grid: int
@@ -32,8 +32,8 @@ class RendererConfig:
     def __post_init__(self):
         if self.width < 1 or self.height < 1 or self.num_cameras < 1 or self.num_probes < 1:
             raise ValueError("width, height, num_cameras, and num_probes must be >= 1")
-        if self.shading not in SHADING.values():
-            raise ValueError(f"shading must be one of {sorted(SHADING)}")
+        if self.fidelity not in FIDELITY.values():
+            raise ValueError(f"fidelity must be one of {sorted(FIDELITY)}")
         if self.output_mode not in OUTPUT_MODE.values():
             raise ValueError(f"output must be one of {sorted(OUTPUT_MODE)}")
         if self.motion_blur_samples not in VALID_MOTION_BLUR_SAMPLES:
@@ -64,7 +64,7 @@ class RendererConfig:
         # must match build_config_string() in _native/render/impl.cpp exactly
         return (
             f"w={self.width};h={self.height};nc={self.num_cameras};np={self.num_probes};"
-            f"sh={self.shading};om={self.output_mode};mb={self.motion_blur_samples};aa={self.anti_aliasing_grid};"
+            f"sh={self.fidelity};om={self.output_mode};mb={self.motion_blur_samples};aa={self.anti_aliasing_grid};"
             f"no={self.num_overlays};moi={self.max_overlay_instances};mopc={self.max_overlays_per_camera};"
             f"ss={1 if self.semantic_segmentation else 0};dmb={1 if self.dynamic_motion_blur else 0}"
         )
@@ -78,7 +78,7 @@ class RendererConfig:
             "HYPERDRONE_RENDER_HEIGHT": self.height,
             "HYPERDRONE_RENDER_NUM_CAMERAS": self.num_cameras,
             "HYPERDRONE_RENDER_NUM_PROBES": self.num_probes,
-            "HYPERDRONE_RENDER_SHADING": self.shading,
+            "HYPERDRONE_RENDER_SHADING": self.fidelity,
             "HYPERDRONE_RENDER_OUTPUT_MODE": self.output_mode,
             "HYPERDRONE_RENDER_MB_SAMPLES": self.motion_blur_samples,
             "HYPERDRONE_RENDER_AA_GRID": self.anti_aliasing_grid,

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/hyperdrone/render/_renderer.py

@@ -8,7 +8,7 @@ from ._config import (
     RENDER_PHASE,
     RENDER_TARGET,
     SAVE_TARGET,
-    SHADING,
+    FIDELITY,
     RendererConfig,
 )
 
@@ -67,18 +67,18 @@ class _DLPackBuffer:
 class Renderer:
     """A JIT-compiled instantiation of the RLtools raytracer.
 
-    Compile-time constants (resolution, camera count, output mode, shading tier, motion
+    Compile-time constants (resolution, camera count, output mode, fidelity tier, motion
     blur, anti-aliasing, overlay capacities) are passed here; the first use of a new
     combination compiles a renderer library into the hyperdrone cache, subsequent uses
     load the cached library directly.
     """
 
-    def __init__(self, width, height, num_cameras=1, num_probes=1, output="rgb", shading="high",
+    def __init__(self, width, height, num_cameras=1, num_probes=1, output="rgb", fidelity="high",
                  motion_blur_samples=0, anti_aliasing_grid=0,
                  num_overlays=0, max_overlay_instances=0, max_overlays_per_camera=0,
                  semantic_segmentation=False, dynamic_motion_blur=False):
-        if isinstance(shading, str):
-            shading = SHADING[shading.lower()]
+        if isinstance(fidelity, str):
+            fidelity = FIDELITY[fidelity.lower()]
         if isinstance(output, str):
             output = OUTPUT_MODE[output.lower()]
         self.config = RendererConfig(
@@ -86,7 +86,7 @@ class Renderer:
             height=int(height),
             num_cameras=int(num_cameras),
             num_probes=int(num_probes),
-            shading=shading,
+            fidelity=fidelity,
             output_mode=output,
             motion_blur_samples=max(1, int(motion_blur_samples)),
             anti_aliasing_grid=max(1, int(anti_aliasing_grid)),
@@ -224,12 +224,16 @@ class Renderer:
         return out
 
     def frame_dlpack(self):
-        """DLPack producer over the live packed-RGBA8 buffer where rendering writes it:
-        CUDA device memory on the OptiX backend, CPU-visible memory elsewhere. Zero-copy —
-        consume with torch.from_dlpack / jax.numpy.from_dlpack / np.from_dlpack (CPU only).
-        Valid after render()/render_sync(); overwritten by the next render."""
+        """Live RGBA8 buffer as a zero-copy uint8 DLPack producer with shape
+        (num_cameras, height, width, 4). CUDA device memory on OptiX, CPU-visible memory
+        elsewhere. Valid after render()/render_sync(); overwritten by the next render."""
         return _DLPackBuffer(self, self._renderer.frame_dlpack, self._renderer.buffer_device_type())
 
+    def frame_raw_dlpack(self):
+        """The same live framebuffer in its native packed representation: a zero-copy
+        uint32 DLPack producer with shape (num_cameras, height, width)."""
+        return _DLPackBuffer(self, self._renderer.frame_raw_dlpack, self._renderer.buffer_device_type())
+
     def depth_dlpack(self):
         """DLPack producer over the live depth buffer; see frame_dlpack for semantics."""
         return _DLPackBuffer(self, self._renderer.depth_dlpack, self._renderer.buffer_device_type())

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/hyperdrone/render/_scene.py

@@ -1,25 +1,25 @@
 import math
 
 from ._component import load_core
-from ._config import SHADING
+from ._config import FIDELITY
 
 
-def _shading_id(shading):
-    return SHADING[shading.lower()] if isinstance(shading, str) else int(shading)
+def _fidelity_id(fidelity):
+    return FIDELITY[fidelity.lower()] if isinstance(fidelity, str) else int(fidelity)
 
 
-def load_scene(path, shading="high", rgb=True):
+def load_scene(path, fidelity="high", rgb=True):
     scene = load_core().Scene()
-    scene.load(str(path), _shading_id(shading), bool(rgb))
+    scene.load(str(path), _fidelity_id(fidelity), bool(rgb))
     return scene
 
 
-def load_object(path, shading="high", rgb=True):
-    return load_core().load_object(str(path), _shading_id(shading), bool(rgb))
+def load_object(path, fidelity="high", rgb=True):
+    return load_core().load_object(str(path), _fidelity_id(fidelity), bool(rgb))
 
 
-def load_assembly(path, shading="high", rgb=True):
-    return load_core().load_assembly(str(path), _shading_id(shading), bool(rgb))
+def load_assembly(path, fidelity="high", rgb=True):
+    return load_core().load_assembly(str(path), _fidelity_id(fidelity), bool(rgb))
 
 
 def make_camera(position, look_at, up=(0.0, 0.0, 1.0), fov=math.radians(60.0), aspect=1.0):

{hyperdrone-0.1.0 → hyperdrone-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hyperdrone"
-version = "0.1.0"
+version = "0.1.2"
 authors = [{name = "Jonas Eschmann", email = "jonas.eschmann@gmail.com"}]
 license = {text = "MIT"}
 description = "The fastest drone simulator and renderer (raytracer)."