| import { pathLength } from "./draft.mjs"; |
| const JOINTS = ["pelvis", "left_hip", "right_hip", "spine1", "left_knee", "right_knee", "spine2", "left_ankle", "right_ankle", "spine3", "left_foot", "right_foot", "neck", "left_collar", "right_collar", "head", "left_shoulder", "right_shoulder", "left_elbow", "right_elbow", "left_wrist", "right_wrist", "left_hand", "right_hand"]; |
| const number = { type: "number" }; |
| const vector = { type: "array", items: number, minItems: 3, maxItems: 3 }; |
| const object = (properties) => ({ type: "object", additionalProperties: false, properties, required: Object.keys(properties) }); |
| const motionSchema = object({ reply: { type: "string" }, plan: { anyOf: [object({ name: { type: "string" }, cycle: number, repeats: { type: "integer" }, followCurve: { type: "boolean" }, speed: number, keyframes: { type: "array", items: object({ time: number, root: vector, joints: { type: "array", items: object({ joint: { type: "string", enum: JOINTS }, rotation: vector }) } }) } }), { type: "null" }] } }); |
| const vec = (v) => Array.isArray(v) && v.length === 3 && v.every((n) => Number.isFinite(n)); |
| function validateCurves(curves) { |
| if (!Array.isArray(curves) || curves.length > 32) throw Error("At most 32 saved curves are supported"); |
| const ids = new Set(); |
| for (const c of curves) { |
| if (!c || typeof c.id !== "string" || !/^[a-zA-Z0-9_-]{1,80}$/.test(c.id) || ids.has(c.id) || !["floor2d", "space3d"].includes(c.mode)) throw Error("Invalid curve identifier"); |
| ids.add(c.id); |
| if (!Array.isArray(c.points) || c.points.length < 2 || c.points.length > 512 || c.points.some((p) => !vec(p) || p.some((n) => Math.abs(n) > 100)) || pathLength(c.points) < 0.15 || pathLength(c.points) > 30.01) throw Error("Curves require a continuous valid stroke between 0.15 and 30 meters"); |
| if (c.mode === "floor2d" && c.points.some((p) => Math.abs(p[1] - c.points[0][1]) > 0.05)) throw Error("Floor curves must stay on the same plane"); |
| } |
| return curves; |
| } |
| function validateMotionPlan(p) { |
| if (!p || p.schema !== "vrbuild-motion-plan/1" || typeof p.name !== "string" || p.name.length > 120 || !Number.isFinite(p.cycle) || p.cycle < 0.25 || p.cycle > 12 || !Number.isInteger(p.repeats) || p.repeats < 1 || p.repeats > 120 || !Number.isFinite(p.duration) || p.duration < 0.25 || p.duration > 60) throw Error("Invalid generated motion duration or name"); |
| if (!Array.isArray(p.keyframes) || p.keyframes.length < 2 || p.keyframes.length > 32) throw Error("Motion requires 2 to 32 keyframes"); |
| let previous = -1; |
| for (const f of p.keyframes) { |
| if (!Number.isFinite(f.time) || f.time <= previous || f.time < 0 || f.time > p.cycle || !vec(f.root) || f.root.some((n) => Math.abs(n) > 2) || !Array.isArray(f.joints) || f.joints.length > 24) throw Error("Invalid generated motion keyframe"); |
| previous = f.time; |
| const names = new Set(); |
| for (const j of f.joints) { |
| if (!JOINTS.includes(j.joint) || names.has(j.joint) || !vec(j.rotation) || j.rotation.some((n) => Math.abs(n) > 180)) throw Error("Invalid generated joint motion"); |
| names.add(j.joint); |
| } |
| } |
| if (p.keyframes[0].time !== 0 || Math.abs(p.keyframes.at(-1).time - p.cycle) > 1e-3) throw Error("Keyframes must span the entire motion cycle"); |
| if (p.trajectory) { |
| validateCurves([p.trajectory]); |
| if (!Number.isFinite(p.trajectory.speed) || p.trajectory.speed < 0.1 || p.trajectory.speed > 2) throw Error("Curve speed must be between 0.1 and 2 meters per second"); |
| } |
| const expected = p.trajectory ? pathLength(p.trajectory.points) / p.trajectory.speed : p.cycle * p.repeats; |
| if (Math.abs(expected - p.duration) > 1e-3) throw Error("Motion duration does not match its trajectory"); |
| return p; |
| } |
| function compileMotion(result, scene, actorId, curveId) { |
| if (!result || typeof result.reply !== "string" || result.reply.length > 3e3) throw Error("Invalid Agent reply"); |
| const actor = scene.actors?.find((a) => a.id === actorId); |
| if (!actor) throw Error("Select one actor first"); |
| if (result.plan === null) return null; |
| const raw = result.plan; |
| let trajectory = null; |
| if (typeof raw.followCurve !== "boolean") throw Error("Invalid motion trajectory instruction"); |
| if (raw.followCurve) { |
| const curve = scene.curves?.find((c) => c.id === curveId); |
| if (!curve) throw Error("Draw and save a curve before requesting movement along it"); |
| trajectory = { ...structuredClone(curve), speed: raw.speed }; |
| } |
| const duration = trajectory ? pathLength(trajectory.points) / trajectory.speed : raw.cycle * raw.repeats; |
| const plan = { schema: "vrbuild-motion-plan/1", name: raw.name, cycle: raw.cycle, repeats: raw.repeats, duration, keyframes: structuredClone(raw.keyframes), trajectory }; |
| return validateMotionPlan(plan); |
| } |
| function applyActorMotion(scene, { actorId, plan }) { |
| validateMotionPlan(plan); |
| if (!scene.actors?.some((a) => a.id === actorId)) throw Error("The actor no longer exists"); |
| const next = structuredClone(scene); |
| next.actors = next.actors.map((a) => a.id === actorId ? { ...a, motionId: null, motionPlan: structuredClone(plan) } : a); |
| if (next.behaviors?.path?.actorIds.includes(actorId)) { |
| delete next.behaviors.path; |
| delete next.behaviors.binding; |
| } |
| return next; |
| } |
| function sampleMotion(plan, seconds) { |
| const time = Math.max(0, Math.min(seconds, plan.duration)); |
| const t = time >= plan.duration ? plan.cycle : time % plan.cycle; |
| let b = plan.keyframes.findIndex((f) => f.time >= t); |
| if (b < 0) b = plan.keyframes.length - 1; |
| const a = Math.max(0, b - 1), fa = plan.keyframes[a], fb = plan.keyframes[b], u = a === b ? 0 : (t - fa.time) / (fb.time - fa.time), alpha = u * u * (3 - 2 * u); |
| const root = fa.root.map((v, i) => v + (fb.root[i] - v) * alpha); |
| let position = null, yaw = null; |
| if (plan.trajectory) { |
| const { points, speed } = plan.trajectory; |
| let remaining = Math.min(time * speed, pathLength(points)); |
| for (let i = 1; i < points.length; i++) { |
| const p = points[i - 1], q = points[i], length = Math.hypot(...q.map((n, k) => n - p[k])); |
| if (remaining <= length || i === points.length - 1) { |
| const f = length ? Math.min(1, remaining / length) : 0; |
| position = p.map((n, k) => n + (q[k] - n) * f); |
| if (Math.hypot(q[0] - p[0], q[2] - p[2]) > 1e-5) yaw = Math.atan2(q[0] - p[0], q[2] - p[2]); |
| break; |
| } |
| remaining -= length; |
| } |
| } |
| return { a: fa, b: fb, alpha, root, position, yaw }; |
| } |
| export { |
| JOINTS, |
| applyActorMotion, |
| compileMotion, |
| motionSchema, |
| sampleMotion, |
| validateCurves, |
| validateMotionPlan |
| }; |
|
|
