hyperdrone 0.0.1__tar.gz → 0.1.0__tar.gz

hyperdrone-0.1.0/.gitignore

@@ -0,0 +1,91 @@
+/cmake-build-debug
+/cmake-build-release
+/cmake-build-debug-cuda
+/cmake-build-release-clang
+/cmake-build-release-clang-16
+/cmake-build-release-clang-16-package
+/cmake-build-release-gcc11
+/build_test
+/build-coverage
+/cmake-build-*
+/build_export
+/conan_build
+/build_car
+/install
+/test_results
+/conan_provider.cmake
+/**/*tfevents*
+/lightning_logs
+/deepsweep_runs
+.dependencies
+*.dot
+
+
+/.idea
+
+.vscode/settings.json
+
+/**/*.h5
+/**/*.hdf5
+/plots
+/build
+
+
+/**/*.swp
+/Testing
+/tests/docker/context
+/**/*.png
+/logs
+/experiments
+
+/data
+/**/__pycache__
+/**/.gdb_history
+/logs_old
+/MUJOCO_LOG.TXT
+/**/*.tfevents
+
+/build-wasm
+/.vs
+/out
+/build_conan
+/CMakeUserPresets.json
+
+/checkpoints
+/checkpoints_old
+/**/.DS_Store
+/**/*.json
+/tmp
+/lldb_type_dump.txt
+/wandb
+/your_project_name
+/**/*.out
+/**/*.pdf
+/**/*.tar.gz
+/experiments*
+/**/*.nsys-rep
+/**/*.sqlite
+/**/*.qdstrm
+/perf.data
+/.venv*
+/**/.ipynb_checkpoints
+/**/*.ipynb
+/**/*.pth
+/foundation-model-experiments
+/1k-experiments
+/*.tar
+/build*
+/resnet_ast.txt
+/runs
+/videos
+*.bin
+/**/*.glb
+/**/*.mp4
+.cache
+/regression-study
+conta
+.claude
+/**/*.tflite
+/**/*.csv
+raytracing_pose_trace*
+camera_poses.txt

hyperdrone-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: hyperdrone
+Version: 0.1.0
+Summary: The fastest drone simulator and renderer (raytracer).
+Author-email: Jonas Eschmann <jonas.eschmann@gmail.com>
+License: MIT
+Requires-Python: >=3.9
+Requires-Dist: nanobind>=2.0
+Requires-Dist: numpy
+Provides-Extra: examples
+Requires-Dist: huggingface-hub; extra == 'examples'
+Requires-Dist: imageio; extra == 'examples'
+Requires-Dist: imageio-ffmpeg; extra == 'examples'
+Requires-Dist: matplotlib; extra == 'examples'
+Requires-Dist: scipy; extra == 'examples'

hyperdrone-0.1.0/README.md

