hyperray 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/environments/hyperdrone/spy/spy.h

@@ -0,0 +1,107 @@
+#include "../../../../version.h"
+#include "../../../../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_ENVIRONMENTS_HYPERDRONE_SPY_SPY_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_ENVIRONMENTS_HYPERDRONE_SPY_SPY_H
+
+#include "../world.h"
+#include "spectator.h"
+#include "ui.h"
+#include <array>
+#include <thread>
+#include <vector>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::environments::hyperdrone {
+    namespace spy {
+        template <typename T_ENVIRONMENT>
+        struct Config {
+            using ENVIRONMENT = T_ENVIRONMENT;
+            using WORLD = typename ENVIRONMENT::ENVIRONMENT;
+            using T = typename WORLD::T;
+            using TI = typename WORLD::TI;
+            using BACKEND = typename WORLD::RENDERER::BACKEND;
+            using SPECTATOR_CONFIG = SpectatorConfig<typename WORLD::RENDERER_CONFIG>;
+            static constexpr TI ATLAS_WIDTH = 1024;
+            static constexpr TI ATLAS_HEIGHT = 1024;
+            static constexpr double REFRESH_INTERVAL = 1.0 / 20.0;
+            static constexpr double UI_REFRESH_INTERVAL = 1.0 / 60.0;
+            static constexpr T MOVE_SPEED = 3;
+        };
+
+        struct Frame {
+            size_t scene_version = 0;
+            size_t sequence = 0;
+            double captured_at = 0;
+            bool valid = false;
+        };
+
+        template <typename T>
+        struct View {
+            T position[3] = {};
+            T yaw = 0;
+            T pitch = 0;
+            size_t scene_version = 0;
+            bool initialized = false;
+        };
+
+        template <typename BACKEND>
+        struct CaptureStorage {};
+
+        template <>
+        struct CaptureStorage<rendering::raytracing::backends::Optix> {
+            struct State;
+            State* state = nullptr;
+        };
+
+        template <typename CONFIG>
+        struct Geometry {
+            static constexpr size_t SLOTS = CONFIG::WORLD::RENDERER_SPEC::MAX_OVERLAY_INSTANCES;
+            rendering::raytracing::Camera<typename CONFIG::T> camera{};
+            OverlaySlot slots[SLOTS > 0 ? SLOTS : 1]{};
+        };
+
+        template <typename CONFIG>
+        struct Buffer {
+            uint32_t* atlas = nullptr;
+            Geometry<CONFIG> geometry{};
+            CaptureStorage<typename CONFIG::BACKEND> capture;
+            std::array<Frame, CONFIG::ENVIRONMENT::NUMBER_OF_ENVIRONMENTS> frames{};
+            SpectatorJob<typename CONFIG::T> job;
+            SpectatorImage image;
+            size_t selected_camera = 0;
+            bool selected_valid = false;
+            bool pending = false;
+        };
+
+        template <typename CONFIG>
+        struct State {
+            ui::Window* window = nullptr;
+            typename CONFIG::ENVIRONMENT* environment = nullptr;
+            Buffer<CONFIG> buffer;
+            Spectator<typename CONFIG::SPECTATOR_CONFIG> spectator;
+            std::vector<View<typename CONFIG::T>> views;
+            std::array<Frame, CONFIG::ENVIRONMENT::NUMBER_OF_ENVIRONMENTS> displayed_frames{};
+            std::thread::id owner;
+            size_t selected_camera = 0;
+            size_t columns = 1;
+            size_t rows = 1;
+            double next_capture = 0;
+            double last_update = 0;
+            double spectator_captured_at = 0;
+            bool reset_camera = true;
+            bool open = false;
+        };
+    }
+
+    template <typename T_CONFIG>
+    struct Spy {
+        using CONFIG = T_CONFIG;
+        spy::State<CONFIG>* state = nullptr;
+        Spy() = default;
+        Spy(const Spy&) = delete;
+        Spy& operator=(const Spy&) = delete;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/environments/hyperdrone/spy/ui.h

@@ -0,0 +1,30 @@
+#include <rl_tools/rl_tools.h>
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_ENVIRONMENTS_HYPERDRONE_SPY_UI_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_ENVIRONMENTS_HYPERDRONE_SPY_UI_H
+
+#include <cstddef>
+#include <cstdint>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::environments::hyperdrone::spy::ui {
+    struct Window;
+    struct Input {
+        std::size_t camera = 0;
+        float forward = 0;
+        float right = 0;
+        float up = 0;
+        float yaw_delta = 0;
+        float pitch_delta = 0;
+        bool reset_camera = false;
+        bool closed = false;
+    };
+
+    Window* create(std::size_t members, std::size_t instances, std::size_t agents, std::size_t cameras_per_agent, int atlas_width, int atlas_height, int columns, int rows, int spectator_width, int spectator_height);
+    Input update(Window* window, double atlas_age, double spectator_age, const char* status);
+    void upload_atlas(Window* window, const std::uint32_t* pixels);
+    void upload_spectator(Window* window, const std::uint32_t* pixels);
+    void destroy(Window* window);
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/environments/hyperdrone/tasks/moving_gate/moving_gate.h

@@ -0,0 +1,103 @@
+#include "../../../../../version.h"
+#include "../../../../../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_ENVIRONMENTS_HYPERDRONE_TASKS_MOVING_GATE_MOVING_GATE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_ENVIRONMENTS_HYPERDRONE_TASKS_MOVING_GATE_MOVING_GATE_H
+
+#include "../../world.h"
+
+#include <string>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::environments::hyperdrone::tasks::moving_gate {
+
+    template <typename T_T, typename T_TI, typename T_NEXT_COMPONENT>
+    struct ComponentSpecification {
+        using T = T_T;
+        using TI = T_TI;
+        using NEXT_COMPONENT = T_NEXT_COMPONENT;
+    };
+    // the gate trajectory: scene-frame center free-space-sampled at reset, fixed facing,
+    // oscillation along the axis
+    template <typename T_SPEC>
+    struct ParametersMovingGate: T_SPEC::NEXT_COMPONENT {
+        using SPEC = T_SPEC;
+        using T = typename SPEC::T;
+        using NEXT_COMPONENT = typename SPEC::NEXT_COMPONENT;
+        T gate_center[3] = {0, 0, 0};
+        T gate_axis[3] = {0, 0, 1};
+        T gate_orientation[4] = {1, 0, 0, 0};  // gate plane normal = orientation-rotated +X
+        T gate_amplitude = 0;
+        T gate_frequency = 0;
+        T gate_aperture_radius = 0;
+    };
+    template <typename T_SPEC>
+    struct StateMovingGate: T_SPEC::NEXT_COMPONENT {
+        using SPEC = T_SPEC;
+        using T = typename SPEC::T;
+        using NEXT_COMPONENT = typename SPEC::NEXT_COMPONENT;
+        static constexpr bool REQUIRES_INTEGRATION = false;
+        static constexpr typename SPEC::TI DIM = 1 + NEXT_COMPONENT::DIM;
+        T gate_phase = 0;
+        bool gate_passed = false;
+        bool gate_crashed = false;
+    };
+
+    template <typename DEVICE, typename PARAMETERS, typename T>
+    RL_TOOLS_FUNCTION_PLACEMENT void gate_pose(DEVICE& device, const PARAMETERS& parameters, T phase, float out[12]){
+        T position[3];
+        T offset = parameters.gate_amplitude * math::sin(device.math, phase);
+        position[0] = parameters.gate_center[0] + offset * parameters.gate_axis[0];
+        position[1] = parameters.gate_center[1] + offset * parameters.gate_axis[1];
+        position[2] = parameters.gate_center[2] + offset * parameters.gate_axis[2];
+        T R[3][3];
+        rl::environments::l2f::quaternion_to_rotation_matrix<DEVICE, T>(parameters.gate_orientation, R);
+        for(unsigned row = 0; row < 3; row++){
+            out[row * 4 + 0] = (float)R[row][0];
+            out[row * 4 + 1] = (float)R[row][1];
+            out[row * 4 + 2] = (float)R[row][2];
+            out[row * 4 + 3] = (float)position[row];
+        }
+    }
+
+    template <typename T_NEXT_WORLD>
+    struct Specification {
+        using NEXT_WORLD = T_NEXT_WORLD;
+        using T = typename NEXT_WORLD::T;
+        using TI = typename NEXT_WORLD::TI;
+        // derive-and-shadow task knobs
+        static constexpr T GATE_AMPLITUDE_MIN = 0.2;
+        static constexpr T GATE_AMPLITUDE_MAX = 0.6;
+        static constexpr T GATE_FREQUENCY_MIN = 0.1;
+        static constexpr T GATE_FREQUENCY_MAX = 0.4;
+        static constexpr T GATE_APERTURE_RADIUS = 0.4;
+        static constexpr T GATE_PASS_REWARD = 10;
+    };
+
+    template <typename T_TASK_SPEC>
+    struct World: T_TASK_SPEC::NEXT_WORLD {
+        using TASK_SPEC = T_TASK_SPEC;
+        using NEXT_WORLD = typename TASK_SPEC::NEXT_WORLD;
+        using T = typename NEXT_WORLD::T;
+        using TI = typename NEXT_WORLD::TI;
+        static_assert(NEXT_WORLD::N_AGENTS == 1, "the moving-gate task is single-agent");
+        static_assert(NEXT_WORLD::RENDERER_CONFIG::NUM_OVERLAYS > 0, "the moving-gate task needs entity slots: set MAX_ENTITY_SLOTS_PER_INSTANCE in the base Specification");
+
+        using Parameters = ParametersMovingGate<ComponentSpecification<T, TI, typename NEXT_WORLD::Parameters>>;
+        using State = StateMovingGate<ComponentSpecification<T, TI, typename NEXT_WORLD::State>>;
+        // privileged contribution for the asymmetric critic: gate-relative position, gate
+        // velocity, phase (sin/cos); the actor stays vision-only
+        static constexpr TI GATE_STATE_DIM = 8;
+        struct ObservationPrivileged {
+            static constexpr TI DIM = NEXT_WORLD::OBSERVATION_DIM_PRIVILEGED + GATE_STATE_DIM;
+            using SHAPE = tensor::Shape<TI, DIM>;
+        };
+        static constexpr TI OBSERVATION_DIM_PRIVILEGED = ObservationPrivileged::DIM;
+
+        std::string gate_asset_path;  // set before init
+        TI entity_kind_index = 0;     // assigned at registration
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/environments/hyperdrone/tasks/moving_gate/operations_cpu.h

@@ -0,0 +1,279 @@
+#include "../../../../../version.h"
+#include "../../../../../rl_tools.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_ENVIRONMENTS_HYPERDRONE_TASKS_MOVING_GATE_OPERATIONS_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_ENVIRONMENTS_HYPERDRONE_TASKS_MOVING_GATE_OPERATIONS_CPU_H
+
+#include "moving_gate.h"
+#include "../../operations_cpu.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    template <typename DEVICE, typename TASK_SPEC>
+    bool set_asset(DEVICE& device, rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>& world, const std::string& name, const std::string& path){
+        if(name == "gate"){
+            world.gate_asset_path = path;
+            return true;
+        }
+        return set_asset(device, static_cast<typename TASK_SPEC::NEXT_WORLD&>(world), name, path);
+    }
+
+    namespace rl::environments::hyperdrone::tasks::moving_gate {
+        template <typename DEVICE, typename TASK_SPEC>
+        RL_TOOLS_FUNCTION_PLACEMENT void drone_scene_position(DEVICE&, const typename World<TASK_SPEC>::Parameters& parameters, const typename World<TASK_SPEC>::State& state, typename TASK_SPEC::T out[3]){
+            using T = typename TASK_SPEC::T;
+            out[0] = parameters.scene_yaw_cos * state.position[0] - parameters.scene_yaw_sin * state.position[1] + parameters.scene_translation[0];
+            out[1] = parameters.scene_yaw_sin * state.position[0] + parameters.scene_yaw_cos * state.position[1] + parameters.scene_translation[1];
+            out[2] = state.position[2] + parameters.scene_translation[2];
+        }
+        // signed distance to the (moving) gate plane and radial offset within it
+        template <typename DEVICE, typename TASK_SPEC>
+        RL_TOOLS_FUNCTION_PLACEMENT void gate_plane_coordinates(DEVICE& device, const typename World<TASK_SPEC>::Parameters& parameters, typename TASK_SPEC::T phase, const typename TASK_SPEC::T position[3], typename TASK_SPEC::T& signed_distance, typename TASK_SPEC::T& radial_distance){
+            using T = typename TASK_SPEC::T;
+            T R[3][3];
+            rl::environments::l2f::quaternion_to_rotation_matrix<DEVICE, T>(parameters.gate_orientation, R);
+            T offset = parameters.gate_amplitude * math::sin(device.math, phase);
+            T relative[3];
+            for(unsigned dim = 0; dim < 3; dim++){
+                relative[dim] = position[dim] - (parameters.gate_center[dim] + offset * parameters.gate_axis[dim]);
+            }
+            // gate local axes are the columns of R; the plane normal is local +X
+            signed_distance = R[0][0] * relative[0] + R[1][0] * relative[1] + R[2][0] * relative[2];
+            T in_plane_y = R[0][1] * relative[0] + R[1][1] * relative[1] + R[2][1] * relative[2];
+            T in_plane_z = R[0][2] * relative[0] + R[1][2] * relative[1] + R[2][2] * relative[2];
+            radial_distance = math::sqrt(device.math, in_plane_y * in_plane_y + in_plane_z * in_plane_z);
+        }
+        // the gate's motion state and interaction flags, advanced after the dynamics step
+        template <typename DEVICE, typename TASK_SPEC>
+        RL_TOOLS_FUNCTION_PLACEMENT void _gate_step(DEVICE& device, const typename World<TASK_SPEC>::Parameters& parameters, const typename World<TASK_SPEC>::State& state, typename World<TASK_SPEC>::State& next_state, typename TASK_SPEC::T dt){
+            using T = typename TASK_SPEC::T;
+            constexpr T TWO_PI = (T)2 * math::PI<T>;
+            T phase = state.gate_phase + TWO_PI * parameters.gate_frequency * dt;
+            phase = phase - math::floor(device.math, phase / TWO_PI) * TWO_PI;
+            next_state.gate_phase = phase;
+            next_state.gate_passed = state.gate_passed;
+            next_state.gate_crashed = state.gate_crashed;
+            T position_before[3], position_after[3];
+            drone_scene_position<DEVICE, TASK_SPEC>(device, parameters, state, position_before);
+            drone_scene_position<DEVICE, TASK_SPEC>(device, parameters, next_state, position_after);
+            T signed_before, radial_before, signed_after, radial_after;
+            gate_plane_coordinates<DEVICE, TASK_SPEC>(device, parameters, state.gate_phase, position_before, signed_before, radial_before);
+            gate_plane_coordinates<DEVICE, TASK_SPEC>(device, parameters, phase, position_after, signed_after, radial_after);
+            if((signed_before <= 0) != (signed_after <= 0)){
+                if(radial_after <= parameters.gate_aperture_radius){
+                    next_state.gate_passed = true;
+                } else {
+                    next_state.gate_crashed = true;
+                }
+            }
+        }
+        template <typename DEVICE, typename TASK_SPEC, typename RNG>
+        RL_TOOLS_FUNCTION_PLACEMENT void _sample_gate(DEVICE& device, const typename World<TASK_SPEC>::NEXT_WORLD::ANNOTATIONS& annotations, typename World<TASK_SPEC>::Parameters& parameters, typename World<TASK_SPEC>::State& state, RNG& rng){
+            using T = typename TASK_SPEC::T;
+            constexpr T TWO_PI = (T)2 * math::PI<T>;
+            auto gate_position = rendering::datasets::annotations::sample_free_position(device, annotations, rng);
+            parameters.gate_center[0] = gate_position.position[0];
+            parameters.gate_center[1] = gate_position.position[1];
+            parameters.gate_center[2] = gate_position.position[2];
+            parameters.gate_axis[0] = 0;
+            parameters.gate_axis[1] = 0;
+            parameters.gate_axis[2] = 1;
+            T facing = gate_position.yaw;
+            parameters.gate_orientation[0] = math::cos(device.math, facing / (T)2);
+            parameters.gate_orientation[1] = 0;
+            parameters.gate_orientation[2] = 0;
+            parameters.gate_orientation[3] = math::sin(device.math, facing / (T)2);
+            parameters.gate_amplitude = random::uniform_real_distribution(device.random, TASK_SPEC::GATE_AMPLITUDE_MIN, TASK_SPEC::GATE_AMPLITUDE_MAX, rng);
+            parameters.gate_frequency = random::uniform_real_distribution(device.random, TASK_SPEC::GATE_FREQUENCY_MIN, TASK_SPEC::GATE_FREQUENCY_MAX, rng);
+            parameters.gate_aperture_radius = TASK_SPEC::GATE_APERTURE_RADIUS;
+            state.gate_phase = random::uniform_real_distribution(device.random, (T)0, TWO_PI, rng);
+            state.gate_passed = false;
+            state.gate_crashed = false;
+        }
+    }
+
+    template <typename DEVICE, typename TASK_SPEC, typename DATASET>
+    void init(DEVICE& device, rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>& world, typename TASK_SPEC::NEXT_WORLD::SharedContext& shared, const DATASET& dataset, const typename DATASET::Corpus& corpus, typename TASK_SPEC::TI first_scene, typename TASK_SPEC::TI num_scenes, typename TASK_SPEC::TI member_index) {
+        using NEXT_WORLD = typename TASK_SPEC::NEXT_WORLD;
+        utils::assert_exit(device, !world.gate_asset_path.empty(), "hyperdrone::tasks::moving_gate: gate_asset_path must be set before init");
+        world.entity_kind_index = register_entity_kind(device, world, shared, world.gate_asset_path);
+        init(device, static_cast<NEXT_WORLD&>(world), shared, dataset, corpus, first_scene, num_scenes, member_index);
+    }
+    template <typename DEVICE, typename TASK_SPEC>
+    void free(DEVICE& device, rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>& world) {
+        using NEXT_WORLD = typename TASK_SPEC::NEXT_WORLD;
+        free(device, static_cast<NEXT_WORLD&>(world));
+    }
+
+    template <typename DEVICE, typename TASK_SPEC, typename RNG>
+    void sample_initial_parameters(DEVICE& device, rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>& world, typename rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>::Parameters& parameters, RNG& rng) {
+        using NEXT_WORLD = typename TASK_SPEC::NEXT_WORLD;
+        sample_initial_parameters(device, static_cast<NEXT_WORLD&>(world), static_cast<typename NEXT_WORLD::Parameters&>(parameters), rng);
+    }
+    // gate trajectory sampling needs the scene (free-space placement), so it rides the state
+    // sampling like the base's scene placement does
+    template <typename DEVICE, typename TASK_SPEC, typename RNG>
+    void sample_initial_state(DEVICE& device, rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>& world, typename rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>::Parameters& parameters, typename rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>::State& state, RNG& rng) {
+        using NEXT_WORLD = typename TASK_SPEC::NEXT_WORLD;
+        sample_initial_state(device, static_cast<NEXT_WORLD&>(world), static_cast<typename NEXT_WORLD::Parameters&>(parameters), static_cast<typename NEXT_WORLD::State&>(state), rng);
+        rl::environments::hyperdrone::tasks::moving_gate::_sample_gate<DEVICE, TASK_SPEC>(device, world.slots[world.active_slot].annotations, parameters, state, rng);
+    }
+    template <typename DEVICE, typename TASK_SPEC, typename PARAMETER_SPEC, typename STATE_SPEC, typename RESET_SPEC, typename RNG>
+    void sample_initial_state(DEVICE& device, rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>& world, Tensor<PARAMETER_SPEC>& parameters, Tensor<STATE_SPEC>& states, const Tensor<RESET_SPEC>& reset_mask, RNG& rng) {
+        using TI = typename TASK_SPEC::TI;
+        using WORLD = rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>;
+        static_assert(utils::typing::is_same_v<typename STATE_SPEC::T, typename WORLD::State>);
+        for (TI instance_i = 0; instance_i < WORLD::INSTANCES; instance_i++) {
+            if (get(device, reset_mask, instance_i)) {
+                sample_initial_state(device, world, get_ref(device, parameters, instance_i), get_ref(device, states, instance_i), rng);
+            }
+        }
+        request_render(device, world, reset_mask);
+    }
+
+    template <typename DEVICE, typename TASK_SPEC, typename PARAMETER_SPEC, typename STATE_SPEC>
+    void prepare_entity_poses(DEVICE& device, rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>& world, Tensor<PARAMETER_SPEC>& parameters, Tensor<STATE_SPEC>& states) {
+        using T = typename TASK_SPEC::T;
+        using TI = typename TASK_SPEC::TI;
+        using WORLD = rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>;
+        using NEXT_WORLD = typename TASK_SPEC::NEXT_WORLD;
+        const auto& kind = world.entity_kinds[world.entity_kind_index];
+        const auto placement = rl::environments::hyperdrone::_entity_placement(world, kind);
+        const float* no_coordinates = nullptr;
+        auto& renderer = get_renderer(device, world);
+        for (TI instance_i = 0; instance_i < WORLD::INSTANCES; instance_i++) {
+            const auto& instance_parameters = get_ref(device, parameters, instance_i);
+            const auto& state = get_ref(device, states, instance_i);
+            float pose[12];
+            rl::environments::hyperdrone::tasks::moving_gate::gate_pose(device, instance_parameters, state.gate_phase, pose);
+            if constexpr (NEXT_WORLD::RENDERER_CONFIG::ENABLE_DYNAMIC_MOTION_BLUR) {
+                float pose_open[12];
+                const T dt = instance_parameters.agents[0].dynamics.integration.dt;
+                constexpr T TWO_PI = (T)2 * math::PI<T>;
+                T phase_open = state.gate_phase - TWO_PI * instance_parameters.gate_frequency * dt * instance_parameters.shutter_fraction;
+                rl::environments::hyperdrone::tasks::moving_gate::gate_pose(device, instance_parameters, phase_open, pose_open);
+                set_transform_pair(device, renderer, rendering::raytracing::OverlayIndex{instance_i}, placement, kind.rig, pose_open, pose, no_coordinates, no_coordinates);
+            } else {
+                set_transform(device, renderer, rendering::raytracing::OverlayIndex{instance_i}, placement, kind.rig, pose, no_coordinates);
+            }
+        }
+    }
+
+    template <typename DEVICE, typename TASK_SPEC, typename PARAMETER_SPEC, typename STATE_SPEC, typename RESET_SPEC>
+    void render(DEVICE& device, rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>& world, Tensor<PARAMETER_SPEC>& parameters, Tensor<STATE_SPEC>& states, const Tensor<RESET_SPEC>& reset_mask_input) {
+        if(!world.render_pending){
+            return;
+        }
+        using NEXT_WORLD = typename TASK_SPEC::NEXT_WORLD;
+        request_render(device, world, reset_mask_input);
+        prepare_entity_poses(device, world, parameters, states);
+        render(device, static_cast<NEXT_WORLD&>(world), parameters, states, world.render_reset);
+    }
+
+    // the gate's motion and interaction flags advance with the environment step
+    template <typename DEVICE, typename TASK_SPEC, typename PARAMETER_SPEC, typename STATE_SPEC, typename ACTION_SPEC, typename NEXT_STATE_SPEC, typename RNG>
+    void step(DEVICE& device, rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>& world, Tensor<PARAMETER_SPEC>& parameters, Tensor<STATE_SPEC>& states, const Tensor<ACTION_SPEC>& actions, Tensor<NEXT_STATE_SPEC>& next_states, RNG& rng) {
+        using T = typename TASK_SPEC::T;
+        using TI = typename TASK_SPEC::TI;
+        using WORLD = rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>;
+        using NEXT_WORLD = typename TASK_SPEC::NEXT_WORLD;
+        if constexpr (NEXT_WORLD::SPEC::HISTORY_LENGTH > 1 || NEXT_WORLD::SPEC::OUTPUT_FLOW){
+            if(world.render_pending){
+                prepare_entity_poses(device, world, parameters, states);
+            }
+        }
+        step(device, static_cast<NEXT_WORLD&>(world), parameters, states, actions, next_states, rng);
+        for (TI instance_i = 0; instance_i < WORLD::INSTANCES; instance_i++) {
+            const auto& instance_parameters = get_ref(device, parameters, instance_i);
+            rl::environments::hyperdrone::tasks::moving_gate::_gate_step<DEVICE, TASK_SPEC>(device, instance_parameters, get_ref(device, states, instance_i), get_ref(device, next_states, instance_i), instance_parameters.agents[0].dynamics.integration.dt);
+        }
+    }
+
+    template <typename DEVICE, typename TASK_SPEC, typename PARAMETER_SPEC, typename STATE_SPEC, typename ACTION_SPEC, typename NEXT_STATE_SPEC, typename REWARD_SPEC, typename RNG>
+    void reward(DEVICE& device, rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>& world, Tensor<PARAMETER_SPEC>& parameters, Tensor<STATE_SPEC>& states, const Tensor<ACTION_SPEC>& actions, Tensor<NEXT_STATE_SPEC>& next_states, Tensor<REWARD_SPEC>& rewards, RNG& rng) {
+        using T = typename TASK_SPEC::T;
+        using TI = typename TASK_SPEC::TI;
+        using WORLD = rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>;
+        using NEXT_WORLD = typename TASK_SPEC::NEXT_WORLD;
+        reward(device, static_cast<NEXT_WORLD&>(world), parameters, states, actions, next_states, rewards, rng);
+        for (TI instance_i = 0; instance_i < WORLD::INSTANCES; instance_i++) {
+            const auto& state = get_ref(device, states, instance_i);
+            const auto& next_state = get_ref(device, next_states, instance_i);
+            if (next_state.gate_passed && !state.gate_passed) {
+                set(device, rewards, get(device, rewards, instance_i) + TASK_SPEC::GATE_PASS_REWARD, instance_i);
+            }
+        }
+    }
+
+    template <typename DEVICE, typename TASK_SPEC, typename PARAMETER_SPEC, typename STATE_SPEC, typename TERMINATED_SPEC, typename RNG>
+    void terminated(DEVICE& device, rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>& world, Tensor<PARAMETER_SPEC>& parameters, Tensor<STATE_SPEC>& states, Tensor<TERMINATED_SPEC>& terminated_flags, RNG& rng) {
+        using TI = typename TASK_SPEC::TI;
+        using WORLD = rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>;
+        using NEXT_WORLD = typename TASK_SPEC::NEXT_WORLD;
+        terminated(device, static_cast<NEXT_WORLD&>(world), parameters, states, terminated_flags, rng);
+        for (TI instance_i = 0; instance_i < WORLD::INSTANCES; instance_i++) {
+            if (get_ref(device, states, instance_i).gate_crashed) {
+                set(device, terminated_flags, true, instance_i);
+            }
+        }
+    }
+
+    template <typename DEVICE, typename TASK_SPEC, typename PARAMETER_SPEC, typename STATE_SPEC, typename OBSERVATION_SPEC, typename RNG>
+    void observe(DEVICE& device, rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>& world, Tensor<PARAMETER_SPEC>& parameters, Tensor<STATE_SPEC>& states, typename TASK_SPEC::NEXT_WORLD::Observation observation_type, Tensor<OBSERVATION_SPEC>& observations, RNG& rng) {
+        using NEXT_WORLD = typename TASK_SPEC::NEXT_WORLD;
+        if(world.render_pending){
+            render(device, world, parameters, states, world.render_reset);
+        }
+        observe(device, static_cast<NEXT_WORLD&>(world), parameters, states, observation_type, observations, rng);
+    }
+
+    // privileged contribution for the asymmetric critic: [dynamics observation | gate state]
+    template <typename DEVICE, typename TASK_SPEC, typename PARAMETER_SPEC, typename STATE_SPEC, typename OBSERVATION_SPEC, typename RNG>
+    void observe(DEVICE& device, rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>& world, Tensor<PARAMETER_SPEC>& parameters, Tensor<STATE_SPEC>& states, typename rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>::ObservationPrivileged, Tensor<OBSERVATION_SPEC>& observations, RNG& rng) {
+        using T = typename TASK_SPEC::T;
+        using TI = typename TASK_SPEC::TI;
+        using WORLD = rl::environments::hyperdrone::tasks::moving_gate::World<TASK_SPEC>;
+        using NEXT_WORLD = typename TASK_SPEC::NEXT_WORLD;
+        static_assert(get<1>(typename OBSERVATION_SPEC::SHAPE{}) == WORLD::OBSERVATION_DIM_PRIVILEGED);
+        constexpr TI BASE_DIM = NEXT_WORLD::OBSERVATION_DIM_PRIVILEGED;
+        auto base_observations = view_range(device, observations, 0, tensor::ViewSpec<1, BASE_DIM>{});
+        observe(device, static_cast<NEXT_WORLD&>(world), parameters, states, typename NEXT_WORLD::ObservationPrivileged{}, base_observations, rng);
+        for (TI instance_i = 0; instance_i < WORLD::INSTANCES; instance_i++) {
+            const auto& instance_parameters = get_ref(device, parameters, instance_i);
+            const auto& state = get_ref(device, states, instance_i);
+            T position[3];
+            rl::environments::hyperdrone::tasks::moving_gate::drone_scene_position<DEVICE, TASK_SPEC>(device, instance_parameters, state, position);
+            T offset = instance_parameters.gate_amplitude * math::sin(device.math, state.gate_phase);
+            T gate_velocity_magnitude = instance_parameters.gate_amplitude * math::cos(device.math, state.gate_phase) * (T)2 * math::PI<T> * instance_parameters.gate_frequency;
+            for (TI dim = 0; dim < 3; dim++) {
+                T gate_position = instance_parameters.gate_center[dim] + offset * instance_parameters.gate_axis[dim];
+                set(device, observations, gate_position - position[dim], instance_i, BASE_DIM + dim);
+                set(device, observations, gate_velocity_magnitude * instance_parameters.gate_axis[dim], instance_i, BASE_DIM + 3 + dim);
+            }
+            set(device, observations, math::sin(device.math, state.gate_phase), instance_i, BASE_DIM + 6);
+            set(device, observations, math::cos(device.math, state.gate_phase), instance_i, BASE_DIM + 7);
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+// ADL entry points: generic composite code dispatches member lifecycle verbs without Tensor
+// arguments, so the task's overloads must be reachable through the member type's namespace
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::environments::hyperdrone::tasks::moving_gate {
+    template <typename DEVICE, typename TASK_SPEC>
+    bool set_asset(DEVICE& device, World<TASK_SPEC>& world, const std::string& name, const std::string& path){
+        return ::rl_tools::set_asset(device, world, name, path);
+    }
+    template <typename DEVICE, typename TASK_SPEC, typename DATASET>
+    void init(DEVICE& device, World<TASK_SPEC>& world, typename TASK_SPEC::NEXT_WORLD::SharedContext& shared, const DATASET& dataset, const typename DATASET::Corpus& corpus, typename TASK_SPEC::TI first_scene, typename TASK_SPEC::TI num_scenes, typename TASK_SPEC::TI member_index){
+        ::rl_tools::init(device, world, shared, dataset, corpus, first_scene, num_scenes, member_index);
+    }
+    template <typename DEVICE, typename TASK_SPEC>
+    void free(DEVICE& device, World<TASK_SPEC>& world){
+        ::rl_tools::free(device, world);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif