diff --git a/README.md b/README.md index 8cd519e..f6626b6 100644 --- a/README.md +++ b/README.md @@ -15,18 +15,31 @@ MuJoCo WASM + onnxruntime-web + three.js, with **Microduck** (legs / rollers), * The application opens directly into simulation, defaults to Microduck, and keeps pause, reset, robot selection and a collapsible keyboard reference on that same screen. There is no welcome / RESUME menu or BIOS animation. Anton is bundled locally, so the default interface does not wait for an external font service. +## v0.5 + +- Brighter shared lighting and the original four-swatch **Line color** control for every robot. +- One session-wide layout of 5–7 physical, draggable geometries replaces the football and scales consistently across robots. +- RP1 uses the supplied textured GLBs, including fixed-hand detail, without changing its 24-DOF physics or trained skills. +- Verified with 66 unit tests, 55 browser tests and production-build checks. See [shared environment](docs/superpowers/verification/shared-robot-environment.md) and [RP1 materials](docs/superpowers/verification/rp1-glb-materials.md) verification records. + ## Robots | Robot | Default scene / presentation | Controls | |---|---|---| -| Microduck | Shared 4.5 × 4.5 m bounded arena, ball, original GLB/palette/comic effects | Existing walking, skating, skills and recovery | -| Microban | Robot-scaled 5.5 × 5.5 m arena, dark/orange grid and comic UI, textured per-body GLB visuals | Walking policy + independent head rotation | -| RP1 | Robot-scaled 22 × 22 m arena/comic UI, original 24-DOF MJCF visuals | Completed walking policy; trained 10 s dance segment (J) and full 4.36 s wave (H) | +| Microduck | Shared 4.5 × 4.5 m bounded arena, 5–7 random interactive geometries, original GLB/comic effects | Existing walking, skating, skills and recovery | +| Microban | Shared robot-scaled 5.5 × 5.5 m arena, interactive geometries, textured per-body GLB visuals | Walking policy + independent head rotation | +| RP1 | Shared robot-scaled 22 × 22 m arena, interactive geometries, user-supplied textured GLB visuals on original 24-DOF physics | Completed walking policy; trained 10 s dance segment (J) and full 4.36 s wave (H) | -Switch robots using **Robot** in the toolbar. Returning to Microduck restores the session's colour and feet / rollers choice, but initializes a fresh physical state. Failed loads keep the previous robot available and show an inline retry action. +Switch robots using **Robot** in the toolbar. Returning to Microduck restores the session's scene-line colour and feet / rollers choice, but initializes a fresh physical state. Failed loads keep the previous robot available and show an inline retry action. Microduck policies / assets originate from [pollen-robotics/microduck](https://github.com/pollen-robotics/microduck) and [pollen-robotics/microduck_rl](https://github.com/pollen-robotics/microduck_rl). Microban physics / policy assets originate from [Rhoban/microban](https://github.com/Rhoban/microban); its textured visual replacement comes from the user-supplied `microban2.zip`. Exact hashes, dirty-worktree provenance and license caveats are included in its [Package source notes](app/public/robots/microban/SOURCE.md). +### Shared scene controls (all robots) + +The scene has brighter ambient / environment illumination plus a hemisphere fill light. The lower-left **Line color** palette retains the original Cream / Graphite / Lavender / Sky swatches and square comic buttons, but now changes **floor and wall grid lines**, not robot materials. The same palette is available for every robot, and its selection is global across robot switches, reset and feet / rollers changes. + +The football is removed. One browser session randomly generates **5–7 lightweight boxes, spheres, cylinders and capsules** shared by **all robots**, clear of both bundled spawn anchors and each other. Their types, colours and relative layout stay identical when switching robots; geometry and positions scale with the existing arena-to-robot ratio. They have real MuJoCo free joints: every robot can push them, they collide with one another, the floor and walls, and the mouse can grab / lift them using spring forces. Reset, locomotion changes and robot switches restore the same session layout; refreshing generates a new layout. Escaped toys are returned individually. This shares environment configuration/layout, not live object momentum between different-scale robot simulations. + ## Keyboard and mouse | Action | Binding | @@ -47,7 +60,7 @@ Microduck policies / assets originate from [pollen-robotics/microduck](https://g The on-screen reference comes from the same Package bindings as the keyboard, and its skill entries are also clickable buttons. Text fields / selectors retain their normal keyboard behavior. Focused buttons retain native Space / Enter behavior without also resetting the robot. Losing focus, pausing, resetting or switching clears held movement keys. -All bundled robots, and future Packages omitting `presentation.world`, use the same **robot-scaled arena template**. Microduck remains at **4.5 × 4.5 m**, with 0.25 m high / 0.05 m thick collision walls. World lengths scale by `dimensions.height / 0.27`: Microban gets **5.5 × 5.5 m**, walls ≈0.306 m high; RP1 gets **22 × 22 m**, walls ≈1.222 m high. Wall thickness, visual geometry, grid spacing and fade distances scale together, preserving Microduck's scene-to-body proportions. Nominal standing height is fixed per package, not inferred from the live pose or root spawn height; missing dimensions retain the reference scale. Interiors stay flat; no relief or automatic coordinate clamping is added. Explicit `world: "flat"` remains available for generic-runtime diagnostics. All robots start with the camera behind the body. Mouse orbit detaches chase mode; **C** restores rear following and the default zoom, including while paused (pressing C again does not detach). Microduck mouse dragging still applies physical forces to the robot / ball. Microban / RP1 mouse dragging orbits the camera. Gamepad / touch are not part of this release's acceptance scope. +All bundled robots, and future Packages omitting `presentation.world`, use the same **robot-scaled arena template**. Microduck remains at **4.5 × 4.5 m**, with 0.25 m high / 0.05 m thick collision walls. World lengths scale by `dimensions.height / 0.27`: Microban gets **5.5 × 5.5 m**, walls ≈0.306 m high; RP1 gets **22 × 22 m**, walls ≈1.222 m high. Wall thickness, visual geometry, grid spacing and fade distances scale together, preserving Microduck's scene-to-body proportions. Nominal standing height is fixed per package, not inferred from the live pose or root spawn height; missing dimensions retain the reference scale. Interiors stay flat; no relief or automatic coordinate clamping is added. Explicit `world: "flat"` remains available for generic-runtime diagnostics. All robots start with the camera behind the body. Mouse orbit detaches chase mode; **C** restores rear following and the default zoom, including while paused (pressing C again does not detach). Dragging any robot or interactive geometry applies physical forces; dragging empty space orbits the camera, consistently for all three robots. Gamepad / touch are not part of this release's acceptance scope. ## Microban fidelity and limits diff --git a/app/e2e/arena-presentation.spec.js b/app/e2e/arena-presentation.spec.js index 966f2f1..c92acc1 100644 --- a/app/e2e/arena-presentation.spec.js +++ b/app/e2e/arena-presentation.spec.js @@ -59,7 +59,7 @@ test("arena appearance matches Microduck while Microban physics stays flat and W expect(state).toEqual({ cell: 0.1 * (0.33 / 0.27), section: 0.6 * (0.33 / 0.27), - color: 0xffb366, + color: 0xf7e6cb, reveal: 1, topo: 0, hiddenFloor: true, diff --git a/app/e2e/chase-camera.spec.js b/app/e2e/chase-camera.spec.js index 0da208a..667e7ff 100644 --- a/app/e2e/chase-camera.spec.js +++ b/app/e2e/chase-camera.spec.js @@ -60,13 +60,15 @@ test("both robots default to the same rear camera and comic UI; Microban keeps f await expect( page.getByRole("navigation", { name: "Simulation controls" }), ).toHaveCSS("border-top-width", "2px"); - await expect(page.getByRole("group", { name: "Duck colours" })).toHaveCount( - 0, - ); + await expect( + page.getByRole("group", { name: "Scene line colours" }), + ).toBeVisible(); await expect( page.getByRole("button", { name: "Rollers", exact: true }), ).toHaveCount(0); - await expect(page.getByText("Drag robot / ball: apply force")).toHaveCount(0); + await expect( + page.getByText("Drag robot / geometry: apply force"), + ).toBeVisible(); await expect(page.getByRole("status")).toContainText("Simplified actuation"); expect( await page.evaluate(() => window.rl.model.geom("platform_floor").id), @@ -74,7 +76,9 @@ test("both robots default to the same rear camera and comic UI; Microban keeps f await page.screenshot({ path: info.outputPath("microban-chase.png") }); await page.evaluate(() => window.__gameApi.switchRobot("microduck-legs")); await rear(page); - await expect(page.getByRole("group", { name: "Duck colours" })).toBeVisible(); + await expect( + page.getByRole("group", { name: "Scene line colours" }), + ).toBeVisible(); expect(errors).toEqual([]); }); for (const id of ["microban", "microduck-legs"]) diff --git a/app/e2e/deployment.spec.js b/app/e2e/deployment.spec.js index b8d8d50..00cfaf3 100644 --- a/app/e2e/deployment.spec.js +++ b/app/e2e/deployment.spec.js @@ -20,7 +20,24 @@ test("deployed assets respect the base path and all three Robot Packages boot", await expect( page.getByRole("button", { name: "Pause", exact: true }), ).toBeEnabled(); - await page.waitForTimeout(500); // capture after the ball's existing appear FX + await page.waitForTimeout(500); // let the physical toys settle + const toys = await page.evaluate(() => { + const r = window.rl; + return { + count: r.interactiveProps.length, + visible: r.scene.getObjectByName("interactive-props").visible, + hasBall: + r.mujoco.mj_name2id( + r.model, + r.mujoco.mjtObj.mjOBJ_BODY.value, + "ball", + ) >= 0, + }; + }); + expect(toys.count).toBeGreaterThanOrEqual(5); + expect(toys.count).toBeLessThanOrEqual(7); + expect(toys.visible).toBe(true); + expect(toys.hasBall).toBe(false); await page.screenshot({ path: info.outputPath("microduck.png") }); await page.getByLabel("Robot", { exact: true }).selectOption("microban"); await expect diff --git a/app/e2e/microduck-regression.spec.js b/app/e2e/microduck-regression.spec.js index ca2bcd6..981383a 100644 --- a/app/e2e/microduck-regression.spec.js +++ b/app/e2e/microduck-regression.spec.js @@ -26,7 +26,7 @@ for (const scenario of [ world.boundary.half_extent = 1.5; await route.fulfill({ response, json: world }); }); - const errors = await bootDuck(page); + const errors = await bootDuck(page, { legacyPhysics: true }); await page.evaluate(async (scenario) => { const r = window.rl; if (scenario === "rollers" || scenario === "crouch") { diff --git a/app/e2e/robot-switching.spec.js b/app/e2e/robot-switching.spec.js index 2682560..0708cbb 100644 --- a/app/e2e/robot-switching.spec.js +++ b/app/e2e/robot-switching.spec.js @@ -11,7 +11,7 @@ test("Microduck → Microban → Microduck restores theme, colours and locomotio const errors = []; page.on("pageerror", (e) => errors.push(e.message)); await ready(page); - await page.getByRole("button", { name: "Lavender colours" }).click(); + await page.getByRole("button", { name: "Lavender scene lines" }).click(); await page.getByRole("button", { name: "Rollers", exact: true }).click(); await page.waitForFunction(() => window.rl?.loco === "rollers"); await page.getByLabel("Robot", { exact: true }).selectOption("microban"); @@ -26,9 +26,9 @@ test("Microduck → Microban → Microduck restores theme, colours and locomotio await expect( page.getByText("Toggle head rotation", { exact: false }), ).toBeVisible(); - await expect(page.getByRole("group", { name: "Duck colours" })).toHaveCount( - 0, - ); + await expect( + page.getByRole("group", { name: "Scene line colours" }), + ).toBeVisible(); expect(await page.evaluate(() => window.rl.buildObs().length)).toBe(63); await page.getByLabel("Robot", { exact: true }).selectOption("microduck"); await page.waitForFunction( @@ -37,7 +37,7 @@ test("Microduck → Microban → Microduck restores theme, colours and locomotio window.rl?.loco === "rollers", ); await expect( - page.getByRole("button", { name: "Lavender colours" }), + page.getByRole("button", { name: "Lavender scene lines" }), ).toHaveAttribute("aria-pressed", "true"); expect(await page.evaluate(() => window.rl.data.time)).toBeLessThan(3); expect(errors).toEqual([]); diff --git a/app/e2e/rp1-visuals.spec.js b/app/e2e/rp1-visuals.spec.js new file mode 100644 index 0000000..5075fa1 --- /dev/null +++ b/app/e2e/rp1-visuals.spec.js @@ -0,0 +1,274 @@ +import { test, expect } from "@playwright/test"; +import { bootDuck } from "./support/simulation.js"; + +async function boot(page) { + await bootDuck(page); + await page.evaluate(() => window.__gameApi.pause()); +} + +test("all 63 RP1 material parts follow 25 physical bodies, including fixed fingers, with original shapes aligned", async ({ + page, +}, info) => { + const errors = []; + page.on("pageerror", (e) => errors.push(e.message)); + await boot(page); + expect(await page.evaluate(() => window.__gameApi.switchRobot("rp1"))).toBe( + true, + ); + const inspect = () => + page.evaluate(async () => { + const r = window.rl, + layer = r.scene.getObjectByName("body-visuals"), + rig = layer.parent; + rig.updateMatrixWorld(true); + const xml = new DOMParser().parseFromString( + await (await fetch("robots/rp1/visuals/rp1_hand_fixed.urdf")).text(), + "text/xml", + ); + const joints = new Map( + [...xml.querySelectorAll("joint")].map((j) => [ + j.querySelector("child").getAttribute("link"), + j, + ]), + ); + const Matrix = rig.matrix.constructor, + Euler = r.controls.object.rotation.constructor; + const correction = new Matrix().makeRotationX(Math.PI / 2); + const urdfRelative = (name, anchor) => { + const result = new Matrix(); + while (name !== anchor) { + const joint = joints.get(name), + origin = joint.querySelector("origin"); + const xyz = (origin?.getAttribute("xyz") ?? "0 0 0") + .split(/\s+/) + .map(Number); + const angles = (origin?.getAttribute("rpy") ?? "0 0 0") + .split(/\s+/) + .map(Number); + const matrix = new Matrix().makeRotationFromEuler( + new Euler(...angles, "ZYX"), + ); + matrix.setPosition(...xyz); + result.premultiply(matrix); + name = joint.querySelector("parent").getAttribute("link"); + } + return result.multiply(correction); + }; + const bounds = (objects, frame) => { + const lo = [Infinity, Infinity, Infinity], + hi = [-Infinity, -Infinity, -Infinity]; + const inverse = frame.matrixWorld.clone().invert(), + vector = frame.position.clone(); + for (const mesh of objects) { + const transform = inverse.clone().multiply(mesh.matrixWorld), + attr = mesh.geometry.attributes.position; + for (let i = 0; i < attr.count; i++) { + vector.fromBufferAttribute(attr, i).applyMatrix4(transform); + vector.toArray().forEach((v, a) => { + lo[a] = Math.min(lo[a], v); + hi[a] = Math.max(hi[a], v); + }); + } + } + return [...lo, ...hi]; + }; + let frameError = 0, + boundsError = 0, + handError = 0, + handParts = 0, + normals = 0, + screens = 0, + emissive = 0, + hidden = 0, + meshes = 0; + for (const frame of layer.children) { + const body = frame.name.slice("body-visual:".length), + id = r.mujoco.mj_name2id( + r.model, + r.mujoco.mjtObj.mjOBJ_BODY.value, + body, + ); + const p = Array.from(r.data.xpos.slice(id * 3, id * 3 + 3)), + q = Array.from(r.data.xquat.slice(id * 4, id * 4 + 4)); + frameError = Math.max( + frameError, + ...p.map((v, i) => Math.abs(v - frame.position.toArray()[i])), + ...[q[1], q[2], q[3], q[0]].map((v, i) => + Math.abs(v - frame.quaternion.toArray()[i]), + ), + ); + const originals = rig.children.filter( + (m) => + m.userData.geomId !== undefined && + r.model.geom_bodyid[m.userData.geomId] === id, + ); + hidden += originals.filter((m) => !m.visible).length; + const replacements = []; + frame.traverse((node) => { + if (node.userData.sourcePart) { + handParts++; + const actual = frame.matrixWorld + .clone() + .invert() + .multiply(node.matrixWorld); + const expected = urdfRelative( + node.userData.sourcePart, + `${body.split("_")[0]}_wrist_roll_link`, + ); + handError = Math.max( + handError, + ...actual.elements.map((v, i) => + Math.abs(v - expected.elements[i]), + ), + ); + } + if (!node.isMesh) return; + meshes++; + replacements.push(node); + for (const m of [node.material].flat()) { + if (m.normalMap?.image?.width > 0) normals++; + if (m.map?.image?.width > 0) screens++; + if (m.emissiveIntensity > 1) emissive++; + } + }); + if (!body.endsWith("_wrist_link")) { + const before = bounds(originals, frame), + after = bounds(replacements, frame); + boundsError = Math.max( + boundsError, + ...before.map((v, i) => Math.abs(v - after[i])), + ); + } + } + return { + bodies: layer.children.length, + frameError, + boundsError, + handError, + handParts, + normals, + screens, + emissive, + hidden, + meshes, + obs: r.buildObs().length, + actions: r.lastAction.length, + actuators: r.model.nu, + }; + }); + const initial = await inspect(); + console.log("RP1 GLB alignment", initial); + expect(initial.bodies).toBe(25); + expect(initial.handParts).toBe(40); + expect(initial.frameError).toBeLessThan(1e-12); + expect(initial.boundsError).toBeLessThan(1e-7); + expect(initial.handError).toBeLessThan(1e-10); + expect(initial.normals).toBeGreaterThanOrEqual(63); + expect(initial.screens).toBeGreaterThanOrEqual(1); + expect(initial.emissive).toBeGreaterThanOrEqual(1); + expect(initial.hidden).toBe(25); + expect(initial.obs).toBe(243); + expect(initial.actions).toBe(24); + expect(initial.actuators).toBe(24); + await page.evaluate(() => { + const r = window.rl; + r.data.qpos[3] = Math.cos(0.4); + r.data.qpos[6] = Math.sin(0.4); + for (let j = 0; j < r.model.njnt; j++) + if (r.model.jnt_type[j] === 3) + r.data.qpos[r.model.jnt_qposadr[j]] += 0.12; + r.mujoco.mj_forward(r.model, r.data); + }); + await page.waitForTimeout(200); + const posed = await inspect(); + expect(posed.frameError).toBeLessThan(1e-12); + expect(posed.boundsError).toBeLessThan(1e-7); + expect(posed.handError).toBeLessThan(1e-10); + await page.evaluate(() => window.rl.resetSim()); + await page.getByRole("button", { name: /Keyboard controls/ }).click(); + await page.mouse.click(950, 750, { button: "right" }); + await page.evaluate(() => { + const r = window.rl; + r.setPropsParked(true); + r.camera.position.set(2.4, 1.35, 1.3); + r.controls.target.set(0, 0.7, 0); + r.controls.update(); + }); + await page.waitForTimeout(300); + await page.screenshot({ path: info.outputPath("rp1-material-front.png") }); + expect(errors).toEqual([]); +}); + +test("RP1 GLBs change no physics, observations or ONNX actions for walking, wave and dance", async ({ + page, +}) => { + await boot(page); + let textured = false; + await page.route("**/robots/rp1/robot.json*", async (route) => { + const response = await route.fetch(), + config = await response.json(); + if (!textured) delete config.render.body_visuals; + await route.fulfill({ response, json: config }); + }); + async function run() { + expect(await page.evaluate(() => window.__gameApi.switchRobot("rp1"))).toBe( + true, + ); + return page.evaluate(async () => { + const r = window.rl, + result = []; + for (const scenario of ["walk", "wave", "dance"]) { + await r.resetSim(); + await r.step(100); + if (scenario === "walk") r.command.set([0.4, 0, 0.15]); + else r.policyState.request(scenario, r.data.time); + for (let i = 0; i < 5; i++) { + await r.step(50); + result.push({ + scenario, + time: r.data.time, + qpos: Array.from(r.data.qpos), + qvel: Array.from(r.data.qvel), + ctrl: Array.from(r.data.ctrl), + action: Array.from(r.lastAction), + obs: Array.from(r.buildObs()), + state: r.policyState.state, + reference: r.referenceFrame, + }); + } + } + return result; + }); + } + const old = await run(); + await page.evaluate(() => window.__gameApi.switchRobot("microduck-legs")); + textured = true; + expect(await run()).toEqual(old); +}); + +test("a partial RP1 material load failure releases the candidate and retry succeeds", async ({ + page, +}) => { + await boot(page); + let fail = true; + await page.route( + "**/robots/rp1/visuals/left_hip_roll_link__visual_0__left_hip_roll_link.glb", + (route) => + fail ? route.fulfill({ status: 404, body: "missing" }) : route.continue(), + ); + expect(await page.evaluate(() => window.__gameApi.switchRobot("rp1"))).toBe( + false, + ); + await expect(page.getByRole("alert")).toContainText("404"); + expect(await page.evaluate(() => window.__store.getState().robotId)).toBe( + "microduck-legs", + ); + expect(await page.evaluate(() => window.rl.model.isDeleted())).toBe(false); + fail = false; + expect(await page.evaluate(() => window.__gameApi.retry())).toBe(true); + expect( + await page.evaluate( + () => window.rl.scene.getObjectByName("body-visuals").children.length, + ), + ).toBe(25); +}); diff --git a/app/e2e/runtime-leaks.spec.js b/app/e2e/runtime-leaks.spec.js index 7ff32a1..89cf870 100644 --- a/app/e2e/runtime-leaks.spec.js +++ b/app/e2e/runtime-leaks.spec.js @@ -3,7 +3,9 @@ import { test, expect } from "@playwright/test"; test("20 robot transitions release old WASM objects and plateau scene/GPU/listeners", async ({ page, }, info) => { - test.setTimeout(180_000); + // Twenty cold transitions now also decode RP1's ~93 MB textured GLBs. + // Keep allocation/listener assertions unchanged; allow load-time headroom. + test.setTimeout(240_000); await page.addInitScript(() => { const add = EventTarget.prototype.addEventListener, remove = EventTarget.prototype.removeEventListener, @@ -57,6 +59,9 @@ test("20 robot transitions release old WASM objects and plateau scene/GPU/listen dataDeleted: data.isDeleted(), ...window.__gameApi.diagnostics(), listeners: window.listenerCount(), + toyGeometries: + window.rl.scene.getObjectByName("interactive-props")?.children + .length ?? 0, }; }, id); expect(sample.success).toBe(true); @@ -70,8 +75,12 @@ test("20 robot transitions release old WASM objects and plateau scene/GPU/listen for (const samples of [duck, ban, rp1]) { expect(samples.at(-1).listeners).toBe(samples[0].listeners); expect(samples.at(-1).sceneChildren).toBe(samples[0].sceneChildren); - expect(samples.at(-1).memory.geometries).toBeLessThanOrEqual( - samples[1].memory.geometries + 1, + // Each runtime owns 5–7 independent toy geometries. Compare the fixed + // scene allocation after removing this intentionally variable count. + expect( + samples.at(-1).memory.geometries - samples.at(-1).toyGeometries, + ).toBeLessThanOrEqual( + samples[1].memory.geometries - samples[1].toyGeometries + 1, ); expect(samples.at(-1).memory.textures).toBeLessThanOrEqual( samples[1].memory.textures + 1, diff --git a/app/e2e/scene-interaction.spec.js b/app/e2e/scene-interaction.spec.js new file mode 100644 index 0000000..c43c988 --- /dev/null +++ b/app/e2e/scene-interaction.spec.js @@ -0,0 +1,255 @@ +import { test, expect } from "@playwright/test"; +import { bootDuck } from "./support/simulation.js"; + +test("bright scene has 5–7 free-body toys, no football, and four original-style line colour buttons", async ({ + page, +}) => { + const errors = await bootDuck(page); + await page.evaluate(async () => { + const r = window.rl; + r.setPropsParked(false); + await r.step(60); + r.render(); + }); + const initial = await page.evaluate(() => { + const r = window.rl; + return { + toys: r.interactiveProps.map((p) => ({ + type: p.type, + dof: p.dofAdr, + mass: r.model.body_mass[p.bodyId], + })), + meshes: r.scene.getObjectByName("interactive-props").children.length, + ballId: r.mujoco.mj_name2id( + r.model, + r.mujoco.mjtObj.mjOBJ_BODY.value, + "ball", + ), + hemisphere: r.scene.parent.children.some( + (o) => o.isHemisphereLight && o.intensity >= 0.7, + ), + environment: r.scene.parent.environmentIntensity, + robotMaterials: [...r.scene.children] + .filter((o) => o.name !== "interactive-props") + .flatMap((o) => { + const result = []; + o.traverse((m) => { + if (m.isMesh && m.material?.color) + result.push([m.uuid, m.material.color.toArray()]); + }); + return result; + }), + }; + }); + expect(initial.toys.length).toBeGreaterThanOrEqual(5); + expect(initial.toys.length).toBeLessThanOrEqual(7); + expect(initial.meshes).toBe(initial.toys.length); + expect(new Set(initial.toys.map((p) => p.type)).size).toBe(4); + expect(initial.toys.every((p) => p.mass > 0 && p.dof >= 0)).toBe(true); + expect(initial.ballId).toBe(-1); + expect(initial.hemisphere).toBe(true); + expect(initial.environment).toBeGreaterThanOrEqual(0.7); + const group = page.getByRole("group", { name: "Scene line colours" }); + await expect(group.getByRole("button")).toHaveCount(4); + for (const [label, hex] of [ + ["Cream", "f7e6cb"], + ["Graphite", "6c6a68"], + ["Lavender", "bfa9cf"], + ["Sky", "a9dbe8"], + ]) { + const button = group.getByRole("button", { name: `${label} scene lines` }); + await button.click(); + await expect(button).toHaveAttribute("aria-pressed", "true"); + const values = await page.evaluate(() => { + const r = window.rl, + lines = [], + robotMaterials = []; + r.scene.traverse((o) => { + if (o.material?.uniforms?.uSectionColor) + lines.push(o.material.uniforms.uSectionColor.value.getHexString()); + }); + for (const o of r.scene.children.filter( + (o) => o.name !== "interactive-props", + )) + o.traverse((m) => { + if (m.isMesh && m.material?.color) + robotMaterials.push([m.uuid, m.material.color.toArray()]); + }); + const style = getComputedStyle( + document.querySelector('[aria-label="Scene line colours"] button'), + ); + return { + lines, + robotMaterials, + radius: style.borderRadius, + width: style.width, + height: style.height, + }; + }); + expect(values.lines).toEqual(Array(5).fill(hex)); + expect(values.robotMaterials).toEqual(initial.robotMaterials); + expect(values.radius).toBe("0px"); + expect(values.width).toBe(values.height); + } + await page.evaluate(() => { + const r = window.rl; + r.chaseCam = false; + r.camera.position.set(-0.2, 1.9, 2.7); + r.controls.target.set(0.1, 0.05, 0); + r.controls.update(); + }); + await page.screenshot({ + path: "test-results/scene-interaction-overview.png", + }); + expect(errors).toEqual([]); +}); + +test("geometry can be dragged with physical force; pause/reset clear grab and restore layout", async ({ + page, +}) => { + const errors = await bootDuck(page); + await page.evaluate(() => { + const r = window.rl; + r.setPropsParked(false); + r.chaseCam = false; + const spec = r.interactiveProps[0], + q = r.data.qpos; + q.set([-0.25, 0, spec.pos[2]], spec.qAdr); + r.mujoco.mj_forward(r.model, r.data); + r.camera.position.set(-0.6, 0.65, 1.2); + r.controls.target.set(q[0], q[2], -q[1]); + r.controls.update(); + r.camera.updateMatrixWorld(); + r.render(); + }); + await page.waitForTimeout(250); + const point = await page.evaluate(() => { + const r = window.rl, + spec = r.interactiveProps[0], + q = r.data.qpos; + const p = r.controls.target + .clone() + .set(q[spec.qAdr], q[spec.qAdr + 2], -q[spec.qAdr + 1]) + .project(r.camera); + const rect = document.querySelector("canvas").getBoundingClientRect(); + return { + x: ((p.x + 1) * rect.width) / 2, + y: ((1 - p.y) * rect.height) / 2, + }; + }); + await page.mouse.move(point.x, point.y); + await page.mouse.down(); + expect(await page.evaluate(() => window.rl.controls.enabled)).toBe(false); + await page.mouse.move(point.x + 90, point.y - 40, { steps: 6 }); + const result = await page.evaluate(async () => { + const r = window.rl, + spec = r.interactiveProps[0]; + await r.step(15); + return { + x: r.data.qpos[spec.qAdr], + force: Array.from( + r.data.xfrc_applied.slice(spec.bodyId * 6, spec.bodyId * 6 + 3), + ), + }; + }); + expect(Math.abs(result.x + 0.25)).toBeGreaterThan(0.01); + expect(result.force.some((v) => Math.abs(v) > 0.001)).toBe(true); + await page.evaluate(() => window.__gameApi.pause()); + expect(await page.evaluate(() => window.rl.controls.enabled)).toBe(true); + await page.mouse.up(); + expect( + await page.evaluate(() => + Array.from(window.rl.data.xfrc_applied).every((v) => v === 0), + ), + ).toBe(true); + await page.evaluate(() => window.__gameApi.reset()); + expect( + await page.evaluate(() => { + const r = window.rl; + return ( + r.interactiveProps.every((p) => + p.pos.every((v, i) => r.data.qpos[p.qAdr + i] === v), + ) && r.controls.enabled + ); + }), + ).toBe(true); + expect(errors).toEqual([]); +}); + +test("toys transfer collision momentum, collide with the robot and floor, and survive a mode switch", async ({ + page, +}) => { + const errors = await bootDuck(page); + const collision = await page.evaluate(async () => { + const r = window.rl; + r.setPropsParked(false); + const specs = r.interactiveProps; + // Keep unrelated toys clear of a two-body collision lane. + specs.forEach((p, i) => { + r.data.qpos.set([-1 + i * 0.3, -1.1, p.pos[2]], p.qAdr); + }); + const a = specs[0], + b = specs[1]; + r.data.qpos.set([0.1, 0.7, a.pos[2]], a.qAdr); + r.data.qpos.set([0.35, 0.7, b.pos[2]], b.qAdr); + r.data.qvel[a.dofAdr] = 1.8; + r.mujoco.mj_forward(r.model, r.data); + await r.step(15); + const moved = r.data.qpos[b.qAdr] - 0.35; + // Launch a toy at the duck. A non-colliding body would cross x=-0.6. + r.resetSim(); + const p = r.interactiveProps.find((s) => s.type === "sphere"); + r.data.qpos.set([-0.35, 0, 0.09], p.qAdr); + r.data.qvel[p.dofAdr] = -1.5; + r.mujoco.mj_forward(r.model, r.data); + let contacts = 0, + minX = 10; + for (let i = 0; i < 15; i++) { + await r.step(1); + contacts = Math.max(contacts, r.data.ncon); + minX = Math.min(minX, r.data.qpos[p.qAdr]); + } + await r.step(100); + const half = r.world.boundary.half_extent; + r.data.qpos.set([half - 0.2, 0.9, p.pos[2]], p.qAdr); + r.data.qvel.fill(0, p.dofAdr, p.dofAdr + 6); + r.data.qvel[p.dofAdr] = 1.5; + r.mujoco.mj_forward(r.model, r.data); + let wallMax = -Infinity; + for (let i = 0; i < 15; i++) { + await r.step(1); + wallMax = Math.max(wallMax, r.data.qpos[p.qAdr]); + } + return { + moved, + contacts, + minX, + wallMax, + half, + finite: Array.from(r.data.qpos).every(Number.isFinite), + aboveFloor: r.interactiveProps.every( + (s) => r.data.qpos[s.qAdr + 2] > 0.025, + ), + }; + }); + expect(collision.moved).toBeGreaterThan(0.025); + expect(collision.contacts).toBeGreaterThan(0); + expect(collision.minX).toBeGreaterThan(-0.58); + expect(collision.wallMax).toBeLessThan(collision.half - 0.03); + expect(collision.aboveFloor).toBe(true); + expect(collision.finite).toBe(true); + await page.evaluate(() => window.rl.setLoco("rollers", { force: true })); + const switched = await page.evaluate(async () => { + const r = window.rl; + await r.step(100); + r.render(); + return { + count: r.interactiveProps.length, + meshes: r.scene.getObjectByName("interactive-props").children.length, + finite: Array.from(r.data.qpos).every(Number.isFinite), + }; + }); + expect(switched.count).toBe(switched.meshes); + expect(switched.finite).toBe(true); + expect(errors).toEqual([]); +}); diff --git a/app/e2e/scene-stability.spec.js b/app/e2e/scene-stability.spec.js new file mode 100644 index 0000000..dcfbe9b --- /dev/null +++ b/app/e2e/scene-stability.spec.js @@ -0,0 +1,68 @@ +import { test, expect } from "@playwright/test"; +import { bootDuck } from "./support/simulation.js"; + +test("two simulated minutes of movement with physical toys stay finite in feet and rollers; escape recovery is local", async ({ + page, +}) => { + const errors = await bootDuck(page); + await page.evaluate(() => { + const r = window.rl; + r.setPropsParked(false); + // A deterministic controller source exercises actual commanded motion, + // independent of frame-rate keyboard polling during manual stepping. + r.controller.addSource({ + id: "stability-drive", + isActive: () => true, + command: new Float32Array([0.25, 0, 0.4]), + }); + }); + for (const mode of ["legs", "rollers"]) { + await page.evaluate(async (mode) => { + const r = window.rl; + await r.setLoco(mode, { force: true }); + r.controller.sources + .find((s) => s.id === "stability-drive") + .command.set(mode === "legs" ? [0.25, 0, 0.4] : [0.4, 0, 0.15]); + }, mode); + let moved = false; + for (let chunk = 0; chunk < 30; chunk++) { + const sample = await page.evaluate(async () => { + const r = window.rl; + await r.step(100); + return { + finite: [r.data.qpos, r.data.qvel, r.data.ctrl].every((array) => + Array.from(array).every(Number.isFinite), + ), + moved: Math.hypot(r.data.qpos[0] + 0.6, r.data.qpos[1]) > 0.04, + inside: r.interactiveProps.every( + (p) => + Math.abs(r.data.qpos[p.qAdr]) < + r.world.boundary.half_extent + 0.11 && + Math.abs(r.data.qpos[p.qAdr + 1]) < + r.world.boundary.half_extent + 0.11, + ), + }; + }); + expect(sample.finite).toBe(true); + expect(sample.inside).toBe(true); + moved ||= sample.moved; + } + expect(moved).toBe(true); + } + const recovery = await page.evaluate(async () => { + const r = window.rl, + p = r.interactiveProps[0]; + r.data.qpos[p.qAdr] = r.world.boundary.half_extent + 1; + r.mujoco.mj_forward(r.model, r.data); + await r.step(1); + return { + actual: Array.from(r.data.qpos.slice(p.qAdr, p.qAdr + 3)), + expected: p.pos, + count: r.interactiveProps.length, + }; + }); + expect(recovery.actual).toEqual(recovery.expected); + expect(recovery.count).toBeGreaterThanOrEqual(5); + expect(recovery.count).toBeLessThanOrEqual(7); + expect(errors).toEqual([]); +}); diff --git a/app/e2e/shared-environment.spec.js b/app/e2e/shared-environment.spec.js new file mode 100644 index 0000000..b36dbb5 --- /dev/null +++ b/app/e2e/shared-environment.spec.js @@ -0,0 +1,157 @@ +import { test, expect } from "@playwright/test"; +import { bootDuck } from "./support/simulation.js"; + +test("all robots share the same scaled random layout, lighting, line palette and global colour selection", async ({ + page, +}) => { + const errors = await bootDuck(page); + let reference; + let expected = { name: "Sky", key: "blue", hex: "a9dbe8" }; + for (const id of ["microduck-legs", "microban", "rp1", "microduck-legs"]) { + if ((await page.evaluate(() => window.__store.getState().robotId)) !== id) + await page.evaluate((id) => window.__gameApi.switchRobot(id), id); + await expect( + page.getByRole("group", { name: "Scene line colours" }), + ).toBeVisible(); + if (!reference) + await page.getByRole("button", { name: "Sky scene lines" }).click(); + const state = await page.evaluate(() => { + const r = window.rl, + scale = r.world.boundary.half_extent / 2.25; + const lines = []; + r.scene.traverse((o) => { + if (o.material?.uniforms?.uSectionColor) + lines.push(o.material.uniforms.uSectionColor.value.getHexString()); + }); + return { + specs: r.interactiveProps.map((p) => ({ + name: p.name, + type: p.type, + color: p.color, + pos: p.pos.map((v) => v / scale), + size: p.size.map((v) => v / scale), + })), + count: r.scene.getObjectByName("interactive-props").children.length, + lines, + lineColor: window.__store.getState().lineColor, + lights: r.scene.parent.children + .filter((o) => o.isLight) + .map((o) => [o.type, o.intensity, o.color.getHex()]), + environment: r.scene.parent.environmentIntensity, + drag: window.__store.getState().runtimeCapabilities.physicalDrag, + }; + }); + expect(state.count).toBeGreaterThanOrEqual(5); + expect(state.count).toBeLessThanOrEqual(7); + expect(state.lines).toEqual(Array(5).fill(expected.hex)); + expect(state.lineColor).toBe(expected.key); + expect(state.drag).toBe(true); + if (!reference) reference = state; + state.specs.forEach((p, i) => { + expect(p.type).toBe(reference.specs[i].type); + expect(p.color).toBe(reference.specs[i].color); + p.pos.forEach((v, j) => + expect(v).toBeCloseTo(reference.specs[i].pos[j], 12), + ); + p.size.forEach((v, j) => + expect(v).toBeCloseTo(reference.specs[i].size[j], 12), + ); + }); + expect(state.lights).toEqual(reference.lights); + expect(state.environment).toBe(reference.environment); + await expect( + page.getByRole("button", { name: `${expected.name} scene lines` }), + ).toHaveAttribute("aria-pressed", "true"); + await expect( + page.getByRole("button", { name: "Rollers", exact: true }), + ).toHaveCount(id === "microduck-legs" ? 1 : 0); + // Also carry a choice made in another robot back to Microduck. + if (id === "rp1") { + await page.getByRole("button", { name: "Lavender scene lines" }).click(); + expected = { name: "Lavender", key: "purple", hex: "bfa9cf" }; + } + } + expect(errors).toEqual([]); +}); + +for (const id of ["microban", "rp1"]) { + test(`${id}: shared toys collide with walls, drag with real force and release on pause`, async ({ + page, + }) => { + const errors = await bootDuck(page); + await page.evaluate((id) => window.__gameApi.switchRobot(id), id); + const wall = await page.evaluate(async () => { + const r = window.rl, + scale = r.world.boundary.half_extent / 2.25, + p = r.interactiveProps.find((s) => s.type === "sphere"), + half = r.world.boundary.half_extent; + r.data.qpos.set([half - 0.2 * scale, 0.9 * scale, p.pos[2]], p.qAdr); + r.data.qvel[p.dofAdr] = 1.5 * scale; + r.mujoco.mj_forward(r.model, r.data); + let max = -Infinity; + for (let i = 0; i < 15; i++) { + await r.step(1); + max = Math.max(max, r.data.qpos[p.qAdr]); + } + await r.resetSim(); + return { max, limit: half - 0.025 * scale }; + }); + expect(wall.max).toBeLessThan(wall.limit); + await page.getByRole("button", { name: /Keyboard controls/ }).click(); + await page.evaluate(() => { + const r = window.rl, + scale = r.world.scale ?? 1, + p = r.interactiveProps[0], + q = r.data.qpos; + q.set([0.25 * scale, -0.3 * scale, p.pos[2]], p.qAdr); + r.mujoco.mj_forward(r.model, r.data); + r.camera.position.set(q[0], q[2] + 0.6 * scale, 1.5 * scale); + r.controls.target.set(q[0], q[2], -q[1]); + r.controls.update(); + window.__gameApi.resume(); + }); + await page.waitForTimeout(200); + const point = await page.evaluate(() => { + const r = window.rl, + p = r.interactiveProps[0], + q = r.data.qpos, + rect = document.querySelector("canvas").getBoundingClientRect(); + const v = r.controls.target + .clone() + .set(q[p.qAdr], q[p.qAdr + 2], -q[p.qAdr + 1]) + .project(r.camera); + return { + x: ((v.x + 1) * rect.width) / 2, + y: ((1 - v.y) * rect.height) / 2, + }; + }); + await page.mouse.move(point.x, point.y); + await page.mouse.down(); + expect(await page.evaluate(() => window.rl.controls.enabled)).toBe(false); + await page.mouse.move(point.x + 70, point.y - 35, { steps: 5 }); + await page.waitForTimeout(200); + expect( + await page.evaluate(() => + Array.from(window.rl.data.xfrc_applied).some((v) => Math.abs(v) > 1e-5), + ), + ).toBe(true); + await page.evaluate(() => window.__gameApi.pause()); + expect(await page.evaluate(() => window.rl.controls.enabled)).toBe(true); + expect( + await page.evaluate(() => + Array.from(window.rl.data.xfrc_applied).every((v) => v === 0), + ), + ).toBe(true); + await page.mouse.up(); + await page.evaluate(() => window.__gameApi.reset()); + expect( + await page.evaluate(() => { + const r = window.rl; + return r.interactiveProps.every((p) => + p.pos.every((v, i) => r.data.qpos[p.qAdr + i] === v), + ); + }), + ).toBe(true); + expect(errors).toEqual([]); + }); +} diff --git a/app/e2e/support/simulation.js b/app/e2e/support/simulation.js index 070dc4b..ffb726d 100644 --- a/app/e2e/support/simulation.js +++ b/app/e2e/support/simulation.js @@ -1,5 +1,5 @@ import { expect } from "@playwright/test"; -export async function bootDuck(page) { +export async function bootDuck(page, { legacyPhysics = false } = {}) { const errors = []; page.on("pageerror", (e) => errors.push(e.message)); await page.addInitScript(() => { @@ -7,7 +7,7 @@ export async function bootDuck(page) { Math.random = () => (seed = (1664525 * seed + 1013904223) >>> 0) / 4294967296; }); - await page.goto("/?boot=1&test=1"); + await page.goto(`/?boot=1&test=1${legacyPhysics ? "&oracle=legacy" : ""}`); await page.waitForFunction( () => window.rl?.prepareTest || window.__store?.getState().bootFailed, ); diff --git a/app/package-lock.json b/app/package-lock.json index 86d8495..211120f 100644 --- a/app/package-lock.json +++ b/app/package-lock.json @@ -1,12 +1,12 @@ { "name": "microduck-sandbox", - "version": "0.4.0", + "version": "0.5.0", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "microduck-sandbox", - "version": "0.4.0", + "version": "0.5.0", "dependencies": { "@emotion/react": "^11.14.0", "@emotion/styled": "^11.14.1", diff --git a/app/package.json b/app/package.json index 98992d2..b79c275 100644 --- a/app/package.json +++ b/app/package.json @@ -1,7 +1,7 @@ { "name": "microduck-sandbox", "private": true, - "version": "0.4.0", + "version": "0.5.0", "type": "module", "scripts": { "dev": "vite", diff --git a/app/public/robots/rp1/SOURCE.md b/app/public/robots/rp1/SOURCE.md index f804602..6efa253 100644 --- a/app/public/robots/rp1/SOURCE.md +++ b/app/public/robots/rp1/SOURCE.md @@ -30,6 +30,18 @@ Source archives under `robolab/data/motions/rp1_bm/`: Both skills use exclusive full-body policies, a physical stop gate, entry/return blends and locomotion interruption. Validation includes three initial headings, walking before/after, repeated episodes without robot reset, keyboard/pause/reset, numerical reference checks and malformed-asset rollback. Initial integration: `docs/superpowers/verification/2026-10-29-rp1-completed-skills.md`; current dance weights: `docs/superpowers/verification/2026-10-29-rp1-dance-23998.md`. UI labels are simply `Dance` and `Wave`; durations and transition behavior remain unchanged. +## User-provided GLB material replacement + +`RP1机器人glb.zip` supplies 63 Blender-exported, self-contained GLBs. `visual-source-manifest.json` records the archive SHA-256, all 63 source-part hashes, 25 output hashes and the exact body mapping. Original MJCF/STL, policy and motion files retain their existing hashes; the only manifest change is `render.body_visuals`. + +- Twenty-three bodies use byte-identical source GLBs. Their Blender Y-up coordinates are rotated +90° about X into MuJoCo body Z-up. All 63 source-part bounds were independently checked against the upstream STL bounds after this axis conversion: exact agreement. +- The existing 24-DOF model has only one `left_wrist_link` / `right_wrist_link` body per side. Each visual wrist therefore composes **20 parts**: wrist roll/yaw/pitch plus the palm and 16 finger pieces. Transforms come from the copied upstream `visuals/rp1_hand_fixed.urdf`; extra wrist yaw/pitch stay neutral, fingers stay in their fixed poses. There are **no additional physical joints or finger-control claims**. +- The assembler preserves source vertex/index/image bytes, remaps GLTF indices and retains original PBR colours, roughness/metalness, normal maps, face screen texture and emissive torso logo. It adds only visual transform wrapper nodes. +- Reproduce with `python3 app/scripts/import-rp1-visuals.py /path/to/RP1机器人glb.zip app/public/robots/rp1/visuals/rp1_hand_fixed.urdf` from the repo root. All inputs/outputs validate before installation; ZIP paths are never extracted. +- Geometry additions in the hands are visual only. Existing collision envelopes intentionally remain those used by the trained 24-DOF model. + +The ZIP supplied no license/attribution file. Do not infer redistribution rights from receipt of these assets. It remains a local-evaluation package under the limitations below. + ## License limitation — local evaluation only The RP1 description submodule does not supply a license file in this checkout. Do **not** infer an Apache/BSD license for its meshes/model or motion data from the platform or RoboLab. Confirm upstream rights before redistributing this package or deploying publicly. diff --git a/app/public/robots/rp1/robot.json b/app/public/robots/rp1/robot.json index 9d5b687..2387be4 100644 --- a/app/public/robots/rp1/robot.json +++ b/app/public/robots/rp1/robot.json @@ -678,7 +678,259 @@ ], "camera": { "distance": 2.4 - } + }, + "body_visuals": [ + { + "body": "base_link", + "path": "visuals/base_link__visual_0__base_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "left_hip_pitch_link", + "path": "visuals/left_hip_pitch_link__visual_0__left_hip_pitch_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "left_hip_roll_link", + "path": "visuals/left_hip_roll_link__visual_0__left_hip_roll_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "left_hip_yaw_link", + "path": "visuals/left_hip_yaw_link__visual_0__left_hip_yaw_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "left_knee_link", + "path": "visuals/left_knee_link__visual_0__left_knee_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "left_ankle_pitch_link", + "path": "visuals/left_ankle_pitch_link__visual_0__left_ankle_pitch_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "left_ankle_roll_link", + "path": "visuals/left_ankle_roll_link__visual_0__left_ankle_roll_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "right_hip_pitch_link", + "path": "visuals/right_hip_pitch_link__visual_0__right_hip_pitch_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "right_hip_roll_link", + "path": "visuals/right_hip_roll_link__visual_0__right_hip_roll_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "right_hip_yaw_link", + "path": "visuals/right_hip_yaw_link__visual_0__right_hip_yaw_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "right_knee_link", + "path": "visuals/right_knee_link__visual_0__right_knee_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "right_ankle_pitch_link", + "path": "visuals/right_ankle_pitch_link__visual_0__right_ankle_pitch_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "right_ankle_roll_link", + "path": "visuals/right_ankle_roll_link__visual_0__right_ankle_roll_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "waist_roll_link", + "path": "visuals/waist_roll_link__visual_0__waist_roll_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "waist_yaw_link", + "path": "visuals/waist_yaw_link__visual_0__waist_yaw_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "left_shoulder_pitch_link", + "path": "visuals/left_shoulder_pitch_link__visual_0__left_shoulder_pitch_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "left_shoulder_roll_link", + "path": "visuals/left_shoulder_roll_link__visual_0__left_shoulder_roll_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "left_shoulder_yaw_link", + "path": "visuals/left_shoulder_yaw_link__visual_0__left_shoulder_yaw_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "left_elbow_link", + "path": "visuals/left_elbow_link__visual_0__left_elbow_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "left_wrist_link", + "path": "visuals/left_wrist_link__fixed_hand.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "right_shoulder_pitch_link", + "path": "visuals/right_shoulder_pitch_link__visual_0__right_shoulder_pitch_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "right_shoulder_roll_link", + "path": "visuals/right_shoulder_roll_link__visual_0__right_shoulder_roll_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "right_shoulder_yaw_link", + "path": "visuals/right_shoulder_yaw_link__visual_0__right_shoulder_yaw_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "right_elbow_link", + "path": "visuals/right_elbow_link__visual_0__right_elbow_link.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + }, + { + "body": "right_wrist_link", + "path": "visuals/right_wrist_link__fixed_hand.glb", + "quaternion": [ + 0.7071067811865476, + 0, + 0, + 0.7071067811865476 + ] + } + ] }, "presentation": { "theme": "comic" diff --git a/app/public/robots/rp1/visual-source-manifest.json b/app/public/robots/rp1/visual-source-manifest.json new file mode 100644 index 0000000..2dec9a7 --- /dev/null +++ b/app/public/robots/rp1/visual-source-manifest.json @@ -0,0 +1,557 @@ +{ + "source": "User-provided RP1\u673a\u5668\u4ebaglb.zip", + "archive_sha256": "8610aac8432203bf68d0efe234062c551ca805ebbe72a92d5fc7350730ebdea2", + "license": "Not supplied in the archive; local evaluation only. Confirm redistribution rights.", + "coordinate_conversion": "Source GLBs are Blender Y-up; attachments rotate +90 degrees about X into MuJoCo body Z-up.", + "assembly": "25 physical body attachments; 20 source parts per wrist (neutral extra wrist axes and fixed fingers). No physical joints added.", + "input_files": [ + { + "file": "base_link__visual_0__base_link.glb", + "sha256": "3db82d0e5fa1fa48fa6f4fe4460bba14568a39b5933acff8b4b1879f582e06b0" + }, + { + "file": "left_hip_pitch_link__visual_0__left_hip_pitch_link.glb", + "sha256": "d8cb2aff7273185a89eba99aab47ce6bf4716f25e70f34afa1529acb802c6193" + }, + { + "file": "left_hip_roll_link__visual_0__left_hip_roll_link.glb", + "sha256": "35361b79fb69096039eb077018c25ae489f16cc5229dcd82256b3a573b168208" + }, + { + "file": "left_hip_yaw_link__visual_0__left_hip_yaw_link.glb", + "sha256": "19fe908274f9fe49b5a8317652e4fe02a6ff93802de87ad7d0383fa1d142b03b" + }, + { + "file": "left_knee_link__visual_0__left_knee_link.glb", + "sha256": "1c01f5c03837d24287d79eff48a9e4bd4203d8516d0375592b159d49fb83f6c9" + }, + { + "file": "left_ankle_pitch_link__visual_0__left_ankle_pitch_link.glb", + "sha256": "4bab717bf7073e28754d1c42f4409141ea775987284ff8575f9c7aef25561e8c" + }, + { + "file": "left_ankle_roll_link__visual_0__left_ankle_roll_link.glb", + "sha256": "76144b6ebf17b2eb5875168cbe6a3c4c12eaeebdd4bd277864887b3894f781b1" + }, + { + "file": "right_hip_pitch_link__visual_0__right_hip_pitch_link.glb", + "sha256": "e299f46bff44d6bbf03592cd6caba3b418fc022260746554e6d2013f31793df4" + }, + { + "file": "right_hip_roll_link__visual_0__right_hip_roll_link.glb", + "sha256": "7cb006f9ba7f950c98287b59695938cfd6460d8fa4546ae6c95bc65ed5c6c6b8" + }, + { + "file": "right_hip_yaw_link__visual_0__right_hip_yaw_link.glb", + "sha256": "35393465aa8103ab436ecc3a635cdce7477600cf65eb03a2942af546cc39c79c" + }, + { + "file": "right_knee_link__visual_0__right_knee_link.glb", + "sha256": "2a5f1f91f6db0cfac3a0e88038613be89cb94066d7f103876b455823edbfb8f3" + }, + { + "file": "right_ankle_pitch_link__visual_0__right_ankle_pitch_link.glb", + "sha256": "c43112750efd953f29dfea5d8d2bb925eb847f74b679fa1d22f734b1e3094b91" + }, + { + "file": "right_ankle_roll_link__visual_0__right_ankle_roll_link.glb", + "sha256": "3856c0074bbead9ade091b2bef4df165d9c1d4b03e0c0f1d8c284cddf091a9f6" + }, + { + "file": "waist_roll_link__visual_0__waist_roll_link.glb", + "sha256": "a4cd49014951ed5c7836bde4a7138eab4119f0ca7249a69e26add388d5fedf32" + }, + { + "file": "waist_yaw_link__visual_0__waist_yaw_link.glb", + "sha256": "cb50b0354f8a0a6d06ff486d46cb849462b84471c20a350b1e4c5a86577ce230" + }, + { + "file": "left_shoulder_pitch_link__visual_0__left_shoulder_pitch_link.glb", + "sha256": "9eb76bc0675578e28707120d64cb042b948312ddc9233e4c28de02ee04a3dbf9" + }, + { + "file": "left_shoulder_roll_link__visual_0__left_shoulder_roll_link.glb", + "sha256": "f72e3ac73f3804acd5e5384c2d10d48aacacb95bf9f98ea0f2426f1b92add0de" + }, + { + "file": "left_shoulder_yaw_link__visual_0__left_shoulder_yaw_link.glb", + "sha256": "909f0dbd40db57b223143c1c89c740c3ea636e5d9b066eb6fe26dab37e2f4975" + }, + { + "file": "left_elbow_link__visual_0__left_elbow_link.glb", + "sha256": "f98a4446175c7b1d98c5a664fabcb6698635c99ccfc8261dedbef9155e1a2043" + }, + { + "file": "left_wrist_roll_link__visual_0__left_wrist_roll_link.glb", + "sha256": "fd4dff45bb8c6caa79ceff1286cf8d8d69de22f781fbbd12a91baf87636e0ad2" + }, + { + "file": "left_wrist_yaw_link__visual_0__left_wrist_yaw_link.glb", + "sha256": "65835f9275362e18801a3247191323f0661f538a3c24836cc78fdd1ec5560a3e" + }, + { + "file": "left_wrist_pitch_link__visual_0__left_wrist_pitch_link.glb", + "sha256": "e036068c1f36349c26a8daba9472fd40cfec5ae55424a55a95a4c75472c9dd48" + }, + { + "file": "right_shoulder_pitch_link__visual_0__right_shoulder_pitch_link.glb", + "sha256": "21d9410ca84dcd3bfea3bd8c08a682d4ff640c79f68e5d9f93ea26bcf904c3ac" + }, + { + "file": "right_shoulder_roll_link__visual_0__right_shoulder_roll_link.glb", + "sha256": "89b5da7da64e2d3207291c7847d347d30fe0b40014ea6d6c4fc9e4bf4e03682c" + }, + { + "file": "right_shoulder_yaw_link__visual_0__right_shoulder_yaw_link.glb", + "sha256": "2f0c17876e2607e8ab4282fadefba6fee6c2a5446b416cce6d0b91f796da2893" + }, + { + "file": "right_elbow_link__visual_0__right_elbow_link.glb", + "sha256": "ef1e9dc1afcf147e78902039f49ef0131f114a11afe873b5095a6c4f509b89b2" + }, + { + "file": "right_wrist_roll_link__visual_0__right_wrist_roll_link.glb", + "sha256": "5efc62e433d732ec26a5b45d3be64f421fb9c26176f168bdde74a9737e48eae3" + }, + { + "file": "right_wrist_yaw_link__visual_0__right_wrist_yaw_link.glb", + "sha256": "f6f7d91665a8645a0b5cbd2e311c78aaf39f9f2554ac232af0425bad7a38164b" + }, + { + "file": "right_wrist_pitch_link__visual_0__right_wrist_pitch_link.glb", + "sha256": "48d0a47d41569a24a8ea4b83e7218084395f9ef96c4dcbcdca1a3acbc060ad64" + }, + { + "file": "lh_base_link__visual_0__base_link.glb", + "sha256": "886152daa0f4982f20d346639c4fd29f779b0d8fbf8e8d4942684bbc0cbe9946" + }, + { + "file": "lh_finger11_link__visual_0__finger11_link.glb", + "sha256": "c59c8b126390c3593f63c92c6b3ea0198174342f0da2a7e63f3f6d6c17c76b80" + }, + { + "file": "lh_finger12_link__visual_0__finger12_link.glb", + "sha256": "dea1f32f1f098fb26e6163abeefb98d4d2e6dfb0c187446b5a3b3dc83c40b4a1" + }, + { + "file": "lh_finger13_link__visual_0__finger13_link.glb", + "sha256": "688ab4e9a8191ae6bda909d099ade525be02a7de758144863dc44d731e4180fe" + }, + { + "file": "lh_finger14_link__visual_0__finger14_link.glb", + "sha256": "3ebdfb11c136e4e990fc99d0af6ed9a46713c799332ecd311b402b562697592c" + }, + { + "file": "lh_finger21_link__visual_0__finger21_link.glb", + "sha256": "7ac15bcfa68e38e33a49942f7a2772e63778d82b7181494a0eacfe1a73510721" + }, + { + "file": "lh_finger22_link__visual_0__finger22_link.glb", + "sha256": "358757dbce84eb6cb81a6da3d2f54c467e395306819382c534624e2c67f4ae73" + }, + { + "file": "lh_finger23_link__visual_0__finger23_link.glb", + "sha256": "0ff49e9c01a744186246671737bc2e45c3ec95980538851a0a142030100db16f" + }, + { + "file": "lh_finger31_link__visual_0__finger31_link.glb", + "sha256": "4ed855cb9634a928da50b6aa645a00b244455c4541403a65dc451f78c941fc1d" + }, + { + "file": "lh_finger32_link__visual_0__finger32_link.glb", + "sha256": "9d688372b46fd24ca06fb4767d2b7b462054949467b9f49b37532ade5827b076" + }, + { + "file": "lh_finger33_link__visual_0__finger33_link.glb", + "sha256": "cb0695f569da22e06d69f9110f0779534bdf64e185d6f27b54ff89dde1f31275" + }, + { + "file": "lh_finger41_link__visual_0__finger41_link.glb", + "sha256": "270a0e7aaae7cee7d0853e0300686d202aa6d92167645dbc6318ddc35ce3e61a" + }, + { + "file": "lh_finger42_link__visual_0__finger42_link.glb", + "sha256": "40cf87025b184bcd92ecc00980c83449c1a62c5e7a849311c960c7b51f871e76" + }, + { + "file": "lh_finger43_link__visual_0__finger43_link.glb", + "sha256": "ac791ee4a9b1877892539cb6d4e5f8145d6ad199cefb2e04ebba449c59d2416d" + }, + { + "file": "lh_finger51_link__visual_0__finger51_link.glb", + "sha256": "e43276c24c230bd35459a5b4f442e0be7840c4db106ada75a51ab83ff4a17dcd" + }, + { + "file": "lh_finger52_link__visual_0__finger52_link.glb", + "sha256": "3c156a7b898e695b3e34287ad12e6b5437bcd478823baffe2cd76702c6dd9626" + }, + { + "file": "lh_finger53_link__visual_0__finger53_link.glb", + "sha256": "140fe9939ed6b58539a77ef0c4cf1608dc0cc16b5c8d043564dbab9b1842dd63" + }, + { + "file": "rh_base_link__visual_0__base_link.glb", + "sha256": "ae7328599013944ceb0ac4e4bb0106c0e58526122624a7bb6e650b138b07840d" + }, + { + "file": "rh_finger11_link__visual_0__finger11_link.glb", + "sha256": "289cdf7c384b181df0d64f47db579af622db3bcbdc42236e667dcb64c494377c" + }, + { + "file": "rh_finger12_link__visual_0__finger12_link.glb", + "sha256": "505bc65a50290aefe7b1882b5ffad4e88bf7059ec9dee355014592a2f21fdd2d" + }, + { + "file": "rh_finger13_link__visual_0__finger13_link.glb", + "sha256": "324cf4f7e6207912d5a709ddc85f53b76be930208c27bff8c46f8d8ec5a61922" + }, + { + "file": "rh_finger14_link__visual_0__finger14_link.glb", + "sha256": "f41140c191686f6afd809f51aa3bd1341517337c160ef019980b7c278dce3296" + }, + { + "file": "rh_finger21_link__visual_0__finger21_link.glb", + "sha256": "f6e9a6ce375be6107158d00df23ab416445eb6970abe25e0f80c840da4611684" + }, + { + "file": "rh_finger22_link__visual_0__finger22_link.glb", + "sha256": "9e89e30d9c3d0115bcfc85b05a6b7761991443df5cd74a75b305b5025a855245" + }, + { + "file": "rh_finger23_link__visual_0__finger23_link.glb", + "sha256": "2c7529aa60a4286e2630146371f6dd77228a5ffd1c8760aa0d34169aa1aeae2c" + }, + { + "file": "rh_finger31_link__visual_0__finger31_link.glb", + "sha256": "253bef5027cbce1a055f4650134bafec3f58dbc8f0a7e417ddc338e3de3d514c" + }, + { + "file": "rh_finger32_link__visual_0__finger32_link.glb", + "sha256": "5b3ff8e747900ebfb2fb36ff5ee1035e741e780dd3613169058643436575e4aa" + }, + { + "file": "rh_finger33_link__visual_0__finger33_link.glb", + "sha256": "d440a8b8bcd8b3e3de414598af99ebfefd214d4eb58d7b4d77d1bd67a81f75cf" + }, + { + "file": "rh_finger41_link__visual_0__finger41_link.glb", + "sha256": "0a2d053155922ebcfaccf6f893665beb72f7ee2b3a9a66694b695995f233c7cf" + }, + { + "file": "rh_finger42_link__visual_0__finger42_link.glb", + "sha256": "aa517ec5881c1ca9840c21ae50461eacba59d76cd835fe735eba19030d49cbbc" + }, + { + "file": "rh_finger43_link__visual_0__finger43_link.glb", + "sha256": "f1d4c2936c26267a20da3c1a4016e51316ac100e46e310ffb57af5debd111ef6" + }, + { + "file": "rh_finger51_link__visual_0__finger51_link.glb", + "sha256": "3800f27cbbd3c7bc79ad72def333d841001614d6e9ba16ce3b9502385102771d" + }, + { + "file": "rh_finger52_link__visual_0__finger52_link.glb", + "sha256": "24a3fd05bfe9273f150c93c2ccb79b723c02e70169c0cb2ed7432ced45be50c8" + }, + { + "file": "rh_finger53_link__visual_0__finger53_link.glb", + "sha256": "98cd0bde6c4d27ad04bd3b567ec9e88a9ed849fe786f2bfdb775c33baacc3638" + } + ], + "body_mapping": { + "base_link": { + "path": "visuals/base_link__visual_0__base_link.glb", + "parts": [ + "base_link" + ] + }, + "left_hip_pitch_link": { + "path": "visuals/left_hip_pitch_link__visual_0__left_hip_pitch_link.glb", + "parts": [ + "left_hip_pitch_link" + ] + }, + "left_hip_roll_link": { + "path": "visuals/left_hip_roll_link__visual_0__left_hip_roll_link.glb", + "parts": [ + "left_hip_roll_link" + ] + }, + "left_hip_yaw_link": { + "path": "visuals/left_hip_yaw_link__visual_0__left_hip_yaw_link.glb", + "parts": [ + "left_hip_yaw_link" + ] + }, + "left_knee_link": { + "path": "visuals/left_knee_link__visual_0__left_knee_link.glb", + "parts": [ + "left_knee_link" + ] + }, + "left_ankle_pitch_link": { + "path": "visuals/left_ankle_pitch_link__visual_0__left_ankle_pitch_link.glb", + "parts": [ + "left_ankle_pitch_link" + ] + }, + "left_ankle_roll_link": { + "path": "visuals/left_ankle_roll_link__visual_0__left_ankle_roll_link.glb", + "parts": [ + "left_ankle_roll_link" + ] + }, + "right_hip_pitch_link": { + "path": "visuals/right_hip_pitch_link__visual_0__right_hip_pitch_link.glb", + "parts": [ + "right_hip_pitch_link" + ] + }, + "right_hip_roll_link": { + "path": "visuals/right_hip_roll_link__visual_0__right_hip_roll_link.glb", + "parts": [ + "right_hip_roll_link" + ] + }, + "right_hip_yaw_link": { + "path": "visuals/right_hip_yaw_link__visual_0__right_hip_yaw_link.glb", + "parts": [ + "right_hip_yaw_link" + ] + }, + "right_knee_link": { + "path": "visuals/right_knee_link__visual_0__right_knee_link.glb", + "parts": [ + "right_knee_link" + ] + }, + "right_ankle_pitch_link": { + "path": "visuals/right_ankle_pitch_link__visual_0__right_ankle_pitch_link.glb", + "parts": [ + "right_ankle_pitch_link" + ] + }, + "right_ankle_roll_link": { + "path": "visuals/right_ankle_roll_link__visual_0__right_ankle_roll_link.glb", + "parts": [ + "right_ankle_roll_link" + ] + }, + "waist_roll_link": { + "path": "visuals/waist_roll_link__visual_0__waist_roll_link.glb", + "parts": [ + "waist_roll_link" + ] + }, + "waist_yaw_link": { + "path": "visuals/waist_yaw_link__visual_0__waist_yaw_link.glb", + "parts": [ + "waist_yaw_link" + ] + }, + "left_shoulder_pitch_link": { + "path": "visuals/left_shoulder_pitch_link__visual_0__left_shoulder_pitch_link.glb", + "parts": [ + "left_shoulder_pitch_link" + ] + }, + "left_shoulder_roll_link": { + "path": "visuals/left_shoulder_roll_link__visual_0__left_shoulder_roll_link.glb", + "parts": [ + "left_shoulder_roll_link" + ] + }, + "left_shoulder_yaw_link": { + "path": "visuals/left_shoulder_yaw_link__visual_0__left_shoulder_yaw_link.glb", + "parts": [ + "left_shoulder_yaw_link" + ] + }, + "left_elbow_link": { + "path": "visuals/left_elbow_link__visual_0__left_elbow_link.glb", + "parts": [ + "left_elbow_link" + ] + }, + "left_wrist_link": { + "path": "visuals/left_wrist_link__fixed_hand.glb", + "parts": [ + "left_wrist_roll_link", + "left_wrist_yaw_link", + "left_wrist_pitch_link", + "lh_base_link", + "lh_finger11_link", + "lh_finger12_link", + "lh_finger13_link", + "lh_finger14_link", + "lh_finger21_link", + "lh_finger22_link", + "lh_finger23_link", + "lh_finger31_link", + "lh_finger32_link", + "lh_finger33_link", + "lh_finger41_link", + "lh_finger42_link", + "lh_finger43_link", + "lh_finger51_link", + "lh_finger52_link", + "lh_finger53_link" + ] + }, + "right_shoulder_pitch_link": { + "path": "visuals/right_shoulder_pitch_link__visual_0__right_shoulder_pitch_link.glb", + "parts": [ + "right_shoulder_pitch_link" + ] + }, + "right_shoulder_roll_link": { + "path": "visuals/right_shoulder_roll_link__visual_0__right_shoulder_roll_link.glb", + "parts": [ + "right_shoulder_roll_link" + ] + }, + "right_shoulder_yaw_link": { + "path": "visuals/right_shoulder_yaw_link__visual_0__right_shoulder_yaw_link.glb", + "parts": [ + "right_shoulder_yaw_link" + ] + }, + "right_elbow_link": { + "path": "visuals/right_elbow_link__visual_0__right_elbow_link.glb", + "parts": [ + "right_elbow_link" + ] + }, + "right_wrist_link": { + "path": "visuals/right_wrist_link__fixed_hand.glb", + "parts": [ + "right_wrist_roll_link", + "right_wrist_yaw_link", + "right_wrist_pitch_link", + "rh_base_link", + "rh_finger11_link", + "rh_finger12_link", + "rh_finger13_link", + "rh_finger14_link", + "rh_finger21_link", + "rh_finger22_link", + "rh_finger23_link", + "rh_finger31_link", + "rh_finger32_link", + "rh_finger33_link", + "rh_finger41_link", + "rh_finger42_link", + "rh_finger43_link", + "rh_finger51_link", + "rh_finger52_link", + "rh_finger53_link" + ] + } + }, + "files": [ + { + "file": "visuals/rp1_hand_fixed.urdf", + "sha256": "2c1f91a82f39298fdda7ec9531d045caff745ba12157f0bb0fcb2f4cf1102948" + }, + { + "file": "visuals/base_link__visual_0__base_link.glb", + "sha256": "3db82d0e5fa1fa48fa6f4fe4460bba14568a39b5933acff8b4b1879f582e06b0" + }, + { + "file": "visuals/left_hip_pitch_link__visual_0__left_hip_pitch_link.glb", + "sha256": "d8cb2aff7273185a89eba99aab47ce6bf4716f25e70f34afa1529acb802c6193" + }, + { + "file": "visuals/left_hip_roll_link__visual_0__left_hip_roll_link.glb", + "sha256": "35361b79fb69096039eb077018c25ae489f16cc5229dcd82256b3a573b168208" + }, + { + "file": "visuals/left_hip_yaw_link__visual_0__left_hip_yaw_link.glb", + "sha256": "19fe908274f9fe49b5a8317652e4fe02a6ff93802de87ad7d0383fa1d142b03b" + }, + { + "file": "visuals/left_knee_link__visual_0__left_knee_link.glb", + "sha256": "1c01f5c03837d24287d79eff48a9e4bd4203d8516d0375592b159d49fb83f6c9" + }, + { + "file": "visuals/left_ankle_pitch_link__visual_0__left_ankle_pitch_link.glb", + "sha256": "4bab717bf7073e28754d1c42f4409141ea775987284ff8575f9c7aef25561e8c" + }, + { + "file": "visuals/left_ankle_roll_link__visual_0__left_ankle_roll_link.glb", + "sha256": "76144b6ebf17b2eb5875168cbe6a3c4c12eaeebdd4bd277864887b3894f781b1" + }, + { + "file": "visuals/right_hip_pitch_link__visual_0__right_hip_pitch_link.glb", + "sha256": "e299f46bff44d6bbf03592cd6caba3b418fc022260746554e6d2013f31793df4" + }, + { + "file": "visuals/right_hip_roll_link__visual_0__right_hip_roll_link.glb", + "sha256": "7cb006f9ba7f950c98287b59695938cfd6460d8fa4546ae6c95bc65ed5c6c6b8" + }, + { + "file": "visuals/right_hip_yaw_link__visual_0__right_hip_yaw_link.glb", + "sha256": "35393465aa8103ab436ecc3a635cdce7477600cf65eb03a2942af546cc39c79c" + }, + { + "file": "visuals/right_knee_link__visual_0__right_knee_link.glb", + "sha256": "2a5f1f91f6db0cfac3a0e88038613be89cb94066d7f103876b455823edbfb8f3" + }, + { + "file": "visuals/right_ankle_pitch_link__visual_0__right_ankle_pitch_link.glb", + "sha256": "c43112750efd953f29dfea5d8d2bb925eb847f74b679fa1d22f734b1e3094b91" + }, + { + "file": "visuals/right_ankle_roll_link__visual_0__right_ankle_roll_link.glb", + "sha256": "3856c0074bbead9ade091b2bef4df165d9c1d4b03e0c0f1d8c284cddf091a9f6" + }, + { + "file": "visuals/waist_roll_link__visual_0__waist_roll_link.glb", + "sha256": "a4cd49014951ed5c7836bde4a7138eab4119f0ca7249a69e26add388d5fedf32" + }, + { + "file": "visuals/waist_yaw_link__visual_0__waist_yaw_link.glb", + "sha256": "cb50b0354f8a0a6d06ff486d46cb849462b84471c20a350b1e4c5a86577ce230" + }, + { + "file": "visuals/left_shoulder_pitch_link__visual_0__left_shoulder_pitch_link.glb", + "sha256": "9eb76bc0675578e28707120d64cb042b948312ddc9233e4c28de02ee04a3dbf9" + }, + { + "file": "visuals/left_shoulder_roll_link__visual_0__left_shoulder_roll_link.glb", + "sha256": "f72e3ac73f3804acd5e5384c2d10d48aacacb95bf9f98ea0f2426f1b92add0de" + }, + { + "file": "visuals/left_shoulder_yaw_link__visual_0__left_shoulder_yaw_link.glb", + "sha256": "909f0dbd40db57b223143c1c89c740c3ea636e5d9b066eb6fe26dab37e2f4975" + }, + { + "file": "visuals/left_elbow_link__visual_0__left_elbow_link.glb", + "sha256": "f98a4446175c7b1d98c5a664fabcb6698635c99ccfc8261dedbef9155e1a2043" + }, + { + "file": "visuals/left_wrist_link__fixed_hand.glb", + "sha256": "7b7bee1c2aa6ba74bc2824bf3ec5c465c33a97e1e0409ccdc551fae74a6218e5" + }, + { + "file": "visuals/right_shoulder_pitch_link__visual_0__right_shoulder_pitch_link.glb", + "sha256": "21d9410ca84dcd3bfea3bd8c08a682d4ff640c79f68e5d9f93ea26bcf904c3ac" + }, + { + "file": "visuals/right_shoulder_roll_link__visual_0__right_shoulder_roll_link.glb", + "sha256": "89b5da7da64e2d3207291c7847d347d30fe0b40014ea6d6c4fc9e4bf4e03682c" + }, + { + "file": "visuals/right_shoulder_yaw_link__visual_0__right_shoulder_yaw_link.glb", + "sha256": "2f0c17876e2607e8ab4282fadefba6fee6c2a5446b416cce6d0b91f796da2893" + }, + { + "file": "visuals/right_elbow_link__visual_0__right_elbow_link.glb", + "sha256": "ef1e9dc1afcf147e78902039f49ef0131f114a11afe873b5095a6c4f509b89b2" + }, + { + "file": "visuals/right_wrist_link__fixed_hand.glb", + "sha256": "57a47c99b86d4efea1cd891147a0aafc86395daa31332a88b6653e44be1449c1" + } + ] +} diff --git a/app/public/robots/rp1/visuals/base_link__visual_0__base_link.glb b/app/public/robots/rp1/visuals/base_link__visual_0__base_link.glb new file mode 100644 index 0000000..b68972e --- /dev/null +++ b/app/public/robots/rp1/visuals/base_link__visual_0__base_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3db82d0e5fa1fa48fa6f4fe4460bba14568a39b5933acff8b4b1879f582e06b0 +size 5014396 diff --git a/app/public/robots/rp1/visuals/left_ankle_pitch_link__visual_0__left_ankle_pitch_link.glb b/app/public/robots/rp1/visuals/left_ankle_pitch_link__visual_0__left_ankle_pitch_link.glb new file mode 100644 index 0000000..7b5cb36 --- /dev/null +++ b/app/public/robots/rp1/visuals/left_ankle_pitch_link__visual_0__left_ankle_pitch_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4bab717bf7073e28754d1c42f4409141ea775987284ff8575f9c7aef25561e8c +size 647008 diff --git a/app/public/robots/rp1/visuals/left_ankle_roll_link__visual_0__left_ankle_roll_link.glb b/app/public/robots/rp1/visuals/left_ankle_roll_link__visual_0__left_ankle_roll_link.glb new file mode 100644 index 0000000..b1f418d --- /dev/null +++ b/app/public/robots/rp1/visuals/left_ankle_roll_link__visual_0__left_ankle_roll_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:76144b6ebf17b2eb5875168cbe6a3c4c12eaeebdd4bd277864887b3894f781b1 +size 1102300 diff --git a/app/public/robots/rp1/visuals/left_elbow_link__visual_0__left_elbow_link.glb b/app/public/robots/rp1/visuals/left_elbow_link__visual_0__left_elbow_link.glb new file mode 100644 index 0000000..a755614 --- /dev/null +++ b/app/public/robots/rp1/visuals/left_elbow_link__visual_0__left_elbow_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f98a4446175c7b1d98c5a664fabcb6698635c99ccfc8261dedbef9155e1a2043 +size 2298284 diff --git a/app/public/robots/rp1/visuals/left_hip_pitch_link__visual_0__left_hip_pitch_link.glb b/app/public/robots/rp1/visuals/left_hip_pitch_link__visual_0__left_hip_pitch_link.glb new file mode 100644 index 0000000..4b84c35 --- /dev/null +++ b/app/public/robots/rp1/visuals/left_hip_pitch_link__visual_0__left_hip_pitch_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d8cb2aff7273185a89eba99aab47ce6bf4716f25e70f34afa1529acb802c6193 +size 1264348 diff --git a/app/public/robots/rp1/visuals/left_hip_roll_link__visual_0__left_hip_roll_link.glb b/app/public/robots/rp1/visuals/left_hip_roll_link__visual_0__left_hip_roll_link.glb new file mode 100644 index 0000000..a47bb30 --- /dev/null +++ b/app/public/robots/rp1/visuals/left_hip_roll_link__visual_0__left_hip_roll_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:35361b79fb69096039eb077018c25ae489f16cc5229dcd82256b3a573b168208 +size 2565752 diff --git a/app/public/robots/rp1/visuals/left_hip_yaw_link__visual_0__left_hip_yaw_link.glb b/app/public/robots/rp1/visuals/left_hip_yaw_link__visual_0__left_hip_yaw_link.glb new file mode 100644 index 0000000..b80e795 --- /dev/null +++ b/app/public/robots/rp1/visuals/left_hip_yaw_link__visual_0__left_hip_yaw_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:19fe908274f9fe49b5a8317652e4fe02a6ff93802de87ad7d0383fa1d142b03b +size 2093580 diff --git a/app/public/robots/rp1/visuals/left_knee_link__visual_0__left_knee_link.glb b/app/public/robots/rp1/visuals/left_knee_link__visual_0__left_knee_link.glb new file mode 100644 index 0000000..1a51e8a --- /dev/null +++ b/app/public/robots/rp1/visuals/left_knee_link__visual_0__left_knee_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1c01f5c03837d24287d79eff48a9e4bd4203d8516d0375592b159d49fb83f6c9 +size 5445868 diff --git a/app/public/robots/rp1/visuals/left_shoulder_pitch_link__visual_0__left_shoulder_pitch_link.glb b/app/public/robots/rp1/visuals/left_shoulder_pitch_link__visual_0__left_shoulder_pitch_link.glb new file mode 100644 index 0000000..d6a4361 --- /dev/null +++ b/app/public/robots/rp1/visuals/left_shoulder_pitch_link__visual_0__left_shoulder_pitch_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9eb76bc0675578e28707120d64cb042b948312ddc9233e4c28de02ee04a3dbf9 +size 1427744 diff --git a/app/public/robots/rp1/visuals/left_shoulder_roll_link__visual_0__left_shoulder_roll_link.glb b/app/public/robots/rp1/visuals/left_shoulder_roll_link__visual_0__left_shoulder_roll_link.glb new file mode 100644 index 0000000..2bd11af --- /dev/null +++ b/app/public/robots/rp1/visuals/left_shoulder_roll_link__visual_0__left_shoulder_roll_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f72e3ac73f3804acd5e5384c2d10d48aacacb95bf9f98ea0f2426f1b92add0de +size 1663960 diff --git a/app/public/robots/rp1/visuals/left_shoulder_yaw_link__visual_0__left_shoulder_yaw_link.glb b/app/public/robots/rp1/visuals/left_shoulder_yaw_link__visual_0__left_shoulder_yaw_link.glb new file mode 100644 index 0000000..d2e7c6a --- /dev/null +++ b/app/public/robots/rp1/visuals/left_shoulder_yaw_link__visual_0__left_shoulder_yaw_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:909f0dbd40db57b223143c1c89c740c3ea636e5d9b066eb6fe26dab37e2f4975 +size 1404696 diff --git a/app/public/robots/rp1/visuals/left_wrist_link__fixed_hand.glb b/app/public/robots/rp1/visuals/left_wrist_link__fixed_hand.glb new file mode 100644 index 0000000..b3dc240 --- /dev/null +++ b/app/public/robots/rp1/visuals/left_wrist_link__fixed_hand.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7b7bee1c2aa6ba74bc2824bf3ec5c465c33a97e1e0409ccdc551fae74a6218e5 +size 22009544 diff --git a/app/public/robots/rp1/visuals/right_ankle_pitch_link__visual_0__right_ankle_pitch_link.glb b/app/public/robots/rp1/visuals/right_ankle_pitch_link__visual_0__right_ankle_pitch_link.glb new file mode 100644 index 0000000..853066a --- /dev/null +++ b/app/public/robots/rp1/visuals/right_ankle_pitch_link__visual_0__right_ankle_pitch_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c43112750efd953f29dfea5d8d2bb925eb847f74b679fa1d22f734b1e3094b91 +size 645324 diff --git a/app/public/robots/rp1/visuals/right_ankle_roll_link__visual_0__right_ankle_roll_link.glb b/app/public/robots/rp1/visuals/right_ankle_roll_link__visual_0__right_ankle_roll_link.glb new file mode 100644 index 0000000..aa27bcb --- /dev/null +++ b/app/public/robots/rp1/visuals/right_ankle_roll_link__visual_0__right_ankle_roll_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3856c0074bbead9ade091b2bef4df165d9c1d4b03e0c0f1d8c284cddf091a9f6 +size 1109796 diff --git a/app/public/robots/rp1/visuals/right_elbow_link__visual_0__right_elbow_link.glb b/app/public/robots/rp1/visuals/right_elbow_link__visual_0__right_elbow_link.glb new file mode 100644 index 0000000..c3a2b63 --- /dev/null +++ b/app/public/robots/rp1/visuals/right_elbow_link__visual_0__right_elbow_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ef1e9dc1afcf147e78902039f49ef0131f114a11afe873b5095a6c4f509b89b2 +size 2305696 diff --git a/app/public/robots/rp1/visuals/right_hip_pitch_link__visual_0__right_hip_pitch_link.glb b/app/public/robots/rp1/visuals/right_hip_pitch_link__visual_0__right_hip_pitch_link.glb new file mode 100644 index 0000000..1be39d7 --- /dev/null +++ b/app/public/robots/rp1/visuals/right_hip_pitch_link__visual_0__right_hip_pitch_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e299f46bff44d6bbf03592cd6caba3b418fc022260746554e6d2013f31793df4 +size 1256592 diff --git a/app/public/robots/rp1/visuals/right_hip_roll_link__visual_0__right_hip_roll_link.glb b/app/public/robots/rp1/visuals/right_hip_roll_link__visual_0__right_hip_roll_link.glb new file mode 100644 index 0000000..3abf730 --- /dev/null +++ b/app/public/robots/rp1/visuals/right_hip_roll_link__visual_0__right_hip_roll_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cb006f9ba7f950c98287b59695938cfd6460d8fa4546ae6c95bc65ed5c6c6b8 +size 2544120 diff --git a/app/public/robots/rp1/visuals/right_hip_yaw_link__visual_0__right_hip_yaw_link.glb b/app/public/robots/rp1/visuals/right_hip_yaw_link__visual_0__right_hip_yaw_link.glb new file mode 100644 index 0000000..317e82b --- /dev/null +++ b/app/public/robots/rp1/visuals/right_hip_yaw_link__visual_0__right_hip_yaw_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:35393465aa8103ab436ecc3a635cdce7477600cf65eb03a2942af546cc39c79c +size 2251368 diff --git a/app/public/robots/rp1/visuals/right_knee_link__visual_0__right_knee_link.glb b/app/public/robots/rp1/visuals/right_knee_link__visual_0__right_knee_link.glb new file mode 100644 index 0000000..a8b94dd --- /dev/null +++ b/app/public/robots/rp1/visuals/right_knee_link__visual_0__right_knee_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2a5f1f91f6db0cfac3a0e88038613be89cb94066d7f103876b455823edbfb8f3 +size 5426536 diff --git a/app/public/robots/rp1/visuals/right_shoulder_pitch_link__visual_0__right_shoulder_pitch_link.glb b/app/public/robots/rp1/visuals/right_shoulder_pitch_link__visual_0__right_shoulder_pitch_link.glb new file mode 100644 index 0000000..81c95d6 --- /dev/null +++ b/app/public/robots/rp1/visuals/right_shoulder_pitch_link__visual_0__right_shoulder_pitch_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:21d9410ca84dcd3bfea3bd8c08a682d4ff640c79f68e5d9f93ea26bcf904c3ac +size 1292728 diff --git a/app/public/robots/rp1/visuals/right_shoulder_roll_link__visual_0__right_shoulder_roll_link.glb b/app/public/robots/rp1/visuals/right_shoulder_roll_link__visual_0__right_shoulder_roll_link.glb new file mode 100644 index 0000000..32fe4d7 --- /dev/null +++ b/app/public/robots/rp1/visuals/right_shoulder_roll_link__visual_0__right_shoulder_roll_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:89b5da7da64e2d3207291c7847d347d30fe0b40014ea6d6c4fc9e4bf4e03682c +size 1811900 diff --git a/app/public/robots/rp1/visuals/right_shoulder_yaw_link__visual_0__right_shoulder_yaw_link.glb b/app/public/robots/rp1/visuals/right_shoulder_yaw_link__visual_0__right_shoulder_yaw_link.glb new file mode 100644 index 0000000..97f7163 --- /dev/null +++ b/app/public/robots/rp1/visuals/right_shoulder_yaw_link__visual_0__right_shoulder_yaw_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2f0c17876e2607e8ab4282fadefba6fee6c2a5446b416cce6d0b91f796da2893 +size 1401220 diff --git a/app/public/robots/rp1/visuals/right_wrist_link__fixed_hand.glb b/app/public/robots/rp1/visuals/right_wrist_link__fixed_hand.glb new file mode 100644 index 0000000..f6db468 --- /dev/null +++ b/app/public/robots/rp1/visuals/right_wrist_link__fixed_hand.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:57a47c99b86d4efea1cd891147a0aafc86395daa31332a88b6653e44be1449c1 +size 22124168 diff --git a/app/public/robots/rp1/visuals/rp1_hand_fixed.urdf b/app/public/robots/rp1/visuals/rp1_hand_fixed.urdf new file mode 100644 index 0000000..d7a1203 --- /dev/null +++ b/app/public/robots/rp1/visuals/rp1_hand_fixed.urdf @@ -0,0 +1,1987 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/public/robots/rp1/visuals/waist_roll_link__visual_0__waist_roll_link.glb b/app/public/robots/rp1/visuals/waist_roll_link__visual_0__waist_roll_link.glb new file mode 100644 index 0000000..6f48ca3 --- /dev/null +++ b/app/public/robots/rp1/visuals/waist_roll_link__visual_0__waist_roll_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a4cd49014951ed5c7836bde4a7138eab4119f0ca7249a69e26add388d5fedf32 +size 1122888 diff --git a/app/public/robots/rp1/visuals/waist_yaw_link__visual_0__waist_yaw_link.glb b/app/public/robots/rp1/visuals/waist_yaw_link__visual_0__waist_yaw_link.glb new file mode 100644 index 0000000..ddbc1d4 --- /dev/null +++ b/app/public/robots/rp1/visuals/waist_yaw_link__visual_0__waist_yaw_link.glb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cb50b0354f8a0a6d06ff486d46cb849462b84471c20a350b1e4c5a86577ce230 +size 3147656 diff --git a/app/scripts/import-rp1-visuals.py b/app/scripts/import-rp1-visuals.py new file mode 100644 index 0000000..45f66e6 --- /dev/null +++ b/app/scripts/import-rp1-visuals.py @@ -0,0 +1,208 @@ +#!/usr/bin/env python3 +"""Import the user's 63 textured parts onto the existing 25-body/24-DOF RP1. + +Usage: python3 app/scripts/import-rp1-visuals.py ARCHIVE HAND_FIXED_URDF +No MJCF, STL, policy, motion or physical joint is changed. The source's fixed +finger poses and neutral wrist yaw/pitch are composed into two visual-only +wrist GLBs. Source images/materials/binary vertex data are retained verbatim. +""" +import copy +import hashlib +import json +import math +from pathlib import Path +import struct +import sys +import xml.etree.ElementTree as ET +import zipfile + + +def sha(data): + return hashlib.sha256(data).hexdigest() + + +def read_glb(data): + if len(data) < 20: + raise ValueError("Truncated GLB") + magic, version, length, size, kind = struct.unpack_from("<5I", data) + if (magic, version, length, kind) != (0x46546C67, 2, len(data), 0x4E4F534A): + raise ValueError("Invalid GLB (possibly an LFS pointer)") + doc = json.loads(data[20:20 + size]) + offset = 20 + size + binary_size, binary_kind = struct.unpack_from("<2I", data, offset) + if binary_kind != 0x004E4942 or offset + 8 + binary_size != len(data): + raise ValueError("Expected one embedded BIN chunk") + for asset in [*doc.get("buffers", []), *doc.get("images", [])]: + if "uri" in asset: + raise ValueError("GLBs must embed all images and buffers") + if len(doc["buffers"]) != 1 or any(k in doc for k in ["skins", "animations", "extensionsRequired"]): + raise ValueError("Expected static, self-contained body GLB") + return doc, data[offset + 8:offset + 8 + binary_size] + + +def identity(): + return [[float(i == j) for j in range(4)] for i in range(4)] + + +def multiply(a, b): + return [[sum(a[i][k] * b[k][j] for k in range(4)) for j in range(4)] for i in range(4)] + + +def origin_matrix(origin): + result = identity() + if origin is None: + return result + xyz = list(map(float, origin.get("xyz", "0 0 0").split())) + roll, pitch, yaw = map(float, origin.get("rpy", "0 0 0").split()) + cr, sr, cp, sp, cy, sy = math.cos(roll), math.sin(roll), math.cos(pitch), math.sin(pitch), math.cos(yaw), math.sin(yaw) + # URDF fixed-axis XYZ = Rz(yaw) Ry(pitch) Rx(roll). + rotation = [[cy * cp, cy * sp * sr - sy * cr, cy * sp * cr + sy * sr], + [sy * cp, sy * sp * sr + cy * cr, sy * sp * cr - cy * sr], + [-sp, cp * sr, cp * cr]] + for i in range(3): + result[i][:3] = rotation[i] + result[i][3] = xyz[i] + return result + + +def assemble(parts): + keys = ["nodes", "materials", "meshes", "textures", "images", "accessors", "bufferViews", "samplers"] + out = {"asset": {"version": "2.0", "generator": "microduck RP1 visual-only fixed-hand assembler"}, + "scene": 0, "scenes": [{"name": "Fixed wrist and hand", "nodes": []}], + **{key: [] for key in keys}} + binary = bytearray() + # Blender's source GLBs are Y-up; the URDF matrices are Z-up. + c = [[1, 0, 0, 0], [0, 0, 1, 0], [0, -1, 0, 0], [0, 0, 0, 1]] + cinv = [[1, 0, 0, 0], [0, 0, -1, 0], [0, 1, 0, 0], [0, 0, 0, 1]] + for name, data, transform in parts: + doc, payload = read_glb(data) + if doc.get("extensionsUsed"): + raise ValueError("Unexpected extension in wrist part; review remapping") + offsets = {key: len(out[key]) for key in keys} + start = len(binary) + binary.extend(payload) + binary.extend(b"\0" * (-len(binary) % 4)) + for key in keys: + for original in doc[key]: + item = copy.deepcopy(original) + if key == "bufferViews": + item["buffer"] = 0 + item["byteOffset"] = item.get("byteOffset", 0) + start + elif key == "accessors": + if "sparse" in item: + raise ValueError("Sparse accessor requires explicit remapping") + if "bufferView" in item: + item["bufferView"] += offsets["bufferViews"] + elif key == "images": + item["bufferView"] += offsets["bufferViews"] + elif key == "textures": + item["source"] += offsets["images"] + if "sampler" in item: + item["sampler"] += offsets["samplers"] + elif key == "materials": + def textures(value): + if isinstance(value, dict): + for field, child in value.items(): + if field.endswith("Texture") and isinstance(child, dict) and "index" in child: + child["index"] += offsets["textures"] + else: + textures(child) + elif isinstance(value, list): + for child in value: + textures(child) + textures(item) + elif key == "meshes": + for primitive in item["primitives"]: + primitive["attributes"] = {k: v + offsets["accessors"] for k, v in primitive["attributes"].items()} + for field, table in [("indices", "accessors"), ("material", "materials")]: + if field in primitive: + primitive[field] += offsets[table] + elif key == "nodes": + if "mesh" in item: + item["mesh"] += offsets["meshes"] + if "children" in item: + item["children"] = [v + offsets["nodes"] for v in item["children"]] + out[key].append(item) + matrix = multiply(multiply(c, transform), cinv) + out["scenes"][0]["nodes"].append(len(out["nodes"])) + out["nodes"].append({"name": f"source-part:{name}", "extras": {"sourcePart": name}, "matrix": [matrix[i][j] for j in range(4) for i in range(4)], + "children": [v + offsets["nodes"] for v in doc["scenes"][doc.get("scene", 0)]["nodes"]]}) + out["buffers"] = [{"byteLength": len(binary)}] + encoded = json.dumps(out, separators=(",", ":")).encode() + encoded += b" " * (-len(encoded) % 4) + total = 12 + 8 + len(encoded) + 8 + len(binary) + return struct.pack("<5I", 0x46546C67, 2, total, len(encoded), 0x4E4F534A) + encoded + struct.pack("<2I", len(binary), 0x004E4942) + binary + + +def import_visuals(archive, urdf): + target = Path(__file__).resolve().parents[1] / "public/robots/rp1" + source_root = ET.fromstring(urdf.read_bytes()) + links = {link.get("name"): link for link in source_root.findall("link")} + expected = {} + for name, link in links.items(): + mesh = Path(link.find("visual/geometry/mesh").get("filename")).stem + expected[name] = f"{name}__visual_0__{mesh}.glb" + with zipfile.ZipFile(archive) as source: + if sorted(source.namelist()) != sorted(expected.values()) or len(expected) != 63: + raise ValueError("Archive must contain exactly the 63 hand-model body GLBs") + inputs = {name: source.read(file) for name, file in expected.items()} + for data in inputs.values(): + read_glb(data) + model = ET.parse(target / "model.xml").getroot() + physical = [body.get("name") for body in model.findall(".//worldbody//body")] + parents = {j.find("child").get("link"): j for j in source_root.findall("joint")} + output, mappings = {}, {} + for body in physical: + if not body.endswith("_wrist_link"): + name = expected[body] + output[name] = inputs[body] + mappings[body] = {"path": f"visuals/{name}", "parts": [body]} + continue + side = body.split("_")[0] + anchor = f"{side}_wrist_roll_link" + prefix = "lh_" if side == "left" else "rh_" + names = [name for name in links if name.startswith(f"{side}_wrist_") or name.startswith(prefix)] + parts = [] + for name in names: + relative = identity() + node = name + while node != anchor: + joint = parents[node] + # The extra two wrist axes are visual-only at neutral; hand + # joints come from the upstream fixed-hand URDF. + if joint.get("type") != "fixed" and "wrist" not in joint.get("name", ""): + raise ValueError("Unexpected moving hand joint") + relative = multiply(origin_matrix(joint.find("origin")), relative) + node = joint.find("parent").get("link") + parts.append((name, inputs[name], relative)) + file = f"{body}__fixed_hand.glb" + output[file] = assemble(parts) + mappings[body] = {"path": f"visuals/{file}", "parts": names} + used = [name for mapping in mappings.values() for name in mapping["parts"]] + if sorted(used) != sorted(links) or len(physical) != 25: + raise ValueError("Every source part must map exactly once to 25 physical bodies") + for data in output.values(): + read_glb(data) + # Commit only after all inputs and assembled outputs validate. No ZIP extraction. + (target / "visuals").mkdir(exist_ok=True) + (target / "visuals/rp1_hand_fixed.urdf").write_bytes(urdf.read_bytes()) + records = [{"file": "visuals/rp1_hand_fixed.urdf", "sha256": sha(urdf.read_bytes())}] + for name, data in output.items(): + (target / "visuals" / name).write_bytes(data) + records.append({"file": f"visuals/{name}", "sha256": sha(data)}) + config = json.loads((target / "robot.json").read_text()) + config["render"]["body_visuals"] = [{"body": body, "path": mappings[body]["path"], + "quaternion": [math.sqrt(0.5), 0, 0, math.sqrt(0.5)]} for body in physical] + (target / "robot.json").write_text(json.dumps(config, indent=2) + "\n") + manifest = {"source": f"User-provided {archive.name}", "archive_sha256": sha(archive.read_bytes()), + "license": "Not supplied in the archive; local evaluation only. Confirm redistribution rights.", + "coordinate_conversion": "Source GLBs are Blender Y-up; attachments rotate +90 degrees about X into MuJoCo body Z-up.", + "assembly": "25 physical body attachments; 20 source parts per wrist (neutral extra wrist axes and fixed fingers). No physical joints added.", + "input_files": [{"file": expected[name], "sha256": sha(data)} for name, data in inputs.items()], + "body_mapping": mappings, "files": records} + (target / "visual-source-manifest.json").write_text(json.dumps(manifest, indent=2) + "\n") + print(f"Imported {len(inputs)} source GLBs into {len(physical)} body attachments; physics/policies untouched") + + +if __name__ == "__main__": + import_visuals(Path(sys.argv[1]), Path(sys.argv[2])) diff --git a/app/src/game/interactive-props.js b/app/src/game/interactive-props.js new file mode 100644 index 0000000..559c410 --- /dev/null +++ b/app/src/game/interactive-props.js @@ -0,0 +1,151 @@ +import * as THREE from "three"; + +const TYPES = ["box", "sphere", "cylinder", "capsule"]; +const COLORS = [ + 0xffb52e, 0x81cbb7, 0xb4a4d4, 0x83bfff, 0xf2efe8, 0xff7a2f, 0xf09caf, +]; + +// One layout per runtime, shared by both locomotion models. A shuffled, +// jittered lattice gives random placement without overlaps or retry loops. +export function generateInteractiveProps({ + halfExtent, + spawn, + avoid = [], + random = Math.random, +}) { + const count = 5 + Math.floor(random() * 3); + const candidates = []; + const limit = halfExtent - 0.2; + for ( + let x = Math.max(-limit, spawn[0] - 0.4); + x <= Math.min(limit, spawn[0] + 1.8); + x += 0.4 + ) { + for (let y = -Math.min(limit, 1.2); y <= Math.min(limit, 1.2); y += 0.4) { + const px = x + (random() - 0.5) * 0.06; + const py = y + (random() - 0.5) * 0.06; + if ( + [spawn, ...avoid].every(([x, y]) => Math.hypot(px - x, py - y) > 0.34) + ) + candidates.push([px, py]); + } + } + for (let i = candidates.length - 1; i > 0; i--) { + const j = Math.floor(random() * (i + 1)); + [candidates[i], candidates[j]] = [candidates[j], candidates[i]]; + } + // Keep at least one toy within immediate walking / kicking reach. + const near = candidates.findIndex( + ([x, y]) => + x > spawn[0] + 0.3 && + x < spawn[0] + 0.85 && + Math.abs(y - spawn[1]) < 0.42, + ); + if (near > 0) + [candidates[0], candidates[near]] = [candidates[near], candidates[0]]; + if (candidates.length < count) + throw new Error("Arena too small for interactive props"); + const offset = Math.floor(random() * TYPES.length); + return candidates.slice(0, count).map(([x, y], i) => { + const type = TYPES[(i + offset) % TYPES.length]; + const r = 0.045 + random() * 0.015; + const h = 0.045 + random() * 0.02; + const size = + type === "box" ? [r, r * 0.85, h] : type === "sphere" ? [r] : [r, h]; + const bottom = type === "sphere" ? r : type === "capsule" ? r + h : h; + const yaw = random() * Math.PI * 2; + return { + name: `interactive_${i}`, + type, + size, + pos: [x, y, bottom + 0.006], + quat: [Math.cos(yaw / 2), 0, 0, Math.sin(yaw / 2)], + mass: 0.04 + random() * 0.04, + color: COLORS[i % COLORS.length], + }; + }); +} + +export function resolvePropAddresses(mujoco, model, specs) { + return specs.map((spec) => { + const jointId = mujoco.mj_name2id( + model, + mujoco.mjtObj.mjOBJ_JOINT.value, + `${spec.name}_joint`, + ); + const bodyId = mujoco.mj_name2id( + model, + mujoco.mjtObj.mjOBJ_BODY.value, + spec.name, + ); + return { + bodyId, + qAdr: model.jnt_qposadr[jointId], + dofAdr: model.jnt_dofadr[jointId], + mass: model.body_mass[bodyId], + }; + }); +} + +export function resetProp(data, address, spec, parked = false, index = 0) { + const q = data.qpos, + v = data.qvel; + q.set(parked ? [50 + index, 0, spec.pos[2]] : spec.pos, address.qAdr); + q.set(spec.quat, address.qAdr + 3); + v.fill(0, address.dofAdr, address.dofAdr + 6); +} + +export function createInteractivePropVisuals(specs) { + const root = new THREE.Group(); + root.name = "interactive-props"; + root.rotation.x = -Math.PI / 2; // MJCF Z-up -> Three Y-up + const meshes = specs.map((spec, index) => { + const [r, h, z] = spec.size; + let geometry; + if (spec.type === "box") + geometry = new THREE.BoxGeometry(2 * r, 2 * h, 2 * z); + else if (spec.type === "sphere") + geometry = new THREE.SphereGeometry(r, 24, 16); + else { + geometry = + spec.type === "cylinder" + ? new THREE.CylinderGeometry(r, r, 2 * h, 24) + : new THREE.CapsuleGeometry(r, 2 * h, 8, 16); + geometry.rotateX(Math.PI / 2); + } + const mesh = new THREE.Mesh( + geometry, + new THREE.MeshStandardMaterial({ + color: spec.color, + roughness: 0.38, + metalness: 0.08, + }), + ); + mesh.name = spec.name; + mesh.userData.interactiveIndex = index; + mesh.position.fromArray(spec.pos); + mesh.quaternion.set(spec.quat[1], spec.quat[2], spec.quat[3], spec.quat[0]); + root.add(mesh); + return mesh; + }); + return { + root, + meshes, + dispose() { + root.removeFromParent(); + meshes.forEach((mesh) => { + mesh.geometry.dispose(); + mesh.material.dispose(); + }); + }, + sync(data, addresses, visible = true) { + root.visible = visible; + const q = data.qpos; + meshes.forEach((mesh, i) => { + const a = addresses[i].qAdr; + mesh.position.set(q[a], q[a + 1], q[a + 2]); + mesh.quaternion.set(q[a + 4], q[a + 5], q[a + 6], q[a + 3]); + }); + }, + }; +} diff --git a/app/src/game/worlds/arena/compose.js b/app/src/game/worlds/arena/compose.js index d318c24..21bd907 100644 --- a/app/src/game/worlds/arena/compose.js +++ b/app/src/game/worlds/arena/compose.js @@ -1,9 +1,8 @@ import { propColliders } from "../../props.js"; +import { appendInteractivePhysics } from "./session-environment.js"; import { arenaWalls } from "../../../platform/worlds/arena.js"; import { ARENA_HALF, - BALL_PARK_POS, - BALL_RADIUS, RELIEF_GRID, RELIEF_HMAX, RELIEF_SINK, @@ -17,6 +16,8 @@ export function composeArenaPhysics( jointNames, defaultPose, spawn, + interactiveProps = [], + floor, boundary = { half_extent: ARENA_HALF, wall_height: 0.25, @@ -30,7 +31,11 @@ export function composeArenaPhysics( for (const [k, v] of Object.entries(attrs)) e.setAttribute(k, v); return e; }; - root.appendChild(el("option", { timestep: String(timestep) })); + // Adding free toys can cross MuJoCo's automatic sparse-Jacobian cutoff + // (nv >= 60). Keep the original small-robot dense path in both modes. + root.appendChild( + el("option", { timestep: String(timestep), jacobian: "dense" }), + ); const body = doc.querySelector("worldbody"); body.appendChild( el("geom", { @@ -38,6 +43,7 @@ export function composeArenaPhysics( type: "plane", size: "0 0 0.05", pos: "0 0 0", + ...(floor?.friction ? { friction: floor.friction.join(" ") } : {}), }), ); for (const wall of arenaWalls(boundary)) @@ -54,20 +60,7 @@ export function composeArenaPhysics( if (c.euler) attrs.euler = c.euler; body.appendChild(el("geom", attrs)); } - const ball = el("body", { name: "ball", pos: BALL_PARK_POS }); - ball.appendChild(el("freejoint", { name: "ball_freejoint" })); - ball.appendChild( - el("geom", { - name: "ball_geom", - type: "sphere", - size: String(BALL_RADIUS), - mass: "0.03", - friction: "0.4 0.01 0.003", - solref: "0.03 0.4", - condim: "6", - }), - ); - body.appendChild(ball); + appendInteractivePhysics(doc, interactiveProps, { group: 0 }); doc.querySelector("asset").appendChild( el("hfield", { name: "terrain", @@ -93,7 +86,7 @@ export function composeArenaPhysics( keyframe.appendChild( el("key", { name: "STAND", - qpos: `${qposFree} ${qposJoints} ${BALL_PARK_POS} 1 0 0 0`, + qpos: `${qposFree} ${qposJoints} ${interactiveProps.map((p) => [...p.pos, ...p.quat].join(" ")).join(" ")}`, ctrl: Array.from(defaultPose).join(" "), }), ); diff --git a/app/src/game/worlds/arena/line-color.js b/app/src/game/worlds/arena/line-color.js new file mode 100644 index 0000000..ffa55c5 --- /dev/null +++ b/app/src/game/worlds/arena/line-color.js @@ -0,0 +1,15 @@ +import * as THREE from "three"; +import { VARIANT_SWATCH_HEX } from "../../variants.js"; + +// The existing four HUD swatches now tint both the floor and enclosure. +// Keep minor lines quieter than section lines, without touching reveal/fade. +export function setArenaLineColor(materials, name) { + const hex = VARIANT_SWATCH_HEX[name]; + if (!hex) return false; + const color = new THREE.Color(hex); + for (const material of materials) { + material.uniforms.uSectionColor.value.copy(color); + material.uniforms.uCellColor.value.copy(color).multiplyScalar(0.55); + } + return true; +} diff --git a/app/src/game/worlds/arena/presentation.js b/app/src/game/worlds/arena/presentation.js index 6eca381..19af0e1 100644 --- a/app/src/game/worlds/arena/presentation.js +++ b/app/src/game/worlds/arena/presentation.js @@ -1,5 +1,6 @@ import * as THREE from "three"; import { makeInfiniteGrid, makeArenaWalls } from "./render.js"; +import { setArenaLineColor } from "./line-color.js"; import { arenaWalls } from "../../../platform/worlds/arena.js"; // Shared appearance; physical collision boxes come only from the World composer. export function createArenaFloorPresentation({ sim, rig, world }) { @@ -43,6 +44,8 @@ export function createArenaFloorPresentation({ sim, rig, world }) { root, grid, walls: wallMeshes, + setLineColor: (name) => + setArenaLineColor([grid.material, ...wallMats], name), update(position) { grid.position.set(position.x, 0, position.z); grid.material.uniforms.uFocus.value.copy(position); diff --git a/app/src/game/worlds/arena/session-environment.js b/app/src/game/worlds/arena/session-environment.js new file mode 100644 index 0000000..84cb44e --- /dev/null +++ b/app/src/game/worlds/arena/session-environment.js @@ -0,0 +1,75 @@ +import { generateInteractiveProps } from "../../interactive-props.js"; + +// One random arrangement for the whole browser session, not one per robot. +// Positions/sizes share the arena's existing robot-relative scale. Reserve +// both bundled spawn anchors so changing robots never starts inside a toy. +export function createSessionEnvironment(random = Math.random) { + let template; + return { + propsFor(world) { + if (world.presentation !== "arena-grid" || !world.boundary) return []; + template ??= generateInteractiveProps({ + halfExtent: 2.25, + spawn: [-0.6, 0], + avoid: [[0, 0]], + random, + }); + const scale = world.boundary.half_extent / 2.25; + return template.map((spec) => ({ + ...spec, + pos: spec.pos.map((v) => v * scale), + size: spec.size.map((v) => v * scale), + quat: [...spec.quat], + // Keep larger robots' toys readily pushable, rather than scaling + // mass cubically into heavy obstacles for the humanoid. + mass: spec.mass * scale * scale, + })); + }, + }; +} + +let seed = 123456789; +const testRandom = () => + (seed = (1664525 * seed + 1013904223) >>> 0) / 4294967296; +const session = createSessionEnvironment( + typeof location !== "undefined" && + new URLSearchParams(location.search).get("test") === "1" + ? testRandom + : Math.random, +); +export const sharedInteractiveProps = (world) => session.propsFor(world); + +export function appendInteractivePhysics(doc, specs, { group = 5 } = {}) { + const body = doc.querySelector("worldbody"); + const el = (tag, attrs) => { + const node = doc.createElement(tag); + for (const [key, value] of Object.entries(attrs)) + node.setAttribute(key, value); + return node; + }; + for (const spec of specs) { + if (doc.querySelector(`[name="${spec.name}"]`)) + throw new Error(`World name collision: ${spec.name}`); + const prop = el("body", { + name: spec.name, + pos: spec.pos.join(" "), + quat: spec.quat.join(" "), + }); + prop.appendChild(el("freejoint", { name: `${spec.name}_joint` })); + prop.appendChild( + el("geom", { + name: `${spec.name}_geom`, + type: spec.type, + size: spec.size.join(" "), + mass: String(spec.mass), + friction: spec.friction ?? "0.5 0.01 0.003", + solref: spec.solref ?? "0.02 1", + condim: "6", + contype: "1", + conaffinity: "1", + group: String(group), + }), + ); + body.appendChild(prop); + } +} diff --git a/app/src/platform/input/PhysicsDrag.js b/app/src/platform/input/PhysicsDrag.js new file mode 100644 index 0000000..b5c57ce --- /dev/null +++ b/app/src/platform/input/PhysicsDrag.js @@ -0,0 +1,158 @@ +import * as THREE from "three"; + +// Same mass-scaled spring perturbation as Microduck, applied every physics +// substep. Shared by generic robots for both their body and the arena toys. +export class PhysicsDrag { + constructor({ + sim, + camera, + controls, + canvas, + objects, + addressFor, + enabled, + halfExtent, + scale = 1, + }) { + Object.assign(this, { + sim, + camera, + controls, + canvas, + objects, + addressFor, + enabled, + halfExtent, + scale, + }); + this.ray = new THREE.Raycaster(); + this.ndc = new THREE.Vector2(); + this.plane = new THREE.Plane(); + this.point = new THREE.Vector3(); + this.direction = new THREE.Vector3(); + this.listeners = []; + const listen = (type, fn, capture = false) => { + window.addEventListener(type, fn, capture); + this.listeners.push(() => window.removeEventListener(type, fn, capture)); + }; + listen( + "pointerdown", + (e) => { + if ( + e.target !== canvas || + e.pointerType !== "mouse" || + e.button !== 0 || + !enabled() + ) + return; + this.setRay(e); + const hit = this.pick(); + if (!hit) return; + const address = addressFor(hit.object); + if (!address) return; + this.grab = { ...address, target: [0, 0, 0] }; + camera.getWorldDirection(this.direction); + this.plane.setFromNormalAndCoplanarPoint( + this.direction.negate(), + hit.point, + ); + this.updateTarget(); + controls.enabled = false; + canvas.style.cursor = "grabbing"; + this.pointerId = e.pointerId; + try { + canvas.setPointerCapture(e.pointerId); + } catch { + /* unavailable */ + } + }, + true, + ); + listen("pointermove", (e) => { + if (this.grab) { + this.setRay(e); + this.updateTarget(); + return; + } + if ( + e.target !== canvas || + e.pointerType !== "mouse" || + e.buttons || + !enabled() + ) + return; + if (performance.now() - (this.hoverAt ?? 0) < 80) return; + this.hoverAt = performance.now(); + this.setRay(e); + canvas.style.cursor = this.pick() ? "grab" : ""; + }); + for (const type of ["pointerup", "pointercancel", "blur"]) + listen(type, () => this.release()); + canvas.addEventListener( + "lostpointercapture", + (this.lostCapture = () => this.release()), + ); + } + setRay(e) { + const rect = this.canvas.getBoundingClientRect(); + this.ndc.set( + ((e.clientX - rect.left) / rect.width) * 2 - 1, + -((e.clientY - rect.top) / rect.height) * 2 + 1, + ); + this.ray.setFromCamera(this.ndc, this.camera); + } + pick() { + return this.ray.intersectObjects(this.objects(), true).find((hit) => { + for (let o = hit.object; o; o = o.parent) if (!o.visible) return false; + return !!this.addressFor(hit.object); + }); + } + updateTarget() { + if (!this.ray.ray.intersectPlane(this.plane, this.point)) return; + const lim = (this.halfExtent ?? 100) - 0.05 * this.scale; + this.grab.target = [ + Math.max(-lim, Math.min(lim, this.point.x)), + Math.max(-lim, Math.min(lim, -this.point.z)), + Math.max(0.02 * this.scale, Math.min(0.45 * this.scale, this.point.y)), + ]; + } + apply() { + const g = this.grab; + if (!g) return; + const { data } = this.sim, + force = []; + for (let i = 0; i < 3; i++) + force[i] = + 100 * (g.target[i] - data.qpos[g.qAdr + i]) - + 10 * data.qvel[g.dofAdr + i]; + const norm = Math.hypot(...force), + clamp = Math.min(1, 200 / (norm || 1)); + for (let i = 0; i < 3; i++) + data.xfrc_applied[g.bodyId * 6 + i] = g.mass * force[i] * clamp; + } + release() { + if (this.grab) + this.sim.data.xfrc_applied.fill( + 0, + this.grab.bodyId * 6, + this.grab.bodyId * 6 + 6, + ); + this.grab = null; + this.controls.enabled = true; + this.canvas.style.cursor = ""; + const id = this.pointerId; + this.pointerId = undefined; + if (id !== undefined) { + try { + this.canvas.releasePointerCapture(id); + } catch { + /* already released */ + } + } + } + dispose() { + this.release(); + this.listeners.forEach((remove) => remove()); + this.canvas.removeEventListener("lostpointercapture", this.lostCapture); + } +} diff --git a/app/src/platform/render/BodyVisuals.js b/app/src/platform/render/BodyVisuals.js index 6762d3c..4bdd7d5 100644 --- a/app/src/platform/render/BodyVisuals.js +++ b/app/src/platform/render/BodyVisuals.js @@ -51,6 +51,7 @@ export class BodyVisuals { visuals.scenes.push(...gltf.scenes); const frame = new THREE.Group(); frame.name = `body-visual:${spec.body}`; + frame.userData.bodyId = ids[i]; gltf.scene.position.fromArray(spec.position ?? [0, 0, 0]); gltf.scene.quaternion.fromArray(spec.quaternion ?? [0, 0, 0, 1]); frame.add(gltf.scene); diff --git a/app/src/platform/runtime/RobotRuntime.js b/app/src/platform/runtime/RobotRuntime.js index 61e9e28..d5586fd 100644 --- a/app/src/platform/runtime/RobotRuntime.js +++ b/app/src/platform/runtime/RobotRuntime.js @@ -16,6 +16,8 @@ import { SkillManager } from "../skills/SkillManager.js"; import { InputRouter } from "../input/InputRouter.js"; import { RigRenderer } from "../render/RigRenderer.js"; import { ChaseCamera } from "../render/ChaseCamera.js"; +import { PhysicsDrag } from "../input/PhysicsDrag.js"; +import { createInteractivePropVisuals } from "../../game/interactive-props.js"; export class RobotRuntime { static async load(options) { @@ -175,7 +177,14 @@ export class RobotRuntime { }, }); this.scene.add(this.rig.root); - if (this.worldPresentation) this.scene.add(this.worldPresentation.root); + this.lineColor = this.environmentSettings?.lineColor ?? "classic"; + if (this.worldPresentation) { + this.scene.add(this.worldPresentation.root); + this.worldPresentation.setLineColor(this.lineColor); + } + this.propsVisuals = createInteractivePropVisuals(this.sim.interactiveSpecs); + this.scene.add(this.propsVisuals.root); + this.syncProps(); this.follow = new THREE.Vector3(); } activate({ paused = false } = {}) { @@ -192,6 +201,35 @@ export class RobotRuntime { this.config.render.camera, ); this.restoreCamera(); + this.drag = new PhysicsDrag({ + sim: this.sim, + camera: this.camera, + controls: this.controls, + canvas: this.renderer.domElement, + objects: () => [this.rig.root, this.propsVisuals.root], + enabled: () => this.active && this.scheduler.running && !this.disposed, + halfExtent: this.world.boundary?.half_extent, + scale: this.world.scale ?? 1, + addressFor: (object) => { + const index = object.userData.interactiveIndex; + if (Number.isInteger(index)) return this.sim.propAddresses[index]; + const id = object.userData.geomId; + let visualBody = false; + for (let node = object; node; node = node.parent) + if (node.userData.bodyId > 0) visualBody = true; + if ( + !visualBody && + (id === undefined || this.sim.model.geom_bodyid[id] === 0) + ) + return null; + return { + bodyId: this.sim.root, + qAdr: this.sim.rootQpos, + dofAdr: this.sim.rootDof, + mass: this.sim.model.body_subtreemass[this.sim.root], + }; + }, + }); this.input.init(); if (!paused) this.resume(); else this.onStatus({ paused: true }); @@ -213,6 +251,11 @@ export class RobotRuntime { } status() { return { + lineColor: this.lineColor, + runtimeCapabilities: { + environmentControls: !!this.worldPresentation, + physicalDrag: true, + }, policyStatus: this.policyStatus(), actuationLabel: this.config.actuation.type === "joint_pd" @@ -220,6 +263,18 @@ export class RobotRuntime { : "", }; } + setLineColor(name) { + if (!this.worldPresentation?.setLineColor(name)) return; + this.lineColor = name; + this.onStatus({ lineColor: name }); + } + syncProps() { + this.propsVisuals.sync( + this.sim.data, + this.sim.propAddresses, + !this.sim.propsParked, + ); + } policyStatus() { return this.policyState.episodes.size ? `Skill: ${this.policyState.active} · ${this.policyState.state}` @@ -241,6 +296,7 @@ export class RobotRuntime { if (!paused) this.resume(); } async pause() { + this.drag?.release(); this.input.clear(); await this.scheduler.pause(); this.onStatus({ paused: true }); @@ -260,6 +316,7 @@ export class RobotRuntime { async #reset() { const running = this.scheduler.running; await this.scheduler.pause(); + this.drag?.release(); this.input.clear(); this.ctx.command.fill(0); for (const policy of this.policies.values()) policy.reset(); @@ -278,6 +335,7 @@ export class RobotRuntime { this.onStatus({ fallen: false }); this.publishPolicyStatus(); this.rig.sync(); + this.syncProps(); if (running) this.scheduler.start(); } triggerAction(action) { @@ -313,8 +371,10 @@ export class RobotRuntime { } for (let i = 0; i < this.config.sim.decimation; i++) { this.actuation.apply(); + this.drag?.apply(); this.sim.step(); } + this.sim.restoreEscapedProps(this.world.boundary?.half_extent); const q = this.sim.data.qpos, a = this.sim.rootQpos, quat = this.sim.data.xquat, @@ -356,6 +416,7 @@ export class RobotRuntime { frame() { if (this.disposed) return; this.rig.sync(); + this.syncProps(); if (this.chaseCamera) { const yaw = this.cameraPose(); this.worldPresentation?.update(this.follow); @@ -395,6 +456,17 @@ export class RobotRuntime { }, scene: this.scene, world: this.world, + get interactiveProps() { + return self.sim.interactiveSpecs.map((spec, i) => ({ + ...spec, + ...self.sim.propAddresses[i], + })); + }, + setPropsParked: (parked) => { + this.drag?.release(); + this.sim.setPropsParked(parked); + this.syncProps(); + }, command: this.input.command, get lastAction() { return self.policies.get(self.activePolicy).ctx.lastAction; @@ -444,6 +516,8 @@ export class RobotRuntime { this.active = false; await this.scheduler.dispose(); this.input.dispose(); + this.drag?.dispose(); + this.propsVisuals.dispose(); this.chaseCamera?.dispose(); this.controls?.dispose(); this.worldPresentation?.dispose(); diff --git a/app/src/platform/runtime/RuntimeManager.js b/app/src/platform/runtime/RuntimeManager.js index 85edc60..c6664fa 100644 --- a/app/src/platform/runtime/RuntimeManager.js +++ b/app/src/platform/runtime/RuntimeManager.js @@ -82,6 +82,9 @@ export class RuntimeManager { camera, renderer: this.renderer, autoStart: false, + environmentSettings: { + lineColor: this.getState().lineColor ?? "classic", + }, publish, onStatus: publish, onTelemetry: (telemetry) => publish({ telemetry }), diff --git a/app/src/platform/sim/SceneComposer.js b/app/src/platform/sim/SceneComposer.js index 52e0098..ca1e844 100644 --- a/app/src/platform/sim/SceneComposer.js +++ b/app/src/platform/sim/SceneComposer.js @@ -1,5 +1,6 @@ import { arenaWalls } from "../worlds/arena.js"; -export function composeScene(xml, config, world) { +import { appendInteractivePhysics } from "../../game/worlds/arena/session-environment.js"; +export function composeScene(xml, config, world, interactiveProps = []) { const doc = new DOMParser().parseFromString(xml, "text/xml"); if ( doc.querySelector("parsererror") || @@ -9,6 +10,7 @@ export function composeScene(xml, config, world) { const option = doc.querySelector("mujoco > option") ?? doc.createElement("option"); option.setAttribute("timestep", String(config.sim.timestep)); + if (interactiveProps.length) option.setAttribute("jacobian", "dense"); if (!option.parentNode) doc.documentElement.append(option); if (world.type !== "flat") throw new Error(`World ${world.id}: generic composer requires flat World`); @@ -44,5 +46,6 @@ export function composeScene(xml, config, world) { worldbody.append(geom); } } + appendInteractivePhysics(doc, interactiveProps); return new XMLSerializer().serializeToString(doc); } diff --git a/app/src/platform/sim/SimCore.js b/app/src/platform/sim/SimCore.js index dc4f819..b6bcfb4 100644 --- a/app/src/platform/sim/SimCore.js +++ b/app/src/platform/sim/SimCore.js @@ -1,5 +1,10 @@ import { fetchChecked } from "../loader/PackageLoader.js"; import { composeScene } from "./SceneComposer.js"; +import { sharedInteractiveProps } from "../../game/worlds/arena/session-environment.js"; +import { + resolvePropAddresses, + resetProp, +} from "../../game/interactive-props.js"; export function resolveAddresses(mujoco, model, names) { const joints = new Map(); for (const name of names) { @@ -42,14 +47,23 @@ export class SimCore { pkg.config.assets.forEach((a, i) => vfs.addBuffer(a.vfs, new Uint8Array(buffers[i])), ); + const interactiveSpecs = sharedInteractiveProps(world); const xml = composeScene( await fetchChecked(pkg.asset(pkg.config.model)), pkg.config, world, + interactiveSpecs, ); model = mujoco.MjModel.from_xml_string(xml, vfs); data = new mujoco.MjData(model); - return new SimCore(mujoco, model, data, vfs, pkg.config); + return new SimCore( + mujoco, + model, + data, + vfs, + pkg.config, + interactiveSpecs, + ); } catch (error) { data?.delete(); model?.delete(); @@ -57,8 +71,10 @@ export class SimCore { throw error; } } - constructor(mujoco, model, data, vfs, config) { - Object.assign(this, { mujoco, model, data, vfs, config }); + constructor(mujoco, model, data, vfs, config, interactiveSpecs = []) { + Object.assign(this, { mujoco, model, data, vfs, config, interactiveSpecs }); + this.propAddresses = resolvePropAddresses(mujoco, model, interactiveSpecs); + this.propsParked = false; const names = [...new Set(Object.values(config.joints.groups).flat())]; this.joints = resolveAddresses(mujoco, model, names); for (const [name, j] of this.joints) { @@ -119,8 +135,36 @@ export class SimCore { for (const [name, joint] of this.joints) data.qpos[joint.qpos] = config.base.initial?.[name] ?? defaults.get(name) ?? 0; + this.resetProps(); mujoco.mj_forward(model, data); } + resetProps() { + this.interactiveSpecs.forEach((spec, i) => + resetProp(this.data, this.propAddresses[i], spec, this.propsParked, i), + ); + } + setPropsParked(parked) { + this.propsParked = parked; + this.resetProps(); + this.mujoco.mj_forward(this.model, this.data); + } + restoreEscapedProps(halfExtent) { + if (this.propsParked || !halfExtent) return; + let restored = false; + this.interactiveSpecs.forEach((spec, i) => { + const a = this.propAddresses[i].qAdr, + q = this.data.qpos; + if ( + Math.abs(q[a]) > halfExtent + 0.1 || + Math.abs(q[a + 1]) > halfExtent + 0.1 || + q[a + 2] < -0.2 + ) { + resetProp(this.data, this.propAddresses[i], spec); + restored = true; + } + }); + if (restored) this.mujoco.mj_forward(this.model, this.data); + } step() { this.mujoco.mj_step(this.model, this.data); } diff --git a/app/src/robots/microduck/runtime.js b/app/src/robots/microduck/runtime.js index 3f2c3fd..d3e2059 100644 --- a/app/src/robots/microduck/runtime.js +++ b/app/src/robots/microduck/runtime.js @@ -38,8 +38,6 @@ import { ObservationPipeline } from "../../platform/policy/ObservationPipeline.j import { ActionPipeline } from "../../platform/policy/ActionPipeline.js"; import { NativeActuation } from "../../platform/sim/actuation/JointPdActuation.js"; import { - BALL_RADIUS, - BALL_PARK_POS, ARENA_HALF as LEGACY_ARENA_HALF, SPAWN_X, SPAWN_Y, @@ -91,7 +89,13 @@ import { playLineBlip, setRumble, } from "../../game/audio.js"; -import { createBallActor } from "../../game/ball-actor.js"; +import { + resolvePropAddresses, + resetProp, + createInteractivePropVisuals, +} from "../../game/interactive-props.js"; +import { setArenaLineColor } from "../../game/worlds/arena/line-color.js"; +import { sharedInteractiveProps } from "../../game/worlds/arena/session-environment.js"; import { loadCustomPolicy as loadCustomPolicyModule, scriptCommandAt, @@ -100,7 +104,6 @@ import { makeInfiniteGrid, makeArenaWalls, } from "../../game/worlds/arena/render.js"; -import { createBallVisual } from "../../game/ball-visual.js"; import { useGame, gameApi, @@ -133,6 +136,7 @@ export async function bootGame({ world, autoStart = true, publish, + environmentSettings, }) { const scope = new Disposables(); try { @@ -149,6 +153,7 @@ export async function bootGame({ world, autoStart, publish, + environmentSettings, }); } catch (err) { await scope.dispose().catch(console.error); @@ -167,6 +172,7 @@ async function boot({ world, autoStart, publish, + environmentSettings, }) { const robot = pkg.config; const boundary = world.boundary ?? { @@ -175,6 +181,14 @@ async function boot({ wall_thickness: 0.05, }; const ARENA_HALF = boundary.half_extent; + const params = new URLSearchParams(location.search); + const testMode = params.get("test") === "1"; + const legacyOracle = testMode && params.get("oracle") === "legacy"; + const interactiveSpecs = legacyOracle + ? (await import("./test-oracle.js")).originalPhysicsProbe() + : sharedInteractiveProps(world); + let propsParked = false; + let propVisuals = null; const rollerPkg = await loadPackage( `${import.meta.env.BASE_URL}robots/microduck-rollers/robot.json`, ); @@ -214,7 +228,6 @@ async function boot({ const bootHalt = (detail) => { if (!publish) globalBootHalt(detail); }; - const testMode = new URLSearchParams(location.search).get("test") === "1"; const clock = new SimulationClock(); const listen = (target, event, callback, options) => scope.listen(target, event, callback, options); @@ -295,6 +308,8 @@ async function boot({ jointNames: JOINT_NAMES, defaultPose: DEFAULT_POSE, spawn: robot.base.spawn, + interactiveProps: interactiveSpecs, + floor: legacyOracle ? undefined : world.floor, boundary, }); } @@ -344,8 +359,10 @@ async function boot({ doneMeshes(`${meshFiles.length} FILES`); const sessions = {}; - // Always boot on the classic (orange) colourway; the quickbar re-skins live. + // The robot retains its palette; the quickbar now tints arena lines. let currentVariant = DEFAULT_VARIANT; + let lineColor = + environmentSettings?.lineColor ?? store().lineColor ?? DEFAULT_VARIANT; const rigPromise = (async () => { const doneRig = bootLine("RENDER RIG"); try { @@ -566,8 +583,7 @@ async function boot({ mujoco.mjtObj.mjOBJ_KEY.value, "STAND", ), - ballQposAdr: model.jnt_qposadr[jointId("ball_freejoint")], - ballDofAdr: model.jnt_dofadr[jointId("ball_freejoint")], + propAddresses: resolvePropAddresses(mujoco, model, interactiveSpecs), // Foot bodies for the footstep audio heuristic (-1 when a variant // has no ankles, e.g. if a future model renames them). ankleIds: ["ankle_left", "ankle_right"].map((n) => @@ -594,8 +610,7 @@ async function boot({ gyroAdr, trunkId, standKeyId, - ballQposAdr, - ballDofAdr, + propAddresses, extraJoints, ankleIds, } = resolveAddrs(model, k); @@ -651,11 +666,10 @@ async function boot({ // Right-stick camera state, read by the telemetry before the camera-orbit // section below has evaluated. let padOrbitLive = false; - // Robot input gate: twist commands, mode changes, rolls, kicks and ball - // spawns all stay inert until the entrance sequence has fully played out. + // Robot input gate: twist commands, mode changes, rolls and kicks + // stay inert until the entrance sequence has fully played out. let inputLocked = true; let ceremony = null; - let ball = null; let stickers = null; // comic popups, currently disabled let mode = "walk"; // "walk" | "sitstand" | "roll" | "kickL" | "kickR" | "crouch" | "groundpick" @@ -678,9 +692,6 @@ async function boot({ const HEAD_SIGNS = new Float32Array([1, -1, 1, -1]); const headTarget = new Float32Array(4); const headSmooth = new Float32Array(4); - // Local-only kickable ball: false while parked at the keyframe spot - // (mesh hidden), true once popped in front of the duck. - let ballActive = false; // The twist the policy actually receives. Mid-roll every movement input // is ignored (zero twist) until the roll hands back to walk on its own. @@ -823,74 +834,26 @@ async function boot({ headTarget.fill(0); headSmooth.fill(0); mujoco.mj_resetDataKeyframe(model, data, standKeyId); + interactiveSpecs.forEach((spec, i) => + resetProp(data, propAddresses[i], spec, propsParked, i), + ); mujoco.mj_forward(model, data); lastAction.fill(0); sitFlag = 0; - // Park the ball in physics immediately; if it was on screen, the - // reverse scan peels it away at its last pose. A queued B-respawn is - // cancelled: a reset means no ball. - ball?.despawn({ cancelQueued: true, parkPhysics: parkBallPhysics }); - ballActive = false; + propVisuals?.sync(data, propAddresses, !propsParked); syncButtons(); - if (!testMode && ceremony) { - startCameraReset(); - spawnBall({ fromQueue: true }); - } + if (!testMode && ceremony) startCameraReset(); } resetSim(); - function parkBallPhysics() { - const qpos = data.qpos, - qvel = data.qvel; - qpos[ballQposAdr] = 50; - qpos[ballQposAdr + 1] = 0; - qpos[ballQposAdr + 2] = BALL_RADIUS; - qpos[ballQposAdr + 3] = 1; - qpos[ballQposAdr + 4] = 0; - qpos[ballQposAdr + 5] = 0; - qpos[ballQposAdr + 6] = 0; - for (let i = 0; i < 6; i++) qvel[ballDofAdr + i] = 0; - mujoco.mj_forward(model, data); - ballActive = false; - } - - // Pop / respawn the ball ~0.35 m in front of the duck, with a small - // random heading + distance jitter. If the ball is already on screen, - // peel it away first (reverse scan) and pop the new one when that - // finishes - same appear/disappear pair as the duck's wireframe ceremony. - function spawnBall(opts = {}) { - if (inputLocked && !opts.fromQueue) return; - if (!ball) return; - if (ball.visual !== "hidden") { - ball.queueRespawn(); - ball.despawn({ parkPhysics: parkBallPhysics }); - return; - } - const qpos = data.qpos, - qvel = data.qvel; - const yaw = Math.atan2( - 2 * (qpos[3] * qpos[6] + qpos[4] * qpos[5]), - 1 - 2 * (qpos[5] * qpos[5] + qpos[6] * qpos[6]), + function setPropsParked(parked) { + endGrabHook(); + propsParked = parked; + interactiveSpecs.forEach((spec, i) => + resetProp(data, propAddresses[i], spec, parked, i), ); - const heading = yaw + (Math.random() - 0.5) * 0.7; - const dist = 0.35 + (Math.random() - 0.5) * 0.1; - const lim = ARENA_HALF - BALL_RADIUS - 0.05; - const clamp = (v) => Math.min(lim, Math.max(-lim, v)); - qpos[ballQposAdr] = clamp(qpos[0] + Math.cos(heading) * dist); - qpos[ballQposAdr + 1] = clamp(qpos[1] + Math.sin(heading) * dist); - qpos[ballQposAdr + 2] = BALL_RADIUS + 0.02; - qpos[ballQposAdr + 3] = 1; - qpos[ballQposAdr + 4] = 0; - qpos[ballQposAdr + 5] = 0; - qpos[ballQposAdr + 6] = 0; - for (let i = 0; i < 6; i++) qvel[ballDofAdr + i] = 0; mujoco.mj_forward(model, data); - ballActive = true; - // Snap the mesh to the new pose BEFORE the scan starts: the FX - // recomputes its bbox from the live mesh. - ball.poseFromQpos(qpos, ballQposAdr); - ball.appear(); - stickers?.pop("spawn"); + propVisuals?.sync(data, propAddresses, !parked); } // ── Observation ───────────────────────────────────────────────────── @@ -1015,14 +978,13 @@ async function boot({ return null; } - // ── Sim-driven audio (footsteps / roller rumble / ball impacts) ────── + // ── Sim-driven audio (footsteps / roller rumble / body bumps) ─────── // Footsteps use a per-foot height heuristic instead of MuJoCo contacts // (the WASM bindings expose no contact array): each ankle's height // RELATIVE to the lower ankle (the planted foot approximates the local // ground, so the measure self-calibrates on the relief terrain), with // lift/contact hysteresis and a per-foot debounce. Tap gain scales with - // the landing speed. Rollers get a speed-following rumble loop instead, - // and the ball thumps on velocity deltas between control steps. + // the landing speed. Rollers get a speed-following rumble loop instead. const STEP_LIFT = 0.012; // m above the planted foot = foot in swing const STEP_CONTACT = 0.005; // m: dropping below this while in swing = step const STEP_DEBOUNCE_MS = 130; @@ -1031,18 +993,11 @@ async function boot({ { air: false, prevZ: 0, lastAt: 0 }, ]; const duckEmitter = createEmitter({ refDistance: 0.5 }); - const ballEmitter = createEmitter({ refDistance: 0.5 }); - scope.add(() => { - duckEmitter.node.disconnect(); - ballEmitter.node.disconnect(); - }); - const ballPrevV = [0, 0, 0]; - let ballPrevValid = false; - let ballThumpAt = 0; + scope.add(() => duckEmitter.node.disconnect()); // Body bumps: trunk velocity deltas gated on obstacle proximity (walls // or prop collider footprints) so the walking gait's own accelerations // (comparable in magnitude to a slow wall hit) never false-trigger. - // Duller than the ball thumps: same samples pitched way down. + // Low-pitched impact samples for body bumps. const BUMP_DV = 0.35; // m/s per control step const BUMP_DEBOUNCE_MS = 300; // rubbing a wall must not machine-gun const BUMP_WALL_PAD = 0.16; // trunk half-width-ish reach to a wall @@ -1126,7 +1081,7 @@ async function boot({ const u = Math.min(1, (dv - BUMP_DV) / 1.5); playSfx("thump", { gain: 0.12 + 0.3 * u, - rate: 0.55 + 0.15 * u + Math.random() * 0.06, // way below the ball's range + rate: 0.55 + 0.15 * u + Math.random() * 0.06, // low-pitched body impact out: duckEmitter.node, }); haptics.pulse("bump", 0.5 + 0.5 * u); // shove felt in the hands @@ -1139,42 +1094,6 @@ async function boot({ } else { bumpPrevValid = false; } - // Ball impacts: |dv| between control steps. Gravity alone accounts for - // ~0.2 m/s per 20 ms step; the 0.5 threshold clears it and rolling noise. - if (ballActive) { - const v = data.qvel; - const b = ballDofAdr; - if (ballPrevValid) { - const dv = Math.hypot( - v[b] - ballPrevV[0], - v[b + 1] - ballPrevV[1], - v[b + 2] - ballPrevV[2], - ); - if (dv > 0.5 && now - ballThumpAt > 90) { - ballThumpAt = now; - const u = Math.min(1, (dv - 0.5) / 3.5); // full at kick-grade hits - playSfx("thump", { - gain: 0.14 + 0.4 * u, - rate: 1.25 - 0.45 * u + Math.random() * 0.08, - out: ballEmitter.node, - }); - // Haptics only when the duck plausibly caused/received the hit: - // a far bounce off a wall shouldn't shake the hands. - const bq = ballQposAdr; - const dBall = Math.hypot( - data.qpos[bq] - data.qpos[0], - data.qpos[bq + 1] - data.qpos[1], - ); - if (dBall < 0.6) haptics.pulse("ballHit", 0.4 + 0.6 * u); - } - } - ballPrevV[0] = v[b]; - ballPrevV[1] = v[b + 1]; - ballPrevV[2] = v[b + 2]; - ballPrevValid = true; - } else { - ballPrevValid = false; - } // Haptic channel scheduler: keeps the roller bed alive between pulses // and cuts the motors when it falls silent. 50 Hz, like everything here. haptics.tick(); @@ -1220,7 +1139,7 @@ async function boot({ applyGrabForce(); // mouse perturbation, fresh velocity every substep mujoco.mj_step(model, data); } - stepAudioSim(); // footsteps / rumble / ball thumps off the fresh state + stepAudioSim(); // footsteps / rumble / body bumps off the fresh state // Command script clock: 50 Hz like everything here. A non-looping // script ends on its own; a looping one runs until R (or a reset). @@ -1317,14 +1236,22 @@ async function boot({ fallenSince = null; } - // Ball respawn watchdog: outside the arena bounds means "escaped - // through a solver glitch", bring it back near the duck. - if (ballActive) { - const q = data.qpos; - const escaped = - Math.abs(q[ballQposAdr]) > ARENA_HALF + 0.1 || - Math.abs(q[ballQposAdr + 1]) > ARENA_HALF + 0.1; - if (escaped) spawnBall(); + // Return escaped toys individually without disturbing the robot or peers. + if (!propsParked) { + let restored = false; + interactiveSpecs.forEach((spec, i) => { + const a = propAddresses[i].qAdr, + q = data.qpos; + if ( + Math.abs(q[a]) > ARENA_HALF + 0.1 || + Math.abs(q[a + 1]) > ARENA_HALF + 0.1 || + q[a + 2] < -0.2 + ) { + resetProp(data, propAddresses[i], spec); + restored = true; + } + }); + if (restored) mujoco.mj_forward(model, data); } if (postKickLock > 0 && mode === "walk") postKickLock--; @@ -1469,7 +1396,7 @@ async function boot({ // Released before models/sessions, even when boot or a later lazy load fails. scope.add(() => scheduler.dispose()); - // ── Scene wiring (grid, walls, rig, ball, arcade row) ──────────────── + // ── Scene wiring (grid, walls, rig, interactive toys, arcade row) ──── // The grid/walls carry ceremony-driven uReveal uniforms and per-frame // focus updates, so the game owns them; lights and environment live in // the R3F layer. @@ -1478,6 +1405,11 @@ async function boot({ reliefGridMat = grid.material; // relief drive mirrors uTopoScale into it const { wallMats, wallMeshes } = makeArenaWalls(boundary); for (const m of wallMeshes) scene.add(m); + grid.name = "arena-grid"; + setArenaLineColor([grid.material, ...wallMats], lineColor); + propVisuals = createInteractivePropVisuals(interactiveSpecs); + scene.add(propVisuals.root); + propVisuals.sync(data, propAddresses, !propsParked); let rig = await rigPromise; scene.add(rig.placer); @@ -1493,9 +1425,9 @@ async function boot({ gyroAdr, trunkId, standKeyId, - ballQposAdr, - ballDofAdr, + propAddresses, extraJoints, + ankleIds, }; // ── Locomotion variant switching (legs <-> rollers) ────────────────── @@ -1572,8 +1504,7 @@ async function boot({ gyroAdr, trunkId, standKeyId, - ballQposAdr, - ballDofAdr, + propAddresses, extraJoints, ankleIds, } = L); @@ -1664,10 +1595,6 @@ async function boot({ setLocked: (v) => { inputLocked = v; controller.setLocked(v); - // A ball is always in play: pop one the moment the entrance or a - // respawn ceremony hands control back. - if (!v && ball && !ballActive && !testMode) - spawnBall({ fromQueue: true }); }, flashReset: () => {}, // Audio twins of the wireframe materialize FX (entrance and respawns): @@ -1693,19 +1620,6 @@ async function boot({ { fireImmediately: true }, ); - const { group: ballGroup, mesh: ballMesh } = createBallVisual(renderer); - scene.add(ballGroup); - ball = createBallActor({ - THREE, - scene, - camera, - renderer, - fxModule: fx, - mesh: ballMesh, - group: ballGroup, - }); - scope.add(() => ball.dispose()); - // ── Prop library (wall/corner dressing + entrance FX) ──────────────── // Every enabled def in props.js: loaded, real-size scaled, floor // snapped, wireframe-materialized with the ceremony (staggered after @@ -1876,7 +1790,7 @@ async function boot({ } // ── Mouse grab, pointer side (pick + drag target + cursor) ──────────── - // Pointer-down on the duck (or the live ball) grabs it; anywhere else + // Pointer-down on the duck or an interactive toy grabs it; anywhere else // falls through to OrbitControls untouched. The pick is a three.js // raycast against the render rig (the WASM bindings expose no // mjv_select, and the rig IS the duck's collision-accurate silhouette @@ -1902,13 +1816,19 @@ async function boot({ } function grabPick() { const duckHit = _grabRaycaster.intersectObject(rig.placer, true)[0]; - const ballHit = ballActive - ? _grabRaycaster.intersectObject(ballMesh, true)[0] + const propHit = !propsParked + ? _grabRaycaster.intersectObjects(propVisuals.meshes, false)[0] : undefined; - if (duckHit && (!ballHit || duckHit.distance <= ballHit.distance)) { + if (duckHit && (!propHit || duckHit.distance <= propHit.distance)) { return { kind: "duck", point: duckHit.point }; } - return ballHit ? { kind: "ball", point: ballHit.point } : null; + return propHit + ? { + kind: "prop", + point: propHit.point, + index: propHit.object.userData.interactiveIndex, + } + : null; } function updateGrabTarget() { if (!_grabRaycaster.ray.intersectPlane(_grabPlane, _grabHit)) return; @@ -1956,18 +1876,7 @@ async function boot({ dofAdr: 0, mass: model.body_subtreemass[trunkId], } - : { - bodyId: mujoco.mj_name2id( - model, - mujoco.mjtObj.mjOBJ_BODY.value, - "ball", - ), - qAdr: ballQposAdr, - dofAdr: ballDofAdr, - mass: model.body_mass[ - mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_BODY.value, "ball") - ], - }; + : propAddresses[pick.index]; camera.getWorldDirection(_grabCamDir); _grabPlane.setFromNormalAndCoplanarPoint( _grabCamDir.negate(), @@ -2050,8 +1959,7 @@ async function boot({ setJoint(rig, JOINT_NAMES[j], qpos[qposAdr[j]]); // Passive hinges (roller wheels): purely visual, driven straight from qpos. for (const ej of extraJoints) setJoint(rig, ej.name, qpos[ej.adr]); - // Ball: live follows qpos; ghost freeze is owned by the ball actor. - if (ball) ball.sync(qpos, ballQposAdr, ballActive); + propVisuals?.sync(data, propAddresses, !propsParked); // Follow cam: ease the orbit target toward the trunk and translate the // camera by the same delta, so the camera-to-duck distance and viewing // angle stay constant while the duck walks. Paused while the reset @@ -2372,18 +2280,9 @@ async function boot({ syncRig(); syncJaw(); ghosts?.update(); - // Spatial audio follows the movers: listener on the camera, emitters - // on the duck trunk and the ball (MJCF Z-up -> three Y-up). + // Spatial audio: listener on the camera, emitter on the duck trunk. updateListener(camera); duckEmitter.setPosition(data.qpos[0], data.qpos[2], -data.qpos[1]); - if (ballActive) { - const q = data.qpos; - ballEmitter.setPosition( - q[ballQposAdr], - q[ballQposAdr + 2], - -q[ballQposAdr + 1], - ); - } controls.update(); updateChaseCam(); if (helperCamera !== camera) { @@ -2391,7 +2290,6 @@ async function boot({ helperCamera.copy(camera); } ceremony.drive(); - ball.drive(() => spawnBall({ fromQueue: true })); waypointMarker.update(dt, waypointSource.target); renderTelemetry(); } @@ -2408,7 +2306,6 @@ async function boot({ controller.on("reset", () => gameApi.reset?.()); controller.on("reset", () => waypointSource.cancel()); - controller.on("spawnBall", () => spawnBall()); controller.on("headToggle", () => toggleHeadMode()); controller.on("chaseToggle", () => startCameraReset()); controller.on("locoToggle", () => toggleLoco()); @@ -2604,7 +2501,7 @@ async function boot({ mode = foot === "left" ? "kickL" : "kickR"; sitFlag = 0; kickRun = { steps: 0 }; - haptics.pulse("kick"); // swing launch; ball contact adds ballHit + haptics.pulse("kick"); // swing launch syncButtons(); stickers?.pop("kick"); return true; @@ -2634,7 +2531,6 @@ async function boot({ ? "Drive" : "Run"; if (store().modeLabel !== label) setStore({ modeLabel: label }); - if (store().ballActive !== ballActive) setStore({ ballActive }); } // ── Public surface for the React UI ────────────────────────────────── @@ -2666,9 +2562,14 @@ async function boot({ loco, locoWant: loco, variant: currentVariant, + lineColor, modeLabel: store().modeLabel, inputBindings: robot.input.bindings, - runtimeCapabilities: { duckControls: true, physicalDrag: true }, + runtimeCapabilities: { + duckControls: true, + environmentControls: true, + physicalDrag: true, + }, }), triggerAction: (action) => { if ( @@ -2678,7 +2579,10 @@ async function boot({ ) kbSource.onAction(action); }, - saveSettings: () => ({ variant: currentVariant, loco: store().locoWant }), + saveSettings: () => ({ + variant: currentVariant, + loco: store().locoWant, + }), restoreSettings: async (settings) => { if (settings?.variant) runtime.setVariant(settings.variant); if (settings?.loco) @@ -2727,13 +2631,17 @@ async function boot({ applyVariant(rig, name); setStore({ variant: name }); }, + setLineColor: (name) => { + if (!setArenaLineColor([grid.material, ...wallMats], name)) return; + lineColor = name; + setStore({ lineColor: name }); + }, requestLoco: (name) => { if (name !== "legs" && name !== "rollers") return; setStore({ locoWant: name }); reconcileLoco(); }, resetSim, - spawnBall: () => spawnBall(), startEntrance: () => ceremony.startEntrance(), loadCustomPolicy: (ref) => loadCustomPolicyIntoGame(ref), clearCustomPolicy: () => revertCustomPolicy(), @@ -2768,7 +2676,13 @@ async function boot({ controller, kbSource, padSource, - spawnBall, + get interactiveProps() { + return interactiveSpecs.map((spec, i) => ({ + ...spec, + ...propAddresses[i], + })); + }, + setPropsParked, triggerKick, triggerRoll, sessions, @@ -2828,12 +2742,6 @@ async function boot({ toggleHeadMode, headTarget, headSmooth, - get ballActive() { - return ballActive; - }, - get ballQposAdr() { - return ballQposAdr; - }, get chaseCam() { return chaseCam; }, @@ -2884,7 +2792,7 @@ async function boot({ await scheduler.pause(); ceremony.setReveal(1); ceremony.setFx(1); - parkBallPhysics(); + setPropsParked(true); inputLocked = false; controller.setLocked(false); } diff --git a/app/src/robots/microduck/test-oracle.js b/app/src/robots/microduck/test-oracle.js new file mode 100644 index 0000000..f78cd98 --- /dev/null +++ b/app/src/robots/microduck/test-oracle.js @@ -0,0 +1,20 @@ +// Archived policy goldens were recorded with exactly one parked sphere. +// Extra free DOFs change MuJoCo floating-point accumulation (especially +// wheel contact), even when the new toys are parked far away. Reproduce +// that original laboratory world ONLY for ?test=1&oracle=legacy. Normal +// simulation and scene-interaction tests always use the 5–7 toy layout. +export function originalPhysicsProbe() { + return [ + { + name: "interactive_0", + type: "sphere", + size: [0.05], + pos: [50, 0, 0.05], + quat: [1, 0, 0, 0], + mass: 0.03, + friction: "0.4 0.01 0.003", + solref: "0.03 0.4", + color: 0xf2efe8, + }, + ]; +} diff --git a/app/src/scene/GameCanvas.jsx b/app/src/scene/GameCanvas.jsx index 30ef7d0..04e2c9a 100644 --- a/app/src/scene/GameCanvas.jsx +++ b/app/src/scene/GameCanvas.jsx @@ -17,7 +17,7 @@ function Game() { room.dispose(); pmrem.dispose(); scene.environment = environment.texture; - scene.environmentIntensity = 0.45; + scene.environmentIntensity = 0.7; bootLog.length = 0; const manager = new RuntimeManager({ scene, @@ -44,7 +44,7 @@ function Game() { for (const method of [ "setVariant", "requestLoco", - "spawnBall", + "setLineColor", "loadCustomPolicy", "clearCustomPolicy", "triggerAction", @@ -68,20 +68,21 @@ function Game() { }, [scene, camera, gl]); useEffect(() => { scene.background = new THREE.Color( - theme === "neutral" ? 0x18202b : 0x08080c, + theme === "neutral" ? 0x18202b : 0x151923, ); gl.setClearColor(scene.background, 1); }, [scene, gl, theme]); useFrame((_, dt) => gameApi.frame?.(Math.min(dt, 0.05))); return ( <> - - - + + + + ); diff --git a/app/src/store.js b/app/src/store.js index b00accf..3b2e18f 100644 --- a/app/src/store.js +++ b/app/src/store.js @@ -38,6 +38,7 @@ export const useGame = create( locoSwitching: false, rollersLoading: false, // OSD line while the roller stack streams in variant: "classic", + lineColor: "classic", // Community move: null = all-official slots. Written by the game // (game.js loadCustomPolicyIntoGame / the watchdog) and by App.jsx for // the boot-time ?move= request. @@ -47,7 +48,6 @@ export const useGame = create( customPolicy: null, padConnected: false, touchMode: false, - ballActive: false, // Throttled telemetry block (4 Hz), bottom-right OSD telemetry: { fps: 0, ctrlHz: 0, speed: 0, odo: 0, peers: 0 }, })), diff --git a/app/src/ui/ControlsHelp.jsx b/app/src/ui/ControlsHelp.jsx index 289435d..f958fd3 100644 --- a/app/src/ui/ControlsHelp.jsx +++ b/app/src/ui/ControlsHelp.jsx @@ -125,7 +125,7 @@ export default function ControlsHelp() { {physicalDrag && ( <>
- Drag robot / ball: apply force + Drag robot / geometry: apply force )} diff --git a/app/src/ui/Hud.jsx b/app/src/ui/Hud.jsx index 39bc598..5f9ea65 100644 --- a/app/src/ui/Hud.jsx +++ b/app/src/ui/Hud.jsx @@ -182,7 +182,8 @@ const hudHitSx = { }; function Quickbar() { - const variant = useGame((s) => s.variant); + const lineColor = useGame((s) => s.lineColor); + const duckControls = useGame((s) => s.runtimeCapabilities.duckControls); const locoWant = useGame((s) => s.locoWant); return ( - + {Object.entries(VARIANT_SWATCH_HEX).map(([name, hex]) => { - const selected = name === variant; + const selected = name === lineColor; const label = VARIANT_LABELS[name] ?? name; return ( { uiClick(); gameApi.setVariant?.(name); }} + onClick={() => { + uiClick(); + gameApi.setLineColor?.(name); + }} sx={{ appearance: "none", width: CELL_H, // square cell inside frame + padding @@ -241,55 +245,64 @@ function Quickbar() { outline: `2px dashed ${CREAM}`, outlineOffset: -5, }, - "@media (prefers-reduced-motion: reduce)": { animation: "none" }, + "@media (prefers-reduced-motion: reduce)": { + animation: "none", + }, }} /> ); })} - - - {[ - { name: "legs", label: "Feet" }, - { name: "rollers", label: "Rollers" }, - ].map(({ name, label }) => { - const selected = locoWant === name; - return ( - { uiClick(); gameApi.requestLoco?.(name); }} - sx={{ - ...hudHitSx, - px: "1.05rem", - background: selected ? ORANGE : "transparent", - color: selected ? COMIC_INK : "rgba(250, 248, 242, 0.72)", - "&:hover": { - color: selected ? COMIC_INK : CREAM, - background: selected ? ORANGE : "rgba(255, 122, 47, 0.12)", - }, - "&:active": { filter: "brightness(0.92)" }, - }} - > - {label} - - ); - })} - - - + {duckControls && ( + + + {[ + { name: "legs", label: "Feet" }, + { name: "rollers", label: "Rollers" }, + ].map(({ name, label }) => { + const selected = locoWant === name; + return ( + { + uiClick(); + gameApi.requestLoco?.(name); + }} + sx={{ + ...hudHitSx, + px: "1.05rem", + background: selected ? ORANGE : "transparent", + color: selected ? COMIC_INK : "rgba(250, 248, 242, 0.72)", + "&:hover": { + color: selected ? COMIC_INK : CREAM, + background: selected + ? ORANGE + : "rgba(255, 122, 47, 0.12)", + }, + "&:active": { filter: "brightness(0.92)" }, + }} + > + {label} + + ); + })} + + + )} + {duckControls && } {/* Sound is fully disabled for now (SOUND_DISABLED in audio.js) - the mute toggle comes back with the finished sound design. */} {/* */} @@ -307,10 +320,15 @@ function PolicyChip() { if (cp?.status !== "active") return null; const title = cp.title || cp.name; const by = cp.author ? ` by ${cp.author}` : ""; - const hint = cp.slot === "trick" || cp.slot === "script" || cp.slot === "sitstand" ? " \u00b7 R" : ""; + const hint = + cp.slot === "trick" || cp.slot === "script" || cp.slot === "sitstand" + ? " \u00b7 R" + : ""; return ( - + { uiClick(); gameApi.clearCustomPolicy?.(); }} + onClick={() => { + uiClick(); + gameApi.clearCustomPolicy?.(); + }} sx={{ ...hudHitSx, px: "0.6rem", @@ -388,7 +409,8 @@ function SoundToggle() { function Telemetry() { const t = useGame((s) => s.telemetry); - const odo = t.odo < 1000 ? `${t.odo.toFixed(1)}M` : `${(t.odo / 1000).toFixed(2)}KM`; + const odo = + t.odo < 1000 ? `${t.odo.toFixed(1)}M` : `${(t.odo / 1000).toFixed(2)}KM`; const lines = []; if (t.peers) lines.push(`${t.peers + 1} ONLINE`); lines.push(`${t.speed.toFixed(2)}M/S \u00b7 ODO ${odo}`); @@ -446,7 +468,11 @@ function OsdLoad() { {l} {"\u2588"} @@ -500,19 +526,22 @@ function PolicyToast() { } export default function Hud() { - const ready = useGame((s) => s.runtimePhase === 'ready'); + const ready = useGame((s) => s.runtimePhase === "ready"); const touchMode = useGame((s) => s.touchMode); const duckControls = useGame((s) => s.runtimeCapabilities.duckControls); + const environmentControls = useGame( + (s) => s.runtimeCapabilities.environmentControls, + ); if (!ready) return null; - if (!duckControls) return ; + if (!duckControls && !environmentControls) return ; return ( <> {!touchMode && ( <> - - + {duckControls && } + {duckControls && } )} diff --git a/app/test/fixtures/microduck/README.md b/app/test/fixtures/microduck/README.md index ab8e9a7..0c1e186 100644 --- a/app/test/fixtures/microduck/README.md +++ b/app/test/fixtures/microduck/README.md @@ -35,6 +35,8 @@ not proof that every possible long-running skill sequence is covered. After the user-requested expansion to a 4.5 m default arena, this original-code oracle explicitly pins the **original 3 m World** through a test-only World response override. The production default remains 4.5 m, tested independently in `bounded-world.spec.js`. No accepted trajectory or tolerance was replaced to hide the intentional World-size change. +After replacing the production football with 5–7 random free-body geometries, the archived oracle additionally uses **`?test=1&oracle=legacy`**. `src/robots/microduck/test-oracle.js` supplies the original single parked sphere's dimensions, mass and contact parameters, with no football texture or gameplay. This keeps the oracle's model DOF count and floating-point accumulation unchanged; the nine accepted trajectories and exact comparisons remain untouched. `?test=1` alone still builds the real 5–7 toy scene; `prepareTest()` parks those toys for isolated stepping, and `scene-interaction.spec.js` explicitly restores them for real collision / drag tests. Production never selects the legacy probe unless both explicit test parameters are present. The Microduck composer fixes `jacobian="dense"` to retain the original solver path when the added toy DOFs cross MuJoCo's automatic sparse threshold. + `npm run test:regression` reads these files. `npm run baseline:record` writes candidate files under ignored `test-results/baseline-candidates/`, never here. A baseline replacement needs an explicit reviewed cause and updated provenance. diff --git a/app/test/interactive-props.test.js b/app/test/interactive-props.test.js new file mode 100644 index 0000000..03c3a46 --- /dev/null +++ b/app/test/interactive-props.test.js @@ -0,0 +1,141 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import * as THREE from "three"; +import { + generateInteractiveProps, + createInteractivePropVisuals, + resetProp, +} from "../src/game/interactive-props.js"; +import { setArenaLineColor } from "../src/game/worlds/arena/line-color.js"; +import { + makeInfiniteGrid, + makeArenaWalls, +} from "../src/game/worlds/arena/render.js"; +import { VARIANT_SWATCH_HEX } from "../src/game/variants.js"; + +function rng(seed) { + return () => (seed = (1664525 * seed + 1013904223) >>> 0) / 4294967296; +} + +test("random layouts have 5–7 varied, separated, lightweight toys inside walls and clear of spawn", () => { + const counts = new Set(); + for (let seed = 0; seed < 1000; seed++) { + for (const halfExtent of [1.5, 2.25]) { + const specs = generateInteractiveProps({ + halfExtent, + spawn: [-0.6, 0, 0.12], + random: rng(seed * 7919), + }); + counts.add(specs.length); + assert.ok(specs.length >= 5 && specs.length <= 7); + assert.equal(new Set(specs.map((p) => p.type)).size, 4); + assert.equal(new Set(specs.map((p) => p.name)).size, specs.length); + assert.ok(specs[0].pos[0] > -0.3 && specs[0].pos[0] < 0.25); + for (const [i, spec] of specs.entries()) { + assert.ok(spec.mass >= 0.04 && spec.mass <= 0.08); + assert.ok(Math.abs(spec.pos[0]) < halfExtent - 0.1); + assert.ok(Math.abs(spec.pos[1]) < halfExtent - 0.1); + assert.ok(Math.hypot(spec.pos[0] + 0.6, spec.pos[1]) > 0.34); + for (const other of specs.slice(i + 1)) + assert.ok( + Math.hypot(spec.pos[0] - other.pos[0], spec.pos[1] - other.pos[1]) > + 0.3, + ); + } + } + } + assert.deepEqual([...counts].sort(), [5, 6, 7]); + assert.notDeepEqual( + generateInteractiveProps({ + halfExtent: 2.25, + spawn: [-0.6, 0], + random: rng(1), + }), + generateInteractiveProps({ + halfExtent: 2.25, + spawn: [-0.6, 0], + random: rng(2), + }), + ); +}); + +test("visual geometry matches MJCF dimensions, poses sync through Z-up root, reset clears only prop DOFs", () => { + const specs = generateInteractiveProps({ + halfExtent: 2.25, + spawn: [-0.6, 0], + random: rng(1), + }); + const view = createInteractivePropVisuals(specs); + const addresses = specs.map((_, i) => ({ + qAdr: 7 + i * 7, + dofAdr: 6 + i * 6, + })); + const data = { + qpos: new Float64Array(7 + specs.length * 7).fill(123), + qvel: new Float64Array(6 + specs.length * 6).fill(42), + }; + specs.forEach((spec, i) => resetProp(data, addresses[i], spec)); + view.sync(data, addresses); + view.root.updateMatrixWorld(true); + view.meshes.forEach((mesh, i) => { + assert.equal(mesh.name, specs[i].name); + assert.equal(mesh.userData.interactiveIndex, i); + assert.deepEqual( + mesh + .getWorldPosition(new THREE.Vector3()) + .toArray() + .map((v) => +v.toFixed(6)), + [specs[i].pos[0], specs[i].pos[2], -specs[i].pos[1]].map( + (v) => +v.toFixed(6), + ), + ); + mesh.geometry.computeBoundingBox(); + const size = mesh.geometry.boundingBox.getSize(new THREE.Vector3()); + const spec = specs[i]; + const height = + 2 * + (spec.type === "sphere" + ? spec.size[0] + : spec.type === "capsule" + ? spec.size[0] + spec.size[1] + : spec.size.at(-1)); + assert.ok(Math.abs(size.z - height) < 1e-7); + }); + assert.deepEqual(Array.from(data.qpos.slice(0, 7)), Array(7).fill(123)); + assert.deepEqual(Array.from(data.qvel.slice(0, 6)), Array(6).fill(42)); + assert.ok(Array.from(data.qvel.slice(6)).every((v) => v === 0)); + resetProp(data, addresses[0], specs[0], true, 0); + view.sync(data, addresses, false); + assert.equal(view.root.visible, false); + assert.equal(data.qpos[addresses[0].qAdr], 50); + for (const mesh of view.meshes) { + mesh.geometry.dispose(); + mesh.material.dispose(); + } +}); + +test("the original four swatches tint floor AND all walls without altering fades or reveal", () => { + const grid = makeInfiniteGrid({ subdivisions: 1 }); + const { wallMats, wallMeshes } = makeArenaWalls(); + const materials = [grid.material, ...wallMats]; + for (const [name, hex] of Object.entries(VARIANT_SWATCH_HEX)) { + assert.equal(setArenaLineColor(materials, name), true); + for (const mat of materials) { + assert.equal( + mat.uniforms.uSectionColor.value.getHexString(), + hex.slice(1), + ); + assert.equal(mat.uniforms.uReveal.value, 0); + assert.ok( + mat.uniforms.uCellColor.value.equals( + mat.uniforms.uSectionColor.value.clone().multiplyScalar(0.55), + ), + ); + } + } + assert.equal(setArenaLineColor(materials, "unknown"), false); + for (const mesh of [grid, ...wallMeshes]) { + mesh.geometry.dispose(); + mesh.material.dispose(); + } +}); diff --git a/app/test/rp1-visuals.test.js b/app/test/rp1-visuals.test.js new file mode 100644 index 0000000..08e5451 --- /dev/null +++ b/app/test/rp1-visuals.test.js @@ -0,0 +1,108 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import fs from "node:fs/promises"; +import { createHash } from "node:crypto"; +import { validateBodyGlb } from "../src/platform/render/BodyVisuals.js"; +import { validatePackage } from "../src/platform/loader/SchemaValidator.js"; + +const root = new URL("../public/robots/rp1/", import.meta.url); +const config = JSON.parse(await fs.readFile(new URL("robot.json", root))); +const manifest = JSON.parse( + await fs.readFile(new URL("visual-source-manifest.json", root)), +); +const load = async (path) => { + const b = await fs.readFile(new URL(path, root)); + return validateBodyGlb( + b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength), + ); +}; + +test("RP1 maps all 63 supplied parts exactly once onto 25 visual-only body attachments", async () => { + validatePackage(config); + assert.equal(config.render.body_visuals.length, 25); + assert.equal(manifest.input_files.length, 63); + const parts = Object.values(manifest.body_mapping).flatMap((m) => m.parts); + assert.equal(parts.length, 63); + assert.equal(new Set(parts).size, 63); + let normals = 0, + colourTextures = 0, + emissive = 0; + for (const spec of config.render.body_visuals) { + assert.ok(!config.assets.some((a) => a.path === spec.path)); + assert.deepEqual(spec.quaternion, [Math.SQRT1_2, 0, 0, Math.SQRT1_2]); + const doc = await load(spec.path); + for (const mat of doc.materials) { + if (mat.normalTexture) { + normals++; + assert.ok(doc.textures[mat.normalTexture.index]); + } + if (mat.pbrMetallicRoughness?.baseColorTexture) colourTextures++; + if (mat.extensions?.KHR_materials_emissive_strength?.emissiveStrength > 1) + emissive++; + } + for (const texture of doc.textures) assert.ok(doc.images[texture.source]); + if (spec.body.endsWith("_wrist_link")) { + const wrappers = doc.nodes.filter((n) => n.extras?.sourcePart); + assert.equal(wrappers.length, 20); + assert.equal(new Set(wrappers.map((n) => n.extras.sourcePart)).size, 20); + assert.deepEqual( + wrappers.map((n) => n.extras.sourcePart).sort(), + [...manifest.body_mapping[spec.body].parts].sort(), + ); + } + } + assert.ok(normals >= 63); + assert.ok(colourTextures >= 1, "face screen texture retained"); + assert.ok(emissive >= 1, "torso logo emissive strength retained"); +}); + +test("23 unchanged body shapes align exactly with original STL bounds after Y-up conversion", async () => { + for (const { body, path } of config.render.body_visuals.filter( + (s) => !s.body.endsWith("_wrist_link"), + )) { + const doc = await load(path), + lo = [Infinity, Infinity, Infinity], + hi = [-Infinity, -Infinity, -Infinity]; + for (const mesh of doc.meshes) + for (const p of mesh.primitives) { + const a = doc.accessors[p.attributes.POSITION]; + for (let i = 0; i < 3; i++) { + lo[i] = Math.min(lo[i], a.min[i]); + hi[i] = Math.max(hi[i], a.max[i]); + } + } + const transformed = [lo[0], -hi[2], lo[1], hi[0], -lo[2], hi[1]]; + const stl = await fs.readFile(new URL(`meshes/${body}.STL`, root)); + const expected = [ + Infinity, + Infinity, + Infinity, + -Infinity, + -Infinity, + -Infinity, + ]; + for (let t = 0; t < stl.readUInt32LE(80); t++) + for (let v = 0; v < 3; v++) + for (let axis = 0; axis < 3; axis++) { + const x = stl.readFloatLE(84 + t * 50 + 12 + v * 12 + axis * 4); + expected[axis] = Math.min(expected[axis], x); + expected[axis + 3] = Math.max(expected[axis + 3], x); + } + assert.deepEqual(transformed, expected, body); + } +}); + +test("original model, physics meshes, policies/motions and imported visual provenance retain reviewed hashes", async () => { + const physical = JSON.parse( + await fs.readFile(new URL("source-manifest.json", root)), + ); + for (const file of [...physical.files, ...manifest.files]) { + assert.equal( + createHash("sha256") + .update(await fs.readFile(new URL(file.file, root))) + .digest("hex"), + file.sha256, + file.file, + ); + } +}); diff --git a/app/test/session-environment.test.js b/app/test/session-environment.test.js new file mode 100644 index 0000000..9aaad3a --- /dev/null +++ b/app/test/session-environment.test.js @@ -0,0 +1,36 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { createSessionEnvironment } from "../src/game/worlds/arena/session-environment.js"; + +const world = (scale) => ({ + presentation: "arena-grid", + boundary: { half_extent: 2.25 * scale }, +}); +test("all robot sizes share one random layout, with scaled geometry and spawn clearances", () => { + let seed = 42; + const scene = createSessionEnvironment( + () => (seed = (1664525 * seed + 1013904223) >>> 0) / 4294967296, + ); + const duck = scene.propsFor(world(1)); + for (const scale of [1, 0.33 / 0.27, 1.32 / 0.27]) { + const props = scene.propsFor(world(scale)); + assert.equal(props.length, duck.length); + props.forEach((p, i) => { + assert.equal(p.type, duck[i].type); + assert.equal(p.color, duck[i].color); + p.pos.forEach((v, j) => + assert.ok(Math.abs(v / scale - duck[i].pos[j]) < 1e-12), + ); + p.size.forEach((v, j) => + assert.ok(Math.abs(v / scale - duck[i].size[j]) < 1e-12), + ); + assert.ok(Math.hypot(p.pos[0] / scale, p.pos[1] / scale) > 0.34); + assert.ok(Math.hypot(p.pos[0] / scale + 0.6, p.pos[1] / scale) > 0.34); + }); + } + const copy = scene.propsFor(world(1)); + copy[0].pos[0] = 100; + copy[0].quat[0] = 0; + assert.deepEqual(scene.propsFor(world(1)), duck); + assert.deepEqual(scene.propsFor({ type: "flat" }), []); +}); diff --git a/docs/robots/rp1.md b/docs/robots/rp1.md index 036858c..b5e0493 100644 --- a/docs/robots/rp1.md +++ b/docs/robots/rp1.md @@ -19,6 +19,23 @@ npm --prefix app run dev -- --host 127.0.0.1 **限制:完整舞蹈参考长 131.46 秒;旧版 model_7999 的长程测试在参考帧 994(约 19.9 秒)失稳。新版 model_23998 目前只验证并开放前 10 秒,完整时长尚未重新验收,不自动延长 duration。** 训练完成不等于任意长度播放已收敛;不能仅延长 duration 就宣称稳定。 +## GLB 材质与外观 + +已接入用户提供的 `RP1机器人glb.zip`:白/灰/蓝 PBR 材质、法线贴图、面部屏幕和发光标识均保留。63 个部件映射到现有 25 个物理 body,物理模型仍为 24 自由度;23 个 body 直接使用原 GLB,双手各 20 个部件按原始固定手 URDF 组合到手腕 body。手指随手腕整体运动,不新增独立手指控制,也不改变行走、舞蹈或挥手策略。 + +模型 XML、原始碰撞体、惯性、关节及全部 ONNX / motion 文件不变;仅新增 `render.body_visuals`。原 GLB 为 Y-up,绑定时统一绕 X 轴 +90°,不能当作 Z-up 直接贴到 body。原始 STL 可视 mesh 会隐藏,而不是与新模型重叠绘制。 + +复现导入: + +```bash +python3 app/scripts/import-rp1-visuals.py "/home/cen/Downloads/RP1机器人glb.zip" \ + app/public/robots/rp1/visuals/rp1_hand_fixed.urdf +npm --prefix app run validate:packages +npm --prefix app run test:e2e -- rp1-visuals +``` + +来源和 SHA-256 见 `app/public/robots/rp1/visual-source-manifest.json`;包内未附再分发许可。首次 RP1 加载会额外读取约 93 MB 的自包含 GLB,具体帧率取决于 GPU;本次没有简化或改写用户的网格、贴图和材质。验证记录见 [RP1 GLB 材质替换](../superpowers/verification/rp1-glb-materials.md)。 + ## 已完成权重 均来自 `/home/cen/Embodied_Workspace/Mujoco_Projects/roboparty_train/logs/rsl_rl`,显式选择最终、完整且稳定的文件,不动态追踪目录中的最新文件: diff --git a/docs/superpowers/verification/microduck-scene-interaction.md b/docs/superpowers/verification/microduck-scene-interaction.md new file mode 100644 index 0000000..ccabec1 --- /dev/null +++ b/docs/superpowers/verification/microduck-scene-interaction.md @@ -0,0 +1,38 @@ +# Microduck 场景提亮、线条调色和交互几何体 + +> 本文记录最初的 Microduck 单机器人改动。后续根据“每个机器人的环境都保持一致”的要求,已推广到所有机器人,并改为会话共享布局和全局线条色;当前规则及验证见 [共享环境验证](shared-robot-environment.md)。 + +## 实现范围 + +- `app/src/scene/GameCanvas.jsx`:新增半球补光,提高环境贴图、环境光、主光和侧光强度;漫画场景背景从近黑调整为深蓝灰。没有添加外部光照资源或网络依赖。 +- `app/src/ui/Hud.jsx`、`app/src/game/worlds/arena/line-color.js`:原左下角四个色块改为 **Line color**,仍使用原 Cream / Graphite / Lavender / Sky 色值、尺寸、边框、选中动画和漫画面板。同步改变地板与四面围墙的粗细网格线,不修改机器人或几何体材质。颜色在 reset、feet / rollers 切换和机器人往返切换时保留。 +- `app/src/game/interactive-props.js`、`app/src/game/worlds/arena/compose.js`、`app/src/robots/microduck/runtime.js`:生产场景删除足球刚体、足球纹理渲染、生成逻辑和足球专属音频/拖拽分支,替换为每次新建 Microduck runtime 随机生成的 **5~7 个**轻量几何体,包括方块、球体、圆柱和胶囊体。 +- 几何体具有独立 MuJoCo freejoint、真实质量、摩擦和碰撞;支持机器人推动/踢动、物体间碰撞、地面/围墙碰撞、鼠标弹簧力拖拽与抬起。生成位置互不重叠并避开机器人出生点,至少一个位于机器人附近。reset / locomotion 切换恢复当前布局;重新进入 Microduck 随机生成新布局。越界物体单独复位。 +- 原有足球素材/历史库文件未做无关删除,但生产 runtime 不再加载或创建足球。 + +## 物理与回归说明 + +新增自由刚体会改变 MuJoCo 的 DOF 数。轮滑模型可能跨越自动 sparse Jacobian 阈值,因此显式保留原来的 `jacobian="dense"`,避免几何体数量影响求解路径。 + +九份历史动作轨迹全部保留,未更新基线或放宽浮点比较。`?test=1&oracle=legacy` 专门复现历史回归使用的 3 m 实验场及一个远处停放的无足球纹理球形物理探针,保留原始 DOF 数和接触参数,从而继续精确比对全部状态。正常运行和 `?test=1` 单独使用时都构建真实的 5~7 个几何体场景。新场景的碰撞、鼠标拖拽、物体数量、材质、光照和运行稳定性由独立浏览器测试覆盖,不以历史实验场测试替代。 + +## 验证覆盖 + +- `app/test/interactive-props.test.js`:2,000 个布局(1,000 个随机种子 × 3 m / 4.5 m 两种边界),验证 5/6/7 数量、四种形状、出生点净空、物体间距、边界和质量;验证可视几何体尺寸、Z-up 转换、刚体状态同步与复位;验证四种颜色同步更新地面与四面墙。 +- `app/e2e/scene-interaction.spec.js`:真实 Chromium + MuJoCo WASM,验证新光源与场景初始内容、四个色块外观与功能、机器人材质不变、鼠标物理拖拽、暂停释放抓取力、重置布局、物体间动量传递、机器人/地面碰撞、腿/轮滑切换后的物体数量及状态。 +- `app/e2e/scene-stability.spec.js`:真实新场景中腿/轮滑各 60 秒模拟时间的连续运动,检查状态有限、物体边界、确实产生移动,以及越界物体单独恢复。 +- `app/e2e/deployment.spec.js`:正常生产入口自动显示 5~7 个物体且不存在足球;继续覆盖三种机器人与静态资源路径。 +- `app/e2e/runtime-leaks.spec.js`:20 次机器人切换后检查 WASM 对象释放、GPU 几何体、纹理和事件监听器无增长;对当前 5~7 个物体带来的预期几何体数量差异做精确扣除,而非放宽泄漏上限。 + +## 执行结果 + +- `cd app && npm test`:**62/62 通过**。 +- `npm run validate:packages`:四个 bundled Package 的 schema、World、资源路径与既有来源校验全部通过。 +- `npm run format:check`、`npm run build`、`git diff --check`:通过。 +- `npm run test:e2e`:**48/48 通过**(13.8 分钟;包含九项精确历史动作回归、三机器人场景/动作、20 次资源切换及新场景交互)。该批启动后补充的连续运动用例另外独立执行并通过。 +- 对最终 `dist/` 启动本地 Vite preview,以 `TEST_BASE_URL=http://127.0.0.1:5175 npm run test:e2e -- scene-interaction scene-stability deployment robot-switching microduck-regression --output=/tmp/microduck-scene-production-final-artifacts` 执行生产包复验:**16/16 通过**(2.7 分钟)。覆盖全部新交互、围墙阻挡、正常入口无足球、两分钟新场景模拟运动和九项历史动作精确回归。 +- 人工查看新场景截图:`app/test-results/scene-interaction-overview.png`,确认补光后的机器人及彩色几何体、浅蓝网格线和保留原样的四格色板显示正常。截图属于忽略的本地测试产物,不提交大尺寸图片。 + +日志:`/tmp/microduck-scene-unit-tests.log`、`/tmp/microduck-scene-full-e2e.log`、`/tmp/microduck-scene-production-final-tests.log`。全量浏览器 JSON 结果另存于 `/tmp/microduck-scene-full-results.json`。 + +边界:没有声称执行连续 15 小时实时时长的压力测试;新增长序列检查为真实 WASM 中累计两分钟的模拟运动。 diff --git a/docs/superpowers/verification/rp1-glb-materials.md b/docs/superpowers/verification/rp1-glb-materials.md new file mode 100644 index 0000000..285bcfa --- /dev/null +++ b/docs/superpowers/verification/rp1-glb-materials.md @@ -0,0 +1,64 @@ +# RP1 用户 GLB 材质替换 + +## 输入与范围 + +- 输入:`/home/cen/Downloads/RP1机器人glb.zip`,63 个自包含 GLB,未包含许可文件。 +- ZIP SHA-256:`8610aac8432203bf68d0efe234062c551ca805ebbe72a92d5fc7350730ebdea2`。 +- 仅新增 RP1 `render.body_visuals` 和可视资源;**原 `model.xml`、STL、惯性、碰撞体、24 个驱动关节、ONNX、motion 文件均未修改**。它们仍通过原 `source-manifest.json` 哈希验证。 +- 复用已有 `BodyVisuals` 渲染替换层,没有为本次替换修改共享渲染器、物理引擎或控制器。其他机器人材质、共享环境及色板不受影响。 + +## 坐标与部件适配 + +GLB 来自 Blender,顶点为 Y-up;现有 body 帧为 MuJoCo Z-up。所有挂载使用绕 X 轴 +90° 四元数。对全部 63 个输入 GLB,按此变换得到的包围盒与原始描述仓库对应 STL 包围盒逐项比较,最大差为 **0**。 + +当前训练模型是 25 个 body / 24 个受控关节,而该可视包包括完整的手腕和灵巧手: + +- 23 个普通 body 使用输入 GLB 原始字节,不改颜色或贴图。 +- 每侧手腕合并 20 个输入部件:wrist roll / yaw / pitch 三段、手掌及 16 个手指部件。 +- 按原始 `rp1_hand_fixed.urdf` 的相对原点和固定指节姿态组合;原 24-DOF 手腕对应 wrist-roll,额外 yaw/pitch 轴固定在中立位。 +- 合成 GLB 仅追加可视变换节点并重映射 GLTF 索引;顶点、索引、图像二进制数据以及 PBR 材质内容保留。 +- 最终为 25 个挂载 GLB,共覆盖 63 个输入部件,且每个部件只使用一次。**没有新增手指/手腕物理自由度,也不声称支持独立手指控制**。 +- 新手部的可视细节不会自动改变原训练模型的碰撞包络。 + +`app/scripts/import-rp1-visuals.py` 是可复现导入器;不会解压任意 ZIP 路径,在完成输入和合成输出验证后才写入包目录。`visual-source-manifest.json` 保存所有输入/输出 SHA-256、部件映射和复制的固定手 URDF 哈希。 + +## 已测定量结果 + +真实 Chromium / MuJoCo WASM / Three.js 中: + +| 指标 | 结果 | +|---|---:| +| 可视 body 挂载 | 25 | +| 手腕/手部源变换节点 | 40(每侧 20) | +| 新可视 mesh | 79 | +| 加载的法线贴图材质 | 77 | +| 面部屏幕颜色贴图 | 1 | +| 保留发光强度的标识材质 | 1 | +| 隐藏的原 STL 可视 mesh | 25 | +| body 姿态跟随误差 | 0 | +| 23 个原形状的三维包围盒最大误差 | `1.3124658082563911e-8 m` | +| 双手变换相对独立 URDF 计算最大误差 | `5.551115123125783e-16` | +| 行走观测 / 动作维度 | 243 / 24(不变) | +| MuJoCo actuator 数 | 24(不变) | + +根朝向及所有 24 个关节改变后再次验证上述坐标关系,不仅验证绑定初始姿态。 + +`rp1-visuals.spec.js` 还在同一会话、同一几何体布局和相同输入下,逐项**精确比较**替换前/后 walk / wave / dance 的 qpos、qvel、ctrl、观测、lastAction、状态机及参考帧;无任何容差放宽。部分 GLB 加载失败时旧机器人继续保留,释放候选资源后可直接 retry 成功。 + +## 测试与限制 + +- 新增三个纯逻辑/资源测试与三个真实浏览器测试;首轮全部通过。 +- 所有 PBR 参数及贴图遵循用户原包,不另行重着色或简化。约 93 MB GLB、约 113 万三角形,首次加载量和 GPU 负担增加;不声称在所有设备具有相同帧率。 +- 资源未附许可,继续仅供本地评估;没有推断公开再分发授权,也没有公开发布。 + +## 最终执行结果 + +- `npm test`:**66/66 通过**。 +- `npm run validate:packages`:四个 Package 均通过;RP1 为 58 条资源路径,原始物理/策略及新增 GLB 的来源哈希全部通过。 +- `npm run format:check`、`npm run build`、Python 语法检查、`git diff --check`:通过。 +- `npm run test:e2e`:**55/55 通过**(20.3 分钟)。含原有所有动作、共享环境、实时控制频率、新材质、加载失败恢复、20 次资源释放检查。 +- 20 次机器人切换时,RP1 GPU 资源保持 **125 geometries / 80 textures / 21 listeners**,各次完全相同;旧 model/data 均删除,未增加资源泄漏容差。该用例冷加载约三分钟,为避免新 93 MB 材质包在慢设备上贴近旧超时上限,测试时限单独由 180 秒调为 240 秒,资源断言原样保留。 +- 最终 `dist/` 生产包复验:`TEST_BASE_URL=http://127.0.0.1:5175 npm run test:e2e -- rp1-visuals shared-environment deployment --output=/tmp/rp1-material-production-artifacts`,**7/7 通过**(3.9 分钟)。再次验证坐标/材质、替换前后逐项数值一致性、错误恢复、三机器人共享环境以及静态资源路径。 +- 人工查看前侧材质截图:蓝白灰配色、脸部屏幕、发光标识和双手外观正常;截图为 `/tmp/rp1-material-production-artifacts/rp1-visuals-all-63-RP1-mat-8a18f-ith-original-shapes-aligned/rp1-material-front.png`。对应开发测试截图亦在 `app/test-results/rp1-visuals-all-63-RP1-mat-8a18f-ith-original-shapes-aligned/rp1-material-front.png`。 + +日志:`/tmp/rp1-visuals-unit.log`、`/tmp/rp1-material-full-e2e.log`、`/tmp/rp1-material-production-e2e.log`;全量 JSON 结果另存 `/tmp/rp1-material-full-results.json`。 diff --git a/docs/superpowers/verification/shared-robot-environment.md b/docs/superpowers/verification/shared-robot-environment.md new file mode 100644 index 0000000..dad678f --- /dev/null +++ b/docs/superpowers/verification/shared-robot-environment.md @@ -0,0 +1,36 @@ +# 所有机器人共享环境 + +## 当前规则 + +- Microduck、Microban、RP1 使用相同的补光、环境贴图亮度、背景、网格线色板和漫画式场景显示。 +- **Line color** 在每个机器人界面都可用,仍为原四种色块及原按钮样式;颜色为全局会话设置,从任意机器人更改后切换其他机器人不会恢复成各自旧颜色。 +- 同一浏览器会话只随机生成一套 **5~7 个**交互几何体。各机器人的种类、色彩、旋转及相对布局相同,保留原先的尺寸适配:4.5 m / 5.5 m / 22 m 场地按机器人尺度缩放,几何体大小与坐标同步缩放。质量按尺度平方增长,保持大机器人场景中的物体轻便可推。 +- 默认出生点 `(-0.6, 0)` 和 `(0, 0)` 均预留净空。不同机器人有独立的物理仿真,切换恢复这套共同的初始布局,不跨不同尺度仿真搬运实时物体速度。刷新页面才重新随机布局。 +- 所有机器人都可与几何体真实碰撞、推移;几何体也与地面、墙壁及其他几何体碰撞。鼠标拖动物体或机器人施加物理弹簧力;拖动空白区域仍然旋转相机。暂停、重置、切换及资源清理时释放抓取力。 +- 仅场景控制共用:Microduck 特有的 Feet / Rollers 按钮不会出现在 Microban / RP1 上;机器人动作、策略、关节控制和尺寸缩放契约不变。 +- 显式无边界诊断 World 不添加干扰物;历史 Microduck 动作 oracle 仍保持原始实验模型,以便继续精确对比九份未修改的轨迹基线。 + +## 关键实现 + +- `app/src/game/worlds/arena/session-environment.js`:会话共享模板及统一 MuJoCo 几何体注入。 +- `app/src/game/interactive-props.js`:统一几何体形状、材质、刚体状态同步和资源清理;生成器支持多个出生点净空。 +- `app/src/platform/sim/{SceneComposer,SimCore}.js`:generic 机器人同样包含交互刚体,重置、越界恢复和显式测试隔离。 +- `app/src/platform/runtime/{RobotRuntime,RuntimeManager}.js`:统一线条颜色、几何体渲染、设置传递、物理拖拽和资源所有权。 +- `app/src/platform/input/PhysicsDrag.js`:generic 机器人/几何体的真实拖拽及每个物理子步施力。 +- `app/src/game/worlds/arena/presentation.js`、`app/src/ui/Hud.jsx`:所有机器人共用地面/围墙调色入口,机器人特有操作仍按 capability 控制。 + +## 新增验证 + +- `app/test/session-environment.test.js`:三个机器人比例使用同一模板;坐标、几何体尺寸按同一尺度变化;避开两个出生点;返回值相互隔离、不污染共享模板;诊断 World 不添加物体。 +- `app/e2e/shared-environment.spec.js`:跨 Microduck → Microban → RP1 → Microduck,检查同一几何体数量、形状、颜色、归一化布局、光源及环境亮度,验证全局颜色继承和机器人特有按钮边界。 +- 同一浏览器用例验证 Microban 和 RP1 的真实围墙碰撞、鼠标施力拖拽、暂停清除抓取力和重置布局。 + +## 执行结果 + +- `cd app && npm test`:**63/63 通过**。 +- `npm run format:check`、`npm run validate:packages`、`npm run build`、`git diff --check`:通过。 +- `npm run test:e2e`:**52/52 通过**(15.0 分钟)。没有为障碍物放宽步行/技能断言;Microban 长序列步行、RP1 行走/舞蹈/挥手、九项 Microduck 精确历史回归、新场景交互、两分钟运动稳定性、20 次切换资源释放均通过。 +- 对最终生产包再次执行 `TEST_BASE_URL=http://127.0.0.1:5175 npm run test:e2e -- shared-environment scene-interaction deployment microduck-regression --output=/tmp/shared-environment-production-artifacts`:**16/16 通过**(3.1 分钟)。其中共享颜色测试还覆盖在 RP1 选择 Lavender 后返回 Microduck,验证不会被 Microduck 的旧设置覆盖。 +- 人工查看生产入口的 Microban / RP1 截图,确认两者均显示相同网格、原四格色板及同布局的彩色几何体,机器人自身呈现不变。截图位于 `/tmp/shared-environment-production-artifacts/deployment-deployed-assets-19ea7-l-three-Robot-Packages-boot/`。 + +日志:`/tmp/shared-environment-unit.log`、`/tmp/shared-environment-full-e2e.log`、`/tmp/shared-environment-production-e2e.log`;全量浏览器 JSON 结果另存于 `/tmp/shared-environment-full-results.json`。