hyperdrone 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,2119 @@
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_ENVIRONMENTS_L2F_OPERATIONS_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_ENVIRONMENTS_L2F_OPERATIONS_CPU_H
+#include "operations_generic.h"
+
+#ifdef RL_TOOLS_ENABLE_JSON
+#include <nlohmann/json.hpp>
+#endif
+
+#include <random>
+#include <string>
+// Why no JSON library? introduces a dependency and increases the compile time (massively in case of e.g. nlohmann::json)
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace rl::environments::l2f::obs_helper{
+        template <typename DEVICE, typename ENV, typename OBS>
+        auto dispatch(DEVICE& device, const ENV& env, const OBS& obs, bool first = true);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::LastComponent<OBS_SPEC>& obs, bool first = true){
+        return "";
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::Multiplex<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::Multiplex<OBS_SPEC>;
+        std::string output;
+        if constexpr(OBS_SPEC::ENABLE){
+            output += rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::CURRENT_COMPONENT{}, first);
+            first = false;
+        }
+        output += rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, first);
+        return output;
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::Position<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::Position<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "Position" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::OrientationQuaternion<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::OrientationQuaternion<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "OrientationQuaternion" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::OrientationRotationMatrix<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::OrientationRotationMatrix<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "OrientationRotationMatrix" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::OrientationWorldZ<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::OrientationWorldZ<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "OrientationWorldZ" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::OrientationMahonyWorldZ<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::OrientationMahonyWorldZ<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "OrientationMahonyWorldZ" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::LinearVelocity<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::LinearVelocity<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "LinearVelocity" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::AngularVelocity<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::AngularVelocity<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "AngularVelocity" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::LinearAccelerationBodyFrame<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::LinearAccelerationBodyFrame<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "LinearAccelerationBodyFrame" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::LinearAccelerationBodyFrameHistory<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::LinearAccelerationBodyFrameHistory<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "LinearAccelerationBodyFrameHistory(" + std::to_string(OBSERVATION::HISTORY_LENGTH) + ")" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::LinearVelocityBodyFrame<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::LinearVelocityBodyFrame<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "LinearVelocityBodyFrame" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::Magnetometer<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::Magnetometer<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "Magnetometer" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::AngularVelocityDelayed<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::AngularVelocityDelayed<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "AngularVelocityDelayed(" + std::to_string(OBS_SPEC::DELAY) + ")" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::PoseIntegral<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::PoseIntegral<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "PoseIntegral" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::RotorSpeeds<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::RotorSpeeds<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "RotorSpeeds" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::ActionHistory<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::ActionHistory<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "ActionHistory(" + std::to_string(OBSERVATION::HISTORY_LENGTH) + ")" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::RandomForce<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::RandomForce<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "RandomForce" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::ParametersMotorPosition<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::ParametersMotorPosition<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "ParametersMotorPosition" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::ParametersThrustCurves<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::ParametersThrustCurves<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "ParametersThrustCurves" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::ParametersMass<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::ParametersMass<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "ParametersMass" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::ParametersInertia<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::ParametersInertia<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "ParametersInertia" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::TrajectoryTrackingPosition<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::TrajectoryTrackingPosition<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "TrajectoryTrackingPosition" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::TrajectoryTrackingLinearVelocity<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::TrajectoryTrackingLinearVelocity<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "TrajectoryTrackingLinearVelocity" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    template <typename DEVICE, typename SPEC, typename OBS_SPEC>
+    std::string string(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::observation::TrajectoryTrackingLookahead<OBS_SPEC>& obs, bool first = true){
+        using OBSERVATION = rl::environments::l2f::observation::TrajectoryTrackingLookahead<OBS_SPEC>;
+        return std::string(first ? "" : ".") + "TrajectoryTrackingLookahead(" + std::to_string(OBS_SPEC::N_STEPS) + ", " + std::to_string(OBS_SPEC::INTERVAL) + ")" + rl::environments::l2f::obs_helper::dispatch(device, env, typename OBSERVATION::NEXT_COMPONENT{}, false);
+    }
+    namespace rl::environments::l2f::obs_helper{
+        template <typename DEVICE, typename ENV, typename OBS>
+        auto dispatch(DEVICE& device, const ENV& env, const OBS& obs, bool first){
+            return string(device, env, obs, first);
+        }
+    }
+    template <typename DEVICE, typename SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env){
+        using ENVIRONMENT = rl::environments::Multirotor<SPEC>;
+        std::string json_string = "{";
+        json_string += "\"name\": \"l2f\",";
+        json_string += "\"observation\": \"";
+        json_string += rl_tools::string(device, env, typename ENVIRONMENT::Observation{});
+        json_string += "\"}";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename T_T, typename T_TI, T_TI N>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::parameters::Dynamics<T_T, T_TI, N>& parameters){
+        using T = typename SPEC::T;
+        using TI = typename DEVICE::index_t;
+
+        std::string json_string = "{";
+        json_string += "\"rotor_positions\": [";
+        for (TI i = 0; i < N; i++){
+            json_string += "[" + std::to_string(parameters.rotor_positions[i][0]) + ", " + std::to_string(parameters.rotor_positions[i][1]) + ", " + std::to_string(parameters.rotor_positions[i][2]) + "]";
+            if (i < N - 1) {
+                json_string += ", ";
+            }
+        }
+        json_string += "], ";
+
+        json_string += "\"rotor_thrust_directions\": [";
+        for (TI i = 0; i < N; i++){
+            json_string += "[" + std::to_string(parameters.rotor_thrust_directions[i][0]) + ", " + std::to_string(parameters.rotor_thrust_directions[i][1]) + ", " + std::to_string(parameters.rotor_thrust_directions[i][2]) + "]";
+            if (i < N - 1) {
+                json_string += ", ";
+            }
+        }
+        json_string += "], ";
+
+        json_string += "\"rotor_torque_directions\": [";
+        for (TI i = 0; i < N; i++){
+            json_string += "[" + std::to_string(parameters.rotor_torque_directions[i][0]) + ", " + std::to_string(parameters.rotor_torque_directions[i][1]) + ", " + std::to_string(parameters.rotor_torque_directions[i][2]) + "]";
+            if (i < N - 1) {
+                json_string += ", ";
+            }
+        }
+        json_string += "], ";
+
+        json_string += "\"rotor_thrust_coefficients\": [";
+        for (TI i = 0; i < N; i++){
+            json_string += "[" + std::to_string(parameters.rotor_thrust_coefficients[i][0]) + ", " + std::to_string(parameters.rotor_thrust_coefficients[i][1]) + ", " + std::to_string(parameters.rotor_thrust_coefficients[i][2]) + "]";
+            if (i < N - 1) {
+                json_string += ", ";
+            }
+        }
+        json_string += "], ";
+
+        json_string += "\"rotor_torque_constants\": [";
+        for (TI i = 0; i < N; i++){
+            json_string += std::to_string(parameters.rotor_torque_constants[i]);
+            if (i < N - 1) {
+                json_string += ", ";
+            }
+        }
+        json_string += "], ";
+
+        json_string += "\"rotor_time_constants_rising\": [";
+        for (TI i = 0; i < N; i++){
+            json_string += std::to_string(parameters.rotor_time_constants_rising[i]);
+            if (i < N - 1) {
+                json_string += ", ";
+            }
+        }
+        json_string += "], ";
+
+        json_string += "\"rotor_time_constants_falling\": [";
+        for (TI i = 0; i < N; i++){
+            json_string += std::to_string(parameters.rotor_time_constants_falling[i]);
+            if (i < N - 1) {
+                json_string += ", ";
+            }
+        }
+        json_string += "], ";
+
+        json_string += "\"mass\": " + std::to_string(parameters.mass) + ", ";
+        json_string += "\"gravity\": [" + std::to_string(parameters.gravity[0]) + ", " + std::to_string(parameters.gravity[1]) + ", " + std::to_string(parameters.gravity[2]) + "], ";
+
+        json_string += "\"J\": [";
+        for (TI i = 0; i < 3; i++) {
+            json_string += "[" + std::to_string(parameters.J[i][0]) + ", " + std::to_string(parameters.J[i][1]) + ", " + std::to_string(parameters.J[i][2]) + "]";
+            if (i < 2) {
+                json_string += ", ";
+            }
+        }
+        json_string += "], ";
+
+        json_string += "\"J_inv\": [";
+        for (TI i = 0; i < 3; i++) {
+            json_string += "[" + std::to_string(parameters.J_inv[i][0]) + ", " + std::to_string(parameters.J_inv[i][1]) + ", " + std::to_string(parameters.J_inv[i][2]) + "]";
+            if (i < 2) {
+                json_string += ", ";
+            }
+        }
+        json_string += "], ";
+
+        json_string += "\"hovering_throttle_relative\": " + std::to_string(parameters.hovering_throttle_relative) + ", ";
+        json_string += "\"action_limit\": {";
+        json_string += "\"min\": " + std::to_string(parameters.action_limit.min) + ", ";
+        json_string += "\"max\": " + std::to_string(parameters.action_limit.max);
+        json_string += "}"; // closing action_limit
+        json_string += "}"; // closing main JSON
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename T>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::parameters::IMU<T>& parameters) {
+        std::string json_string = "{";
+        json_string += "\"gyro_bias\": {";
+        json_string += "\"init_max\": " + std::to_string(parameters.gyro_bias.init_max) + ", ";
+        json_string += "\"tau\": " + std::to_string(parameters.gyro_bias.tau) + ", ";
+        json_string += "\"sigma\": " + std::to_string(parameters.gyro_bias.sigma);
+        json_string += "}";
+        json_string += "}";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename T>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::parameters::CTBRController<T>& parameters) {
+        std::string json_string = "{";
+        json_string += "\"thrust_min\": " + std::to_string(parameters.thrust_min) + ", ";
+        json_string += "\"thrust_max\": " + std::to_string(parameters.thrust_max) + ", ";
+        json_string += "\"rate_limit\": [" + std::to_string(parameters.rate_limit[0]) + ", " + std::to_string(parameters.rate_limit[1]) + ", " + std::to_string(parameters.rate_limit[2]) + "], ";
+        json_string += "\"kp\": [" + std::to_string(parameters.kp[0]) + ", " + std::to_string(parameters.kp[1]) + ", " + std::to_string(parameters.kp[2]) + "], ";
+        json_string += "\"kd\": [" + std::to_string(parameters.kd[0]) + ", " + std::to_string(parameters.kd[1]) + ", " + std::to_string(parameters.kd[2]) + "], ";
+        json_string += "\"torque_limit\": [" + std::to_string(parameters.torque_limit[0]) + ", " + std::to_string(parameters.torque_limit[1]) + ", " + std::to_string(parameters.torque_limit[2]) + "]";
+        json_string += "}";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::parameters::Integration<PARAM_SPEC>& parameters) {
+        return std::string("{\"dt\": ") + std::to_string(parameters.dt) + "}";
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::parameters::Initialization<PARAM_SPEC>& parameters) {
+        std::string json_string = "{";
+        json_string += "\"guidance\": " + std::to_string(parameters.guidance) + ", ";
+        json_string += "\"max_position\": " + std::to_string(parameters.max_position) + ", ";
+        json_string += "\"max_angle\": " + std::to_string(parameters.max_angle) + ", ";
+        json_string += "\"max_linear_velocity\": " + std::to_string(parameters.max_linear_velocity) + ", ";
+        json_string += "\"max_angular_velocity\": " + std::to_string(parameters.max_angular_velocity) + ", ";
+        json_string += "\"relative_rpm\": " + std::string(parameters.relative_rpm ? "true" : "false") + ", ";
+        json_string += "\"min_rpm\": " + std::to_string(parameters.min_rpm) + ", ";
+        json_string += "\"max_rpm\": " + std::to_string(parameters.max_rpm);
+        json_string += "}";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename T, unsigned T_ACTION_DIM>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::parameters::reward_functions::Squared<T, T_ACTION_DIM>& parameters) {
+        std::string json_string = "{";
+        json_string += "\"non_negative\": " + std::string(parameters.non_negative ? "true" : "false") + ", ";
+        json_string += "\"scale\": " + std::to_string(parameters.scale) + ", ";
+        json_string += "\"constant\": " + std::to_string(parameters.constant) + ", ";
+        json_string += "\"termination_penalty\": " + std::to_string(parameters.termination_penalty) + ", ";
+        json_string += "\"position\": " + std::to_string(parameters.position) + ", ";
+        json_string += "\"position_clip\": " + std::to_string(parameters.position_clip) + ", ";
+        json_string += "\"orientation\": " + std::to_string(parameters.orientation) + ", ";
+        json_string += "\"linear_velocity\": " + std::to_string(parameters.linear_velocity) + ", ";
+        json_string += "\"angular_velocity\": " + std::to_string(parameters.angular_velocity) + ", ";
+        json_string += "\"linear_acceleration\": " + std::to_string(parameters.linear_acceleration) + ", ";
+        json_string += "\"angular_acceleration\": " + std::to_string(parameters.angular_acceleration) + ", ";
+        json_string += "\"action\": [";
+        for(typename DEVICE::index_t action_i = 0; action_i < T_ACTION_DIM; action_i++){
+            json_string += std::to_string(parameters.action[action_i]);
+            if(action_i + 1 < T_ACTION_DIM){
+                json_string += ", ";
+            }
+        }
+        json_string += "], ";
+        json_string += "\"d_action\": [";
+        for(typename DEVICE::index_t action_i = 0; action_i < T_ACTION_DIM; action_i++){
+            json_string += std::to_string(parameters.d_action[action_i]);
+            if(action_i + 1 < T_ACTION_DIM){
+                json_string += ", ";
+            }
+        }
+        json_string += "], ";
+        json_string += "\"position_error_integral\": " + std::to_string(parameters.position_error_integral);
+        json_string += "}";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::parameters::Termination<PARAM_SPEC>& parameters) {
+        std::string json_string = "{";
+        json_string += "\"enabled\": " + std::string(parameters.enabled ? "true" : "false") + ", ";
+        json_string += "\"position_threshold\": " + std::to_string(parameters.position_threshold) + ", ";
+        json_string += "\"angle_threshold\": " + std::to_string(parameters.angle_threshold) + ", ";
+        json_string += "\"linear_velocity_threshold\": " + std::to_string(parameters.linear_velocity_threshold) + ", ";
+        json_string += "\"angular_velocity_threshold\": " + std::to_string(parameters.angular_velocity_threshold) + ", ";
+        json_string += "\"position_integral_threshold\": " + std::to_string(parameters.position_integral_threshold) + ", ";
+        json_string += "\"orientation_integral_threshold\": " + std::to_string(parameters.orientation_integral_threshold);
+        json_string += "}";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::parameters::ObservationNoise<PARAM_SPEC>& parameters) {
+        std::string json_string = "{";
+        json_string += "\"position\": " + std::to_string(parameters.position) + ", ";
+        json_string += "\"orientation\": " + std::to_string(parameters.orientation) + ", ";
+        json_string += "\"linear_velocity\": " + std::to_string(parameters.linear_velocity) + ", ";
+        json_string += "\"angular_velocity\": " + std::to_string(parameters.angular_velocity) + ", ";
+        json_string += "\"imu_acceleration\": " + std::to_string(parameters.imu_acceleration);
+        json_string += "}";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::parameters::ActionNoise<PARAM_SPEC>& parameters) {
+        std::string json_string = "{";
+        json_string += "\"normalized_rpm\": " + std::to_string(parameters.normalized_rpm);
+        json_string += "}";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::parameters::MDP<PARAM_SPEC>& parameters) {
+        std::string json_string = "{";
+        json_string += "\"init\": " + json(device, env, parameters.init) + ", ";
+        json_string += "\"reward\": " + json(device, env, parameters.reward) + ", ";
+        json_string += "\"observation_noise\": " + json(device, env, parameters.observation_noise) + ", ";
+        json_string += "\"action_noise\": " + json(device, env, parameters.action_noise) + ", ";
+        json_string += "\"termination\": " + json(device, env, parameters.termination);
+        json_string += "}";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::ParametersBase<PARAM_SPEC>& parameters, bool top_level=true){
+        using T = typename SPEC::T;
+        using TI = typename DEVICE::index_t;
+        std::string json_string = top_level ? "{" : "";
+        json_string += "\"dynamics\": " + json(device, env, parameters.dynamics) + ", ";
+        json_string += "\"integration\": " + json(device, env, parameters.integration) + ", ";
+        json_string += "\"mdp\": " + json(device, env, parameters.mdp);
+        json_string += top_level ? "}" : "";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::parameters::Disturbances<PARAM_SPEC>& parameters) {
+        std::string json_string = "{";
+        json_string += "\"random_force\": {";
+        json_string += "\"mean\": " + std::to_string(parameters.random_force.mean) + ", ";
+        json_string += "\"std\": " + std::to_string(parameters.random_force.std);
+        json_string += "}, ";
+        json_string += "\"random_torque\": {";
+        json_string += "\"mean\": " + std::to_string(parameters.random_torque.mean) + ", ";
+        json_string += "\"std\": " + std::to_string(parameters.random_torque.std);
+        json_string += "}";
+        json_string += "}";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::ParametersDisturbances<PARAM_SPEC>& parameters, bool top_level=true){
+        using T = typename SPEC::T;
+        using TI = typename DEVICE::index_t;
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, static_cast<const typename PARAM_SPEC::NEXT_COMPONENT&>(parameters), false);
+        json_string += ", \"disturbances\": " + json(device, env, parameters.disturbances);
+        json_string += (top_level ? "}" : "");
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::ParametersIMU<PARAM_SPEC>& parameters, bool top_level=true){
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, static_cast<const typename PARAM_SPEC::NEXT_COMPONENT&>(parameters), false);
+        json_string += ", \"imu\": " + json(device, env, parameters.imu);
+        json_string += (top_level ? "}" : "");
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::ParametersCTBRController<PARAM_SPEC>& parameters, bool top_level=true){
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, static_cast<const typename PARAM_SPEC::NEXT_COMPONENT&>(parameters), false);
+        json_string += ", \"ctbr_controller\": " + json(device, env, parameters.ctbr_controller);
+        json_string += (top_level ? "}" : "");
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::parameters::DomainRandomization<PARAM_SPEC>& parameters) {
+        std::string json_string = "{";
+        json_string += "\"thrust_to_weight_min\": " + std::to_string(parameters.thrust_to_weight_min) + ", ";
+        json_string += "\"thrust_to_weight_max\": " + std::to_string(parameters.thrust_to_weight_max) + ", ";
+        json_string += "\"torque_to_inertia_min\": " + std::to_string(parameters.torque_to_inertia_min) + ", ";
+        json_string += "\"torque_to_inertia_max\": " + std::to_string(parameters.torque_to_inertia_max) + ", ";
+        json_string += "\"mass_min\": " + std::to_string(parameters.mass_min) + ", ";
+        json_string += "\"mass_max\": " + std::to_string(parameters.mass_max) + ", ";
+        json_string += "\"mass_size_deviation\": " + std::to_string(parameters.mass_size_deviation) + ", ";
+        json_string += "\"rotor_time_constant_rising_min\": " + std::to_string(parameters.rotor_time_constant_rising_min) + ", ";
+        json_string += "\"rotor_time_constant_rising_max\": " + std::to_string(parameters.rotor_time_constant_rising_max) + ", ";
+        json_string += "\"rotor_time_constant_falling_min\": " + std::to_string(parameters.rotor_time_constant_falling_min) + ", ";
+        json_string += "\"rotor_time_constant_falling_max\": " + std::to_string(parameters.rotor_time_constant_falling_max) + ", ";
+        json_string += "\"rotor_torque_constant_min\": " + std::to_string(parameters.rotor_torque_constant_min) + ", ";
+        json_string += "\"rotor_torque_constant_max\": " + std::to_string(parameters.rotor_torque_constant_max) + ", ";
+        json_string += "\"orientation_offset_angle_max\": " + std::to_string(parameters.orientation_offset_angle_max) + ", ";
+        json_string += "\"disturbance_force_max\": " + std::to_string(parameters.disturbance_force_max);
+        json_string += "}";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::ParametersDomainRandomization<PARAM_SPEC>& parameters, bool top_level=true){
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, static_cast<const typename PARAM_SPEC::NEXT_COMPONENT&>(parameters), false);
+        json_string += ", \"domain_randomization\": " + json(device, env, parameters.domain_randomization);
+        json_string += (top_level ? "}" : "");
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename TRAJ_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::parameters::trajectories::Trajectory<TRAJ_SPEC>& parameters) {
+        using TI = typename DEVICE::index_t;
+        using TRAJECTORY = rl::environments::l2f::parameters::trajectories::Trajectory<TRAJ_SPEC>;
+        std::string json_string = "{";
+        json_string += "\"LENGTH\": " + std::to_string(TRAJECTORY::LENGTH) + ", ";
+        json_string += "\"DT\": " + std::to_string(TRAJECTORY::DT) + ", ";
+        json_string += "\"steps\": [";
+        for (TI step_i=0; step_i < TRAJECTORY::LENGTH; ++step_i){
+            json_string += "{";
+            json_string += "\"position\": [" + std::to_string(parameters.steps[step_i].position[0]) + ", " + std::to_string(parameters.steps[step_i].position[1]) + ", " + std::to_string(parameters.steps[step_i].position[2]) + "], ";
+            json_string += "\"yaw\": " + std::to_string(parameters.steps[step_i].yaw) + ", ";
+            json_string += "\"linear_velocity\": [" + std::to_string(parameters.steps[step_i].linear_velocity[0]) + ", " + std::to_string(parameters.steps[step_i].linear_velocity[1]) + ", " + std::to_string(parameters.steps[step_i].linear_velocity[2]) + "], ";
+            json_string += "\"yaw_velocity\": " + std::to_string(parameters.steps[step_i].yaw_velocity);
+            json_string += "}";
+            json_string += (step_i < TRAJECTORY::LENGTH-1 ? ", " : "");
+        }
+        json_string += "]";
+        json_string += "}";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename T>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::parameters::trajectories::lissajous::Parameters<T>& parameters) {
+        std::string json_string = "{";
+        json_string += "\"A\": " + std::to_string(parameters.A) + ", ";
+        json_string += "\"B\": " + std::to_string(parameters.B) + ", ";
+        json_string += "\"C\": " + std::to_string(parameters.C) + ", ";
+        json_string += "\"a\": " + std::to_string(parameters.a) + ", ";
+        json_string += "\"b\": " + std::to_string(parameters.b) + ", ";
+        json_string += "\"c\": " + std::to_string(parameters.c) + ", ";
+        json_string += "\"interval\": " + std::to_string(parameters.interval) + ", ";
+        json_string += "\"ramp_duration\": " + std::to_string(parameters.ramp_duration);
+        json_string += "}";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename TRAJ_PARAM_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::parameters::trajectories::TaggedParameters<TRAJ_PARAM_SPEC>& parameters) {
+        std::string json_string = "{";
+        if (parameters.type == rl::environments::l2f::parameters::trajectories::Type::LISSAJOUS) {
+            json_string += "\"type\": \"LISSAJOUS\", ";
+            json_string += "\"lissajous\": " + json(device, env, parameters.parameters.lissajous);
+        }
+        else {
+            utils::assert_exit(device, false, "L2F json export: Unknown trajectory_parameters type");
+        }
+        json_string += "}";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::ParametersTrajectory<PARAM_SPEC>& parameters, bool top_level=true){
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, static_cast<const typename PARAM_SPEC::NEXT_COMPONENT&>(parameters), false);
+        json_string += ", \"trajectory\": " + json(device, env, parameters.trajectory);
+        json_string += ", \"trajectory_parameters\": " + json(device, env, parameters.trajectory_parameters);
+        json_string += (top_level ? "}" : "");
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename T, typename TI>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::parameters::ObservationDelay<T, TI>& parameters) {
+        std::string json_string = "{";
+        json_string += "\"linear_velocity\": " + std::to_string(parameters.linear_velocity) + ", ";
+        json_string += "\"angular_velocity\": " + std::to_string(parameters.angular_velocity);
+        json_string += "}";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const rl::environments::l2f::ParametersObservationDelay<PARAM_SPEC>& parameters, bool top_level=true){
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, static_cast<const typename PARAM_SPEC::NEXT_COMPONENT&>(parameters), false);
+        json_string += ", \"observation_delay\": " + json(device, env, parameters.observation_delay);
+        json_string += (top_level ? "}" : "");
+        return json_string;
+    }
+
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, const rl::environments::l2f::StateBase<STATE_SPEC>& state, bool top_level=true){
+        std::string json_string = top_level ? "{" : "";
+        json_string += "\"position\": [" + std::to_string(state.position[0]) + ", " + std::to_string(state.position[1]) + ", " + std::to_string(state.position[2]) + "], ";
+        json_string += "\"orientation\": [" + std::to_string(state.orientation[0]) + ", " + std::to_string(state.orientation[1]) + ", " + std::to_string(state.orientation[2]) + ", " + std::to_string(state.orientation[3]) + "], ";
+        json_string += "\"linear_velocity\": [" + std::to_string(state.linear_velocity[0]) + ", " + std::to_string(state.linear_velocity[1]) + ", " + std::to_string(state.linear_velocity[2]) + "], ";
+        json_string += "\"angular_velocity\": [" + std::to_string(state.angular_velocity[0]) + ", " + std::to_string(state.angular_velocity[1]) + ", " + std::to_string(state.angular_velocity[2]) + "]";
+        json_string += top_level ? "}" : "";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, const rl::environments::l2f::StateLastAction<STATE_SPEC>& state, bool top_level=true){
+        using TI = typename DEVICE::index_t;
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, parameters, static_cast<const typename STATE_SPEC::NEXT_COMPONENT&>(state), false) + ", ";
+        json_string += "\"last_action\": [";
+        for (TI action_i = 0; action_i < SPEC::PARAMETERS::N; action_i++){
+            json_string += std::to_string(state.last_action[action_i]);
+            if (action_i < SPEC::PARAMETERS::N - 1) {
+                json_string += ", ";
+            }
+        }
+        json_string += "]";
+        json_string += top_level ? "}" : "";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, const rl::environments::l2f::StateLinearAcceleration<STATE_SPEC>& state, bool top_level=true){
+        using TI = typename DEVICE::index_t;
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, parameters, static_cast<const typename STATE_SPEC::NEXT_COMPONENT&>(state), false) + ", ";
+        json_string += "\"linear_acceleration\": [";
+        for (TI i = 0; i < 3; i++){
+            json_string += std::to_string(state.linear_acceleration[i]);
+            if (i < 2) {
+                json_string += ", ";
+            }
+        }
+        json_string += "]";
+        json_string += top_level ? "}" : "";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, const rl::environments::l2f::StateGyroBias<STATE_SPEC>& state, bool top_level=true){
+        using TI = typename DEVICE::index_t;
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, parameters, static_cast<const typename STATE_SPEC::NEXT_COMPONENT&>(state), false) + ", ";
+        json_string += "\"gyro_bias\": [";
+        for (TI i = 0; i < 3; i++){
+            json_string += std::to_string(state.gyro_bias[i]);
+            if (i < 2) {
+                json_string += ", ";
+            }
+        }
+        json_string += "]";
+        json_string += top_level ? "}" : "";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, const rl::environments::l2f::StateMahony<STATE_SPEC>& state, bool top_level=true){
+        using TI = typename DEVICE::index_t;
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, parameters, static_cast<const typename STATE_SPEC::NEXT_COMPONENT&>(state), false) + ", ";
+        json_string += "\"q_estimate\": [";
+        for (TI i = 0; i < 4; i++){
+            json_string += std::to_string(state.q_estimate[i]);
+            if (i < 3) {
+                json_string += ", ";
+            }
+        }
+        json_string += "], ";
+        json_string += "\"bias_estimate\": [";
+        for (TI i = 0; i < 3; i++){
+            json_string += std::to_string(state.bias_estimate[i]);
+            if (i < 2) {
+                json_string += ", ";
+            }
+        }
+        json_string += "]";
+        json_string += top_level ? "}" : "";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, const rl::environments::l2f::StateCTBRController<STATE_SPEC>& state, bool top_level=true){
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, parameters, static_cast<const typename STATE_SPEC::NEXT_COMPONENT&>(state), false) + ", ";
+        json_string += "\"previous_angular_velocity\": [" + std::to_string(state.previous_angular_velocity[0]) + ", " + std::to_string(state.previous_angular_velocity[1]) + ", " + std::to_string(state.previous_angular_velocity[2]) + "]";
+        json_string += top_level ? "}" : "";
+        return json_string;
+    }
+    namespace rl::environments::l2f::detail{
+        template <typename FloatT>
+        inline std::string lossless_to_string(FloatT v){
+            // round-trip-safe textual representation; max_digits10 guarantees
+            // re-parsing yields exactly the same FloatT value.
+            char buf[64];
+            constexpr int digits = std::numeric_limits<FloatT>::max_digits10;
+            std::snprintf(buf, sizeof(buf), "%.*g", digits, (double)v);
+            return std::string(buf);
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, const rl::environments::l2f::StateLinearAccelerationHistory<STATE_SPEC>& state, bool top_level=true){
+        using TI = typename DEVICE::index_t;
+        using T = typename STATE_SPEC::T;
+        using STATE = rl::environments::l2f::StateLinearAccelerationHistory<STATE_SPEC>;
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, parameters, static_cast<const typename STATE_SPEC::NEXT_COMPONENT&>(state), false) + ", ";
+        json_string += "\"linear_acceleration_body_history\": [";
+        for (TI step_i = 0; step_i < STATE_SPEC::HISTORY_LENGTH; step_i++){
+            json_string += "[";
+            for (TI dim_i = 0; dim_i < STATE::ACCELERATION_DIM; dim_i++){
+                json_string += rl::environments::l2f::detail::lossless_to_string<T>(state.linear_acceleration_body_history[step_i][dim_i]);
+                if (dim_i < STATE::ACCELERATION_DIM - 1) {
+                    json_string += ", ";
+                }
+            }
+            json_string += "]";
+            if (step_i + 1 < STATE_SPEC::HISTORY_LENGTH) {
+                json_string += ", ";
+            }
+        }
+        json_string += "], ";
+        json_string += "\"acceleration_history_step\": " + std::to_string(state.acceleration_history_step);
+        json_string += top_level ? "}" : "";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, const rl::environments::l2f::StateAngularVelocityDelay<STATE_SPEC>& state, bool top_level=true){
+        using TI = typename DEVICE::index_t;
+        using STATE = rl::environments::l2f::StateAngularVelocityDelay<STATE_SPEC>;
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, parameters, static_cast<const typename STATE_SPEC::NEXT_COMPONENT&>(state), false) + ", ";
+        json_string += "\"angular_velocity_history\": [";
+        for (TI step_i = 0; step_i < STATE::HISTORY_MEM_LENGTH; step_i++){
+            json_string += "[";
+            for (TI dim_i = 0; dim_i < 3; dim_i++){
+                json_string += std::to_string(state.angular_velocity_history[step_i][dim_i]);
+                if (dim_i < 2) {
+                    json_string += ", ";
+                }
+            }
+            json_string += "]";
+            if (step_i < STATE::HISTORY_MEM_LENGTH - 1) {
+                json_string += ", ";
+            }
+        }
+        json_string += "]";
+        json_string += top_level ? "}" : "";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, const rl::environments::l2f::StateLinearVelocityDelay<STATE_SPEC>& state, bool top_level=true){
+        using TI = typename DEVICE::index_t;
+        using STATE = rl::environments::l2f::StateLinearVelocityDelay<STATE_SPEC>;
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, parameters, static_cast<const typename STATE_SPEC::NEXT_COMPONENT&>(state), false) + ", ";
+        json_string += "\"linear_velocity_history\": [";
+        for (TI step_i = 0; step_i < STATE::HISTORY_MEM_LENGTH; step_i++){
+            json_string += "[";
+            for (TI dim_i = 0; dim_i < 3; dim_i++){
+                json_string += std::to_string(state.linear_velocity_history[step_i][dim_i]);
+                if (dim_i < 2) {
+                    json_string += ", ";
+                }
+            }
+            json_string += "]";
+            if (step_i < STATE::HISTORY_MEM_LENGTH - 1) {
+                json_string += ", ";
+            }
+        }
+        json_string += "]";
+        json_string += top_level ? "}" : "";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, const rl::environments::l2f::StatePoseErrorIntegral<STATE_SPEC>& state, bool top_level=true){
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, parameters, static_cast<const typename STATE_SPEC::NEXT_COMPONENT&>(state), false) + ", ";
+        json_string += "\"position_integral\": [" + std::to_string(state.position_integral[0]) + ", " + std::to_string(state.position_integral[1]) + ", " + std::to_string(state.position_integral[2]) + "], ";
+        json_string += "\"orientation_integral\": " + std::to_string(state.orientation_integral);
+        json_string += top_level ? "}" : "";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, const rl::environments::l2f::StateRotors<STATE_SPEC>& state, bool top_level=true){
+        using TI = typename DEVICE::index_t;
+        using STATE = rl::environments::l2f::StateRotors<STATE_SPEC>;
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, parameters, static_cast<const typename STATE_SPEC::NEXT_COMPONENT&>(state), false) + ", ";
+        json_string += "\"rpm\": [";
+        for (TI action_i = 0; action_i < STATE::ACTION_DIM; action_i++){
+            json_string += std::to_string(state.rpm[action_i]);
+            if (action_i < STATE::ACTION_DIM - 1) {
+                json_string += ", ";
+            }
+        }
+        json_string += "]";
+        json_string += top_level ? "}" : "";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, const rl::environments::l2f::StateRotorsHistory<STATE_SPEC>& state, bool top_level=true){
+        using TI = typename DEVICE::index_t;
+        using STATE = rl::environments::l2f::StateRotorsHistory<STATE_SPEC>;
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, parameters, static_cast<const typename STATE::NEXT_COMPONENT&>(state), false) + ", ";
+        json_string += "\"action_history\": [";
+        for (TI step_i = 0; step_i < STATE_SPEC::HISTORY_LENGTH; step_i++){
+            json_string += "[";
+            for (TI action_i = 0; action_i < SPEC::PARAMETERS::N; action_i++){
+                json_string += std::to_string(state.action_history[step_i][action_i]);
+                if (action_i < SPEC::PARAMETERS::N - 1) {
+                    json_string += ", ";
+                }
+            }
+            json_string += "]";
+            if (step_i < STATE_SPEC::HISTORY_LENGTH - 1) {
+                json_string += ", ";
+            }
+        }
+        json_string += "]";
+        json_string += top_level ? "}" : "";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, const rl::environments::l2f::StateRandomForce<STATE_SPEC>& state, bool top_level=true){
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, parameters, static_cast<const typename STATE_SPEC::NEXT_COMPONENT&>(state), false) + ", ";
+        json_string += "\"force\": [" + std::to_string(state.force[0]) + ", " + std::to_string(state.force[1]) + ", " + std::to_string(state.force[2]) + "], ";
+        json_string += "\"torque\": [" + std::to_string(state.torque[0]) + ", " + std::to_string(state.torque[1]) + ", " + std::to_string(state.torque[2]) + "]";
+        json_string += top_level ? "}" : "";
+        return json_string;
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    std::string json(DEVICE& device, const rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, const rl::environments::l2f::StateTrajectory<STATE_SPEC>& state, bool top_level=true){
+        std::string json_string = top_level ? "{" : "";
+        json_string += json(device, env, parameters, static_cast<const typename STATE_SPEC::NEXT_COMPONENT&>(state), false) + ", ";
+        json_string += "\"trajectory\": {";
+        json_string += "\"trajectory_step\": " + std::to_string(state.trajectory_step);
+        json_string += "}";
+        json_string += top_level ? "}" : "";
+        return json_string;
+    }
+#ifdef RL_TOOLS_ENABLE_JSON
+    template <typename DEVICE, typename SPEC, typename T_T, typename T_TI, T_TI N>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::parameters::Dynamics<T_T, T_TI, N>& parameters){
+        using TI = typename DEVICE::index_t;
+        for (TI i = 0; i < N; i++){
+            parameters.rotor_positions[i][0] = json_object["rotor_positions"][i][0];
+            parameters.rotor_positions[i][1] = json_object["rotor_positions"][i][1];
+            parameters.rotor_positions[i][2] = json_object["rotor_positions"][i][2];
+            parameters.rotor_thrust_directions[i][0] = json_object["rotor_thrust_directions"][i][0];
+            parameters.rotor_thrust_directions[i][1] = json_object["rotor_thrust_directions"][i][1];
+            parameters.rotor_thrust_directions[i][2] = json_object["rotor_thrust_directions"][i][2];
+            parameters.rotor_torque_directions[i][0] = json_object["rotor_torque_directions"][i][0];
+            parameters.rotor_torque_directions[i][1] = json_object["rotor_torque_directions"][i][1];
+            parameters.rotor_torque_directions[i][2] = json_object["rotor_torque_directions"][i][2];
+            parameters.rotor_thrust_coefficients[i][0] = json_object["rotor_thrust_coefficients"][i][0];
+            parameters.rotor_thrust_coefficients[i][1] = json_object["rotor_thrust_coefficients"][i][1];
+            parameters.rotor_thrust_coefficients[i][2] = json_object["rotor_thrust_coefficients"][i][2];
+            parameters.rotor_torque_constants[i] = json_object["rotor_torque_constants"][i];
+            parameters.rotor_time_constants_rising[i] = json_object["rotor_time_constants_rising"][i];
+            parameters.rotor_time_constants_falling[i] = json_object["rotor_time_constants_falling"][i];
+        }
+
+        parameters.mass = json_object["mass"];
+        parameters.gravity[0] = json_object["gravity"][0];
+        parameters.gravity[1] = json_object["gravity"][1];
+        parameters.gravity[2] = json_object["gravity"][2];
+
+        for (TI i = 0; i < 3; i++) {
+            for (TI j = 0; j < 3; j++) {
+                parameters.J[i][j] = json_object["J"][i][j];
+                parameters.J_inv[i][j] = json_object["J_inv"][i][j];
+            }
+        }
+
+        parameters.hovering_throttle_relative = json_object["hovering_throttle_relative"];
+        parameters.action_limit.min = json_object["action_limit"]["min"];
+        parameters.action_limit.max = json_object["action_limit"]["max"];
+    }
+    template <typename DEVICE, typename SPEC, typename T>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::parameters::IMU<T>& parameters) {
+        const auto& gb_json = json_object["gyro_bias"];
+        parameters.gyro_bias.init_max = gb_json.value("init_max", (T)0);
+        parameters.gyro_bias.tau = gb_json.value("tau", (T)0);
+        parameters.gyro_bias.sigma = gb_json.value("sigma", (T)0);
+    }
+    template <typename DEVICE, typename SPEC, typename T>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::parameters::CTBRController<T>& parameters) {
+        parameters.thrust_min = json_object["thrust_min"];
+        parameters.thrust_max = json_object["thrust_max"];
+        for(typename DEVICE::index_t i = 0; i < 3; i++){
+            parameters.rate_limit[i] = json_object["rate_limit"][i];
+            parameters.kp[i] = json_object["kp"][i];
+            parameters.kd[i] = json_object["kd"][i];
+            parameters.torque_limit[i] = json_object["torque_limit"][i];
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::parameters::Integration<PARAM_SPEC>& parameters) {
+        parameters.dt = json_object["dt"];
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::parameters::Initialization<PARAM_SPEC>& parameters) {
+        parameters.guidance = json_object["guidance"];
+        parameters.max_position = json_object["max_position"];
+        parameters.max_angle = json_object["max_angle"];
+        parameters.max_linear_velocity = json_object["max_linear_velocity"];
+        parameters.max_angular_velocity = json_object["max_angular_velocity"];
+        parameters.relative_rpm = json_object["relative_rpm"];
+        parameters.min_rpm = json_object["min_rpm"];
+        parameters.max_rpm = json_object["max_rpm"];
+    }
+    template <typename DEVICE, typename SPEC, typename T, unsigned T_ACTION_DIM>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::parameters::reward_functions::Squared<T, T_ACTION_DIM>& parameters) {
+        parameters.non_negative = json_object["non_negative"];
+        parameters.scale = json_object["scale"];
+        parameters.constant = json_object["constant"];
+        parameters.termination_penalty = json_object["termination_penalty"];
+        parameters.position = json_object["position"];
+        parameters.position_clip = json_object["position_clip"];
+        parameters.orientation = json_object["orientation"];
+        parameters.linear_velocity = json_object["linear_velocity"];
+        parameters.angular_velocity = json_object["angular_velocity"];
+        parameters.linear_acceleration = json_object["linear_acceleration"];
+        parameters.angular_acceleration = json_object["angular_acceleration"];
+        if(json_object["action"].is_array()){
+            for(typename DEVICE::index_t action_i = 0; action_i < T_ACTION_DIM; action_i++){
+                parameters.action[action_i] = json_object["action"][action_i];
+            }
+        }
+        else{
+            T action = json_object["action"];
+            for(typename DEVICE::index_t action_i = 0; action_i < T_ACTION_DIM; action_i++){
+                parameters.action[action_i] = action;
+            }
+        }
+        if(json_object["d_action"].is_array()){
+            for(typename DEVICE::index_t action_i = 0; action_i < T_ACTION_DIM; action_i++){
+                parameters.d_action[action_i] = json_object["d_action"][action_i];
+            }
+        }
+        else{
+            T d_action = json_object["d_action"];
+            for(typename DEVICE::index_t action_i = 0; action_i < T_ACTION_DIM; action_i++){
+                parameters.d_action[action_i] = d_action;
+            }
+        }
+        parameters.position_error_integral = json_object["position_error_integral"];
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::parameters::Termination<PARAM_SPEC>& parameters) {
+        parameters.enabled = json_object["enabled"];
+        parameters.position_threshold = json_object["position_threshold"];
+        parameters.angle_threshold = json_object.value("angle_threshold", (PARAM_SPEC)0);
+        parameters.linear_velocity_threshold = json_object["linear_velocity_threshold"];
+        parameters.angular_velocity_threshold = json_object["angular_velocity_threshold"];
+        parameters.position_integral_threshold = json_object["position_integral_threshold"];
+        parameters.orientation_integral_threshold = json_object["orientation_integral_threshold"];
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::parameters::ObservationNoise<PARAM_SPEC>& parameters) {
+        parameters.position = json_object["position"];
+        parameters.orientation = json_object["orientation"];
+        parameters.linear_velocity = json_object["linear_velocity"];
+        parameters.angular_velocity = json_object["angular_velocity"];
+        parameters.imu_acceleration = json_object["imu_acceleration"];
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::parameters::ActionNoise<PARAM_SPEC>& parameters) {
+        parameters.normalized_rpm = json_object["normalized_rpm"];
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::parameters::MDP<PARAM_SPEC>& parameters) {
+        from_json(device, env, json_object["init"], parameters.init);
+        from_json(device, env, json_object["reward"], parameters.reward);
+        from_json(device, env, json_object["observation_noise"], parameters.observation_noise);
+        from_json(device, env, json_object["action_noise"], parameters.action_noise);
+        from_json(device, env, json_object["termination"], parameters.termination);
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::ParametersBase<PARAM_SPEC>& parameters){
+        from_json(device, env, json_object["dynamics"], parameters.dynamics);
+        from_json(device, env, json_object["integration"], parameters.integration);
+        from_json(device, env, json_object["mdp"], parameters.mdp);
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::parameters::Disturbances<PARAM_SPEC>& parameters) {
+        parameters.random_force.mean = json_object["random_force"]["mean"];
+        parameters.random_force.std = json_object["random_force"]["std"];
+        parameters.random_torque.mean = json_object["random_torque"]["mean"];
+        parameters.random_torque.std = json_object["random_torque"]["std"];
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::ParametersDisturbances<PARAM_SPEC>& parameters){
+        from_json(device, env, json_object, static_cast<typename PARAM_SPEC::NEXT_COMPONENT&>(parameters));
+        from_json(device, env, json_object["disturbances"], parameters.disturbances);
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::ParametersIMU<PARAM_SPEC>& parameters){
+        from_json(device, env, json_object, static_cast<typename PARAM_SPEC::NEXT_COMPONENT&>(parameters));
+        if (json_object.contains("imu")){
+            from_json(device, env, json_object["imu"], parameters.imu);
+        }
+        else {
+            parameters.imu.gyro_bias.init_max = 0;
+            parameters.imu.gyro_bias.tau = 0;
+            parameters.imu.gyro_bias.sigma = 0;
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::ParametersCTBRController<PARAM_SPEC>& parameters){
+        from_json(device, env, json_object, static_cast<typename PARAM_SPEC::NEXT_COMPONENT&>(parameters));
+        from_json(device, env, json_object["ctbr_controller"], parameters.ctbr_controller);
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::parameters::DomainRandomization<PARAM_SPEC>& parameters) {
+        parameters.thrust_to_weight_min = json_object["thrust_to_weight_min"];
+        parameters.thrust_to_weight_max = json_object["thrust_to_weight_max"];
+        parameters.torque_to_inertia_min = json_object["torque_to_inertia_min"];
+        parameters.torque_to_inertia_max = json_object["torque_to_inertia_max"];
+        parameters.mass_min = json_object["mass_min"];
+        parameters.mass_max = json_object["mass_max"];
+        parameters.mass_size_deviation = json_object["mass_size_deviation"];
+        parameters.rotor_time_constant_rising_min = json_object["rotor_time_constant_rising_min"];
+        parameters.rotor_time_constant_rising_max = json_object["rotor_time_constant_rising_max"];
+        parameters.rotor_time_constant_falling_min = json_object["rotor_time_constant_falling_min"];
+        parameters.rotor_time_constant_falling_max = json_object["rotor_time_constant_falling_max"];
+        parameters.rotor_torque_constant_min = json_object["rotor_torque_constant_min"];
+        parameters.rotor_torque_constant_max = json_object["rotor_torque_constant_max"];
+        parameters.orientation_offset_angle_max = json_object["orientation_offset_angle_max"];
+        parameters.disturbance_force_max = json_object["disturbance_force_max"];
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::ParametersDomainRandomization<PARAM_SPEC>& parameters){
+        from_json(device, env, json_object, static_cast<typename PARAM_SPEC::NEXT_COMPONENT&>(parameters));
+        from_json(device, env, json_object["domain_randomization"], parameters.domain_randomization);
+    }
+    template <typename DEVICE, typename SPEC, typename TRAJ_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::parameters::trajectories::Trajectory<TRAJ_SPEC>& trajectory) {
+        using T = typename TRAJ_SPEC::T;
+        using TI = typename DEVICE::index_t;
+        using TRAJECTORY = rl::environments::l2f::parameters::trajectories::Trajectory<TRAJ_SPEC>;
+        rl_tools::utils::assert_exit(device, json_object["LENGTH"] == TRAJECTORY::LENGTH, "Mismatch in trajectory length");
+        T json_dt = json_object["DT"];
+        T traj_dt = TRAJECTORY::DT;
+        rl_tools::utils::assert_exit(device, json_dt == traj_dt, "Mismatch in trajectory dt");
+        for (TI step_i = 0; step_i < TRAJECTORY::LENGTH; step_i++){
+            auto& step = trajectory.steps[step_i];
+            for (TI axis_i=0; axis_i < 3; axis_i++){
+                step.position[axis_i] = json_object["steps"][step_i]["position"][axis_i];
+                step.yaw = json_object["steps"][step_i]["yaw"];
+                step.linear_velocity[axis_i] = json_object["steps"][step_i]["linear_velocity"][axis_i];
+                step.yaw_velocity = json_object["steps"][step_i]["yaw_velocity"];
+            }
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename T>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::parameters::trajectories::lissajous::Parameters<T>& parameters) {
+        parameters.A = json_object["A"];
+        parameters.B = json_object["B"];
+        parameters.C = json_object["C"];
+        parameters.a = json_object["a"];
+        parameters.b = json_object["b"];
+        parameters.c = json_object["c"];
+        // backwards compat, deprecated
+        if (json_object.contains("duration")) {
+            parameters.interval = json_object["duration"];
+        }
+        else {
+            parameters.interval = json_object["interval"];
+        }
+        parameters.ramp_duration = json_object["ramp_duration"];
+    }
+    template <typename DEVICE, typename SPEC, typename TRAJ_PARAM_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::parameters::trajectories::TaggedParameters<TRAJ_PARAM_SPEC>& parameters) {
+        std::string type_str = json_object["type"];
+        if (type_str == "LISSAJOUS") {
+            parameters.type = rl::environments::l2f::parameters::trajectories::Type::LISSAJOUS;
+            from_json(device, env, json_object["lissajous"], parameters.parameters.lissajous);
+        }
+        else {
+            utils::assert_exit(device, false, "L2F json import: Unknown trajectory_parameters type");
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::ParametersTrajectory<PARAM_SPEC>& parameters){
+        from_json(device, env, json_object, static_cast<typename PARAM_SPEC::NEXT_COMPONENT&>(parameters));
+        from_json(device, env, json_object["trajectory"], parameters.trajectory);
+        from_json(device, env, json_object["trajectory_parameters"], parameters.trajectory_parameters);
+    }
+    template <typename DEVICE, typename SPEC, typename T, typename TI>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::parameters::ObservationDelay<T, TI>& parameters) {
+        parameters.linear_velocity = json_object["linear_velocity"];
+        parameters.angular_velocity = json_object["angular_velocity"];
+    }
+    template <typename DEVICE, typename SPEC, typename PARAM_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, nlohmann::json json_object, rl::environments::l2f::ParametersObservationDelay<PARAM_SPEC>& parameters){
+        from_json(device, env, json_object, static_cast<typename PARAM_SPEC::NEXT_COMPONENT&>(parameters));
+        from_json(device, env, json_object["observation_delay"], parameters.observation_delay);
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, std::string json_string, PARAMETERS& parameters){
+        nlohmann::json json_object = nlohmann::json::parse(json_string);
+        from_json(device, env, json_object, parameters);
+    }
+
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, nlohmann::json json_object, rl::environments::l2f::StateBase<STATE_SPEC>& state){
+        using TI = typename DEVICE::index_t;
+        for (TI i = 0; i < 3; i++){
+            state.position[i] = json_object["position"][i];
+            state.orientation[i] = json_object["orientation"][i];
+            state.linear_velocity[i] = json_object["linear_velocity"][i];
+            state.angular_velocity[i] = json_object["angular_velocity"][i];
+        }
+        state.orientation[3] = json_object["orientation"][3];
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, nlohmann::json json_object, rl::environments::l2f::StateLastAction<STATE_SPEC>& state){
+        from_json(device, env, parameters, json_object, static_cast<typename STATE_SPEC::NEXT_COMPONENT&>(state));
+        for (typename DEVICE::index_t action_i = 0; action_i < SPEC::PARAMETERS::N; action_i++){
+            state.last_action[action_i] = json_object["last_action"][action_i];
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, nlohmann::json json_object, rl::environments::l2f::StateLinearAcceleration<STATE_SPEC>& state){
+        using TI = typename DEVICE::index_t;
+        from_json(device, env, parameters, json_object, static_cast<typename STATE_SPEC::NEXT_COMPONENT&>(state));
+        for (TI i = 0; i < 3; i++){
+            state.linear_acceleration[i] = json_object["linear_acceleration"][i];
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, nlohmann::json json_object, rl::environments::l2f::StateGyroBias<STATE_SPEC>& state){
+        using TI = typename DEVICE::index_t;
+        from_json(device, env, parameters, json_object, static_cast<typename STATE_SPEC::NEXT_COMPONENT&>(state));
+        for (TI i = 0; i < 3; i++){
+            state.gyro_bias[i] = json_object["gyro_bias"][i];
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, nlohmann::json json_object, rl::environments::l2f::StateMahony<STATE_SPEC>& state){
+        using TI = typename DEVICE::index_t;
+        using T = typename STATE_SPEC::T;
+        using STATE = rl::environments::l2f::StateMahony<STATE_SPEC>;
+        from_json(device, env, parameters, json_object, static_cast<typename STATE_SPEC::NEXT_COMPONENT&>(state));
+        if(json_object.contains("q_estimate")){
+            for (TI i = 0; i < 4; i++){
+                state.q_estimate[i] = json_object["q_estimate"][i];
+            }
+        }
+        else if(json_object.contains("world_z_body_estimate")){
+            T world_z_body[3];
+            for (TI i = 0; i < 3; i++){
+                world_z_body[i] = json_object["world_z_body_estimate"][i];
+            }
+            state.q_estimate[0] = 1;
+            state.q_estimate[1] = 0;
+            state.q_estimate[2] = 0;
+            state.q_estimate[3] = 0;
+            rl::environments::l2f::mahony_quaternion_from_accel(device, world_z_body, state.q_estimate);
+        }
+        else{
+            T world_z_body[3];
+            rl::environments::l2f::quaternion_to_world_z_body<DEVICE, T>(state.orientation, world_z_body);
+            state.q_estimate[0] = 1;
+            state.q_estimate[1] = 0;
+            state.q_estimate[2] = 0;
+            state.q_estimate[3] = 0;
+            rl::environments::l2f::mahony_quaternion_from_accel(device, world_z_body, state.q_estimate);
+        }
+        if(json_object.contains("bias_estimate")){
+            for (TI i = 0; i < 3; i++){
+                state.bias_estimate[i] = json_object["bias_estimate"][i];
+            }
+        }
+        else if(json_object.contains("gyro_bias_tangent")){
+            for (TI i = 0; i < 3; i++){
+                state.bias_estimate[i] = json_object["gyro_bias_tangent"][i];
+            }
+        }
+        else{
+            for (TI i = 0; i < 3; i++){
+                state.bias_estimate[i] = 0;
+            }
+        }
+        T q_norm = math::sqrt(device.math,
+            state.q_estimate[0]*state.q_estimate[0] +
+            state.q_estimate[1]*state.q_estimate[1] +
+            state.q_estimate[2]*state.q_estimate[2] +
+            state.q_estimate[3]*state.q_estimate[3]);
+        if(q_norm > (T)1e-12){
+            for(TI i = 0; i < 4; i++){
+                state.q_estimate[i] /= q_norm;
+            }
+        }
+        else{
+            state.q_estimate[0] = 1;
+            state.q_estimate[1] = 0;
+            state.q_estimate[2] = 0;
+            state.q_estimate[3] = 0;
+        }
+        for(TI i = 0; i < 3; i++){
+            state.bias_estimate[i] = math::clamp(device.math, state.bias_estimate[i], -STATE::MAX_BIAS, STATE::MAX_BIAS);
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, nlohmann::json json_object, rl::environments::l2f::StateCTBRController<STATE_SPEC>& state){
+        using TI = typename DEVICE::index_t;
+        from_json(device, env, parameters, json_object, static_cast<typename STATE_SPEC::NEXT_COMPONENT&>(state));
+        for(TI i = 0; i < 3; i++){
+            state.previous_angular_velocity[i] = json_object["previous_angular_velocity"][i];
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, nlohmann::json json_object, rl::environments::l2f::StateLinearAccelerationHistory<STATE_SPEC>& state){
+        using TI = typename DEVICE::index_t;
+        using STATE = rl::environments::l2f::StateLinearAccelerationHistory<STATE_SPEC>;
+        from_json(device, env, parameters, json_object, static_cast<typename STATE_SPEC::NEXT_COMPONENT&>(state));
+        const auto& hist = json_object.at("linear_acceleration_body_history");
+        if (hist.size() != STATE_SPEC::HISTORY_LENGTH){
+            throw std::runtime_error("StateLinearAccelerationHistory: linear_acceleration_body_history has " + std::to_string(hist.size()) + " entries, expected " + std::to_string(STATE_SPEC::HISTORY_LENGTH));
+        }
+        for(TI step_i = 0; step_i < STATE_SPEC::HISTORY_LENGTH; step_i++){
+            const auto& step_entry = hist.at(step_i);
+            if (step_entry.size() != STATE::ACCELERATION_DIM){
+                throw std::runtime_error("StateLinearAccelerationHistory: entry " + std::to_string(step_i) + " has " + std::to_string(step_entry.size()) + " components, expected " + std::to_string(STATE::ACCELERATION_DIM));
+            }
+            for(TI dim_i = 0; dim_i < STATE::ACCELERATION_DIM; dim_i++){
+                state.linear_acceleration_body_history[step_i][dim_i] = step_entry.at(dim_i);
+            }
+        }
+        TI raw_step = json_object.at("acceleration_history_step");
+        if constexpr(STATE_SPEC::HISTORY_LENGTH == 0){
+            state.acceleration_history_step = 0;
+        }
+        else{
+            if (raw_step >= STATE_SPEC::HISTORY_LENGTH){
+                throw std::runtime_error("StateLinearAccelerationHistory: acceleration_history_step " + std::to_string(raw_step) + " out of range [0, " + std::to_string(STATE_SPEC::HISTORY_LENGTH) + ")");
+            }
+            state.acceleration_history_step = raw_step;
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, nlohmann::json json_object, rl::environments::l2f::StateAngularVelocityDelay<STATE_SPEC>& state){
+        using TI = typename DEVICE::index_t;
+        using STATE = rl::environments::l2f::StateAngularVelocityDelay<STATE_SPEC>;
+        from_json(device, env, parameters, json_object, static_cast<typename STATE::NEXT_COMPONENT&>(state));
+        for(TI step_i = 0; step_i < STATE_SPEC::HISTORY_LENGTH; step_i++){
+            for(TI dim_i = 0; dim_i < 3; dim_i++){
+                state.angular_velocity_history[step_i][dim_i] = json_object["angular_velocity_history"][step_i][dim_i];
+            }
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, nlohmann::json json_object, rl::environments::l2f::StateLinearVelocityDelay<STATE_SPEC>& state){
+        using TI = typename DEVICE::index_t;
+        using STATE = rl::environments::l2f::StateLinearVelocityDelay<STATE_SPEC>;
+        from_json(device, env, parameters, json_object, static_cast<typename STATE::NEXT_COMPONENT&>(state));
+        for(TI step_i = 0; step_i < STATE_SPEC::HISTORY_LENGTH; step_i++){
+            for(TI dim_i = 0; dim_i < 3; dim_i++){
+                state.linear_velocity_history[step_i][dim_i] = json_object["linear_velocity_history"][step_i][dim_i];
+            }
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, nlohmann::json json_object, rl::environments::l2f::StatePoseErrorIntegral<STATE_SPEC>& state){
+        from_json(device, env, parameters, json_object, static_cast<typename STATE_SPEC::NEXT_COMPONENT&>(state));
+        state.position_integral[0] = json_object["position_integral"][0];
+        state.position_integral[1] = json_object["position_integral"][1];
+        state.position_integral[2] = json_object["position_integral"][2];
+        state.orientation_integral = json_object["orientation_integral"];
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, nlohmann::json json_object, rl::environments::l2f::StateRotors<STATE_SPEC>& state){
+        using TI = typename DEVICE::index_t;
+        using STATE = rl::environments::l2f::StateRotors<STATE_SPEC>;
+        from_json(device, env, parameters, json_object, static_cast<typename STATE_SPEC::NEXT_COMPONENT&>(state));
+        for (TI action_i = 0; action_i < STATE::ACTION_DIM; action_i++){
+            state.rpm[action_i] = json_object["rpm"][action_i];
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, nlohmann::json json_object, rl::environments::l2f::StateRotorsHistory<STATE_SPEC>& state){
+        using TI = typename DEVICE::index_t;
+        using STATE = rl::environments::l2f::StateRotorsHistory<STATE_SPEC>;
+        from_json(device, env, parameters, json_object, static_cast<typename STATE::NEXT_COMPONENT&>(state));
+        for(TI step_i = 0; step_i < STATE_SPEC::HISTORY_LENGTH; step_i++){
+            for(TI action_i = 0; action_i < SPEC::PARAMETERS::N; action_i++){
+                state.action_history[step_i][action_i] = json_object["action_history"][step_i][action_i];
+            }
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, nlohmann::json json_object, rl::environments::l2f::StateRandomForce<STATE_SPEC>& state){
+        using TI = typename DEVICE::index_t;
+        from_json(device, env, parameters, json_object, static_cast<typename STATE_SPEC::NEXT_COMPONENT&>(state));
+        for (TI i = 0; i < 3; i++){
+            state.force[i] = json_object["force"][i];
+            state.torque[i] = json_object["torque"][i];
+        }
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE_SPEC>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, nlohmann::json json_object, rl::environments::l2f::StateTrajectory<STATE_SPEC>& state){
+        using TI = typename DEVICE::index_t;
+        from_json(device, env, parameters, json_object, static_cast<typename STATE_SPEC::NEXT_COMPONENT&>(state));
+        state.trajectory_step = json_object["trajectory"]["trajectory_step"];
+    }
+    template <typename DEVICE, typename SPEC, typename PARAMETERS, typename STATE>
+    void from_json(DEVICE& device, rl::environments::Multirotor<SPEC>& env, const PARAMETERS& parameters, std::string json_string, STATE& state){
+        using TI = typename DEVICE::index_t;
+        nlohmann::json json_object = nlohmann::json::parse(json_string);
+        from_json(device, env, parameters, json_object, state);
+    }
+#endif
+    template <typename DEVICE, typename SPEC>
+    std::string get_ui(DEVICE& device, rl::environments::Multirotor<SPEC>& env){
+        // just the body of `function render(ctx, state, action) {` (so that it can be easily processed by `new Function("ctx", "state", "action", body)`
+#ifndef _MSC_VER
+        std::string ui = R"RL_TOOLS_LITERAL(
+
+
+
+
+
+
+
+
+
+
+
+
+
+import * as THREE from "three"
+import {OrbitControls} from "three-orbitcontrols"
+import {GLTFLoader} from "three-gltfloader"
+
+export class CoordinateSystem{
+    constructor(origin, length=1, diameter=0.01) {
+        this.cs = new THREE.Group()
+        const material_red = new THREE.MeshLambertMaterial({color: 0xAA0000})
+        const material_green = new THREE.MeshLambertMaterial({color: 0x00AA00})
+        const material_blue = new THREE.MeshLambertMaterial({color: 0x0000AA})
+        const line = new THREE.BoxGeometry(length, diameter, diameter)
+        var x = new THREE.Mesh( line, material_red);
+        x.position.set(length/2, 0, 0)
+        var y = new THREE.Mesh( line, material_green);
+        y.position.set(0, length/2, 0)
+        y.rotation.set(0, 0, Math.PI/2)
+        var z = new THREE.Mesh( line, material_blue);
+        z.position.set(0, 0, length/2)
+        z.rotation.set(0, Math.PI/2, 0)
+        this.cs.add(x)
+        this.cs.add(y)
+        this.cs.add(z)
+        this.cs.position.set(origin[0], origin[1], origin[2])
+    }
+    get(){
+        return this.cs
+    }
+}
+
+function norm(a){
+    return Math.sqrt(a.map(x => x**2).reduce((a, c) => a + c, 0))
+}
+
+function Matrix4FromRotMatTranspose(rotMat){
+    const m = new THREE.Matrix4()
+    m.set(
+        rotMat[0][0], rotMat[1][0], rotMat[2][0], 0,
+        rotMat[0][1], rotMat[1][1], rotMat[2][1], 0,
+        rotMat[0][2], rotMat[1][2], rotMat[2][2], 0,
+        0, 0, 0, 1)
+    return m
+}
+
+function Matrix4FromRotMat(rotMat){
+    const m = new THREE.Matrix4()
+    m.set(
+        rotMat[0][0], rotMat[0][1], rotMat[0][2], 0,
+        rotMat[1][0], rotMat[1][1], rotMat[1][2], 0,
+        rotMat[2][0], rotMat[2][1], rotMat[2][2], 0,
+        0, 0, 0, 1)
+    return m
+}
+
+
+
+
+class State{
+    constructor(canvas, {devicePixelRatio, showAxes=false, capture=false, camera_position=[0.5, 0.5, 1], camera_distance=null, interactive=true, conta_url="/conta/"}){
+        this.canvas = canvas
+        this.IS_MOBILE = this.is_mobile();
+        this.actualDevicePixelRatio = devicePixelRatio || window.devicePixelRatio
+        this.devicePixelRatio = !this.IS_MOBILE ? this.actualDevicePixelRatio : Math.min(this.actualDevicePixelRatio || 1, 2)
+        this.showAxes = showAxes
+        this.cursor_grab = interactive // Instruct the embedding code to make the cursor a grab cursor
+        this.render_tick = 0
+        this.capture = capture
+        this.camera_position = camera_position
+        this.camera_distance = camera_distance
+        this.interactive = interactive
+        this.lastCanvasWidth = 0
+        this.lastCanvasHeight = 0
+        this.conta_url = conta_url
+    }
+
+    is_mobile() {
+        const isIOS = /iP(hone|ad|od)/.test(navigator.platform) || /iPhone|iPad|iPod/.test(navigator.userAgent);
+        const isAndroid = /Android/.test(navigator.userAgent);
+        const isMobile = /Mobi|Android/i.test(navigator.userAgent) || 'ontouchstart' in window || navigator.maxTouchPoints > 0;
+        const isTablet = /iPad|Android(?!.*Mobile)/.test(navigator.userAgent);
+        return isIOS || isAndroid || isMobile || isTablet;
+    }
+
+    async initialize(){
+        const width = this.canvas.width
+        const height = this.canvas.height
+        this.scene = new THREE.Scene();
+        this.camera = new THREE.PerspectiveCamera( 40, width / height, 0.1, 1000 );
+        this.scene.add(this.camera);
+
+        this.renderer = new THREE.WebGLRenderer({
+            canvas: this.canvas,
+            antialias: !this.IS_MOBILE,
+            alpha: !this.IS_MOBILE,
+            powerPreference: this.IS_MOBILE ? 'low-power' : 'high-performance',
+            preserveDrawingBuffer: this.capture && !this.IS_MOBILE
+          });
+
+        this.renderer.setPixelRatio(this.devicePixelRatio)
+        this.renderer.setClearColor(0xffffff, 0);
+
+        this.renderer.setSize(width/this.actualDevicePixelRatio, height/this.actualDevicePixelRatio);
+
+        this.lastCanvasWidth = this.canvas.width
+        this.lastCanvasHeight = this.canvas.height
+
+
+        // canvasContainer.appendChild(this.renderer.domElement );
+
+        this.controls = this.interactive ? new OrbitControls(this.camera, this.renderer.domElement) : null;
+
+        // this.controls.enabled = false;
+        // window.addEventListener('keydown', (event) => {
+        //     if (event.key === 'Alt') {
+        //         this.controls.enabled = true;
+        //         this.canvas.style.cursor = "grab"
+        //     }
+        // });
+
+        // window.addEventListener('keyup', (event) => {
+        //     if (event.key === 'Alt') {
+        //         this.controls.enabled = false;
+        //         this.canvas.style.cursor = "default"
+        //     }
+        // });
+        this.canvas.title = "Alt+Drag to rotate the camera. Alt+CTRL+Drag to move the camera."
+
+        this.simulator = new THREE.Group()
+        this.simulator.rotation.set(-Math.PI / 2, 0, Math.PI / 2, 'XYZ');
+
+        // const axesHelper = new THREE.AxesHelper(5);
+        // this.scene.add(axesHelper)
+        this.scene.add(this.simulator)
+
+        var light = new THREE.AmbientLight( 0xffffff,0.5 ); // soft white light
+        this.scene.add(light);
+        var directionalLight = new THREE.DirectionalLight( 0xffffff, 0.4 )
+        directionalLight.position.set(-100, 100, 0)
+        directionalLight.target.position.set(0, 0, 0)
+        this.scene.add( directionalLight )
+        var directionalLight = new THREE.DirectionalLight( 0xffffff, 0.3 )
+        directionalLight.position.set(0, 100, 100)
+        directionalLight.target.position.set(0, 0, 0)
+        this.scene.add( directionalLight )
+        var directionalLight = new THREE.DirectionalLight( 0xffffff, 0.2 )
+        directionalLight.position.set(0, 100, -100)
+        directionalLight.target.position.set(0, 0, 0)
+        this.scene.add( directionalLight )
+
+        // this.camera.position.set(...this.camera_position)
+        // this.camera.quaternion.set(-0.14, 0.70, 0.14, 0.68)
+        // this.controls.target.set(0.0, 0.0, 0.0)
+        // this.controls.minDistance = 1
+        // this.controls.minDistance = 5
+        // this.controls.update()
+
+        this.camera_set = false
+        this.THREE = THREE
+    }
+
+}
+
+
+function thrust_direction_to_quaternion(thrust_direction){
+    const x = thrust_direction[0];
+    const y = thrust_direction[1];
+    const z = thrust_direction[2];
+
+    const z_unit = [0.0, 0.0, 1.0];
+
+    let cross_x = z_unit[1] * z - z_unit[2] * y;
+    let cross_y = z_unit[2] * x - z_unit[0] * z;
+    let cross_z = z_unit[0] * y - z_unit[1] * x;
+
+    const dot = z_unit[0] * x + z_unit[1] * y + z_unit[2] * z;
+
+    const angle = Math.acos(dot);
+
+    const cross_magnitude = Math.sqrt(cross_x * cross_x + cross_y * cross_y + cross_z * cross_z);
+    if (cross_magnitude != 0) {
+        cross_x /= cross_magnitude;
+        cross_y /= cross_magnitude;
+        cross_z /= cross_magnitude;
+    }
+
+    const half_angle = angle / 2.0;
+    const sin_half_angle = Math.sin(half_angle);
+
+    const qw = Math.cos(half_angle);
+    const qx = cross_x * sin_half_angle;
+    const qy = cross_y * sin_half_angle;
+    const qz = cross_z * sin_half_angle;
+    return [qw, qx, qy, qz];
+}
+
+export class DroneMesh{
+  static glbCache = new Map();
+  static gltfLoader = new GLTFLoader();
+
+  constructor(parameters, origin, displayIMUCoordinateSystem, displayActions, conta_url){
+    console.assert(parameters.ui)
+    this.group = new THREE.Group()
+    const url = `${conta_url}${parameters.ui.model}`
+    
+    if (DroneMesh.glbCache.has(url)) {
+      this.loaded = DroneMesh.glbCache.get(url)
+    } else {
+      const loadingPromise = DroneMesh.gltfLoader.loadAsync(url).then((gltf) => {
+        return gltf
+      }).catch((error) => {
+        DroneMesh.glbCache.delete(url)
+        throw error
+      })
+      
+      DroneMesh.glbCache.set(url, loadingPromise)
+      this.loaded = loadingPromise
+    }
+    
+    this.loaded.then((gltf) => {
+      const object = gltf.scene.clone()
+      const object_group = new THREE.Group()
+      object_group.add(object)
+//      if(parameters.ui.name == "x500"){
+      object_group.rotation.set(Math.PI / 2, 0, Math.PI / 2, 'ZYX')
+      const scale = 0.5
+      object_group.scale.set(scale, scale, scale)
+//      }
+      this.group.add(object_group)
+    })
+    if (displayIMUCoordinateSystem) {
+      const scale = 1 //model.mass
+      const coordinateSystemLength = Math.cbrt(scale)
+      const coordinateSystemThickness = 0.01 * coordinateSystemLength
+      this.group.add((new CoordinateSystem([0, 0, 0], coordinateSystemLength, coordinateSystemThickness)).get())
+    }
+  }
+  get(){
+    return this.group
+  }
+  set_action(action){ }
+}
+
+export class DroneDefault{
+    constructor(parameters, origin, displayIMUCoordinateSystem, displayActions){
+        const url = window.location.href;
+        const urlObj = new URL(url);
+        const params = new URLSearchParams(urlObj.search);
+        if(params.has('L2FDisplayActions') === true){
+            displayActions = params.get('L2FDisplayActions') === "true";
+        }
+
+        // console.log(model)
+        this.origin = origin
+        this.parameters = parameters
+        this.droneFrame = new THREE.Group()
+        this.drone = new THREE.Group()
+        if(origin){
+            this.drone.position.set(...origin)
+        }
+        // this.drone.add((new CoordinateSystem()).get())
+        // this.drone.add((new CoordinateSystem(10 * this.scale, 0.1 * this.scale)).get())
+        this.scale = parameters.dynamics.mass
+        const material = new THREE.MeshLambertMaterial({color: 0xAAAAAA})
+        const clockwise_rotor_material = new THREE.MeshLambertMaterial({color: 0x00FF00})
+        const counter_clockwise_rotor_material = new THREE.MeshLambertMaterial({color: 0xFF0000})
+
+        const coordinateSystemLength = Math.cbrt(this.scale)
+        const coordinateSystemThickness = 0.01 * coordinateSystemLength
+
+        const centerSize = Math.cbrt(this.scale) / 15
+        const centerForm = new THREE.BoxGeometry(centerSize, centerSize, centerSize*0.3)
+        const center = new THREE.Mesh( centerForm, material);
+
+        this.parameters.dynamics["imu_position"] = [0, 0, 0]
+        this.parameters.dynamics["imu_orientation"] = [1, 0, 0, 0]
+
+        this.imuGroup = new THREE.Group()
+        this.imuGroup.position.set(...this.parameters.dynamics.imu_position)
+        this.imuGroup.quaternion.set(this.parameters.dynamics.imu_orientation[1], this.parameters.dynamics.imu_orientation[2], this.parameters.dynamics.imu_orientation[3], this.parameters.dynamics.imu_orientation[0])
+        if (displayIMUCoordinateSystem) {
+            this.imuGroup.add((new CoordinateSystem([0, 0, 0], coordinateSystemLength, coordinateSystemThickness)).get())
+        }
+        this.drone.add(this.imuGroup)
+        this.drone.add(center)
+
+        this.rotors = []
+
+        const averageArmLength = this.parameters.dynamics.rotor_positions.map(position => norm(position)).reduce((a, c) => a + c, 0) / this.parameters.dynamics.rotor_positions.length
+        for(const [rotorIndex, rotor_position] of this.parameters.dynamics.rotor_positions.entries()){
+            let rotorCageRadiusFactor = 1
+            let rotorCageThicknessFactor = 1
+            const rotorCageRadius =  averageArmLength/3 * Math.sqrt(rotorCageRadiusFactor)
+            const rotorCageThickness = averageArmLength/20 * Math.sqrt(rotorCageThicknessFactor)
+            const armGroup = new THREE.Group()
+            const length = norm(rotor_position)
+            const armDiameter = averageArmLength/10
+            const armLength = length - rotorCageRadius
+            const armForm = new THREE.CylinderGeometry( armDiameter/2, armDiameter/2, armLength, 8 );
+            const rot = new THREE.Quaternion(); // Geometry extends in y -> transform y to relative pos
+            rot.setFromUnitVectors(new THREE.Vector3(...[0, 1, 0]), (new THREE.Vector3(...rotor_position)).normalize());
+            armGroup.quaternion.set(rot.x, rot.y, rot.z, rot.w)
+
+            const arm = new THREE.Mesh(armForm, material)
+            arm.position.set(0, armLength/2, 0)
+            armGroup.add(arm)
+
+            const rotorGroup = new THREE.Group()
+            rotorGroup.position.set(...rotor_position)
+
+            const thrust_orientation = thrust_direction_to_quaternion(this.parameters.dynamics.rotor_thrust_directions[rotorIndex])
+            rotorGroup.quaternion.set(thrust_orientation[3], thrust_orientation[0], thrust_orientation[1], thrust_orientation[2])
+            // rotorGroup.add((new CoordinateSystem([0, 0, 0], 0.1, 0.01)).get())
+            const rotorCageForm = new THREE.TorusGeometry(rotorCageRadius, rotorCageThickness, 16, 32 );
+            const cageMaterial = (this.parameters.dynamics.rotor_thrust_directions[rotorIndex][2] < 0 ? clockwise_rotor_material : counter_clockwise_rotor_material)// new THREE.MeshLambertMaterial({color: 0xAAAAAA})
+            const rotorCage = new THREE.Mesh(rotorCageForm, cageMaterial)
+            rotorGroup.add(rotorCage)
+
+            const forceArrow = new THREE.ArrowHelper(new THREE.Vector3(0,0,1), new THREE.Vector3(0,0,0 ), 0, 0x000000);
+            if(displayActions){
+                rotorGroup.add(forceArrow)
+            }
+
+            this.drone.add(rotorGroup)
+            this.drone.add(armGroup)
+            this.droneFrame.add(this.drone)
+            this.rotors.push({
+                forceArrow,
+                rotorCage
+            })
+        }
+
+    }
+    get(){
+        return this.droneFrame
+    }
+    // setState(state){
+    //   const mat = Matrix4FromRotMat(state.orientation)
+    //   this.droneFrame.quaternion.setFromRotationMatrix(mat)
+    //   this.droneFrame.position.set(state.pose.position[0] + this.origin[0], state.pose.position[1] + this.origin[1], state.pose.position[2] + this.origin[2])
+    //   const avg_rot_rate = state.rotor_states.reduce((a, c) => a + c["power"], 0)/state.rotor_states.length
+    //   state.rotor_states.map((rotorState, i) => {
+    //     const forceArrow = this.rotors[i].forceArrow
+    //     const rotorCage = this.rotors[i].rotorCage
+    //     const min_rpm = this.model.rotors[i].min_rpm
+    //     const max_rpm = this.model.rotors[i].max_rpm
+
+
+    //     const rot_rate = rotorState["power"]
+    //     const force_magnitude = (rot_rate - avg_rot_rate)/max_rpm * 10///1000
+    //     forceArrow.setDirection(new THREE.Vector3(0, 0, rot_rate)) //Math.sign(force_magnitude)))
+    //     forceArrow.setLength(Math.cbrt(this.this.scale)/10) //Math.abs(force_magnitude))
+    //   })
+    // }
+    set_action(action){
+        for(let i = 0; i < 4; i++){
+            const forceArrow = this.rotors[i].forceArrow
+            const force_magnitude = action[i]
+            forceArrow.setDirection(new THREE.Vector3(0, 0, force_magnitude))
+            forceArrow.setLength(Math.cbrt(this.scale)/10)
+        }
+    }
+
+}
+
+async function drone_factory(parameters, origin, displayIMUCoordinateSystem, displayActions, conta_url){
+  if(parameters.ui && parameters.ui.enable && parameters.ui.model){
+    try{
+      const model = new DroneMesh(parameters, origin, displayIMUCoordinateSystem, displayActions, conta_url)
+      await model.loaded
+      return model
+    }
+    catch(error){
+      console.error("An error occurred:", error.message);
+    }
+  }
+  return new DroneDefault(parameters, origin, displayIMUCoordinateSystem, displayActions)
+}
+
+export async function init(canvas, options){
+    const state = new State(canvas, options)
+    await state.initialize()
+    return state
+}
+function clear_episode(ui_state){
+    if(ui_state.drone){
+        ui_state.simulator.remove(ui_state.drone.get())
+        if(ui_state.showAxes){
+            ui_state.simulator.remove(ui_state.origin_coordinate_system.get())
+        }
+    }
+    if(ui_state.drones){
+        ui_state.drones.map(drone => ui_state.simulator.remove(drone.get()))
+        if(ui_state.showAxes){
+            ui_state.origin_coordinate_systems.map(cs => ui_state.simulator.remove(cs.get()))
+        }
+    }
+    // Clear trajectory visualization
+    if(ui_state.trajectoryVis){
+        ui_state.simulator.remove(ui_state.trajectoryVis.group)
+        ui_state.trajectoryVis = null
+    }
+    if(ui_state.trajectoryVisArray){
+        ui_state.trajectoryVisArray.forEach(tv => {
+            if(tv) ui_state.simulator.remove(tv.group)
+        })
+        ui_state.trajectoryVisArray = null
+    }
+}
+function set_camera(ui_state, distance, target){
+    const scale = 1/Math.sqrt(ui_state.camera_position[0]**2 + ui_state.camera_position[1]**2 + ui_state.camera_position[2]**2) * distance
+    const tx = target ? target[0] : 0
+    const ty = target ? target[1] : 0
+    const tz = target ? target[2] : 0
+    if(!ui_state.camera_set){
+        ui_state.camera.position.set(ui_state.camera_position[0] * scale + tx, ui_state.camera_position[1] * scale + ty, ui_state.camera_position[2] * scale + tz)
+        ui_state.camera.lookAt(tx, ty, tz)
+        if(ui_state.controls){
+            ui_state.controls.target.set(tx, ty, tz)
+        }
+        ui_state.camera_set = true
+        if(ui_state.controls) ui_state.controls.update()
+    }
+}
+export async function episode_init(ui_state, parameters){
+    let distance = (parameters.ui && parameters.ui.camera_distance) ? parameters.ui.camera_distance : Math.cbrt(parameters.dynamics.mass) * 2
+    if(ui_state.camera_distance){
+        distance = ui_state.camera_distance
+    }
+    set_camera(ui_state, distance)
+    clear_episode(ui_state)
+    ui_state.drone = await drone_factory(parameters, [0, 0, 0], ui_state.showAxes, false, ui_state.conta_url)
+    ui_state.simulator.add(ui_state.drone.get())
+    const scale = parameters.dynamics.mass
+    if(ui_state.showAxes){
+        ui_state.origin_coordinate_system = new CoordinateSystem([0, 0, 0], 1 * scale, 0.01 * scale)
+        ui_state.simulator.add(ui_state.origin_coordinate_system.get())
+    }
+    ui_state.trajectoryVis = create_trajectory_visualization(parameters, scale)
+    if(ui_state.trajectoryVis){
+        ui_state.simulator.add(ui_state.trajectoryVis.group)
+    }
+    await setup_onboard_camera(ui_state, parameters)
+}
+
+export async function episode_init_multi(ui_state, parameters){
+    const grid_distance = 0.0
+    const grid_size = Math.ceil(Math.sqrt(parameters.length))
+    let distance = (grid_distance > 0 ? grid_distance * grid_size * 2 : Math.cbrt(parameters[0].dynamics.mass))
+    if(parameters.ui && parameters.ui.camera_distance){
+        distance = parameters.ui.camera_distance
+    }
+    if(ui_state.camera_distance){
+        distance = ui_state.camera_distance
+    }
+    set_camera(ui_state, distance)
+    clear_episode(ui_state)
+    ui_state.drones = []
+    ui_state.trajectoryVisArray = []
+    if(!ui_state.showAxes && ui_state.origin_coordinate_systems){
+        ui_state.origin_coordinate_systems.forEach(cs => {
+            ui_state.simulator.remove(cs.get())
+        })
+    }
+    ui_state.origin_coordinate_systems = []
+    await Promise.all(parameters.map(async (parameter, i) => {
+        const x = (i % grid_size) * grid_distance
+        const y = Math.floor(i / grid_size) * grid_distance
+        const drone = await drone_factory(parameter, [x, y, 0], ui_state.showAxes, false, ui_state.conta_url)
+        ui_state.simulator.add(drone.get())
+        if(ui_state.showAxes){
+            const cs = new CoordinateSystem([x, y, 0], 1, 0.01)
+            ui_state.simulator.add(cs.get())
+            ui_state.origin_coordinate_systems.push(cs)
+        }
+        ui_state.drones.push(drone)
+        // Create trajectory visualization for first N drones only (performance optimization)
+        const MAX_TRAJECTORY_VISUALIZATIONS = 5
+        if(i < MAX_TRAJECTORY_VISUALIZATIONS){
+            const scale = parameter.dynamics.mass
+            const trajectoryVis = create_trajectory_visualization(parameter, scale)
+            if(trajectoryVis){
+                // Offset trajectory to match drone grid position
+                trajectoryVis.group.position.set(x, y, 0)
+                ui_state.simulator.add(trajectoryVis.group)
+            }
+            ui_state.trajectoryVisArray.push(trajectoryVis)
+        } else {
+            ui_state.trajectoryVisArray.push(null)
+        }
+    }))
+    await setup_onboard_camera(ui_state, parameters[0])
+}
+
+function get_desired_onboard_dims(parameters){
+    const visual = parameters && parameters.visual
+    if(visual && visual.cam_width && visual.cam_height && visual.fov){
+        return {
+            cam_w: visual.cam_width,
+            cam_h: visual.cam_height,
+            fov: visual.fov,
+        }
+    }
+    throw new Error("get_desired_onboard_dims: parameters.visual is missing cam_width/cam_height")
+}
+
+function ensure_onboard_render_state(ui_state, cam_w, cam_h, fov){
+    if(!ui_state.onboard_scene) return
+    const aspect = cam_w / cam_h
+    const vfov_deg = 2 * Math.atan(Math.tan(fov / 2) / aspect) * 180 / Math.PI
+    let rt_changed = false
+    if(!ui_state.onboard_render_target){
+        ui_state.onboard_render_target = new THREE.WebGLRenderTarget(cam_w, cam_h)
+        rt_changed = true
+    } else if(ui_state.onboard_render_target.width !== cam_w || ui_state.onboard_render_target.height !== cam_h){
+        ui_state.onboard_render_target.setSize(cam_w, cam_h)
+        rt_changed = true
+    }
+    const buf_size = cam_w * cam_h * 4
+    if(!ui_state.onboard_pixel_buffer || ui_state.onboard_pixel_buffer.length !== buf_size){
+        ui_state.onboard_pixel_buffer = new Uint8Array(buf_size)
+    }
+    if(ui_state.onboard_camera){
+        const eps = 1e-4
+        if(Math.abs(ui_state.onboard_camera.aspect - aspect) > eps || Math.abs(ui_state.onboard_camera.fov - vfov_deg) > eps){
+            ui_state.onboard_camera.aspect = aspect
+            ui_state.onboard_camera.fov = vfov_deg
+            ui_state.onboard_camera.updateProjectionMatrix()
+        }
+    }
+    ui_state.onboard_overlay_max_extent = Math.max(cam_w, cam_h) * 3
+    if(rt_changed){
+        ui_state.onboard_overlay_quad = null
+        ui_state.onboard_overlay_blit_scene = null
+        ui_state.onboard_overlay_blit_camera = null
+    }
+}
+
+async function setup_onboard_camera(ui_state, parameters){
+    const visual = parameters.visual
+    if(!visual || !visual.scene_hash || visual.scene_hash === '0000000000000000000000000000000000000000') return
+    const dims = get_desired_onboard_dims(parameters)
+    const aspect = dims.cam_w / dims.cam_h
+    const vfov_deg = 2 * Math.atan(Math.tan(dims.fov / 2) / aspect) * 180 / Math.PI
+    ui_state.onboard_camera = new THREE.PerspectiveCamera(vfov_deg, aspect, 0.05, 100)
+    ui_state.onboard_scene = new THREE.Scene()
+    ui_state.onboard_scene.background = new THREE.Color(0x87CEEB)
+    const ambient = new THREE.AmbientLight(0xffffff, 0.6)
+    ui_state.onboard_scene.add(ambient)
+    const dir_light = new THREE.DirectionalLight(0xffffff, 0.8)
+    dir_light.position.set(5, 10, 5)
+    ui_state.onboard_scene.add(dir_light)
+    const scene_url = `${ui_state.conta_url}data/${visual.scene_hash}`
+    try {
+        const prev_enabled = THREE.ColorManagement.enabled
+        THREE.ColorManagement.enabled = false
+        const gltf = await new GLTFLoader().loadAsync(scene_url)
+        THREE.ColorManagement.enabled = prev_enabled
+        ui_state.onboard_scene.add(gltf.scene)
+    } catch(e) {
+        console.error('Failed to load scene GLB for onboard camera:', e)
+        ui_state.onboard_camera = null
+        ui_state.onboard_scene = null
+    }
+    ui_state.onboard_scene_translation = visual.scene_translation || [0, 0, 0]
+    ensure_onboard_render_state(ui_state, dims.cam_w, dims.cam_h, dims.fov)
+}
+
+function update_onboard_camera(ui_state, state, parameters){
+    if(!ui_state.onboard_camera || !ui_state.onboard_scene) return
+    const st = ui_state.onboard_scene_translation || [0, 0, 0]
+    // FLU (X-fwd, Y-left, Z-up) → Three.js Y-up: (x,y,z) → (x, z, -y)
+    // st is in FLU coordinates
+    ui_state.onboard_camera.position.set(state.position[0] + st[0], state.position[2] + st[2], -(state.position[1] + st[1]))
+    // FLU quat axis (ax,ay,az) → Three.js axis (ax, az, -ay)
+    const qw = state.orientation[0], qx = state.orientation[1], qy = state.orientation[2], qz = state.orientation[3]
+    const scene_quat = new THREE.Quaternion(qx, qz, -qy, qw)
+    // Camera forward = body +X = Three.js +X, Three.js camera looks along -Z
+    const body_to_cam = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), -Math.PI / 2)
+    ui_state.onboard_camera.quaternion.copy(scene_quat.multiply(body_to_cam))
+}
+
+function render_onboard_overlay(ui_state){
+    if(!ui_state.onboard_camera || !ui_state.onboard_scene || !ui_state.renderer) return
+    const max_extent = ui_state.onboard_overlay_max_extent || 128
+    const rt = ui_state.onboard_render_target
+    const rt_aspect = (rt && rt.width && rt.height) ? (rt.width / rt.height) : (ui_state.onboard_camera.aspect || 1)
+    const overlay_w = rt_aspect >= 1 ? max_extent : Math.max(1, Math.round(max_extent * rt_aspect))
+    const overlay_h = rt_aspect >= 1 ? Math.max(1, Math.round(max_extent / rt_aspect)) : max_extent
+    const margin = 10
+    const canvas_w = ui_state.canvas.width / ui_state.devicePixelRatio
+    const canvas_h = ui_state.canvas.height / ui_state.devicePixelRatio
+    const x = canvas_w - overlay_w - margin
+    const prev_autoClear = ui_state.renderer.autoClear
+    ui_state.renderer.autoClear = false
+    ui_state.renderer.setScissorTest(true)
+    ui_state.renderer.setViewport(x, margin, overlay_w, overlay_h)
+    ui_state.renderer.setScissor(x, margin, overlay_w, overlay_h)
+    ui_state.renderer.clearDepth()
+    if(ui_state.onboard_obs_resolution && ui_state.onboard_render_target){
+        if(!ui_state.onboard_overlay_quad){
+            const geo = new THREE.PlaneGeometry(2, 2)
+            const mat = new THREE.MeshBasicMaterial({map: ui_state.onboard_render_target.texture, depthTest: false})
+            mat.map.magFilter = THREE.NearestFilter
+            ui_state.onboard_overlay_quad = new THREE.Mesh(geo, mat)
+            ui_state.onboard_overlay_blit_scene = new THREE.Scene()
+            ui_state.onboard_overlay_blit_scene.add(ui_state.onboard_overlay_quad)
+            ui_state.onboard_overlay_blit_camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1)
+        }
+        ui_state.renderer.render(ui_state.onboard_overlay_blit_scene, ui_state.onboard_overlay_blit_camera)
+    } else {
+        ui_state.renderer.render(ui_state.onboard_scene, ui_state.onboard_camera)
+    }
+    ui_state.renderer.setScissorTest(false)
+    ui_state.renderer.setViewport(0, 0, canvas_w, canvas_h)
+    ui_state.renderer.autoClear = prev_autoClear
+}
+
+export async function setup_onboard_scene(ui_state, scene_hash, cam_w, cam_h, fov){
+    const aspect = cam_w / cam_h
+    const vfov_deg = 2 * Math.atan(Math.tan(fov / 2) / aspect) * 180 / Math.PI
+    ui_state.onboard_camera = new THREE.PerspectiveCamera(vfov_deg, aspect, 0.05, 100)
+    ui_state.onboard_scene = new THREE.Scene()
+    ui_state.onboard_scene.background = new THREE.Color(0x87CEEB)
+    ui_state.onboard_scene.add(new THREE.AmbientLight(0xffffff, 0.6))
+    const dir_light = new THREE.DirectionalLight(0xffffff, 0.8)
+    dir_light.position.set(5, 10, 5)
+    ui_state.onboard_scene.add(dir_light)
+    if(scene_hash && scene_hash !== 'none'){
+        const scene_url = `${ui_state.conta_url}${scene_hash}`
+        try {
+            const prev_enabled = THREE.ColorManagement.enabled
+            THREE.ColorManagement.enabled = false
+            const gltf = await new GLTFLoader().loadAsync(scene_url)
+            THREE.ColorManagement.enabled = prev_enabled
+            ui_state.onboard_scene.add(gltf.scene)
+        } catch(e) {
+            console.error('Failed to load scene GLB:', e)
+        }
+    }
+    ui_state.onboard_scene_translation = [0, 0, 0]
+    ensure_onboard_render_state(ui_state, cam_w, cam_h, fov)
+}
+
+export function render_onboard_pixels(ui_state, state, parameters){
+    if(!ui_state.onboard_camera || !ui_state.onboard_scene || !ui_state.renderer) return null
+    const dims = get_desired_onboard_dims(parameters)
+    ensure_onboard_render_state(ui_state, dims.cam_w, dims.cam_h, dims.fov)
+    if(!ui_state.onboard_render_target) return null
+    update_onboard_camera(ui_state, state, parameters)
+    ui_state.renderer.setRenderTarget(ui_state.onboard_render_target)
+    ui_state.renderer.render(ui_state.onboard_scene, ui_state.onboard_camera)
+    ui_state.renderer.setRenderTarget(null)
+    const w = ui_state.onboard_render_target.width, h = ui_state.onboard_render_target.height
+    ui_state.renderer.readRenderTargetPixels(ui_state.onboard_render_target, 0, 0, w, h, ui_state.onboard_pixel_buffer)
+    const rgb = new Float32Array(w * h * 3)
+    for(let y = 0; y < h; y++){
+        const src_y = h - 1 - y
+        for(let x = 0; x < w; x++){
+            const dst = (y * w + x) * 3
+            const src = (src_y * w + x) * 4
+            rgb[dst + 0] = ui_state.onboard_pixel_buffer[src + 0] / 255
+            rgb[dst + 1] = ui_state.onboard_pixel_buffer[src + 1] / 255
+            rgb[dst + 2] = ui_state.onboard_pixel_buffer[src + 2] / 255
+        }
+    }
+    return rgb
+}
+
+function update_camera(ui_state){
+    const currentWidth = ui_state.canvas.width
+    const currentHeight = ui_state.canvas.height
+    const hasResized = currentWidth !== ui_state.lastCanvasWidth || currentHeight !== ui_state.lastCanvasHeight
+
+    if (hasResized) {
+        const width = currentWidth / ui_state.devicePixelRatio;
+        const height = currentHeight / ui_state.devicePixelRatio;
+
+        if (ui_state.camera.aspect !== width / height) {
+            ui_state.camera.aspect = width / height;
+            ui_state.camera.updateProjectionMatrix();
+        }
+
+        if (ui_state.renderer) {
+            ui_state.renderer.setPixelRatio(ui_state.devicePixelRatio);
+            ui_state.renderer.setSize(width, height, false);
+        }
+
+        ui_state.lastCanvasWidth = currentWidth
+        ui_state.lastCanvasHeight = currentHeight
+    }
+
+    if(ui_state.interactive && ui_state.controls){
+        ui_state.controls.update()
+    }
+    if(ui_state.renderer){
+        ui_state.renderer.render(ui_state.scene, ui_state.camera);
+    }
+    ui_state.render_tick += 1
+}
+
+function clip_position(scale, position){
+    const extent = Math.cbrt(scale) * 300 // to maybe prevent threejs from exploding
+    const max_position = extent
+    const min_position = -extent
+    return position.map((p) => {
+        if(p > max_position){
+            return max_position
+        }
+        else if(p < min_position){
+            return min_position
+        }
+        else{
+            return p
+        }
+    })
+}
+
+function get_trajectory_index(trajectory_step, trajectory_length){
+    const full_step = trajectory_step
+    const interval = Math.floor(full_step / trajectory_length)
+    const forward = interval % 2 === 0
+    const progress = full_step % trajectory_length
+    const position = forward ? progress : (trajectory_length - progress - 1)
+    return position
+}
+
+function create_trajectory_visualization(parameters, scale){
+    if(!parameters.trajectory || !parameters.trajectory.steps){
+        return null
+    }
+    const trajectory = parameters.trajectory
+    const steps = trajectory.steps
+    if(steps.length < 2){
+        return null
+    }
+    
+    const group = new THREE.Group()
+    
+    // Create trajectory line
+    const points = steps.map(step => new THREE.Vector3(step.position[0], step.position[1], step.position[2]))
+    const curve = new THREE.CatmullRomCurve3(points, false)
+    const lineThickness = Math.cbrt(scale) * 0.02
+    const tubeGeometry = new THREE.TubeGeometry(curve, steps.length * 4, lineThickness, 8, false)
+    const lineMaterial = new THREE.MeshLambertMaterial({color: 0x4488FF, transparent: true, opacity: 0.6})
+    const trajectoryMesh = new THREE.Mesh(tubeGeometry, lineMaterial)
+    group.add(trajectoryMesh)
+    
+    // Create bug (target indicator sphere)
+    const bugRadius = Math.cbrt(scale) * 0.05
+    const bugGeometry = new THREE.SphereGeometry(bugRadius, 16, 16)
+    const bugMaterial = new THREE.MeshLambertMaterial({color: 0xFF4444, emissive: 0x441111})
+    const bug = new THREE.Mesh(bugGeometry, bugMaterial)
+    bug.position.set(steps[0].position[0], steps[0].position[1], steps[0].position[2])
+    group.add(bug)
+    
+    return {
+        group: group,
+        bug: bug,
+        steps: steps,
+        length: trajectory.LENGTH || steps.length
+    }
+}
+
+function update_trajectory_bug(trajectoryVis, trajectory_step){
+    if(!trajectoryVis || !trajectoryVis.bug || trajectory_step === undefined){
+        return
+    }
+    const index = get_trajectory_index(trajectory_step, trajectoryVis.length)
+    const step = trajectoryVis.steps[index]
+    if(step){
+        trajectoryVis.bug.position.set(step.position[0], step.position[1], step.position[2])
+    }
+}
+
+export async function render(ui_state, parameters, state, action) {
+    if(ui_state.drone){
+        ui_state.drone.get().position.set(...clip_position(parameters.dynamics.mass, state.position))
+        ui_state.drone.get().quaternion.copy(new THREE.Quaternion(state.orientation[1], state.orientation[2], state.orientation[3], state.orientation[0]).normalize())
+    }
+    if(ui_state.trajectoryVis && state.trajectory && state.trajectory.trajectory_step !== undefined){
+        update_trajectory_bug(ui_state.trajectoryVis, state.trajectory.trajectory_step)
+    }
+    if(ui_state.show_onboard_preview && ui_state.onboard_scene){
+        const dims = get_desired_onboard_dims(parameters)
+        ensure_onboard_render_state(ui_state, dims.cam_w, dims.cam_h, dims.fov)
+        if(ui_state.onboard_obs_resolution && ui_state.onboard_render_target){
+            render_onboard_pixels(ui_state, state, parameters)
+        } else {
+            update_onboard_camera(ui_state, state, parameters)
+        }
+    }
+    update_camera(ui_state)
+    if(ui_state.show_onboard_preview && ui_state.onboard_scene) render_onboard_overlay(ui_state)
+}
+
+export async function render_multi(ui_state, parameters, states, actions){
+    if(ui_state.drones && ui_state.drones.length == states.length){
+        states.map((state, i) => {
+            const action = actions[i]
+            const current_parameters = parameters[i]
+            ui_state.drones[i].get().position.set(...clip_position(current_parameters.dynamics.mass, state.position))
+            ui_state.drones[i].get().quaternion.copy(new THREE.Quaternion(state.orientation[1], state.orientation[2], state.orientation[3], state.orientation[0]).normalize())
+            ui_state.drones[i].set_action(action)
+            if(ui_state.trajectoryVisArray && ui_state.trajectoryVisArray[i] && state.trajectory && state.trajectory.trajectory_step !== undefined){
+                update_trajectory_bug(ui_state.trajectoryVisArray[i], state.trajectory.trajectory_step)
+            }
+        })
+        if(ui_state.show_onboard_preview && ui_state.onboard_scene){
+            const dims = get_desired_onboard_dims(parameters[0])
+            ensure_onboard_render_state(ui_state, dims.cam_w, dims.cam_h, dims.fov)
+            if(ui_state.onboard_obs_resolution && ui_state.onboard_render_target){
+                render_onboard_pixels(ui_state, states[0], parameters[0])
+            } else {
+                update_onboard_camera(ui_state, states[0], parameters[0])
+            }
+        }
+    }
+    update_camera(ui_state)
+    if(ui_state.show_onboard_preview && ui_state.onboard_scene) render_onboard_overlay(ui_state)
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        )RL_TOOLS_LITERAL";
+#else
+        std::string ui = "";
+#endif
+        return ui;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif