hyperdrone 0.1.6__tar.gz → 0.1.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hyperdrone
-Version: 0.1.6
+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

{hyperdrone-0.1.6 → 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.6 → hyperdrone-0.1.7}/hyperdrone/_vendor/rl-tools/src/rendering/raytracing/README.md

@@ -135,6 +135,18 @@ rlt::probe_launch(device, renderer);
 
 The host-verb form of the same step (`advance_flow` → `set_transform`/camera upload → `update` → `render`) is `src/rendering/raytracing/example/flow.cpp`.
 
+## Gamepad flight viewer
+
+`rendering_raytracing_interactive_gamepad` uses [gamepad-mapper](https://github.com/jonas-eschmann/gamepad-mapper) and L2F collective-thrust/body-rate dynamics with the configured rendering backend. With a local mapper checkout, SDL3 (3.2+), JSON, GLFW and OpenGL available, configure and build:
+
+```sh
+cmake -B build -DCMAKE_BUILD_TYPE=Release -DRL_TOOLS_GAMEPAD_MAPPER_SOURCE_DIR=/path/to/gamepad-mapper -DSDL3_DIR=/path/to/SDL3/cmake
+cmake --build build --target rendering_raytracing_interactive_gamepad -j5
+./build/src/rendering/raytracing/example/rendering_raytracing_interactive_gamepad [scene.glb]
+```
+
+The first run calibrates `Roll`, `Pitch`, `Throttle` and `Yaw` on the first connected controller and saves the `rl-tools-flight` profile; `--profile NAME` selects another profile and `--map` recalibrates it. Follow the terminal prompts with roll/yaw right, pitch forward and throttle up. Throttle spans zero to twice the drone's weight (center = hover when level); roll/pitch rates span ±4 rad/s and yaw ±2 rad/s, with a 5% stick deadzone. `P` starts/pauses flight, `R` resets to the initial level pose and pauses, `C` captures a pose, and Escape exits. Disconnection pauses flight; reconnect and restart to resume. The camera follows bank as well as pitch/yaw, and `--record-camera-pose trace.json` records it. Physics runs at fixed 10 ms steps with 1 ms integration substeps; frame stalls contribute at most 100 ms. Scene geometry is visual only: there are no collisions.
+
 ## Backends
 
 | backend | device code | notes |

{hyperdrone-0.1.6 → hyperdrone-0.1.7}/hyperdrone/_vendor/rl-tools/src/rendering/raytracing/example/CMakeLists.txt

@@ -153,6 +153,18 @@ if(glfw3_FOUND AND OpenGL_FOUND)
             OpenGL::GL
     )
 
