hyperverse 0.0.1__py3-none-any.whl

hyperdrone/examples/Benchmark.ipynb

@@ -0,0 +1,102 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0",
+   "metadata": {},
+   "source": [
+    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/rl-tools/rl-tools-internal/blob/render/interface/python/hyperdrone/hyperdrone/examples/Benchmark.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install --upgrade -qq \"hyperdrone[examples]\"\n",
+    "!pip install -qq torch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "from hyperdrone import render\n",
+    "from hyperdrone.examples.data import procthor_scene_path\n",
+    "\n",
+    "NUM_CAMERAS = 4096\n",
+    "WIDTH, HEIGHT = 64, 64\n",
+    "ITERATIONS = 500\n",
+    "\n",
+    "scene = render.load_scene(procthor_scene_path(), fidelity=\"medium\")\n",
+    "renderer = render.Renderer(\n",
+    "    width=WIDTH, \n",
+    "    height=HEIGHT, \n",
+    "    num_cameras=NUM_CAMERAS, \n",
+    "    output=\"rgb\", \n",
+    "    fidelity=\"medium\")\n",
+    "renderer.init(scene)\n",
+    "renderer.generate_cameras(center=(-3.92, -5.67, 1.0), radius=0.01, fov=80)\n",
+    "\n",
+    "start = time.perf_counter()\n",
+    "for _ in range(ITERATIONS):\n",
+    "    renderer.render_launch()\n",
+    "renderer.synchronize()\n",
+    "elapsed = time.perf_counter() - start\n",
+    "\n",
+    "frames = ITERATIONS * NUM_CAMERAS\n",
+    "print(f\"Throughput: {frames / elapsed:.1f} frames/s\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import torch\n",
+    "\n",
+    "frame = torch.from_dlpack(renderer.frame_dlpack())\n",
+    "print(f\"Framebuffer: {frame.shape}, {frame.dtype}, {frame.device}\")\n",
+    "\n",
+    "GRID = 12\n",
+    "frames = frame[:GRID**2*16][::16].reshape(GRID, GRID, HEIGHT, WIDTH, 4)\n",
+    "tiled = frames.permute(0, 2, 1, 3, 4).reshape(GRID * HEIGHT, GRID * WIDTH, 4)\n",
+    "plt.figure(figsize=(12, 12))\n",
+    "plt.imshow(tiled.cpu())\n",
+    "plt.axis(\"off\")\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "kernelspec": {
+   "display_name": ".venv (3.9.6.final.0)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

hyperdrone/examples/HyperDrone.ipynb

@@ -0,0 +1,514 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/rl-tools/rl-tools-internal/blob/render/interface/python/hyperdrone/hyperdrone/examples/HyperDrone.ipynb)\n",
+    "\n",
+    "# HyperDrone\n",
+    "\n",
+    "Fly the C++ RLtools training environment from Python: **use it, configure it, drive it,\n",
+    "or extend it**. Each section produces a short video; the last cell combines them into\n",
+    "`hyperdrone.mp4`.\n",
+    "\n",
+    "1. **Fly the preset** — an X500, then a batch of different drone models.\n",
+    "2. **A task is one knob** — current and target images, side by side.\n",
+    "3. **Your own task is a Python loop** — rewards, goals, and independent episode resets.\n",
+    "4. **Your own world is a small C++ header** — motion-blurred propellers and anti-aliasing.\n",
+    "\n",
+    "RAPTOR supplies the motor commands using **privileged state**, not pixels. The images\n",
+    "are the environment's visual observations; this is an API demonstration, not a trained\n",
+    "visual-navigation policy. First construction JIT-compiles each configuration and caches it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "import importlib.util\n",
+    "import site\n",
+    "import sysconfig\n",
+    "from pathlib import Path\n",
+    "\n",
+    "checkout = next((path for path in [Path.cwd(), *Path.cwd().parents] if (path / \"interface/python/hyperdrone/pyproject.toml\").is_file()), None)\n",
+    "if checkout is not None:\n",
+    "    %pip install -q -e \"{checkout}/interface/python/conta\" -e \"{checkout}/interface/python/hyperdrone[examples]\"\n",
+    "    site.addsitedir(sysconfig.get_paths()[\"purelib\"])  # activates the editable install's .pth without a kernel restart\n",
+    "elif importlib.util.find_spec(\"hyperdrone\") is None:  # fresh runtime (e.g. Colab)\n",
+    "    %pip install -q \"hyperdrone[examples]\"\n",
+    "%pip install -q foundation-policy==1.0.1"
+   ],
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup\n",
+    "\n",
+    "The two content hashes pin the scene corpus; `conta` downloads it once into the shared\n",
+    "cache. Every listed scene stays resident, so keep this working set small. Set\n",
+    "`HYPERDRONE_SCENES` to a directory of `.glb` files to use your own scenes.\n",
+    "\n",
+    "We film at 25 FPS, capturing every fourth 10 ms dynamics step: playback is real time.\n",
+    "The small initial displacement and nearby goals keep these indoor demonstrations compact.\n",
+    "\n",
+    "The folded cell below contains only video-formatting helpers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "import os\n",
+    "from contextlib import closing\n",
+    "from dataclasses import replace\n",
+    "from pathlib import Path\n",
+    "\n",
+    "import numpy as np\n",
+    "from foundation_policy import Raptor\n",
+    "from IPython.display import Video, display\n",
+    "from scipy.spatial.transform import Rotation\n",
+    "\n",
+    "from hyperdrone.env import EnvConfig, MultiEnvironment\n",
+    "from hyperdrone.examples.data import PROCTHOR_SCENE, rigged_model_path, x500_model_path\n",
+    "\n",
+    "scenes = [PROCTHOR_SCENE, {\n",
+    "    \"description\": \"ai2thor-hab/glb/ProcTHOR-Train-0.glb\",\n",
+    "    \"hash\": \"28d17959b463626d64257f0d9ea8e47daae68409\",\n",
+    "}]\n",
+    "if os.environ.get(\"HYPERDRONE_SCENES\"):\n",
+    "    scenes = sorted(Path(os.environ[\"HYPERDRONE_SCENES\"]).glob(\"*.glb\"))[:2]\n",
+    "WIDTH, HEIGHT, SEED = 640, 360, 5\n",
+    "STEPS, STRIDE, FPS = 500, 4, 25\n",
+    "output = Path(\"hyperdrone_videos\")\n",
+    "output.mkdir(exist_ok=True)\n",
+    "drone_asset = x500_model_path()\n",
+    "config = EnvConfig(instances=1, cam_width=WIDTH, cam_height=HEIGHT, preset=\"x500_fpv\")\n",
+    "initial = {\"mdp\": {\"init\": {\n",
+    "    \"guidance\": 0.0, \"max_position\": 0.25, \"max_angle\": 0.1,\n",
+    "    \"max_linear_velocity\": 0.0, \"max_angular_velocity\": 0.0,\n",
+    "    \"min_rpm\": 0.0, \"max_rpm\": 0.0,\n",
+    "}}}\n",
+    "\n",
+    "def camera(position, pitch, yaw, fov):\n",
+    "    orientation = Rotation.from_euler(\"ZY\", [yaw, pitch]).as_quat()[[3, 0, 1, 2]].tolist()\n",
+    "    return {\"fov\": fov, \"mount\": {\"pose\": {\"position\": position, \"orientation\": orientation}}}\n",
+    "\n",
+    "fpv = camera([0.1, 0, 0.32], 0.3, 0, 100)\n",
+    "chase = camera([-0.8, -0.8, 0.6], 0.45, np.pi / 4, 65)"
+   ],
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": true
+    }
+   },
+   "source": [
+    "from itertools import zip_longest\n",
+    "\n",
+    "import imageio.v2 as imageio\n",
+    "import matplotlib\n",
+    "from PIL import Image, ImageDraw, ImageFont\n",
+    "\n",
+    "\n",
+    "FONT = ImageFont.truetype(str(Path(matplotlib.get_data_path()) / \"fonts/ttf/DejaVuSans.ttf\"), 16)\n",
+    "\n",
+    "\n",
+    "def rgb(image):\n",
+    "    return image if image.dtype == np.uint8 else (np.clip(image, 0, 1) * 255).astype(np.uint8)\n",
+    "\n",
+    "\n",
+    "def writer(path, fps):\n",
+    "    return imageio.get_writer(str(path), fps=fps, codec=\"libx264\", quality=8, macro_block_size=1)\n",
+    "\n",
+    "\n",
+    "def panel(images, titles):\n",
+    "    images = [rgb(image) for image in images]\n",
+    "    height, width = images[0].shape[:2]\n",
+    "    canvas = Image.new(\"RGB\", (width * len(images), height + 32), \"#111827\")\n",
+    "    draw = ImageDraw.Draw(canvas)\n",
+    "    for i, (image, title) in enumerate(zip(images, titles)):\n",
+    "        canvas.paste(Image.fromarray(image), (i * width, 32))\n",
+    "        draw.text((i * width + 12, 6), title, font=FONT, fill=\"#e5e7eb\")\n",
+    "    return np.asarray(canvas)\n",
+    "\n",
+    "\n",
+    "def pair(left, right, output, titles, fps):\n",
+    "    with imageio.get_reader(str(left)) as a, imageio.get_reader(str(right)) as b, writer(output, fps) as out:\n",
+    "        for images in zip_longest(a, b):\n",
+    "            if any(image is None for image in images):\n",
+    "                raise ValueError(\"The two camera takes have different frame counts\")\n",
+    "            out.append_data(panel(images, titles))\n",
+    "\n",
+    "\n",
+    "def join(paths, output, fps):\n",
+    "    with writer(output, fps) as out:\n",
+    "        for path in paths:\n",
+    "            with imageio.get_reader(str(path)) as source:\n",
+    "                for frame in source:\n",
+    "                    out.append_data(frame)"
+   ],
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "def block(state, layout, name):\n",
+    "    offset, size = layout.blocks[name]\n",
+    "    return state[:, offset:offset + size]\n",
+    "\n",
+    "def pilots(env):\n",
+    "    policies = [Raptor() for _ in range(env.total_instances)]\n",
+    "    for policy in policies:\n",
+    "        policy.reset()\n",
+    "    return policies, np.zeros((env.total_instances, env.action_dim), dtype=np.float32)\n",
+    "\n",
+    "def act(env, policies, previous, target=0, layout=None):\n",
+    "    layout = env.observation_layout_privileged if layout is None else layout\n",
+    "    state = env.observe_privileged()\n",
+    "    observation = np.concatenate([\n",
+    "        block(state, layout, \"position\") - target,\n",
+    "        *[block(state, layout, name) for name in\n",
+    "          (\"orientation_rotation_matrix\", \"linear_velocity\", \"angular_velocity\")],\n",
+    "        previous,\n",
+    "    ], axis=1)\n",
+    "    return np.concatenate([policy.evaluate_step(row[None]) for policy, row in zip(policies, observation)]).astype(np.float32)\n",
+    "\n",
+    "def replay(configuration, tape, mount, path, dynamics_parameters=initial, seed=SEED):\n",
+    "    with closing(MultiEnvironment(scenes, config=configuration, seed=seed, drone_asset=drone_asset,\n",
+    "                                  parameters={\"dynamics\": dynamics_parameters, \"camera\": mount})) as take:\n",
+    "        take.reset()\n",
+    "        fps = 1 / (STRIDE * take.dt)\n",
+    "        with writer(path, fps) as video:\n",
+    "            for step, (action, state) in enumerate(tape):\n",
+    "                take.step(action)\n",
+    "                np.testing.assert_array_equal(take.observe_privileged(), state)\n",
+    "                if (step + 1) % STRIDE == 0:\n",
+    "                    image = take.observe().reshape(-1, HEIGHT, WIDTH, 3)[0]\n",
+    "                    video.append_data(rgb(image))"
+   ],
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Fly the preset\n",
+    "\n",
+    "`preset=\"x500_fpv\"` selects the platform, including its visible body and dynamics-driven\n",
+    "propellers. Fly back to the origin, then shift the goal by 25 cm. These coordinates are\n",
+    "relative to the episode's scene placement, not absolute room coordinates.\n",
+    "\n",
+    "The second camera is a replay with a different mount. It uses the recorded motor commands\n",
+    "and checks every state for exact equality, so both views show the same flight."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "tape = []\n",
+    "with closing(MultiEnvironment(scenes, config=config, seed=SEED, drone_asset=drone_asset,\n",
+    "                              parameters={\"dynamics\": initial, \"camera\": fpv})) as env:\n",
+    "    env.reset()\n",
+    "    base_layout = env.observation_layout_privileged\n",
+    "    nominal_dynamics = env.parameters[\"dynamics\"][\"dynamics\"]\n",
+    "    image_layout = env.observation_layout\n",
+    "    policies, previous = pilots(env)\n",
+    "    assert np.isclose(STRIDE * env.dt, 1 / FPS)\n",
+    "    with writer(output / \"preset-fpv.mp4\", FPS) as video:\n",
+    "        for step in range(STEPS):\n",
+    "            target = np.array([0.25 if step >= 200 else 0, 0, 0], dtype=np.float32)\n",
+    "            previous = act(env, policies, previous, target)\n",
+    "            env.step(previous)\n",
+    "            tape.append((previous.copy(), env.observe_privileged()))\n",
+    "            if (step + 1) % STRIDE == 0:\n",
+    "                video.append_data(rgb(env.frames()[0]))\n",
+    "\n",
+    "replay(config, tape, chase, output / \"preset-chase.mp4\")\n",
+    "pair(output / \"preset-fpv.mp4\", output / \"preset-chase.mp4\", output / \"01-preset.mp4\",\n",
+    "     [\"1 / Fly the preset - FPV\", \"Same flight - chase camera\"], FPS)\n",
+    "display(Video(str(output / \"01-preset.mp4\"), embed=True))"
+   ],
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Multiple drone models\n",
+    "\n",
+    "`drones=` pairs each rigged GLB with its dynamics and camera; every instance samples an\n",
+    "entry uniformly at reset, independently of the scene. `max_drones` is the compiled table\n",
+    "capacity. `env.drones` contains nominal parameters; `instance_parameters()` reports the\n",
+    "sampled drone index and current parameters. These are independent episodes, not a swarm."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "names = [\"x500\", \"crazyflie\"]\n",
+    "drones = [{\"asset\": rigged_model_path(name), \"parameters\": {\n",
+    "    \"dynamics\": {\"dynamics\": {\"model\": name}},\n",
+    "    \"camera\": fpv if name == \"x500\" else camera([0.2, 0, 0.2], 0.3, 0, 100),\n",
+    "}} for name in names]\n",
+    "batch_config = replace(config, instances=2, max_drones=2)\n",
+    "with closing(MultiEnvironment(scenes, config=batch_config, seed=SEED, drones=drones,\n",
+    "                              parameters={\"dynamics\": initial})) as mixed:\n",
+    "    mixed.reset()\n",
+    "    sampled = mixed.instance_parameters()\n",
+    "    print(\"nominal masses:\", {name: entry[\"parameters\"][\"dynamics\"][\"dynamics\"][\"mass\"]\n",
+    "                              for name, entry in zip(names, mixed.drones)})\n",
+    "    titles = [f\"{names[p['drone']]} | {p['dynamics']['dynamics']['mass']:.3f} kg | instance {i}\"\n",
+    "              for i, p in enumerate(sampled)]\n",
+    "    policies, previous = pilots(mixed)\n",
+    "    with writer(output / \"02-models.mp4\", FPS) as video:\n",
+    "        for step in range(300):\n",
+    "            previous = act(mixed, policies, previous)\n",
+    "            mixed.step(previous)\n",
+    "            if (step + 1) % STRIDE == 0:\n",
+    "                video.append_data(panel(mixed.frames(), titles))\n",
+    "display(Video(str(output / \"02-models.mp4\"), embed=True))"
+   ],
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. A task is one knob\n",
+    "\n",
+    "`task=\"target_frame\"` adds the desired image to the observation. The named layout locates\n",
+    "both channel blocks. RAPTOR returns toward the origin while the reference image stays\n",
+    "fixed for the episode; small propeller and pose differences remain at the goal."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "with closing(MultiEnvironment(scenes, config=replace(config, task=\"target_frame\"), seed=SEED,\n",
+    "                              drone_asset=drone_asset, parameters={\"dynamics\": initial, \"camera\": fpv})) as task:\n",
+    "    print(\"preset:\", image_layout.blocks, \"target_frame:\", task.observation_layout.blocks)\n",
+    "    task.reset()\n",
+    "    task.render(np.ones(task.total_instances, dtype=bool))\n",
+    "    target_offset, target_size = task.observation_layout.blocks[\"target_image\"]\n",
+    "    target_image = task.frames()[0, ..., target_offset:target_offset + target_size].copy()\n",
+    "    policies, previous = pilots(task)\n",
+    "    with writer(output / \"03-target.mp4\", FPS) as video:\n",
+    "        for step in range(STEPS):\n",
+    "            previous = act(task, policies, previous)\n",
+    "            task.step(previous)\n",
+    "            if (step + 1) % STRIDE == 0:\n",
+    "                frame = task.frames()[0]\n",
+    "                images = [frame[..., offset:offset + size] for offset, size in task.observation_layout.blocks.values()]\n",
+    "                np.testing.assert_array_equal(images[1], target_image)\n",
+    "                video.append_data(panel(images, [\"2 / Current image - returning to the goal\", \"Target image - fixed this episode\"]))\n",
+    "display(Video(str(output / \"03-target.mp4\"), embed=True))"
+   ],
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Your own task is a Python loop\n",
+    "\n",
+    "The preset's reward is zero. Here Python defines distance/velocity shaping, success,\n",
+    "failure, and independent time limits, then resets only the finished instances and their\n",
+    "recurrent pilots. Each new episode reverses that instance's goal. Halfway through, rotate\n",
+    "the scene and reset everyone: the same task now runs in another room."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "with closing(MultiEnvironment(scenes, config=batch_config, seed=SEED, drone_asset=drone_asset,\n",
+    "                              parameters={\"dynamics\": initial, \"camera\": fpv})) as env:\n",
+    "    env.reset()\n",
+    "    policies, previous = pilots(env)\n",
+    "    targets = np.array([[0.2, 0, 0], [-0.2, 0, 0]], dtype=np.float32)\n",
+    "    age, episodes = np.zeros(2, dtype=int), np.zeros(2, dtype=int)\n",
+    "    last_reset = np.full(2, -100)\n",
+    "    with writer(output / \"04-python-task.mp4\", FPS) as video:\n",
+    "        for step in range(800):\n",
+    "            previous = act(env, policies, previous, targets)\n",
+    "            env.step(previous)\n",
+    "            state = env.observe_privileged()\n",
+    "            distance = np.linalg.norm(block(state, base_layout, \"position\") - targets, axis=1)\n",
+    "            speed = np.linalg.norm(block(state, base_layout, \"linear_velocity\"), axis=1)\n",
+    "            reward = -distance - 0.1 * speed\n",
+    "            age += 1\n",
+    "            terminated = ((distance < 0.04) & (speed < 0.15) & (age >= 100)) | (distance > 1.0)\n",
+    "            reset = terminated | (age >= [250, 350])\n",
+    "            if step == 399:\n",
+    "                env.rotate_scene()\n",
+    "                reset[:] = True\n",
+    "            env.reset(reset)\n",
+    "            for i in np.flatnonzero(reset):\n",
+    "                policies[i].reset()\n",
+    "                previous[i] = 0\n",
+    "                age[i] = 0\n",
+    "                episodes[i] += 1\n",
+    "                targets[i] *= -1\n",
+    "                last_reset[i] = step\n",
+    "            if (step + 1) % STRIDE == 0:\n",
+    "                env.render(reset)\n",
+    "                titles = [f\"3 / Instance {i} | episode {episodes[i]} | \" +\n",
+    "                          (\"RESET\" if step - last_reset[i] < 20 else f\"reward {reward[i]:.2f} | error {distance[i]:.2f} m\")\n",
+    "                          for i in range(2)]\n",
+    "                video.append_data(panel(env.frames(), titles))\n",
+    "    print(\"completed episodes:\", episodes.tolist())\n",
+    "display(Video(str(output / \"04-python-task.mp4\"), embed=True))"
+   ],
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Your own world is a small C++ header\n",
+    "\n",
+    "Derive from the shipped specification to change rendering and observation features;\n",
+    "`spec_header=` lets the JIT compile that World directly. Its content hash is part of the\n",
+    "cache key. Leave `preset` / `task` / `n_agents` at their defaults when supplying a header.\n",
+    "\n",
+    "Compare two shutter samples with eight plus 2×2 anti-aliasing. Both configurations enable\n",
+    "motion blur, so they make the same reset-time random draws; the replay verifies equal\n",
+    "states. Custom Worlds export flat observations: reshape their images explicitly, and use\n",
+    "the X500 privileged layout because this header preserves its dynamics observation chain.\n",
+    "\n",
+    "The X500 fit uses normalized motor speed. As in Renderer.ipynb, use an illustrative\n",
+    "10,000 RPM full scale; rescale its thrust polynomial to preserve the force curve while\n",
+    "giving the propeller animation a rotation rate in RPM."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "%%writefile my_world.h\n",
+    "#pragma once\n",
+    "#include <rl_tools/rl/environments/hyperdrone/presets.h>\n",
+    "#include <cstddef>\n",
+    "\n",
+    "namespace hyperdrone_env_user {\n",
+    "    struct SPEC: rl_tools::rl::environments::hyperdrone::presets::X500FPV<float, std::size_t> {\n",
+    "        static constexpr std::size_t INSTANCES_PER_ENVIRONMENT = 1;\n",
+    "        static constexpr std::size_t CAM_WIDTH = 640;\n",
+    "        static constexpr std::size_t CAM_HEIGHT = 360;\n",
+    "        using SHADING = rl_tools::rendering::raytracing::High;\n",
+    "        static constexpr bool ENABLE_MOTION_BLUR = true;\n",
+    "        static constexpr std::size_t MOTION_BLUR_SAMPLES = 8;\n",
+    "        static constexpr bool ENABLE_ANTI_ALIASING = true;\n",
+    "        static constexpr std::size_t ANTI_ALIASING_GRID_SIZE = 2;\n",
+    "    };\n",
+    "    using WORLD = rl_tools::rl::environments::hyperdrone::World<SPEC>;\n",
+    "}"
+   ],
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "rpm_scale = 10_000.0\n",
+    "custom_dynamics = {**initial, \"dynamics\": {\n",
+    "    \"action_limit\": {key: value * rpm_scale for key, value in nominal_dynamics[\"action_limit\"].items()},\n",
+    "    \"rotor_thrust_coefficients\": (np.array(nominal_dynamics[\"rotor_thrust_coefficients\"]) /\n",
+    "                                  [1, rpm_scale, rpm_scale ** 2]).tolist(),\n",
+    "}}\n",
+    "custom_seed = 1\n",
+    "header = Path(\"my_world.h\").read_text()\n",
+    "preview_header = output / \"my_world_preview.h\"\n",
+    "preview_header.write_text(header.replace(\"MOTION_BLUR_SAMPLES = 8\", \"MOTION_BLUR_SAMPLES = 2\")\n",
+    "                               .replace(\"ANTI_ALIASING_GRID_SIZE = 2\", \"ANTI_ALIASING_GRID_SIZE = 1\"))\n",
+    "custom_tape = []\n",
+    "with closing(MultiEnvironment(scenes, config=EnvConfig(spec_header=str(preview_header)), seed=custom_seed,\n",
+    "                              drone_asset=drone_asset, parameters={\"dynamics\": custom_dynamics, \"camera\": chase})) as custom:\n",
+    "    custom.reset()\n",
+    "    policies, previous = pilots(custom)\n",
+    "    with writer(output / \"two-samples.mp4\", FPS) as video:\n",
+    "        for step in range(STEPS):\n",
+    "            target = np.array([0.25 if step >= 200 else 0, 0, 0], dtype=np.float32)\n",
+    "            previous = act(custom, policies, previous, target, layout=base_layout)\n",
+    "            custom.step(previous)\n",
+    "            custom_tape.append((previous.copy(), custom.observe_privileged()))\n",
+    "            if (step + 1) % STRIDE == 0:\n",
+    "                views = custom.observe().reshape(custom.total_instances, HEIGHT, WIDTH, custom.image_channels)\n",
+    "                video.append_data(rgb(views[0]))\n",
+    "\n",
+    "replay(EnvConfig(spec_header=\"my_world.h\"), custom_tape, chase, output / \"motion-blur.mp4\", custom_dynamics, seed=custom_seed)\n",
+    "pair(output / \"two-samples.mp4\", output / \"motion-blur.mp4\", output / \"05-custom-world.mp4\",\n",
+    "     [\"4 / Two shutter samples\", \"Your header - 8 shutter samples + 2x2 AA\"], FPS)\n",
+    "display(Video(str(output / \"05-custom-world.mp4\"), embed=True))"
+   ],
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## The whole flight demo\n",
+    "\n",
+    "The combined MP4 contains all five clips at real-time speed. For a compiled task with a\n",
+    "moving object, reward, and collision termination, continue with [Orbiter.ipynb](Orbiter.ipynb).\n",
+    "For manual renderer/dynamics composition see [Renderer.ipynb](Renderer.ipynb);\n",
+    "for throughput see [Benchmark.ipynb](Benchmark.ipynb)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "clips = [output / name for name in (\"01-preset.mp4\", \"02-models.mp4\", \"03-target.mp4\",\n",
+    "                                   \"04-python-task.mp4\", \"05-custom-world.mp4\")]\n",
+    "join(clips, \"hyperdrone.mp4\", FPS)\n",
+    "display(Video(\"hyperdrone.mp4\", embed=True))\n",
+    "print(\"Saved\", Path(\"hyperdrone.mp4\").resolve())"
+   ],
+   "execution_count": null,
+   "outputs": []
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "kernelspec": {
+   "display_name": ".venv (3.12.3)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}