| import {languagePattern} from "../../shared/language.mjs"; |
| import { entityLabel } from "../../shared/entity-label.mjs"; |
| import * as THREE from "three"; |
| import { setApiSession } from "../api.mjs"; |
| import { applyCinema, isCamera, isLight, isRig, objectQuaternion, editableControls, curvePoints, groundCreateCommand } from "../../shared/cinema.mjs"; |
| import { createTriggerRegionLayer } from "./trigger-region-layer.mjs"; |
| import { createCinemaLayer } from "./cinema-layer.mjs"; |
| import { createVirtualScene, applyRecordedTransforms } from "./virtual-video.mjs"; |
| import { createActorLayer } from "./actor-view.mjs"; |
| import { productionSpecialist } from "../../shared/production-intent.mjs"; |
| import { previewScope, isolatePreviewActors } from "../../shared/preview-scope.mjs"; |
| import { uprightMonitorPose } from "../../shared/monitor-pose.mjs"; |
| import { createTrackTriggerRuntime } from "../../shared/track-triggers.mjs"; |
| import { cameraViewIntent } from "../../shared/camera-view-intent.mjs"; |
| function createProductionStudio({ world, scene, renderer, api, getState, getSelection, getView, getSpatialKey, getMeshes, pickGround = () => null, canCreate = () => true, canMonitor = () => true, assets, onState, onPreview, onChange, onSelect = () => { |
| }, onPlay, notice, hideMenu, pauseScene, transport }) { |
| let editing = false, session = null, transitioning = false, editor = null, pending = null, saving = false, request = null, monitor = null, selectedCamera = null, playing = false, time = 0, lastMonitor = 0, definitionKey = "", speed = 0.5, neutral = false; |
| const triggerRuntime = createTrackTriggerRuntime(); |
| let triggerKey = "", triggerStatusKey = ""; |
| const regionLayer = createTriggerRegionLayer(world), rig = createCinemaLayer(world), guides = new THREE.Group(); |
| world.add(guides); |
| let hasPlayed = false, focusIds = [], activeScope = null, modeTransition = null, previewRevision = null; |
| const vec = (p) => new THREE.Vector3(...p), quat = (q) => new THREE.Quaternion(...q); |
| const state = () => getState(), definition = () => pending?.scene || state().scene; |
| const changed = () => onChange(); |
| const focus = () => previewScope(state().scene, editing ? getSelection() : focusIds); |
| const requestPlay = (options) => onPlay ? onPlay(options) : play(options); |
| function clearGuides() { |
| for (const o of [...guides.children]) { |
| o.geometry?.dispose(); |
| o.material?.dispose(); |
| guides.remove(o); |
| } |
| } |
| function dirty() { |
| return !!editor || !!pending; |
| } |
| function requireEdit() { |
| if (!editing || session?.mode !== "edit" || transitioning) throw Error("Enter edit mode first."); |
| closeMonitor(); |
| } |
| function transformable() { |
| return editor?.type === "poses"; |
| } |
| function savedCameras() { |
| return state().scene.objects.filter(isCamera); |
| } |
| function closeMonitor() { |
| if (!monitor) return; |
| scene.remove(monitor.screen); |
| monitor.screen.geometry.dispose(); |
| monitor.screen.material.dispose(); |
| monitor.target.dispose(); |
| monitor.actors.dispose(); |
| monitor.content.userData.cinema?.dispose(); |
| monitor.flood?.dispose(); |
| monitor.content.traverse((o) => { |
| o.geometry?.dispose(); |
| o.material?.dispose(); |
| }); |
| monitor = null; |
| changed(); |
| } |
| async function syncMode(next) { |
| transitioning = true; |
| changed(); |
| try { |
| session = await api("/api/authoring/session", { ...session ? { id: session.id, epoch: session.epoch } : {}, mode: next }); |
| setApiSession(session); |
| } catch (error) { |
| session = null; |
| setApiSession(null); |
| notice("Mode sync failed. Refresh and retry: " + error.message); |
| throw error; |
| } finally { |
| transitioning = false; |
| changed(); |
| } |
| } |
| function cancel() { |
| if (saving) { |
| notice("Saving. Undo will be available when finished."); |
| return; |
| } |
| const hadPreview = !!pending; |
| if (request) api("/api/cinema/cancel", {}).catch(() => { |
| }); |
| request?.abort(); |
| request = null; |
| editor = null; |
| pending = null; |
| clearGuides(); |
| if (hadPreview) onPreview(null); |
| neutral = false; |
| changed(); |
| } |
| function selectCamera(id) { |
| const list = savedCameras(); |
| if (!list.length) throw Error("Create and save a virtual camera first."); |
| const selected = editing ? list.find((c) => getSelection().includes(c.id)) : null; |
| const target = id ? list.find((c) => c.id === id) : selected || list.find((c) => c.id === selectedCamera) || list[0]; |
| if (!target) throw Error("Select a saved scene camera."); |
| selectedCamera = target.id; |
| return target; |
| } |
| function openMonitor(id) { |
| if (!session || !["edit", "explore"].includes(session.mode) || dirty() || transitioning || saving || !canMonitor()) throw Error("A Save or B Cancel the current edit before viewing a saved camera."); |
| const camera = selectCamera(id); |
| closeMonitor(); |
| world.updateMatrixWorld(true); |
| const content = createVirtualScene(state().scene, world.matrixWorld), actors = createActorLayer(content.userData.contentWorld, assets), flood = content.userData.flood; |
| const target = new THREE.WebGLRenderTarget(768, 432), screen = new THREE.Mesh(new THREE.PlaneGeometry(1.08, 0.6075), new THREE.MeshBasicMaterial({ map: target.texture, toneMapped: false, side: THREE.DoubleSide, depthTest: false, depthWrite: false })); |
| screen.renderOrder = 18; |
| scene.add(screen); |
| monitor = { content, actors, flood, target, screen, revision: state().revision, key: getSpatialKey() }; |
| recenterMonitor(); |
| hideMenu(); |
| notice(`${entityLabel(camera)} · A Recenter · B Close · Save camera edits before reopening`); |
| changed(); |
| } |
| function recenterMonitor() { |
| if (!monitor) return false; |
| const view = getView(), pose = uprightMonitorPose(view.getWorldPosition(new THREE.Vector3()).toArray(), view.getWorldQuaternion(new THREE.Quaternion()).toArray(), monitor.yaw || 0); |
| monitor.screen.position.fromArray(pose.position); |
| monitor.screen.quaternion.fromArray(pose.quaternion); |
| monitor.yaw = pose.yaw; |
| monitor.screen.updateMatrixWorld(true); |
| changed(); |
| return true; |
| } |
| function adjustCamera() { |
| const id = selectedCamera; |
| requireEdit(); |
| if (!id) throw Error("Select a saved camera first."); |
| onSelect(id); |
| startPoses(); |
| } |
| function cameraStep(delta) { |
| const list = savedCameras(); |
| if (!list.length) return openMonitor(); |
| const index = list.findIndex((c) => c.id === selectedCamera); |
| selectedCamera = list[(index + delta + list.length) % list.length].id; |
| if (!monitor) openMonitor(selectedCamera); |
| else { |
| notice("Current camera: " + entityLabel(list.find((c) => c.id === selectedCamera))); |
| changed(); |
| } |
| } |
| function startPoses() { |
| requireEdit(); |
| if (dirty() || saving || request) throw Error("Save or cancel the current operation first."); |
| const targets = [...state().scene.objects, ...state().scene.actors || []].filter((o) => getSelection().includes(o.id)); |
| if (!targets.length) throw Error("Select an object first."); |
| if (targets.some((o) => o.editable !== true && (o.id === "ground" || o.category === "structure" || /^(wall|ceiling)(_|-|$)/.test(o.id)))) throw Error("Reference structure is locked."); |
| pauseScene(); |
| playing = false; |
| const poses = targets.map((o) => ({ id: o.id, position: [...o.position], quaternion: objectQuaternion(o) })); |
| const forward = getView().getWorldDirection(new THREE.Vector3()).transformDirection(world.matrixWorld.clone().invert()); |
| forward.y = 0; |
| forward.normalize(); |
| editor = { type: "poses", poses, revision: state().revision, key: getSpatialKey(), forward, grab: null }; |
| neutral = false; |
| hideMenu(); |
| changed(); |
| notice("Transform: L stick Move · L grip + stick Height · R stick Rotate · R grip Grab · A Save · B Revert"); |
| } |
| function drawControls() { |
| clearGuides(); |
| if (editor?.type !== "curve") return; |
| const points = curvePoints(editor.controls, true), path = new THREE.CurvePath(); |
| for (let i = 1; i < points.length; i++) path.add(new THREE.LineCurve3(vec(points[i - 1]), vec(points[i]))); |
| const line = new THREE.Mesh(new THREE.TubeGeometry(path, Math.min(256, points.length * 2), 0.022, 6, false), new THREE.MeshBasicMaterial({ color: "#ad95ff", toneMapped: false })); |
| line.userData.curveSegment = true; |
| guides.add(line); |
| editor.controls.forEach((p, index) => { |
| const m = new THREE.Mesh(new THREE.SphereGeometry(0.065, 12, 8), new THREE.MeshBasicMaterial({ color: editor.grab?.index === index ? "#ffffff" : "#ffcf70", depthTest: false, toneMapped: false })); |
| m.position.fromArray(p); |
| m.userData.controlIndex = index; |
| m.renderOrder = 10; |
| guides.add(m); |
| }); |
| } |
| function editCurve(id) { |
| requireEdit(); |
| if (dirty()) throw Error("Save or cancel the current operation first."); |
| const c = state().scene.curves?.find((c2) => c2.id === id); |
| if (!c) throw Error("Save and select a curve first."); |
| editor = { type: "curve", id, controls: editableControls(c), revision: state().revision, key: getSpatialKey(), grab: null }; |
| drawControls(); |
| hideMenu(); |
| changed(); |
| notice("Grip and pull control points · A Save smoothed curve · B Cancel"); |
| } |
| function localHand(controller) { |
| world.updateMatrixWorld(true); |
| controller.updateMatrixWorld(true); |
| return world.matrixWorld.clone().invert().multiply(controller.matrixWorld); |
| } |
| function grab(controller, ray) { |
| if (!editor || editor.type === "placement" || editor.grab || saving) return false; |
| const hand = localHand(controller); |
| if (editor.type === "poses") editor.grab = { controller, start: hand.clone().invert(), poses: structuredClone(editor.poses) }; |
| else { |
| const hit = ray.intersectObjects(guides.children, false)[0]; |
| if (!hit) return false; |
| let index = hit.object.userData.controlIndex; |
| if (index === void 0) { |
| if (editor.controls.length >= 64) throw Error("Up to 64 control points."); |
| const point = world.worldToLocal(hit.point.clone()); |
| let best = Infinity; |
| index = 1; |
| for (let i = 1; i < editor.controls.length; i++) { |
| const near = new THREE.Line3(vec(editor.controls[i - 1]), vec(editor.controls[i])).closestPointToPoint(point, true, new THREE.Vector3()).distanceToSquared(point); |
| if (near < best) { |
| best = near; |
| index = i; |
| } |
| } |
| editor.controls.splice(index, 0, point.toArray()); |
| } |
| editor.grab = { controller, index, start: hand.clone().invert(), point: vec(editor.controls[index]) }; |
| drawControls(); |
| } |
| neutral = false; |
| changed(); |
| return true; |
| } |
| function release() { |
| if (editor?.grab) { |
| editor.grab = null; |
| neutral = false; |
| changed(); |
| } |
| } |
| function input(sources, dt) { |
| if (!editor || saving) return; |
| dt = Math.min(dt, 0.05); |
| if (editor.revision !== state().revision || editor.key !== getSpatialKey()) { |
| cancel(); |
| notice("Scene or alignment changed. Edits reverted."); |
| return; |
| } |
| if (editor.grab) { |
| const g = editor.grab; |
| if (!g.controller.visible) { |
| cancel(); |
| notice("Tracking interrupted. Edits cancelled."); |
| return; |
| } |
| const delta2 = localHand(g.controller).multiply(g.start), alpha = 1 - Math.exp(-20 * dt); |
| if (editor.type === "poses") for (let i = 0; i < editor.poses.length; i++) { |
| const base = g.poses[i], matrix = delta2.clone().multiply(new THREE.Matrix4().compose(vec(base.position), quat(base.quaternion), new THREE.Vector3(1, 1, 1))), p = new THREE.Vector3(), q2 = new THREE.Quaternion(); |
| matrix.decompose(p, q2, new THREE.Vector3()); |
| editor.poses[i].position = vec(editor.poses[i].position).lerp(p, alpha).toArray().map((v) => THREE.MathUtils.clamp(v, -99, 99)); |
| editor.poses[i].quaternion = quat(editor.poses[i].quaternion).slerp(q2, alpha).toArray(); |
| } |
| else { |
| const previousY = editor.controls[g.index][1]; |
| editor.controls[g.index] = g.point.clone().applyMatrix4(delta2).toArray().map((v) => THREE.MathUtils.clamp(v, -99, 99)); |
| if (state().scene.curves.find((c) => c.id === editor.id)?.mode === "floor2d") editor.controls[g.index][1] = previousY; |
| drawControls(); |
| } |
| return; |
| } |
| if (editor.type !== "poses") return; |
| const pad = (hand) => sources.find((s) => s.handedness === hand)?.gamepad?.axes || [], left = pad("left"), right = pad("right"), axes = [left[2] || 0, left[3] || 0, right[2] || 0, right[3] || 0]; |
| const grip = sources.find((s) => s.handedness === "left")?.gamepad?.buttons?.[1], vertical = !!(grip && (grip.pressed || grip.value > 0.65)); |
| if (editor.vertical !== vertical) { |
| editor.vertical = vertical; |
| neutral = false; |
| } |
| if (!neutral) { |
| neutral = axes.every((v) => Math.abs(v) < 0.18); |
| return; |
| } |
| const [x, y, rx, ry] = axes.map((v) => Math.abs(v) > 0.18 ? v : 0); |
| if (!x && !y && !rx && !ry) return; |
| const forward = editor.forward, side = new THREE.Vector3(-forward.z, 0, forward.x), delta = vertical ? new THREE.Vector3(0, -y * speed * dt, 0) : side.multiplyScalar(x).addScaledVector(forward, -y).multiplyScalar(speed * dt); |
| const q = new THREE.Quaternion().setFromEuler(new THREE.Euler(-ry * dt * 0.8, -rx * dt * 0.8, 0, "YXZ")); |
| for (const p of editor.poses) { |
| p.position = vec(p.position).add(delta).toArray().map((v) => THREE.MathUtils.clamp(v, -99, 99)); |
| p.quaternion = q.clone().multiply(quat(p.quaternion)).normalize().toArray(); |
| } |
| } |
| function beginPlacement(command) { |
| requireEdit(); |
| if (dirty() || saving || request || !canCreate()) throw Error("Save or cancel the current operation first."); |
| applyCinema(state().scene, groundCreateCommand(command, [0, 0, 0])); |
| pauseScene(); |
| clearGuides(); |
| const cursor = new THREE.Mesh(new THREE.RingGeometry(0.18, 0.25, 48), new THREE.MeshBasicMaterial({ color: "#b79bea", side: THREE.DoubleSide, toneMapped: false })); |
| cursor.rotation.x = -Math.PI / 2; |
| cursor.visible = false; |
| guides.add(cursor); |
| editor = { type: "placement", command: structuredClone(command), point: null, cursor, revision: state().revision, key: getSpatialKey() }; |
| hideMenu(); |
| changed(); |
| notice("Point at ground with your right hand · A Create · B Cancel"); |
| } |
| function updatePlacement(ray) { |
| if (editor?.type !== "placement" || saving) return; |
| if (editor.revision !== state().revision || editor.key !== getSpatialKey()) { |
| cancel(); |
| notice("Scene or alignment changed. Placement cancelled."); |
| return; |
| } |
| const hit = ray && pickGround(ray), point = hit?.toArray?.() || hit || null; |
| let valid = !!point; |
| try { |
| if (valid) groundCreateCommand(editor.command, point); |
| } catch { |
| valid = false; |
| } |
| const wasValid = !!editor.point; |
| editor.point = valid ? [...point] : null; |
| editor.cursor.visible = valid; |
| if (valid) editor.cursor.position.fromArray(point).add(new THREE.Vector3(0, 0.015, 0)); |
| if (wasValid !== valid) changed(); |
| } |
| function preview(command) { |
| requireEdit(); |
| if (dirty()) throw Error("Save or cancel the current operation first."); |
| if (command.op === "create") return beginPlacement(command); |
| pending = { command, scene: applyCinema(state().scene, command), revision: state().revision, key: getSpatialKey() }; |
| onPreview(pending.scene); |
| changed(); |
| } |
| async function save() { |
| requireEdit(); |
| if (saving) return; |
| if (editor?.grab) throw Error("Release the grip before saving."); |
| if (editor && (editor.key !== getSpatialKey() || editor.revision !== state().revision)) { |
| cancel(); |
| throw Error("Scene or alignment changed. Choose a new point or restart editing."); |
| } |
| const command = editor?.type === "placement" ? groundCreateCommand(editor.command, editor.point) : editor?.type === "poses" ? { op: "poses", poses: editor.poses } : editor?.type === "curve" ? { op: "curve", id: editor.id, controls: editor.controls, smooth: true } : pending?.command; |
| if (!command) return; |
| const revision = editor?.revision ?? pending.revision; |
| if (revision !== state().revision) throw Error("Scene changed. Cancel and restart editing."); |
| saving = true; |
| changed(); |
| try { |
| const next = await api("/api/cinema/commit", { revision, command }); |
| editor = null; |
| pending = null; |
| clearGuides(); |
| onPreview(null); |
| onState(next); |
| notice(command.op === "create" ? "Created at your point · Use Transform to adjust position and height." : "Saved · Left grip or Interaction → Rehearse selection."); |
| } finally { |
| saving = false; |
| changed(); |
| } |
| if (command.op === "create") onSelect(command.id); |
| } |
| function play({ restart = false, ids } = {}) { |
| if (editing || session?.mode !== "explore" || transitioning || dirty() || saving) throw Error("Save edits, click the right stick to explore, then use left grip to rehearse."); |
| const next = previewScope(state().scene, ids ?? focusIds); |
| if (!next.ownerIds.length || next.missingIds.length) throw Error("Enter edit mode and select an object to rehearse."); |
| if (!next.playable) throw Error("Bind a curve or save an interaction for this object first."); |
| const same = activeScope && JSON.stringify(activeScope) === JSON.stringify(next) && previewRevision === state().revision; |
| if (playing && !restart && same) return; |
| const first = !hasPlayed || restart || !same; |
| try { |
| transport(first ? "start" : "resume", next); |
| } catch (error) { |
| activeScope = null; |
| hasPlayed = false; |
| playing = false; |
| time = 0; |
| pauseScene(); |
| changed(); |
| throw error; |
| } |
| if (first) { |
| time = 0; |
| triggerRuntime.sync(state().scene); |
| triggerKey = JSON.stringify(state().scene); |
| triggerRuntime.start(next.objectIds); |
| } else triggerRuntime.resume(); |
| focusIds = [...next.ownerIds]; |
| activeScope = next; |
| previewRevision = state().revision; |
| hasPlayed = true; |
| playing = true; |
| hideMenu(); |
| notice(`Rehearsing: ${next.label} · Left grip Pause / Resume · Right stick click Edit`); |
| changed(); |
| } |
| function pause() { |
| playing = false; |
| triggerRuntime.pause(); |
| transport("pause", activeScope); |
| changed(); |
| } |
| async function handleText(text, context) { |
| const viewAction = cameraViewIntent(text); |
| if (viewAction === "recenter") { |
| if (!monitor) return "Ask Camera Agent to open the monitor first."; |
| recenterMonitor(); |
| return "Monitor recentered upright. Camera pose and playback are preserved."; |
| } |
| if (viewAction === "close") { |
| closeMonitor(); |
| return "Camera monitor closed."; |
| } |
| if (viewAction) { |
| if (context?.revision !== void 0 && context.revision !== state().revision) throw Error("Scene changed while speaking. Select the camera again."); |
| if (dirty() || saving || transitioning || request) return "A Save or B Cancel the current edit before viewing a camera."; |
| if (viewAction === "preview") { |
| const ids = context?.targetIds || getSelection(), camera = state().scene.objects.find((o) => isCamera(o) && ids.includes(o.id)); |
| openMonitor(camera?.id); |
| } else cameraStep(viewAction === "next" ? 1 : -1); |
| return `Viewing saved camera ${entityLabel(savedCameras().find((c) => c.id === selectedCamera))}. B Close; editing closes the monitor.`; |
| } |
| if (editor?.type === "poses") { |
| if (languagePattern("transform.faster").test(text)) { |
| speed = Math.min(4, speed * 2); |
| return `Movement speed is now ${speed} m/s.`; |
| } |
| if (languagePattern("transform.slower").test(text)) { |
| speed = Math.max(0.025, speed / 2); |
| return `Movement speed is now ${speed} m/s.`; |
| } |
| if (languagePattern("transform.verticalRequest").test(text)) { |
| const metres = languagePattern("transform.meters").test(text) && !languagePattern("transform.centimeters").test(text), amount = Number(text.match(/\d+(?:\.\d+)?/)?.[0] || 20) * (metres ? 1 : 0.01) * (languagePattern("transform.lower").test(text) ? -1 : 1); |
| for (const p of editor.poses) p.position[1] = THREE.MathUtils.clamp(p.position[1] + amount, -99, 99); |
| return "Height preview adjusted. A Save, B Revert."; |
| } |
| return "A Save or B Cancel this edit. You can also say faster, slower, or raise by 20 centimetres."; |
| } |
| if (dirty()) return "A Save or B Cancel the current preview first."; |
| const words = text.trim().replace(languagePattern("punctuation.production-studio.1"), ""); |
| if (languagePattern("preview.stop").test(words)) { |
| pause(); |
| return "Rehearsal paused. Left grip to resume."; |
| } |
| if (languagePattern("preview.play").test(words)) { |
| await requestPlay({ restart: languagePattern("preview.restart").test(words) }); |
| return `Rehearsing ${activeScope?.label || focus().label}. Left grip to pause / resume.`; |
| } |
| const targetIds = editing ? context?.targetIds || getSelection() : focusIds; |
| const specialist = productionSpecialist(text, { scene: state().scene, ids: targetIds }); |
| if (editing && !specialist) return null; |
| if (request || transitioning) throw Error("The previous request is still processing."); |
| const captured = session && { ...session }; |
| if (context?.revision !== void 0 && context.revision !== state().revision) throw Error("Scene changed while speaking. Please retry."); |
| if (context?.productionEpoch && context.productionEpoch !== captured?.epoch) throw Error("Mode changed while speaking. Please retry."); |
| request = new AbortController(); |
| const controller = request; |
| changed(); |
| try { |
| const result = await api("/api/cinema/agent", { prompt: text, revision: state().revision, ids: targetIds, curveId: context?.curveId || null, specialist: specialist || "camera" }, { signal: controller.signal, timeoutMs: 125e3 }); |
| if (controller.signal.aborted || session?.epoch !== captured?.epoch) return null; |
| if (result.action === "edit") { |
| if (result.command.op === "create") { |
| request = null; |
| beginPlacement(result.command); |
| return "Placement ready. Point at ground with your right hand. A Create, B Cancel."; |
| } |
| preview(result.command); |
| } else if (result.action === "editCurve") editCurve(result.id); |
| else if (result.action === "preview") openMonitor(result.id); |
| else if (result.action === "next") cameraStep(1); |
| else if (result.action === "previous") cameraStep(-1); |
| else if (result.action === "close") closeMonitor(); |
| else if (result.action === "play") { |
| request = null; |
| changed(); |
| await requestPlay(result.id ? { ids: [result.id] } : {}); |
| } else if (result.action === "pause") pause(); |
| return result.reply || "Done."; |
| } finally { |
| if (request === controller) request = null; |
| changed(); |
| } |
| } |
| function frame(dt, actors = [], transforms = [], flood = { states: [] }, tracking = {}) { |
| const d = definition(), next = JSON.stringify(d); |
| if (next !== definitionKey) { |
| definitionKey = next; |
| rig.sync(d); |
| } |
| if (activeScope && previewRevision !== state().revision) { |
| activeScope = null; |
| hasPlayed = false; |
| playing = false; |
| time = 0; |
| pauseScene(); |
| notice("Scene updated. Select an object again to rehearse."); |
| changed(); |
| } |
| if (!editing && playing) time += Math.min(dt, 0.1); |
| const targets = [...d.objects, ...(d.actors || []).map((o) => ({ ...o, position: actors.find((a) => a.id === o.id)?.position || o.position }))]; |
| const savedKey = JSON.stringify(state().scene); |
| if (savedKey !== triggerKey) { |
| triggerKey = savedKey; |
| triggerRuntime.sync(state().scene); |
| } |
| const triggerState = triggerRuntime.tick({ ...tracking, active: !!tracking.active && !editing && playing }); |
| regionLayer.frame(d, { editing, states: triggerState.states }); |
| const statusKey = triggerState.states.map((s) => s.id + ":" + (s.fired ? "fired" : s.inside ? Math.floor(s.dwell) : "waiting")).join("|"); |
| if (statusKey !== triggerStatusKey) { |
| triggerStatusKey = statusKey; |
| const s = triggerState.states[0]; |
| if (s) notice(s.fired ? "Region condition met. Starting this object's movement." : s.inside ? `Dwell in region: ${s.dwell.toFixed(1)} / ${s.seconds} s` : `Enter the floor region · Dwell continuously for ${s.seconds} s`); |
| } |
| const activeIds = activeScope?.objectIds || []; |
| const frames = rig.frame(editing ? null : time, targets, [...transforms, ...editor?.type === "poses" ? editor.poses : []], activeIds, triggerState.clocks); |
| for (const p of frames) { |
| const mesh = getMeshes().get(p.id); |
| if (!mesh) continue; |
| if (isRig(mesh.userData.definition)) { |
| mesh.visible = editing; |
| if (!mesh.userData.cinemaGuide) { |
| const arrow = new THREE.ArrowHelper(new THREE.Vector3(0, 0, -1), new THREE.Vector3(), 2.5, isCamera(mesh.userData.definition) ? 5554943 : 16767874, 0.6, 0.3); |
| mesh.add(arrow); |
| mesh.userData.cinemaGuide = arrow; |
| } |
| } |
| if (editor?.poses?.some((o) => o.id === p.id) || mesh.userData.definition.track) { |
| mesh.position.fromArray(p.position); |
| mesh.quaternion.fromArray(p.quaternion); |
| } |
| } |
| if (monitor) { |
| if (dirty() || !canMonitor() || monitor.revision !== state().revision || monitor.key !== getSpatialKey()) { |
| closeMonitor(); |
| return frames; |
| } |
| const now = performance.now(); |
| if (now - lastMonitor > 1e3 / 24) { |
| lastMonitor = now; |
| const w = monitor.content.userData.contentWorld; |
| w.matrix.copy(world.matrixWorld); |
| w.matrixWorldNeedsUpdate = true; |
| monitor.actors.apply(actors, { clean: false }); |
| applyRecordedTransforms(monitor.content, [...transforms, ...frames.filter((p) => d.objects.find((o) => o.id === p.id)?.track)]); |
| monitor.flood?.frame(flood, { showRegions: false }); |
| const cameraLayer = monitor.content.userData.cinema; |
| cameraLayer?.frame(editing ? null : time, targets, [], activeIds, triggerState.clocks); |
| const camera = cameraLayer?.cameras.get(selectedCamera); |
| if (camera) { |
| monitor.content.updateMatrixWorld(true); |
| const previous = renderer.getRenderTarget(), xr = renderer.xr.enabled; |
| try { |
| renderer.xr.enabled = false; |
| renderer.setRenderTarget(monitor.target); |
| renderer.render(monitor.content, camera); |
| } finally { |
| renderer.setRenderTarget(previous); |
| renderer.xr.enabled = xr; |
| } |
| } |
| } |
| } |
| return frames; |
| } |
| return { |
| initialize: () => modeTransition = syncMode("edit"), |
| ready: () => modeTransition, |
| setEditing(value, scope = value ? "edit" : "explore") { |
| if (transitioning) return false; |
| if (session?.mode === scope && editing === value) return true; |
| if (dirty() || saving || request) { |
| notice("Save or cancel the current operation first."); |
| return false; |
| } |
| if (!value && scope === "explore") focusIds = [...getSelection()]; |
| editing = value; |
| closeMonitor(); |
| triggerRuntime.stop(); |
| playing = false; |
| hasPlayed = false; |
| activeScope = null; |
| time = 0; |
| pauseScene(); |
| neutral = false; |
| modeTransition = syncMode(scope); |
| modeTransition.catch(() => { |
| }); |
| return true; |
| }, |
| cancel, |
| save, |
| startPoses, |
| editCurve, |
| grab, |
| release, |
| input, |
| frame, |
| handleText, |
| preview, |
| openMonitor, |
| closeMonitor, |
| recenterMonitor, |
| adjustCamera, |
| cameraStep, |
| updatePlacement, |
| create(kind) { |
| beginPlacement({ op: "create", id: "rig-" + crypto.randomUUID(), kind }); |
| }, |
| async complete() { |
| requireEdit(); |
| if (dirty()) throw Error("Save the current tool edits first."); |
| saving = true; |
| changed(); |
| try { |
| onState(await api("/api/cinema/commit", { revision: state().revision, command: { op: "complete" } })); |
| notice("Setup complete. Explore, rehearse and record."); |
| } finally { |
| saving = false; |
| changed(); |
| } |
| }, |
| play, |
| pause, |
| stopClock() { |
| playing = false; |
| triggerRuntime.stop(); |
| }, |
| isolateActors: (frames) => isolatePreviewActors(state().scene, frames, activeScope || { actorIds: frames.filter((f) => !f.preview).map((f) => f.id) }), |
| allowsInteraction: (ids) => !activeScope || playing && ids.every((id) => activeScope.targetIds.includes(id)), |
| cameraView: () => !editing && selectedCamera ? rig.cameras.get(selectedCamera) : null, |
| livePoses: () => editor?.type === "poses" ? editor.poses.map((p) => ({ ...p, yaw: new THREE.Euler().setFromQuaternion(quat(p.quaternion), "YXZ").y })) : [], |
| state: () => ({ editing, epoch: session?.epoch, tool: editor?.type === "poses" ? "transform" : editor?.type || null, vertical: !!editor?.vertical, placing: editor?.type === "placement", placement: editor?.type === "placement" ? { kind: editor.command.kind, point: editor.point ? [...editor.point] : null, visible: editor.cursor.visible } : null, dirty: dirty(), saving, requesting: !!request, transitioning, monitor: !!monitor, monitorPose: monitor ? { position: monitor.screen.position.toArray(), quaternion: monitor.screen.quaternion.toArray() } : null, triggers: triggerRuntime.snapshot(), selectedCamera, cameraName: entityLabel(savedCameras().find((c) => c.id === selectedCamera)), playing, time, speed, previewIds: focus().targetIds, previewLabel: focus().label, canPreview: !!focus().playable, activePreviewIds: activeScope?.targetIds || [], previewObjectIds: activeScope?.objectIds || [] }), |
| busy: () => dirty() || saving || !!request || transitioning || !session, |
| manipulating: () => !!editor && editor.type !== "placement" |
| }; |
| } |
| export { |
| createProductionStudio |
| }; |
|
|