+    find_path(RL_TOOLS_GAMEPAD_MAPPER_SOURCE_DIR NAMES include/gamepad_mapper/gamepad_mapper.hpp HINTS "${PROJECT_SOURCE_DIR}/../gamepad-mapper" DOC "Path to the gamepad-mapper checkout")
+    find_package(SDL3 3.2 CONFIG QUIET)
+    if(RL_TOOLS_GAMEPAD_MAPPER_SOURCE_DIR AND SDL3_FOUND AND TARGET nlohmann_json::nlohmann_json)
+        add_library(rendering_raytracing_gamepad_mapper STATIC "${RL_TOOLS_GAMEPAD_MAPPER_SOURCE_DIR}/src/gamepad_mapper.cpp")
+        target_include_directories(rendering_raytracing_gamepad_mapper PUBLIC "${RL_TOOLS_GAMEPAD_MAPPER_SOURCE_DIR}/include")
+        target_link_libraries(rendering_raytracing_gamepad_mapper PUBLIC SDL3::SDL3 PRIVATE nlohmann_json::nlohmann_json)
+        target_compile_features(rendering_raytracing_gamepad_mapper PUBLIC cxx_std_17)
+        add_executable(rendering_raytracing_interactive_gamepad interactive.cpp)
+        target_link_libraries(rendering_raytracing_interactive_gamepad PRIVATE RLtools::RLtools rendering_raytracing_backend rendering_raytracing_stb rendering_raytracing_gamepad_mapper glfw OpenGL::GL)
+        target_compile_definitions(rendering_raytracing_interactive_gamepad PRIVATE RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD)
+    endif()
+
     add_executable(rendering_raytracing_interactive_depth EXCLUDE_FROM_ALL interactive.cpp)
     target_link_libraries(rendering_raytracing_interactive_depth
         PRIVATE

hyperdrone-0.1.7/hyperdrone/_vendor/rl-tools/src/rendering/raytracing/example/gamepad/gamepad.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <rl_tools/containers/matrix/persist_code.h>
+#include "../../../../rl/zoo/l2f/environment_ctbr.h"
+#include <rl_tools/numeric_types/policy.h>
+#include <gamepad_mapper/gamepad_mapper.hpp>
+
+namespace rl_tools::rendering::raytracing::interactive_gamepad {
+    struct Input {
+        SDL_Joystick* joystick = nullptr;
+        gamepad_mapper::Mapping mapping;
+        bool initialized = false;
+        bool connected = false;
+    };
+
+    template <typename DEVICE>
+    struct Config {
+        using TYPE_POLICY = numeric_types::Policy<double>;
+        using T = typename TYPE_POLICY::DEFAULT;
+        using TI = typename DEVICE::index_t;
+        using BASE = rl::zoo::l2f::ENVIRONMENT_CTBR_FACTORY<DEVICE, TYPE_POLICY, TI>;
+        static constexpr T DEADZONE = 0.05;
+        static constexpr double DT = 0.01;
+        static constexpr double MAX_FRAME_DT = 0.1;
+        struct STATIC_PARAMETERS: BASE::ENVIRONMENT_STATIC_PARAMETERS {
+            using STATE_BASE = rl::environments::l2f::StateBase<rl::environments::l2f::StateSpecification<T, TI>>;
+            using STATE_CTBR = rl::environments::l2f::StateCTBRController<rl::environments::l2f::StateSpecification<T, TI, STATE_BASE>>;
+            using STATE_TYPE = rl::environments::l2f::StateRotors<rl::environments::l2f::StateRotorsSpecification<T, TI, false, STATE_CTBR>>;
+            static constexpr auto PARAMETER_VALUES = [] {
+                auto parameters = BASE::nominal_parameters;
+                parameters.integration.dt = DT;
+                parameters.mdp.action_noise.normalized_rpm = 0;
+                return parameters;
+            }();
+        };
+        using ENVIRONMENT = rl::environments::Multirotor<rl::environments::l2f::Specification<T, TI, STATIC_PARAMETERS>>;
+        using ACTION = Matrix<matrix::Specification<T, TI, 1, ENVIRONMENT::ACTION_DIM, false>>;
+    };
+
+    template <typename DEVICE>
+    struct Flight {
+        using CONFIG = Config<DEVICE>;
+        typename CONFIG::ENVIRONMENT environment;
+        typename CONFIG::ENVIRONMENT::Parameters parameters;
+        typename CONFIG::ENVIRONMENT::State state, initial_state;
+        typename CONFIG::ACTION action;
+        typename DEVICE::SPEC::RANDOM::template ENGINE<> rng;
+        double accumulator = 0;
+        bool paused = true;
+    };
+}

hyperdrone-0.1.7/hyperdrone/_vendor/rl-tools/src/rendering/raytracing/example/gamepad/operations_cpu.h

@@ -0,0 +1,153 @@
+#pragma once
+
+#include "gamepad.h"
+#include <SDL3/SDL.h>
+#include <algorithm>
+#include <csignal>
+#include <iostream>
+#include <stdexcept>
+
+namespace rl_tools::rendering::raytracing::interactive_gamepad {
+    inline volatile std::sig_atomic_t stopped = 0;
+
+    inline void stop(int) {
+        stopped = 1;
+    }
+}
+
+namespace rl_tools {
+    template <typename DEVICE>
+    void free(DEVICE&, rendering::raytracing::interactive_gamepad::Input& input) {
+        if(input.joystick) {
+            SDL_CloseJoystick(input.joystick);
+            input.joystick = nullptr;
+        }
+        if(input.initialized) {
+            SDL_Quit();
+            input.initialized = false;
+        }
+        input.connected = false;
+    }
+
+    template <typename DEVICE>
+    void init(DEVICE& device, rendering::raytracing::interactive_gamepad::Input& input, const std::string& profile, bool remap) {
+        using namespace rendering::raytracing::interactive_gamepad;
+        SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, "1");
+        SDL_SetHint(SDL_HINT_NO_SIGNAL_HANDLERS, "1");
+        if(!SDL_Init(SDL_INIT_JOYSTICK)) {
+            throw std::runtime_error(SDL_GetError());
+        }
+        input.initialized = true;
+        std::signal(SIGINT, stop);
+        std::signal(SIGTERM, stop);
+        try {
+            int count = 0;
+            auto* ids = SDL_GetJoysticks(&count);
+            auto id = ids && count > 0 ? ids[0] : 0;
+            SDL_free(ids);
+            if(!id) {
+                throw std::runtime_error("No game controller found. Connect a controller and restart.");
+            }
+            input.joystick = SDL_OpenJoystick(id);
+            if(!input.joystick) {
+                throw std::runtime_error(SDL_GetError());
+            }
+            const auto path = gamepad_mapper::profile_path(profile);
+            std::cout << "Gamepad profile: " << path << "\nMap Roll/Pitch/Yaw toward right/forward/right, and Throttle toward maximum thrust.\n";
+            input.mapping = gamepad_mapper::load_or_map(input.joystick, {"Roll", "Pitch", "Throttle", "Yaw"}, {}, remap, path, false, [] { return stopped != 0; });
+            const auto reading = gamepad_mapper::read_gamepad(input.joystick, input.mapping);
+            for(const auto* channel : {"Roll", "Pitch", "Throttle", "Yaw"}) {
+                if(reading.axes.count(channel) != 1) {
+                    throw std::runtime_error(std::string("Gamepad profile is missing ") + channel + "; rerun with --map.");
+                }
+            }
+            input.connected = true;
+        }
+        catch(...) {
+            free(device, input);
+            throw;
+        }
+    }
+
+    template <typename DEVICE>
+    void init(DEVICE& device, rendering::raytracing::interactive_gamepad::Flight<DEVICE>& flight, const float position[3], float yaw) {
+        using CONFIG = typename rendering::raytracing::interactive_gamepad::Flight<DEVICE>::CONFIG;
+        init(device, flight.environment);
+        initial_parameters(device, flight.environment, flight.parameters);
+        initial_state(device, flight.environment, flight.parameters, flight.state);
+        init(device, flight.rng, 0);
+        for(typename CONFIG::TI i = 0; i < 3; i++) {
+            flight.state.position[i] = position[i];
+        }
+        flight.state.orientation[0] = math::cos(device.math, yaw / 2);
+        flight.state.orientation[3] = math::sin(device.math, yaw / 2);
+        const auto& dynamics = flight.parameters.dynamics;
+        for(typename CONFIG::TI i = 0; i < 4; i++) {
+            flight.state.rpm[i] = rotor_command_from_thrust(device, flight.parameters, i, -dynamics.mass * dynamics.gravity[2] / 4);
+        }
+        flight.initial_state = flight.state;
+        flight.accumulator = 0;
+        flight.paused = true;
+    }
+
+    template <typename DEVICE>
+    void reset(DEVICE&, rendering::raytracing::interactive_gamepad::Flight<DEVICE>& flight) {
+        flight.state = flight.initial_state;
+        flight.accumulator = 0;
+        flight.paused = true;
+    }
+
+    template <typename DEVICE>
+    void step(DEVICE& device, rendering::raytracing::interactive_gamepad::Flight<DEVICE>& flight, const gamepad_mapper::State& input, double elapsed) {
+        using CONFIG = typename rendering::raytracing::interactive_gamepad::Flight<DEVICE>::CONFIG;
+        using T = typename CONFIG::T;
+        if(flight.paused) {
+            flight.accumulator = 0;
+            return;
+        }
+        const auto axis = [&](const char* name) {
+            T value = math::clamp(device.math, T(input.axes.at(name)), T(-1), T(1));
+            T magnitude = math::max(device.math, math::abs(device.math, value) - CONFIG::DEADZONE, T(0)) / (1 - CONFIG::DEADZONE);
+            return value < 0 ? -magnitude : magnitude;
+        };
+        const auto& dynamics = flight.parameters.dynamics;
+        T thrust = (axis("Throttle") + 1) * (-dynamics.mass * dynamics.gravity[2]);
+        T collective = rotor_command_from_thrust(device, flight.parameters, typename CONFIG::TI(0), thrust / 4);
+        set(flight.action, 0, 0, 2 * (collective - dynamics.action_limit.min) / (dynamics.action_limit.max - dynamics.action_limit.min) - 1);
+        set(flight.action, 0, 1, axis("Roll"));
+        set(flight.action, 0, 2, axis("Pitch"));
+        set(flight.action, 0, 3, -axis("Yaw"));
+        flight.accumulator += std::clamp(elapsed, 0.0, CONFIG::MAX_FRAME_DT);
+        while(flight.accumulator + 1e-12 >= CONFIG::DT) {
+            typename CONFIG::ENVIRONMENT::State next_state;
+            step(device, flight.environment, flight.parameters, flight.state, flight.action, next_state, flight.rng);
+            flight.state = next_state;
+            flight.accumulator -= CONFIG::DT;
+        }
+    }
+
+    template <typename DEVICE>
+    void step(DEVICE& device, rendering::raytracing::interactive_gamepad::Input& input, rendering::raytracing::interactive_gamepad::Flight<DEVICE>& flight, double elapsed) {
+        if(!input.connected) {
+            flight.paused = true;
+            flight.accumulator = 0;
+            return;
+        }
+        try {
+            auto reading = gamepad_mapper::read_gamepad(input.joystick, input.mapping);
+            SDL_Event event;
+            while(SDL_PollEvent(&event)) {
+                if(event.type == SDL_EVENT_QUIT) {
+                    rendering::raytracing::interactive_gamepad::stopped = 1;
+                }
+            }
+            step(device, flight, reading, elapsed);
+        }
+        catch(const std::exception& error) {
+            input.connected = false;
+            flight.paused = true;
+            flight.accumulator = 0;
+            std::cerr << error.what() << " Flight paused; reconnect the controller and restart.\n";
+        }
+    }
+}

