import os
import cv2
import numpy as np
import torch
from PIL import Image
from transformers import AutoModelForVision2Seq, AutoProcessor

# 【关键点 1】：必须在 Genesis 初始化之前加载 PyTorch VLA 模型，避免显存分配冲突
model_path = "/mnt/robot/models/openvla-mcx-card"
processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True, local_files_only=True)
model = AutoModelForVision2Seq.from_pretrained(
    model_path,
    torch_dtype=torch.bfloat16,
    trust_remote_code=True,
    device_map="auto",
    local_files_only=True
).eval()

# 【关键点 2】：模型加载完毕后，再初始化 Genesis 物理引擎
import genesis as gs
gs.init(backend=gs.gpu)

# 搭建场景
scene = gs.Scene(show_viewer=False, sim_options=gs.options.SimOptions(dt=0.01))
plane = scene.add_entity(gs.morphs.Plane())

# 加载 Franka 机械臂、桌面与目标蓝块
franka_urdf = os.path.join(os.path.dirname(gs.__file__), "assets", "urdf", "panda_bullet", "panda.urdf")
franka = scene.add_entity(gs.morphs.URDF(file=franka_urdf, pos=(0.0, 0.0, 0.0)))
table = scene.add_entity(gs.morphs.Box(pos=(0.6, 0.0, 0.1), size=(0.6, 0.8, 0.2), fixed=True),
                         surface=gs.surfaces.Plastic(color=(0.6, 0.6, 0.6)))
blue_block = scene.add_entity(gs.morphs.Box(pos=(0.71, 0.01, 0.22), size=(0.04, 0.04, 0.04)),
                             surface=gs.surfaces.Plastic(color=(0.0, 0.0, 1.0)))

# 设立双相机：cam 供 VLA 推理输入 (224x224)，wide_cam 供人类视角的 MP4 导出 (640x480)
cam = scene.add_camera(res=(224, 224), pos=(1.0, 0.0, 0.5), lookat=(0.57, -0.08, 0.22), up=(0, 0, 1))
wide_cam = scene.add_camera(res=(640, 480), pos=(2.2, 1.6, 1.7), lookat=(0.4, 0.0, 0.35), up=(0, 0, 1), fov=45)

scene.build()

motors_dof = np.arange(7)
fingers_dof = np.arange(7, 9)
end_effector = franka.get_link("panda_link7")

# 配置高刚度 PD 增益以实现精确的关节追踪
franka.set_dofs_kp(np.array([4500, 4500, 3500, 3500, 2000, 2000, 2000]), motors_dof)
franka.set_dofs_kv(np.array([450, 450, 350, 350, 200, 200, 200]), motors_dof)

# 闭环推理控制循环
instruction = "Pick up the blue block and place it on the target"
prompt = f"In: {instruction}\nOut:"

for step_idx in range(500):
    # 1. 采集 VLA 视角图像并预处理
    img_vla = cam.render(rgb=True)[0] if isinstance(cam.render(rgb=True), tuple) else cam.render(rgb=True)
    pil_img = Image.fromarray(img_vla.astype(np.uint8))
    
    inputs = processor(prompt, pil_img)
    inputs = {k: v.to("cuda", dtype=torch.bfloat16) if v.is_floating_point() else v.to("cuda") for k, v in inputs.items()}
    
    # 2. VLA 推理预测动作
    with torch.inference_mode():
        raw_action = model.predict_action(inputs["input_ids"], unnorm_key="bridge_orig", do_sample=False, pixel_values=inputs["pixel_values"])
    raw_action = raw_action.cpu().float().numpy() if isinstance(raw_action, torch.Tensor) else np.array(raw_action, dtype=np.float32)
    
    # 3. 动作反归一化与 IK 求解
    pos_scale = 0.08
    delta_pos = raw_action[:3] * (pos_scale / 0.05)
    current_pos = end_effector.get_pos().cpu().numpy()
    current_quat = end_effector.get_quat().cpu().numpy()
    
    target_ee_pos = current_pos + delta_pos
    # 调用 IK 求解器获取广义坐标 qpos (16,)，并截取前 7 个臂部关节角
    qpos_target = franka.inverse_kinematics(link=end_effector, pos=target_ee_pos, quat=current_quat)
    joint_targets = qpos_target[motors_dof]
    
    # 4. 执行控制与物理步进
    franka.control_dofs_position(joint_targets, motors_dof)
    scene.step()