@@ -0,0 +1,164 @@
+# hyperdrone
+
+Drone simulation stack for RLtools: raytracing renderer, L2F multirotor dynamics, and
+environment setup under one Python package.
+
+| Subpackage | What it is |
+|---|---|
+| `hyperdrone.render` | Raytracing renderer (OptiX / Metal / Vulkan / generic CPU). Self-contained — no dependency on drone dynamics. |
+| `hyperdrone.dynamics` | Vectorized, stateful L2F multirotor simulator (`Sim`); cpu and cuda variants. |
+| `hyperdrone.env` | Environment setup: free-space sampling, spawning, and the `World` wiring of sim + renderer. |
+| `hyperdrone.jit` | Shared compile-and-cache infrastructure both domain packages build on. |
+| `hyperdrone.cuda` | CUDA staging helpers (`upload` → DLPack tensor sets). |
+
+Native components are JIT-compiled per set of compile-time constants (resolution, camera
+count, drone count, ...) into a persistent cache; later uses load the cached library
+directly. `render` and `dynamics` are peers that never import each other — the coupling
+surface is a plain DLPack tensor of packed camera bases, device-resident on OptiX + CUDA.
+
+## Install
+
+From an rl-tools checkout (development):
+
+```bash
+.venv/bin/pip install -e interface/python/hyperdrone
+```
+
+From an sdist (self-contained — bundles the rl-tools headers and raytracing sources, no
+checkout needed):
+
+```bash
+pip install hyperdrone-<version>.tar.gz
+```
+
+Install the dependencies used by the packaged examples with:
+
+```bash
+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,
+Vulkan dev + glslang for the VULKAN backend. Nothing beyond the compiler for
+GENERIC + cpu.
+
+## Environment
+
+| Variable | Meaning |
+|---|---|
+| `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_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 |
+| `HYPERDRONE_OFFLINE` | forbid network during builds (requires seeded/vendored dependencies) |
+| `HYPERDRONE_BUILD_JOBS` | parallel build jobs (default 5) |
+
+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.
+
+Whenever a renderer is successfully allocated, RLtools reports the selected backend on
+stderr, for example `#rl_tools::rendering::raytracing: backend=metal`. The
+`Renderer.backend` property provides the same lowercase name programmatically.
+
+## Rendering
+
+```python
+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")
+
+renderer = render.Renderer(width=320, height=240, num_cameras=4, output="rgbd", shading="high")
+renderer.init(scene)
+
+camera = renderer.camera(position=(0, 0, 1.5), look_at=(1, 0, 1.5), fov=math.radians(80))
+renderer.set_cameras(np.repeat(camera[None], 4, axis=0))
+renderer.render()
+
+rgb   = renderer.frame()    # (4, 240, 320, 4) uint8
+depth = renderer.depth()    # (4, 240, 320) float32
+```
+
+The renderer operates in the L2F FLU frame: +X forward, +Y left, +Z up; GLB assets are
+swizzled at load time. Procedural scenes (`render.Scene()` + `render.Object` /
+`render.Mesh` / `render.SceneLight`), segmentation output, overlays (per-camera dynamic
+content via `AssetPool` + `spawn`/`attach`), motion blur, and anti-aliasing follow the
+same API as before under `hyperdrone.render.*`.
+
+### Zero-copy I/O (DLPack)
+
+```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
+```
+
+Inputs accept any DLPack producer. CUDA-resident camera input (OptiX):
+`set_cameras` dispatches on `__dlpack_device__`, so a CUDA tensor — a torch GPU tensor,
+a set pre-uploaded with `hyperdrone.cuda.upload`, or `Sim.camera_bases()` — is handed
+over device-to-device on the render stream, fully async; `stream=` takes the producer's
+cudaStream_t handle for event-ordered hand-off.
+
+## Dynamics
+
+```python
+from hyperdrone import dynamics
+
+sim = dynamics.Sim(num_drones=4096, model="x500_sim", device="cuda")
+sim.reset(seed=0)                     # deterministic; host-sampled, identical on cpu/cuda
+sim.step(actions)                     # (N, 4) float32 in [-1, 1], host or CUDA tensor
+sim.state["position"]                 # zero-copy DLPack views, CUDA-resident on cuda
+sim.state.numpy("position")           # host copy
+sim.observe()                         # (N, 18): position, rotation matrix, velocities
+sim.parameters["mass"] = masses       # per-drone runtime parameters (until the next reset)
+
+cameras = sim.camera_bases(fov=math.radians(100), aspect=renderer.aspect)
+renderer.set_cameras(cameras, stream=sim.stream)   # device-resident hand-off
+```
+
+`num_drones` and domain randomization are compile-time (the JIT key); the model preset
+(`crazyflie`, `x500_real`, `x500_sim`, `mrs`, ...), integration `dt`, and all physical
+parameters are runtime. `set_compute_mdp(True)` adds reward/termination computation to
+each step (`sim.rewards()`, `sim.terminated()`). One process can use one dynamics
+variant (cpu or cuda).
+
+## Environment setup
+
+```python
+from hyperdrone import dynamics, env, render
+
+scene = render.load_scene("warehouse.glb", shading="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")
+world = env.World(scene, sim, renderer)
+world.spawn(positions)
+frames = world.step(actions).frame()
+```
+
+`FreeSpaceSampler` rides the renderer's collision probes (works on every backend,
+including GENERIC on CPU-only machines) and is deterministic given a seed. `World` is
+sugar, not load-bearing: it wires `sim.step → camera_bases → set_cameras → render` with
+the right streams and nothing else.
+
+End-to-end example: `python -m hyperdrone.examples.drone_flythrough`; renderer benchmark:
+`python -m hyperdrone.examples.benchmark` (flag-compatible with the C++ benchmark
+counterpart).
+
+## Tests
+
+```bash
+HYPERDRONE_RENDER_BACKEND=GENERIC .venv/bin/python -m pytest interface/python/hyperdrone/tests -v
+```
+
+`tests/jit` exercises the build infrastructure against a toy component in seconds;
+`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).

hyperdrone-0.1.0/hatch_build.py

@@ -0,0 +1,38 @@
+"""sdist self-containment: snapshot the required subset of the rl-tools repository into
+hyperdrone/_vendor/rl-tools so `pip install hyperdrone` works without a checkout. The
+manifest is explicit — never "copy everything". Wheels built directly from a checkout skip
+vendoring (they are for local use where the checkout exists); release wheels are built
+from the sdist, where the vendored tree is already on disk."""
+from pathlib import Path
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+VENDOR_MANIFEST = (
+    "include/rl_tools",
+    "src/rendering/raytracing",
+    "CMakeLists.txt",
+    "cmake",
+    "LICENSE",
+)
+
+
+class VendorRlToolsHook(BuildHookInterface):
+    def initialize(self, version, build_data):
+        if self.target_name != "sdist":
+            return
+        repository = self._repository_root()
+        if repository is None:
+            return  # building from an sdist: the vendored tree is already in place
+        force_include = build_data.setdefault("force_include", {})
+        for entry in VENDOR_MANIFEST:
+            source = repository / entry
+            if source.exists():
+                force_include[str(source)] = f"hyperdrone/_vendor/rl-tools/{entry}"
+
+    def _repository_root(self):
+        candidate = Path(self.root)
+        for _ in range(8):
+            if (candidate / "include" / "rl_tools").is_dir():
+                return candidate
+            candidate = candidate.parent
+        return None

hyperdrone-0.1.0/hyperdrone/__init__.py

@@ -0,0 +1,28 @@
+"""hyperdrone — drone simulation stack for RLtools.
+
+Subpackages:
+  hyperdrone.render   — raytracing renderer (self-contained, no drone dynamics)
+  hyperdrone.dynamics — L2F multirotor simulator (vectorized, stateful Sim)
+  hyperdrone.env      — environment setup: scene composition, free-space sampling, spawning
+  hyperdrone.jit      — shared compile-and-cache infrastructure
+  hyperdrone.cuda     — CUDA staging helpers (DLPack tensor sets)
+
+Native components are JIT-compiled per set of compile-time constants and cached under
+~/.cache/hyperdrone (override with HYPERDRONE_CACHE_DIR). Importing hyperdrone (or any
+subpackage) is cheap; the first build happens on first use.
+"""
+import importlib
+
+__version__ = "0.1.0"
+
+_SUBPACKAGES = ("render", "dynamics", "env", "jit", "cuda")
+
+
+def __getattr__(name):
+    if name in _SUBPACKAGES:
+        return importlib.import_module(f".{name}", __name__)
+    raise AttributeError(f"module 'hyperdrone' has no attribute {name}")
+
+
+def __dir__():
+    return sorted(list(globals()) + list(_SUBPACKAGES))

hyperdrone-0.1.0/hyperdrone/_native/cmake/hyperdrone_jit.cmake

@@ -0,0 +1,43 @@
+# Shared JIT machinery: one MODULE target per configs/<key>.txt file in the build tree.
+# Each file holds NAME=VALUE compile definitions written by hyperdrone.jit; the target is
+# named <COMPONENT>_<key> and its artifact lands in <build>/jit/<COMPONENT>_<key>.so.
+#
+# A component may define, before calling this function:
+#   function(hyperdrone_component_libraries DEFINES OUT_LIBRARIES)
+# to map a config's definition list to extra link libraries (set ${OUT_LIBRARIES} in
+# PARENT_SCOPE); used e.g. by render to pick the backend device-program library.
+function(hyperdrone_jit_add_configs)
+    cmake_parse_arguments(ARG "" "COMPONENT" "SOURCES;LINK" ${ARGN})
+    set(config_dir ${CMAKE_BINARY_DIR}/configs)
+    file(MAKE_DIRECTORY ${config_dir})
+    file(GLOB config_files ${config_dir}/*.txt)
+    foreach(config_file IN LISTS config_files)
+        set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${config_file})
+        get_filename_component(config_key ${config_file} NAME_WE)
+        file(STRINGS ${config_file} config_defines)
+        set(target ${ARG_COMPONENT}_${config_key})
+        add_library(${target} MODULE ${ARG_SOURCES})
+        target_include_directories(${target} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/../common)
+        target_compile_definitions(${target} PRIVATE ${config_defines})
+        set(extra_libraries "")
+        if(COMMAND hyperdrone_component_libraries)
+            hyperdrone_component_libraries("${config_defines}" extra_libraries)
+        endif()
+        target_link_libraries(${target} PRIVATE ${ARG_LINK} ${extra_libraries})
+        set_target_properties(${target} PROPERTIES
+            LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/jit
+            PREFIX ""
+        )
+    endforeach()
+endfunction()
+
+# Reads NAME=VALUE from a definitions list into <PREFIX>_<NAME> variables in the caller's
+# scope (helper for hyperdrone_component_libraries implementations).
+function(hyperdrone_jit_parse_defines DEFINES PREFIX)
+    foreach(define IN LISTS DEFINES)
+        string(REGEX MATCH "^([A-Za-z0-9_]+)=(.*)$" _match "${define}")
+        if(_match)
+            set(${PREFIX}_${CMAKE_MATCH_1} "${CMAKE_MATCH_2}" PARENT_SCOPE)
+        endif()
+    endforeach()
+endfunction()

hyperdrone-0.1.0/hyperdrone/_native/common/bindings.h

@@ -0,0 +1,39 @@
+#pragma once
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+
+#include <array>
+#include <cstring>
+#include <stdexcept>
+
+namespace hyperdrone {
+    namespace nb = nanobind;
+
+    using Vec3 = std::array<float, 3>;
+    using Vec4 = std::array<float, 4>;
+    using FloatArray = nb::ndarray<const float, nb::c_contig, nb::device::cpu>;
+    using Transform = nb::ndarray<const float, nb::c_contig, nb::device::cpu>;
+
+    inline void extract_transform(const Transform& transform, float out[12]){
+        if(transform.ndim() == 1 && transform.shape(0) == 12){
+            std::memcpy(out, transform.data(), 12 * sizeof(float));
+        }
+        else if(transform.ndim() == 2 && transform.shape(0) == 3 && transform.shape(1) == 4){
+            std::memcpy(out, transform.data(), 12 * sizeof(float));
+        }
+        else {
+            throw std::invalid_argument("hyperdrone: transform must have shape (12,) or (3, 4)");
+        }
+    }
+
+    inline nb::ndarray<nb::numpy, float> make_owned_array(const float* values, std::initializer_list<size_t> shape){
+        size_t count = 1;
+        for(size_t dim : shape){
+            count *= dim;
+        }
+        float* buffer = new float[count];
+        std::memcpy(buffer, values, count * sizeof(float));
+        nb::capsule owner(buffer, [](void* pointer) noexcept { delete[] (float*)pointer; });
+        return nb::ndarray<nb::numpy, float>(buffer, shape, owner);
+    }
+}

hyperdrone-0.1.0/hyperdrone/_native/common/cuda_staging.h

@@ -0,0 +1,68 @@
+#pragma once
+// GPU staging buffer for device-resident inputs: uploads a host float32 array once; slices
+// along axis 0 are handed out as DLPack CUDA views (e.g. one pre-sampled camera set per
+// slice). Registered by every CUDA-capable component core so hyperdrone.cuda can resolve a
+// provider from whichever domain package is in use.
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <cuda_runtime.h>
+
+#include <stdexcept>
+#include <vector>
+
+namespace hyperdrone {
+    struct CudaBuffer {
+        void* pointer = nullptr;
+        std::vector<size_t> shape;
+
+        explicit CudaBuffer(nanobind::ndarray<const float, nanobind::c_contig, nanobind::device::cpu> source){
+            shape.assign(source.shape_ptr(), source.shape_ptr() + source.ndim());
+            const size_t bytes = source.size() * sizeof(float);
+            if(cudaMalloc(&pointer, bytes) != cudaSuccess){
+                throw std::runtime_error("hyperdrone: cudaMalloc failed");
+            }
+            if(cudaMemcpy(pointer, source.data(), bytes, cudaMemcpyHostToDevice) != cudaSuccess){
+                cudaFree(pointer);
+                pointer = nullptr;
+                throw std::runtime_error("hyperdrone: upload to CUDA device memory failed");
+            }
+        }
+        ~CudaBuffer(){
+            if(pointer != nullptr){
+                cudaFree(pointer);
+            }
+        }
+        CudaBuffer(const CudaBuffer&) = delete;
+        CudaBuffer& operator=(const CudaBuffer&) = delete;
+
+        size_t slice_elements() const {
+            size_t count = 1;
+            for(size_t dimension = 1; dimension < shape.size(); dimension++){
+                count *= shape[dimension];
+            }
+            return count;
+        }
+        const float* slice_pointer(size_t index) const {
+            if(shape.empty() || index >= shape[0]){
+                throw std::out_of_range("hyperdrone: CudaBuffer slice index out of range");
+            }
+            return (const float*)pointer + index * slice_elements();
+        }
+    };
+
+    inline void register_cuda_staging(nanobind::module_& m){
+        namespace nb = nanobind;
+        nb::class_<CudaBuffer>(m, "CudaBuffer")
+            .def(nb::init<nb::ndarray<const float, nb::c_contig, nb::device::cpu>>(), nb::arg("source"))
+            .def_prop_ro("shape", [](const CudaBuffer& buffer){ return buffer.shape; })
+            .def("slice_dlpack", [](CudaBuffer& buffer, size_t index){
+                std::vector<size_t> slice_shape(buffer.shape.begin() + 1, buffer.shape.end());
+                return nb::ndarray<>((void*)buffer.slice_pointer(index), slice_shape.size(), slice_shape.data(),
+                                     nb::find(&buffer), nullptr, nb::dtype<float>(), nb::device::cuda::value, 0);
+            }, nb::arg("index"))
+            .def("dlpack", [](CudaBuffer& buffer){
+                return nb::ndarray<>(buffer.pointer, buffer.shape.size(), buffer.shape.data(),
+                                     nb::find(&buffer), nullptr, nb::dtype<float>(), nb::device::cuda::value, 0);
+            });
+    }
+}

hyperdrone-0.1.0/hyperdrone/_native/common/jit_host.h

@@ -0,0 +1,69 @@
+#pragma once
+// Host side of the JIT ABI seam: dlopen a per-config artifact, resolve its
+// hyperdrone_<component>_* symbols, validate iface version and canonical config string,
+// and manage instance lifetime. Libraries stay loaded for the process lifetime so repeated
+// construction is cheap and CUDA/driver teardown ordering stays trivial.
+#include <dlfcn.h>
+#include <map>
+#include <stdexcept>
+#include <string>
+
+namespace hyperdrone {
+    template <typename IFACE>
+    struct JitLibrary {
+        IFACE* (*create)();
+        void (*destroy)(IFACE*);
+        const char* (*config_string)();
+        int (*iface_version)();
+    };
+
+    template <typename IFACE>
+    JitLibrary<IFACE>& get_jit_library(const std::string& path, const std::string& symbol_prefix, int expected_iface_version){
+        static std::map<std::string, JitLibrary<IFACE>> libraries;
+        auto existing = libraries.find(path);
+        if(existing != libraries.end()){
+            return existing->second;
+        }
+        void* handle = dlopen(path.c_str(), RTLD_NOW | RTLD_LOCAL);
+        if(handle == nullptr){
+            throw std::runtime_error("hyperdrone: failed to load JIT library: " + std::string(dlerror()));
+        }
+        JitLibrary<IFACE> library;
+        library.create = (IFACE* (*)())dlsym(handle, (symbol_prefix + "_create").c_str());
+        library.destroy = (void (*)(IFACE*))dlsym(handle, (symbol_prefix + "_destroy").c_str());
+        library.config_string = (const char* (*)())dlsym(handle, (symbol_prefix + "_config_string").c_str());
+        library.iface_version = (int (*)())dlsym(handle, (symbol_prefix + "_iface_version").c_str());
+        if(library.create == nullptr || library.destroy == nullptr || library.config_string == nullptr || library.iface_version == nullptr){
+            throw std::runtime_error("hyperdrone: JIT library is missing the " + symbol_prefix + "_{create,destroy,config_string,iface_version} symbols: " + path);
+        }
+        if(library.iface_version() != expected_iface_version){
+            throw std::runtime_error("hyperdrone: JIT library was built against iface version "
+                + std::to_string(library.iface_version()) + " but the core module expects "
+                + std::to_string(expected_iface_version) + " (stale cache): " + path);
+        }
+        return libraries.emplace(path, library).first->second;
+    }
+
+    template <typename IFACE>
+    struct JitInstance {
+        IFACE* instance = nullptr;
+        void (*destroy)(IFACE*) = nullptr;
+
+        JitInstance(const std::string& path, const std::string& symbol_prefix, int expected_iface_version, const std::string& expected_config){
+            JitLibrary<IFACE>& library = get_jit_library<IFACE>(path, symbol_prefix, expected_iface_version);
+            const std::string actual_config = library.config_string();
+            if(actual_config != expected_config){
+                throw std::runtime_error("hyperdrone: JIT library config mismatch (expected \"" + expected_config + "\", library reports \"" + actual_config + "\"): " + path);
+            }
+            destroy = library.destroy;
+            instance = library.create();
+        }
+        ~JitInstance(){
+            if(instance != nullptr){
+                destroy(instance);
+            }
+        }
+        JitInstance(const JitInstance&) = delete;
+        JitInstance& operator=(const JitInstance&) = delete;
+    };
+}

hyperdrone-0.1.0/hyperdrone/_native/dynamics/CMakeLists.txt

@@ -0,0 +1,66 @@
+cmake_minimum_required(VERSION 3.24)
+project(hyperdrone_dynamics LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+set(RLTOOLS_ROOT "" CACHE PATH "Path to the rl-tools source root")
+set(HYPERDRONE_VARIANT "CPU" CACHE STRING "Dynamics device (CPU|CUDA)")
+
+if(NOT RLTOOLS_ROOT)
+    message(FATAL_ERROR "RLTOOLS_ROOT must point to the rl-tools source root")
+endif()
+
+set(RL_TOOLS_ENABLE_TARGETS OFF CACHE BOOL "" FORCE)
+set(RL_TOOLS_ENABLE_TESTS OFF CACHE BOOL "" FORCE)
+set(RL_TOOLS_ENABLE_GIT_DIFF OFF CACHE BOOL "" FORCE)
+set(RL_TOOLS_WARNINGS_AS_ERRORS OFF CACHE BOOL "" FORCE)
+
+if(HYPERDRONE_VARIANT STREQUAL "CUDA")
+    enable_language(CUDA)
+    set(CMAKE_CUDA_STANDARD 17)
+    set(CMAKE_CUDA_STANDARD_REQUIRED ON)
+    if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
+        set(CMAKE_CUDA_ARCHITECTURES native)
+    endif()
+endif()
+
+add_subdirectory(${RLTOOLS_ROOT} rl_tools EXCLUDE_FROM_ALL)
+
+find_package(Python COMPONENTS Interpreter Development.Module REQUIRED)
+execute_process(
+    COMMAND ${Python_EXECUTABLE} -m nanobind --cmake_dir
+    OUTPUT_VARIABLE nanobind_DIR
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    COMMAND_ERROR_IS_FATAL ANY
+)
+find_package(nanobind CONFIG REQUIRED)
+
+nanobind_add_module(hyperdrone_dynamics_core host.cpp)
+target_include_directories(hyperdrone_dynamics_core PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../common)
+target_link_libraries(hyperdrone_dynamics_core PRIVATE ${CMAKE_DL_LIBS})
+set_target_properties(hyperdrone_dynamics_core PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+
+set(HYPERDRONE_DYNAMICS_EXTRA_LINK "")
+if(HYPERDRONE_VARIANT STREQUAL "CUDA")
+    find_package(CUDAToolkit REQUIRED)
+    target_compile_definitions(hyperdrone_dynamics_core PRIVATE HYPERDRONE_DYNAMICS_CUDA=1)
+    target_link_libraries(hyperdrone_dynamics_core PRIVATE CUDA::cudart)
+    add_compile_definitions(HYPERDRONE_DYNAMICS_CUDA=1)
+    set_source_files_properties(impl.cpp PROPERTIES LANGUAGE CUDA)
+else()
+    # per-drone parallelism on the CPU variant; drones are independent, so this stays
+    # deterministic for a fixed seed
+    find_package(OpenMP QUIET)
+    if(OpenMP_CXX_FOUND)
+        set(HYPERDRONE_DYNAMICS_EXTRA_LINK OpenMP::OpenMP_CXX)
+    endif()
+endif()
+
+include(${CMAKE_CURRENT_SOURCE_DIR}/../cmake/hyperdrone_jit.cmake)
+hyperdrone_jit_add_configs(
+    COMPONENT dynamics
+    SOURCES impl.cpp
+    LINK RLtools::RLtools ${HYPERDRONE_DYNAMICS_EXTRA_LINK}
+)