{hyperdrone-0.1.6 → hyperdrone-0.1.7}/hyperdrone/_vendor/rl-tools/src/rendering/raytracing/example/interactive.cpp

@@ -15,6 +15,11 @@
 #include "environment/environment.h"
 #include "environment/operations_cpu.h"
 
+#ifdef RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD
+#include "gamepad/operations_cpu.h"
+#include <metra/metra.h>
+#endif
+
 #include <GLFW/glfw3.h>
 
 #include <conta/conta.h>
@@ -263,6 +268,10 @@ struct InputState {
 
 static InputState g_input;
 static bool g_capture_pose_requested = false;
+#ifdef RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD
+static bool g_reset_flight_requested = false;
+static bool g_pause_flight_requested = false;
+#endif
 #if RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_OUTPUT_MODE == RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_RGBD
 static bool g_show_depth = true;
 #endif
@@ -317,6 +326,10 @@ struct InteractiveOptions {
     std::string record_camera_pose_path;
     float linear_velocity = 3.0f;
     bool help = false;
+#ifdef RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD
+    std::string gamepad_profile = "rl-tools-flight";
+    bool remap_gamepad = false;
+#endif
 };
 
 struct RecordedCameraPose {
@@ -330,11 +343,16 @@ struct RecordedCameraPose {
 };
 
 static void print_usage(const char* argv0) {
+#ifdef RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD
+    std::cerr << "Usage: " << argv0 << " [conta:HASH | scene.glb] [--profile name] [--map] [--record-camera-pose trace.json]\n";
+    std::cerr << "  Gamepad: Roll/Pitch/Yaw body rates, Throttle 0..2x weight (center = hover).\n  P: fly/pause, R: reset and pause, C: capture pose, Esc: exit. No scene collisions.\n";
+#else
     std::cerr << "Usage: " << argv0 << " [conta:HASH | scene.glb] [--record-camera-pose trace.json] [--linear-velocity m/s]" << std::endl;
+#endif
     std::cerr << "  Without arguments the default scene is fetched via conta (downloaded into the cache if required)" << std::endl;
 }
 
-static bool parse_float_arg(const std::string& value, float& out) {
+[[maybe_unused]] static bool parse_float_arg(const std::string& value, float& out) {
     char* end = nullptr;
     const float parsed = std::strtof(value.c_str(), &end);
     if(end == value.c_str() || *end != '\0' || !std::isfinite(parsed)) {
@@ -351,6 +369,16 @@ static bool parse_options(int argc, char** argv, InteractiveOptions& options) {
             options.help = true;
             return true;
         }
+#ifdef RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD
+        if(arg == "--map") {
+            options.remap_gamepad = true;
+            continue;
+        }
+        if(arg == "--profile" && i + 1 < argc) {
+            options.gamepad_profile = argv[++i];
+            continue;
+        }
+#endif
         const std::string record_prefix = "--record-camera-pose=";
         const std::string record_trace_prefix = "--record-camera-trace=";
         const std::string linear_velocity_prefix = "--linear-velocity=";
@@ -367,6 +395,7 @@ static bool parse_options(int argc, char** argv, InteractiveOptions& options) {
         else if(arg.compare(0, record_trace_prefix.size(), record_trace_prefix) == 0) {
             options.record_camera_pose_path = arg.substr(record_trace_prefix.size());
         }
+#ifndef RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD
         else if(arg == "--linear-velocity") {
             if(i + 1 >= argc) {
                 std::cerr << "Missing value for " << arg << std::endl;
@@ -383,6 +412,7 @@ static bool parse_options(int argc, char** argv, InteractiveOptions& options) {
                 return false;
             }
         }
+#endif
         else if(!arg.empty() && arg[0] == '-') {
             std::cerr << "Unknown argument: " << arg << std::endl;
             return false;
@@ -408,7 +438,7 @@ static std::string camera_cache_path(const std::string& scene_path) {
     return cache_dir + "/" + key + ".cam";
 }
 
-static void save_camera_state(const std::string& path, float x, float y, float z, float yaw, float pitch) {
+[[maybe_unused]] static void save_camera_state(const std::string& path, float x, float y, float z, float yaw, float pitch) {
     if (path.empty()) return;
     std::ofstream f(path, std::ios::binary);
     if (f) f.write(reinterpret_cast<const char*>(&x), 4)
@@ -585,6 +615,15 @@ static void key_callback(GLFWwindow* window, int key, int /*scancode*/, int acti
         g_capture_pose_requested = true;
         return;
     }
+#ifdef RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD
+    if(key == GLFW_KEY_R && action == GLFW_PRESS) {
+        g_reset_flight_requested = true;
+    }
+    if(key == GLFW_KEY_P && action == GLFW_PRESS) {
+        g_pause_flight_requested = true;
+    }
+    return;
+#endif
 #if RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_OUTPUT_MODE == RL_TOOLS_RENDERING_RAYTRACING_OUTPUT_RGBD
     if (key == GLFW_KEY_TAB && action == GLFW_PRESS) {
         g_show_depth = !g_show_depth;
@@ -607,7 +646,7 @@ static void key_callback(GLFWwindow* window, int key, int /*scancode*/, int acti
     if (key == GLFW_KEY_LEFT_SHIFT) g_input.down = pressed;
 }
 
-static void cursor_pos_callback(GLFWwindow* /*window*/, double xpos, double ypos) {
+[[maybe_unused]] static void cursor_pos_callback(GLFWwindow* /*window*/, double xpos, double ypos) {
     if (!g_input.cursor_captured) return;
     if (g_input.first_mouse) {
         g_input.last_mouse_x = xpos;
@@ -628,7 +667,7 @@ static void cursor_pos_callback(GLFWwindow* /*window*/, double xpos, double ypos
     if (g_input.pitch < -max_pitch) g_input.pitch = -max_pitch;
 }
 
-static void mouse_button_callback(GLFWwindow* window, int button, int action, int /*mods*/) {
+[[maybe_unused]] static void mouse_button_callback(GLFWwindow* window, int button, int action, int /*mods*/) {
     if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS) {
         if (g_input.cursor_captured) {
             glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
@@ -642,6 +681,12 @@ static void mouse_button_callback(GLFWwindow* window, int button, int action, in
 }
 
 int main(int argc, char** argv) {
+    using rlt::free;
+#ifdef RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD
+    using rlt::init;
+    using rlt::reset;
+    using rlt::step;
+#endif
     using T = float;
     using TI = unsigned int;
     constexpr TI CAM_WIDTH = 1280;
@@ -717,8 +762,28 @@ int main(int argc, char** argv) {
         std::cout << "Restored camera from " << cam_cache << std::endl;
     }
 
+#ifdef RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD
+    rlt::rendering::raytracing::interactive_gamepad::Input gamepad;
+    rlt::rendering::raytracing::interactive_gamepad::Flight<DEVICE> flight;
+    try {
+        init(device, gamepad, options.gamepad_profile, options.remap_gamepad);
+        init(device, flight, state.position, cached_yaw);
+    }
+    catch(const std::exception& error) {
+        std::cerr << error.what() << std::endl;
+        free(device, gamepad);
+        free(device, env);
+        return rlt::rendering::raytracing::interactive_gamepad::stopped ? 0 : 1;
+    }
+    std::cout << "P: fly/pause | R: reset | C: capture pose | Esc: exit\nThrottle: 0..2x weight, centered stick hovers when level. Body rate limits: roll/pitch 4 rad/s, yaw 2 rad/s. No scene collisions.\n";
+#endif
+
     if (!glfwInit()) {
         std::cerr << "Failed to initialize GLFW" << std::endl;
+#ifdef RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD
+        free(device, gamepad);
+#endif
+        free(device, env);
         return 1;
     }
     glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
@@ -726,14 +791,20 @@ int main(int argc, char** argv) {
     if (!window) {
         std::cerr << "Failed to create GLFW window" << std::endl;
         glfwTerminate();
+#ifdef RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD
+        free(device, gamepad);
+#endif
+        free(device, env);
         return 1;
     }
     glfwMakeContextCurrent(window);
     glfwSwapInterval(0);
     glfwSetKeyCallback(window, key_callback);
+#ifndef RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD
     glfwSetCursorPosCallback(window, cursor_pos_callback);
     glfwSetMouseButtonCallback(window, mouse_button_callback);
     glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+#endif
 
     g_input.yaw = cached_yaw;
     g_input.pitch = cached_pitch;
@@ -773,6 +844,9 @@ int main(int argc, char** argv) {
     auto last_time = std::chrono::steady_clock::now();
     const auto trace_start_time = last_time;
     size_t frame_index = 0;
+#ifdef RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD
+    double render_seconds = 0;
+#endif
 
     while (!glfwWindowShouldClose(window)) {
         auto now = std::chrono::steady_clock::now();
@@ -782,6 +856,36 @@ int main(int argc, char** argv) {
 
         glfwPollEvents();
 
+#ifdef RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD
+        if(rlt::rendering::raytracing::interactive_gamepad::stopped) {
+            break;
+        }
+        if(g_reset_flight_requested) {
+            reset(device, flight);
+            g_reset_flight_requested = false;
+        }
+        if(g_pause_flight_requested) {
+            flight.paused = !flight.paused;
+            flight.accumulator = 0;
+            dt = 0;
+            g_pause_flight_requested = false;
+        }
+        step(device, gamepad, flight, dt);
+        glfwSetWindowTitle(window, !gamepad.connected ? "RLtools Gamepad - DISCONNECTED" : flight.paused ? "RLtools Gamepad - PAUSED (P: fly, R: reset)" : "RLtools Gamepad - FLYING (P: pause, R: reset)");
+        using rlt::rl::environments::l2f::rotate_vector_by_quaternion;
+        const T body_forward[3] = {1, 0, 0};
+        const T body_up[3] = {0, 0, 1};
+        const T orientation[4] = {T(flight.state.orientation[0]), T(flight.state.orientation[1]), T(flight.state.orientation[2]), T(flight.state.orientation[3])};
+        T forward[3], up[3], eye[3], look_at[3];
+        rotate_vector_by_quaternion<DEVICE, T>(orientation, body_forward, forward);
+        rotate_vector_by_quaternion<DEVICE, T>(orientation, body_up, up);
+        for(TI i = 0; i < 3; i++) {
+            state.position[i] = eye[i] = flight.state.position[i];
+            look_at[i] = eye[i] + forward[i];
+        }
+        state.yaw = g_input.yaw = std::atan2(forward[1], forward[0]);
+        g_input.pitch = std::asin(std::clamp(forward[2], T(-1), T(1)));
+#else
         float cos_yaw = std::cos(g_input.yaw);
         float sin_yaw = std::sin(g_input.yaw);
         float dx = 0, dy = 0, dz = 0;
@@ -812,6 +916,7 @@ int main(int argc, char** argv) {
             eye[2] + std::sin(g_input.pitch)
         };
         T up[3] = {0, 0, 1};
+#endif
         const auto camera = rlt::make_camera_data(eye, look_at, up, fov, aspect);
 
         if (g_capture_pose_requested) {
@@ -941,12 +1046,18 @@ int main(int argc, char** argv) {
             }
         }
 #else
+#ifdef RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD
+        const auto render_start = std::chrono::steady_clock::now();
+#endif
         rlt::render(device, *env.renderer);
             {
                 rlt::Tensor<typename decltype(env.renderer->frame_buffer)::SPEC> frame_alias;
                 frame_alias._data = pixels.data();
                 rlt::copy(env.renderer->device, device, rlt::frame_buffer(device, *env.renderer), frame_alias);
             }
+#ifdef RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD
+        render_seconds += std::chrono::duration<double>(std::chrono::steady_clock::now() - render_start).count();
+#endif
 #endif
 
         {
@@ -995,7 +1106,14 @@ int main(int argc, char** argv) {
         glfwSwapBuffers(window);
     }
 
+#ifdef RL_TOOLS_RENDERING_RAYTRACING_INTERACTIVE_GAMEPAD
+    if(frame_index > 0) {
+        metra::log("raytracing/interactive_gamepad/render_ms", render_seconds * 1000 / frame_index);
+    }
+    free(device, gamepad);
+#else
     save_camera_state(cam_cache, state.position[0], state.position[1], state.position[2], g_input.yaw, g_input.pitch);
+#endif
     const bool pose_recorded = write_camera_trace_json(
         options.record_camera_pose_path,
         resolved_scene_path,

{hyperdrone-0.1.6 → hyperdrone-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hyperdrone"
-version = "0.1.6"
+version = "0.1.7"
 authors = [{name = "Jonas Eschmann", email = "jonas.eschmann@gmail.com"}]
 license = {text = "MIT"}
 description = "The fastest drone simulator and renderer (raytracer)."
@@ -13,7 +13,7 @@ requires-python = ">=3.9"
 dependencies = ["numpy", "nanobind>=2.0"]
 
 [project.optional-dependencies]
-examples = ["scipy", "matplotlib", "imageio", "imageio-ffmpeg"]
+examples = ["scipy>=1.15", "matplotlib", "imageio", "imageio-ffmpeg"]
 gym = ["gymnasium>=1.0"]
 
 [tool.hatch.build.targets.wheel]