• 框架初始化顺序冲突（Taichi CUDA vs. PyTorch CUDA）

┌─────────────────────────┐
│  Genesis 物理仿真环境    │
└────────────┬────────────┘
             │ cam.render(rgb=True)
             ▼
┌─────────────────────────┐
│ numpy.ndarray (224,224,3)│ uint8 图像
└────────────┬────────────┘
             │ PIL.Image.fromarray()
             ▼
┌─────────────────────────┐
│ PIL.Image RGB 实例      │
└────────────┬────────────┘
             │ processor(prompt, pil_img)
             ▼
┌─────────────────────────┐
│ PyTorch Dict Tensors    │ pixel_values: (1, 3, 224, 224) bfloat16
│ (CUDA Device)           │ input_ids: (1, seq_len) int64
└─────────────────────────┘

# 采集当前相机帧，注意 Genesis 1.2.2 的 render 接口可能返回图像数组或元组
img_raw = cam.render(rgb=True)
img_rgb = img_raw[0] if isinstance(img_raw, tuple) else img_raw

# 归一化为 uint8 格式的 numpy 数组 (224, 224, 3)
if img_rgb.dtype in (np.float32, np.float64):
    img_uint8 = (np.clip(img_rgb, 0.0, 1.0) * 255).astype(np.uint8)
else:
    img_uint8 = img_rgb.astype(np.uint8)

from PIL import Image

# 1. 转换为 PIL Image 对象
pil_img = Image.fromarray(img_uint8)

# 2. 构造符合 OpenVLA 契约的文本 Prompt
instruction = "Pick up the blue block and place it on the target"
prompt = f"In: {instruction}\nOut:"

# 3. 通过 Processor 生成 Token 与图像张量
inputs = processor(prompt, pil_img)

# 4. 传输至 GPU，并注意数据类型区分：图像浮点数转为 bfloat16，文本 token ID 保持 long 类型
inputs = {
    k: v.to("cuda", dtype=torch.bfloat16) if v.is_floating_point() else v.to("cuda")
    for k, v in inputs.items()
}

with torch.inference_mode():
    raw_action = model.predict_action(
        inputs["input_ids"],
        unnorm_key="bridge_orig", # Bridge V2 数据集反归一化统计量
        do_sample=False,          # 采用确定性贪心解码
        pixel_values=inputs["pixel_values"]
    )

# 转为 CPU 上的 numpy 浮点数组，形状为 (7,)
raw_action = raw_action.cpu().float().numpy() if isinstance(raw_action, torch.Tensor) else np.array(raw_action, dtype=np.float32)

┌───────────────────────────┐
│ VLA 原始输出 raw_action (7,)│
└─────────────┬─────────────┘
              │ 1. pos_scale 缩放与相对旋转计算
              ▼
┌───────────────────────────┐
│ 位移增量 ΔP (3,)           │
│ 旋转增量 ΔR (3, Axis-Angle)│
└─────────────┬─────────────┘
              │ 2. 读取当前末端姿态 P_curr, Q_curr，合成目标位姿
              ▼
┌───────────────────────────┐
│ 目标世界位姿:             │
│ P_target (3,)             │
│ Q_target (4, Quaternion)  │
└─────────────┬─────────────┘
              │ 3. Genesis 内置逆运动学 (IK) 求解
              ▼
┌───────────────────────────┐
│ 机器人广义关节角 qpos (16,)│
└─────────────┬─────────────┘
              │ 4. 索引截取 motors_dof [0..6]
              ▼
┌───────────────────────────┐
│ 臂部关节控制目标 joint_targets (7,)│
└─────────────┬─────────────┘
              │ 5. franka.control_dofs_position()
              ▼
┌───────────────────────────┐
│  Genesis 物理仿真器步进     │ scene.step()
└───────────────────────────┘

# 激活环境并启动 Stage 2 批量自动化闭环测试
source /mnt/robot/genesis_vla_env.sh
export TMPDIR=/mnt/robot/tmp

python batch_eval_vla.py \
    --output_dir stage2_eval_8scene \
    --steps 1000

 from genesis.options.vis import DirectionalLight
 vis_options = gs.options.VisOptions(
     ambient_light=(0.15, 0.15, 0.15),
     lights=[DirectionalLight(dir=(0, 0, -1), color=(1, 1, 1), intensity=0.3)]
 )
 scene = gs.Scene(vis_options=vis_options)

结果分析与 Agent 验证闸门（verify_stage2.py）

为确保评估结果的真实可靠，我编写了 verify_stage2.py 无图像验证闸门。该脚本对生成的 8 个场景产物进行 41 项自动化断言校验:

• 压测结果分析

8 个自动化测试场景的量化汇总数据（1000 步/场景）如下表所示：

• 关键现象与结论

• 内容鲁棒性与相机敏感性的非对称表现
  
  对比基线场景（35.61 cm）与场景 2、5、6（34.65～34.91 cm）可知，视觉干扰物与光照变动对模型收敛行为几乎没有影响。
  然而，当变动相机角度时（场景 3、7、8），收敛距离明显变近（场景 7 达到 14.89 cm）。这表明 VLA 模型对场景背景内容具有良好的鲁棒性，但对相机外参变动表现出极高的敏感性。

• 目标偏离导致的行为崩溃
  
  在场景 4 中，当目标偏离模型固有的偏置收敛点时，末端距离大幅发散至 267.36 cm。这进一步印证了在未经过原生仿真环境适配的情况下，模型缺乏跨环境的三维空间泛化能力。

（以上结论仅针对本实验内8次测试做出）

通过 Stage 2 的程序化场景生成与批量评估，成功搭建了一套高效率、配置驱动的具身智能算法压测管线，展现了genesis-world为研究提供结构化实验数据的能力。

Stage 3：极速单卡并发强化学习训练（Go2 四足机器人步态学习）

在具身智能控制领域，强化学习（RL）是训练多足机器人实现复杂地形平稳行走与奔跑的核心方法。传统 RL 训练往往需要数千个 CPU 核心进行并行环境采样，数据在 CPU 与 GPU 之间频繁拷贝传输，导致训练效率受限。

在 Stage 3 中，我们会利用 Genesis World 平台，在单张 NVIDIA A800-40GB GPU 上成功拉起 2048 个并发的 Unitree Go2 四足机器人物理环境，配合 PPO 算法库（rsl_rl），实现端到端纯 GPU 加速的极速步态强化学习训练。

训练目标与进程隔离架构设计

本阶段的核心目标是在单卡环境下，让 2048 个并发的 Go2 机器人经过 100 代（Iterations）PPO 迭代，从“僵直不动”进化为“能够稳定追踪速度指令平稳奔跑的步态”；

同时在 Epoch 0（未受训）、Epoch 50（中期训练）与 Epoch 100（训练成熟） 三个节点自动保存模型权重并无头渲染录制 MP4 视频。

为避免大规模物理仿真（2048 个环境）与 Nyx 相机渲染在同一个 Python 进程中，因同时申请 GPU 资源而引发显存碎片化或 CUDA 上下文冲突，我设计了主控调度 + 进程隔离（Process-Isolated Subprocess） 的架构：

                    ┌─────────────────────────┐
                    │   run_orchestrator.py   │  主控调度脚本
                    └────────────┬────────────┘
                                 │
                   subprocess.run(cwd="stage3/")
                                 │
        ┌────────────────────────┴────────────────────────┐
        ▼                                                 ▼
┌───────────────────────────────┐     ┌───────────────────────────────┐
│     train_subprocess.py       │     │      eval_subprocess.py       │
│  - 纯 GPU 物理采样 (2048 envs)│     │  - 单环境无头渲染 (1 env)     │
│  - 无相机构建，专注 PPO 更新   │     │  - Nyx 相机跟踪 + MP4 导出    │
│  - 产出 model_50/100.pt       │     │  - 独立初始化 gs.init()       │
└───────────────────────────────┘     └───────────────────────────────┘

主控脚本 run_orchestrator.py 按序触发 5 个独立的阶段任务：

• 阶段 1：调用 eval_subprocess.py 录制无权重的零动作视频（Epoch 0）。
• 阶段 2：调用 train_subprocess.py 运行 0  50 代 PPO 训练，保存 model_50.pt。
• 阶段 3：调用 eval_subprocess.py 加载 model_50.pt 录制中期步态视频（Epoch 50）。
• 阶段 4：调用 train_subprocess.py --resume 执行 50  100 代增量训练，保存 model_100.pt。
• 阶段 5：调用 eval_subprocess.py 加载 model_100.pt 录制最终奔跑步态视频（Epoch 100）。

Genesis World 工具链的技术优势

极速单卡并发训练之所以能够实现，得益于 Genesis World 在物理引擎底层设计上的几项突破性技术优势：

• JIT 编译与大规模 GPU 刚体并行解算（Taichi CUDA Backend）

实践过程中的“坑”与调优记录

在将官方 Go2 步态训练示例转化为高可靠的自动化流水线时，我记录并修复了 5 处关键的接口与逻辑坑点：

• 相机添加时机冲突（assert_unbuilt 限制）

• 现象：在评测脚本中，试图在创建 env = Go2Env(...) 之后调用 env.scene.add_camera() 时，抛出 GenesisException: Scene is already built。
• 原因：官方 Go2Env 类在 __init__ 内部会自动执行 self.scene.build()。而在 Genesis 中，相机注册接口 add_camera() 带有 @gs.assert_unbuilt 装饰器，禁止在场景编译后添加传感器。
• 解决方案：重构 Go2Env 类的初始化构造函数，增加可选参数 camera_cfg。在 Go2Env.__init__ 内部、执行 scene.build() 之前注入相机创建逻辑：

• cam.render(rgb=True) 的 4 元组返回值

• 现象：调用 frame = cam.render(rgb=True) 后执行 (frame * 255).astype(...) 时报错：AttributeError: 'tuple' object has no attribute 'astype'。
• 原因：Genesis 相机渲染接口返回的是一个 4 元组 (rgb, depth, segmentation, normal)，即使只传 rgb=True，其它位置依然填充为 None。
• 解决方案：提取元组的第 0 位元素作为 RGB 图像张量：

• rsl_rl 5.0.1 0-Based 迭代索引与文件名规范化

• 现象：训练 50 代后，磁盘上仅生成了 model_49.pt，而没有主控脚本期待的 model_50.pt。
• 原因：rsl_rl 5.0.1 的内部循环索引采用 0-based 机制（for it in range(0, 50)，实际 it 为 ）。训练结束保存时，内部写入的文件名对应最后一步的索引 49。
• 解决方案：在 train_subprocess.py 中，训练结束后手动将计数器校准至绝对目标值，并显式执行规范化保存，确保生成标准命名的 Checkpoint：

• OnPolicyRunner.load() 返回类型与断点续训（Resume）算术

• 现象：调用 loaded = runner.load(checkpoint) 后执行 loaded.get("iter") 抛出 AttributeError: 'NoneType' object has no attribute 'get'。
• 原因：OnPolicyRunner.load() 返回的是模型的元数据 infos（默认为 None），而不是权重字典本身。
• 解决方案：直接使用 PyTorch 加载 Checkpoint 读取已完成的迭代次数，并按绝对目标算术计算剩余增量步数：

• 推理阶段的策略网络输入契约

• 现象：在 eval_subprocess.py 中，若将环境 reset 得到的 obs["policy"] 裸张量直接输入策略 policy(obs["policy"])，会触发 IndexError: too many indices for tensor 报错。
• 原因：rsl_rl 的网络架构内部会自动根据配置检索 obs["policy"] 键。因此，策略网络期望接收完整的 TensorDict，而不是已经提取出的底层张量。
• 解决方案：直接将环境返回的整个 obs 字典传入策略：action = policy(obs)。

训练效果演进与多阶段视频验证

为了客观证明强化学习的训练效果，我在无图像查看能力的 Headless 云服务器上，通过 TensorBoard 标量日志（Train/mean_reward）与 ffprobe 视频元数据分析相结合的方式，完成了对训练全生命周期的自动化验证。

• 训练指标客观数据演进

下表记录了 2048 个并发 Go2 环境在 100 代训练过程中的核心指标演进：

从数据变化可以看出，mean_reward 从 -0.1788 大幅提升至 +13.2399， Episode 平均生存长度从 19 步 增加到接近满步的 997 步（单次 Episode 最大长度为 1000 步），证明策略网络成功学会了维持躯体平衡并高效向前奔跑。

• 全生命周期可视化成果展示

以下为通过 run_orchestrator.py 在三个关键训练阶段自动录制导出的四足机器人步态视频：

（1）未受训初始状态（Epoch 0）

未开始训练时，策略网络输出零动作或随机噪声，机器人静止不动：

▲Epoch 0 训练初期四足机器人未受训状态（倒地挣扎）表现©【深蓝具身智能】编译

（2）训练中期步态演进（Epoch 50）

经过 50 代训练后，机器人学会了利用四肢支撑躯干，试图颤巍地向前迈步：

▲Epoch 50 训练中期四足机器人步态演进（能够站立与蹒跚移动）表现©【深蓝具身智能】编译

（3）训练成熟期步态（Epoch 100）

完成 100 代训练后，机器人形成了极其平稳、流畅的奔跑步态，能够高精度追踪设定的线速度命令：

通过结合 Genesis 极速的 GPU 刚体并行解算能力与进程隔离的视频渲染管线，Stage 3 在短时间内高效完成了四足机器人步态强化学习的完整闭环，展现了 Genesis 平台在大规模机器人策略学习任务中的巨大优势。

Stage 4：刚柔耦合——布料、海绵与含水玻璃杯的多物理场“无穿透”交互仿真

在机器人复杂操作任务中，机械臂不仅需要操纵刚体，还需要与各类柔性体（如布料、海绵）以及流体（如容器中的液体）进行物理交互。

这类刚柔耦合与刚流耦合仿真，往往是传统仿真平台最为棘手的难题之一。

在 Stage 4 中，利用 Genesis World 的统一多物理场求解器，构建了三个具有代表性的高级物理交互场景：

• 二维柔性布料折叠（PBD.Cloth）
  

• 三维体积海绵挤压（PBD.Elastic）

• 倾倒玻璃杯与 SPH 液体扩散（SPH.Liquid）

多物理场仿真设计与场景选型

为了全面评估 Genesis World 在不同物理介质上的解算能力，Stage 4 针对三类典型的非刚体形态进行了独立的场景设计与控制规划，机械臂由确定性轨迹控制（结合内置逆运动学 IK 或雅可比伪逆运动学）：

                              ┌─────────────────────────────────────────┐
                              │    Genesis World 多物理场仿真平台       │
                              └────────────────────┬────────────────────┘
                                                   │
         ┌─────────────────────────────────────────┼─────────────────────────────────────────┐
         ▼                                         ▼                                         ▼
┌─────────────────────────┐               ┌─────────────────────────┐               ┌─────────────────────────┐
│ 二维柔性布料 (PBD.Cloth)│               │ 三维体积海绵(PBD.Elastic)│               │ 刚流耦合液体(SPH.Liquid)│
├─────────────────────────┤               ├─────────────────────────┤               ├─────────────────────────┤
│ - 红色 16x16 膜结构     │               │ - 10x10x7cm 四面体网格  │               │ - 145 颗 SPH 液体粒子   │
│ - 抬高桌面 (Z=0.40m)    │               │ - 4 墙透明托盘 (opacity)│               │ - 3kg 透明玻璃杯 URDF   │
│ - 按压/横扫屈曲折叠     │               │ - 按压/准静态慢速释放   │               │ - 雅可比运动学推倒      │
└─────────────────────────┘               └─────────────────────────┘               └─────────────────────────┘

在传统的物理仿真搭建中，模拟刚体、柔性体与流体往往需要拼接不同的物理引擎（例如用 PhysX 解算刚体，用 Flex 解算柔体，再用 SPH 库解算流体），不同引擎间的碰撞检测与接触力传递极易出现穿模或物理发散。

Genesis World 在 Stage 4 中展现出了极具技术壁垒的优势：

实践过程中的“坑”与调优记录

在三个场景的调试过程中，也遇到了多处涉及物理引擎约束与运动学的深层次问题，以下为踩坑与解决记录：

（1）二维布料折叠场景（PBD.Cloth）

# 布料场景构建与手动间距计算代码片段
cloth = scene.add_entity(
    morph=gs.morphs.Mesh(file="stage4/meshes/cloth.obj", pos=(0.5, 0.0, 0.41)),
    material=gs.materials.PBD.Cloth(rho=4.0, stretch_compliance=1e-7, static_friction=0.5),
    surface=gs.surfaces.Plastic(color=(1.0, 0.0, 0.0)) # 表面材质必须传给 add_entity
)

# 坑点：PBD 柔体不支持 franka.get_contacts()，需通过 GPU Tensor 计算顶点最小欧氏距离
finger_left_verts = franka.get_link("panda_leftfinger").get_verts()   # (18, 3)
finger_right_verts = franka.get_link("panda_rightfinger").get_verts() # (18, 3)
finger_verts = torch.cat([finger_left_verts, finger_right_verts], dim=0)
cloth_particles = cloth.get_particles_pos()                          # (N, 3)

# 手动计算指尖网格与布料粒子的最小间距
min_clearance = torch.cdist(finger_verts.float(), cloth_particles.float()).min().item()

• 坑 1：IPC 耦合器环境依赖与 PBD 降级
• 现象：原计划采用高精度的 IPC（Incremental Potential Contact）耦合器，但在主环境中尝试安装依赖库 pyuipc 时，其强制拉取的 NumPy 2.5.1 破坏了环境中的 Numba 依赖，导致 Genesis 整体无法导入。
• 解决方案：采用安全的 try-except 结构，当捕获到 ImportError 时，自动优雅降级至基于位置的动柔体求解器 PBDOptions()。PBD 求解器在保持极高稳定性的同时，无需任何外部二进制依赖。
• 坑 2：PBD 柔体与传统刚体接触 API 不兼容
• 现象：调用 franka.get_contacts(with_entity=cloth) 时抛出 AttributeError: 'PBD2DEntity' object has no attribute 'geom_start'。
• 原因：PBD 布料在 Genesis 内部被表达为粒子系统，不参与刚体管线的碰撞对查询。
• 解决方案：改用手动 GPU 距离计算。通过提取 Franka 指尖网格顶点 finger.get_verts() 与布料粒子位置 cloth.get_particles_pos()，利用 torch.cdist 计算两者的最小欧氏距离 min_clearance，作为无穿透判定证据。

（2）三维体积海绵挤压场景（PBD.Elastic）

# 3D 体积海绵与透明托盘构建片段
sponge = scene.add_entity(
    morph=gs.morphs.Box(pos=(0.5, 0.0, 0.44), size=(0.10, 0.10, 0.07)),
    material=gs.materials.PBD.Elastic(rho=200.0, stretch_compliance=1e-5, volume_compliance=1e-4),
    surface=gs.surfaces.Plastic(color=(0.9, 0.8, 0.1)) # 黄色海绵
)

# 4 墙透明托盘：防止海绵被夹爪扫动的侧向力弹飞，设置 opacity=0.12 解决视觉遮挡
tray_wall = scene.add_entity(
    morph=gs.morphs.Box(pos=(0.5, 0.0, 0.44), size=(0.12, 0.12, 0.08)),
    surface=gs.surfaces.Plastic(color=(0.8, 0.8, 0.8), opacity=0.12),
    fixed=True
)

• 坑 3：FEM.Solid 无 IPC 时无法解算刚柔接触
• 现象：尝试使用基于连续介质力学的 FEM.Elastic 材质时，机械臂手指直接穿透海绵。
• 原因：Genesis 源码查验表明，FEM.Solid 求解器的刚柔接触依赖 IPCCoupler。在无 IPC 的环境下，FEM 求解器只计算内部弹性力，不计算刚体接触。
• 解决方案：采用 gs.materials.PBD.Elastic 材质。Genesis 会自动调用 TetGen 对 Box 进行四面体化（生成约 806 个粒子），完美实现了三维体积弹性体的受压形变。
• 坑 4：海绵逃逸与准静态慢速释放
• 现象：机械臂下压海绵后，若保持持续压力，海绵会在侧向力作用下向上挤出托盘；若快速抬起夹爪，释放的弹性势能会将海绵弹出桌面。
• 解决方案：摒弃 Hold 阶段，设计“接近  按压  慢速浅释放”的三阶段轨迹。在释放阶段，夹爪以约  的准静态速度极慢抬起 ，海绵在不飞出的前提下平稳复原至接近初始高度（约 ）。

（3）倾倒玻璃杯与水流扩散场景（SPH.Liquid）

# SPH 流体与玻璃杯场景构建片段
scene = gs.Scene(
    sim_options=gs.options.SimOptions(dt=4e-4), # SPH 稳定性要求 dt <= 4e-4s
    sph_options=gs.options.SPHOptions(particle_size=0.015, pressure_solver="DFSPH"),
    coupler_options=gs.options.LegacyCouplerOptions(rigid_sph=True), # 开启刚流耦合
    show_viewer=False
)

# 盛水透明玻璃杯 URDF（包含底板与 4 墙碰撞体，重 3kg 避免被轻易弹飞）
glass_cup = scene.add_entity(
    morph=gs.morphs.URDF(file="stage4/glass_cup.urdf", pos=(0.5, 0.0, 0.40)),
    surface=gs.surfaces.Plastic(color=(0.9, 0.9, 1.0), opacity=0.15)
)

# SPH 液体粒子填充
water = scene.add_entity(
    morph=gs.morphs.Box(pos=(0.5, 0.0, 0.45), size=(0.08, 0.08, 0.10)),
    material=gs.materials.SPH.Liquid(rho=1000, stiffness=5000, mu=0.01, sampler="regular"),
    surface=gs.surfaces.Plastic(color=(0.2, 0.45, 1.0), vis_mode="recon") # 开启平滑水面重建
)

• 坑 5：SPH 物理仿真步长与接触推力模式
• 现象：使用常规时间步长（）时，水粒子在玻璃杯内发生爆炸性飞溅；使用传统 IK 或位置 PD 驱动机械臂推倒玻璃杯时，运动学推力的无限刚度会将玻璃杯直接弹飞出桌面。
• 解决方案：
1. 将物理时间步缩短至 ，并将流体粘度调至 、刚度调至 ，获得平静的液体状态；
2. 将玻璃杯质量设为 （增加惯性）；
3. 机械臂推倒动作采用雅可比伪逆运动学推力（），直接计算关节角度增量。这种方式既能精准控制末端推力，又能避免传统 IK 在奇异点附近的跳变，成功将玻璃杯平稳碰倒并使液体自然溢出。
• 坑 6：SPH 离散粒子的平滑水面重建（vis_mode="recon"）
• 现象：默认渲染模式下，液体被绘制为一颗颗独立的蓝色小圆珠（Particle mode），视觉上缺乏液体的连续性。
• 解决方案：将水面材质的渲染模式指定为 vis_mode="recon"。Genesis 会调用底层的 pysplashsurf 库，在每帧渲染时将离散的 SPH 粒子场实时重建为连续光滑的三维液体网格（连续连片水面）。此过程完全在主进程内安全运行，无 CUDA 跨进程死锁风险。

实验效果展示与多物理场

在无图像查看能力的 Headless 云服务器上，我通过 verify_stage4.py 自动化闸门，对三个多物理场测试场景进行了文件结构、ffprobe 视频流、JSON 物理日志以及形变/洒水数值断言的校验。

三个场景均一次性通过了自动化验证闸门（STAGE 4 VERIFICATION PASSED），输出了视频与量化报告：

（1）二维柔性布料折叠（PBD.Cloth）

机械臂从上方接近红色平铺布料，下压并执行横扫动作，布料在桌面滑动并产生自然的屈曲折叠：

▲Stage 4 红色可变形布料在机械臂按压与横扫下的屈曲褶皱表现©【深蓝具身智能】编译

（2）三维体积海绵挤压（PBD.Elastic）

机械臂在透明托盘内从上至下压榨黄色海绵，随后准静态慢速抬起夹爪，海绵在透明托盘内经历显著的体积压缩与弹性复原：

• 视觉可见性：侧视透明墙下海绵黄色掩码像素全程高于 611 像素，形变剖面清晰。

▲Stage 4 黄色海绵在透明托盘内的 3D 体积挤压与回弹表现©【深蓝具身智能】编译

（3）倾倒玻璃杯与 SPH 液体扩散（SPH.Liquid）

机械臂柔性接近透明玻璃杯杯沿，施加雅可比运动学推力将玻璃杯碰倒，杯中的 SPH 蓝水顺畅倾泻扩散至桌面：

• 表面重建（Recon）：水面呈光滑连续片状，连通域采样显示为单一 2802 像素大块，展示出极高的流体渲染真实感。

▲Stage 4 倾倒含水透明玻璃杯及 SPH 水流溢出扩散表现©【深蓝具身智能】编译

回看这四个阶段，真正被验证的并非某个模型有多强，而是一套范式是否成立：

当仿真器把渲染、物理与控制收进同一 GPU 原生闭环，具身智能的"评估—迭代"循环才得以从以天计压缩到以分钟计。

Stage 1 的 sim-to-sim 偏差与夹爪失效提醒我们，跨平台迁移远未解决；Stage 3 与 Stage 4 则证明，统一多物理场求解器能让刚体、柔体与流体在同一场景里被同等地"无穿透"对待。

本文所有结论都建立在有限样本与特定平台之上，离可落地的真实机器人操作仍有距离。

但通过 Stage 4 的探索，Genesis World 证明了其在处理复杂多物理场（刚体、柔体、体积弹性体、流体）协同仿真方面的强大能力，为具身智能机器人在真实物理世界中的复杂触觉感知与精细操作研究提供了坚实的基础。

本项目Genesis World已开源：https://github.com/GimpelZhang/genesis-world-tour

扫码添加阿蓝，选择想要加入的交流群即可

（按照提交顺序邀请，请尽早选择）

👇