| import * as THREE from "three"; |
| import { createDraftTool } from "./draft-tool.mjs"; |
| import { REGION_LIMITS, regionFrame, framePoint, frameUV, closeRegionStroke, validateRegions, regionObjectId } from "../../shared/interaction-regions.mjs"; |
| import { surfaceFrame, surfaceUV } from "../../shared/region-surfaces.mjs"; |
| import { isDoor } from "../../shared/doors.mjs"; |
| function createInteractionDraftTool(options) { |
| const { world, pickGround, pickObject } = options, path = createDraftTool(options), group = new THREE.Group(); |
| world.add(group); |
| group.visible = false; |
| let scene, door, side, regions = [], stroke = null, owner = null, enabled = false, message = "", version = 0, forceFloor = false; |
| const colour = (surface) => surface === "floor" ? 3198395 : 15562137; |
| function dispose() { |
| for (const child of [...group.children]) { |
| child.geometry?.dispose(); |
| child.material?.dispose(); |
| group.remove(child); |
| } |
| } |
| function outline(points, color, closed = true) { |
| if (!points.length) return; |
| const vertices = (closed ? [...points, points[0]] : points).map((p) => new THREE.Vector3(...p)), line = new THREE.Line(new THREE.BufferGeometry().setFromPoints(vertices), new THREE.LineBasicMaterial({ color, depthTest: false, toneMapped: false })); |
| line.renderOrder = 15; |
| group.add(line); |
| } |
| function paint() { |
| version++; |
| dispose(); |
| if (!enabled) return; |
| if (isDoor(door)) { |
| const frame = regionFrame(scene, { doorId: door.id, surface: "door-frame", side }); |
| const w = door.size[0] / 2 + 0.6, lo = -door.size[1] / 2 - 0.1, hi = door.size[1] / 2 + 0.3; |
| outline([[-w, lo], [w, lo], [w, hi], [-w, hi]].map((p) => framePoint(frame, p)), 7571094); |
| } |
| for (const r of regions) outline(r.points.map((p) => framePoint(regionFrame(scene, r), p)), colour(r.surface)); |
| if (stroke) outline(stroke.points.map((p) => framePoint(stroke.frame, p)), colour(stroke.surface), false); |
| } |
| function hit(ray, locked = stroke) { |
| world.updateMatrixWorld(true); |
| const ground = pickGround(ray); |
| if (locked?.surface === "floor" || !locked && forceFloor) return ground && (!locked || Math.abs(ground.y - locked.floorY) < 0.05) ? { point: [ground.x, ground.z], surface: "floor", floorY: ground.y, frame: regionFrame(scene, { surface: "floor", floorY: ground.y }) } : null; |
| const objectHit = pickObject?.(ray, door.id); |
| if (objectHit && (!locked || locked.surface === "object-surface")) { |
| const frameData = locked?.frameData || surfaceFrame(door, objectHit.point, objectHit.normal); |
| const frame2 = regionFrame(scene, { objectId: door.id, surface: "object-surface", frame: frameData }); |
| if (new THREE.Vector3(...objectHit.normal).dot(new THREE.Vector3(...frame2.normal)) < 0.25) return null; |
| return { point: surfaceUV(door, frameData, objectHit.point), surface: "object-surface", frameData, frame: frame2 }; |
| } |
| if (locked?.surface === "object-surface") return null; |
| if (!isDoor(door)) return !locked && ground ? { point: [ground.x, ground.z], surface: "floor", floorY: ground.y, frame: regionFrame(scene, { surface: "floor", floorY: ground.y }) } : null; |
| const origin = world.worldToLocal(ray.ray.origin.clone()), direction = ray.ray.direction.clone().transformDirection(new THREE.Matrix4().copy(world.matrixWorld).invert()), localRay = new THREE.Ray(origin, direction); |
| const frame = locked?.frame || regionFrame(scene, { doorId: door.id, surface: "door-frame", side }); |
| const plane = new THREE.Plane().setFromNormalAndCoplanarPoint(new THREE.Vector3(...frame.normal), new THREE.Vector3(...frame.origin)), point = localRay.intersectPlane(plane, new THREE.Vector3()); |
| const uv = point && frameUV(frame, point.toArray()); |
| const inFrame = uv && Math.abs(uv[0]) <= door.size[0] / 2 + 0.6 && uv[1] >= -door.size[1] / 2 - 0.1 && uv[1] <= door.size[1] / 2 + 0.3; |
| const doorHit = inFrame ? { point: uv, surface: "door-frame", side, frame } : null; |
| if (locked) return doorHit; |
| if (doorHit && (!ground || origin.distanceTo(point) < origin.distanceTo(ground))) return doorHit; |
| return ground ? { point: [ground.x, ground.z], surface: "floor", floorY: ground.y, frame: regionFrame(scene, { surface: "floor", floorY: ground.y }) } : null; |
| } |
| function interrupt(reason) { |
| if (stroke) { |
| stroke = null; |
| owner = null; |
| message = reason || "Stroke cancelled. Completed regions are preserved."; |
| paint(); |
| } |
| } |
| const api = { |
| open(points, opts) { |
| enabled = false; |
| group.visible = false; |
| path.open(points, opts); |
| }, |
| openRegions(definition, doorId, viewer) { |
| path.close(); |
| scene = definition; |
| door = scene.objects.find((o) => o.id === doorId); |
| if (!door) throw Error("Select an object first."); |
| const normal = [Math.sin(door.rotation), 0, Math.cos(door.rotation)]; |
| side = viewer.reduce((s, n, i) => s + (n - door.position[i]) * normal[i], 0) >= 0 ? 1 : -1; |
| regions = structuredClone((scene.regions || []).filter((r) => regionObjectId(r) === doorId)); |
| stroke = null; |
| owner = null; |
| enabled = true; |
| group.visible = true; |
| forceFloor = false; |
| message = "Draw sources on the selected object and a floor dwell region. Close each loop before releasing."; |
| paint(); |
| }, |
| active: () => enabled || path.active(), |
| close() { |
| enabled = false; |
| group.visible = false; |
| stroke = null; |
| owner = null; |
| regions = []; |
| dispose(); |
| path.close(); |
| }, |
| begin(ray, input) { |
| if (!enabled) return path.begin(ray, input); |
| if (owner) return false; |
| if (regions.length >= REGION_LIMITS.perDoor) { |
| message = "Up to 8 regions per object. Undo a region to draw another."; |
| return false; |
| } |
| const h = hit(ray); |
| if (!h) { |
| message = "Start on the selected object or on the floor."; |
| return false; |
| } |
| stroke = { ...h, points: [h.point] }; |
| owner = input; |
| message = h.surface === "floor" ? "Drawing floor trigger…" : "Drawing object source…"; |
| paint(); |
| return true; |
| }, |
| update(ray, input) { |
| if (!enabled) return path.update(ray, input); |
| if (owner !== input || !stroke) return; |
| const h = hit(ray); |
| if (!h) { |
| interrupt("The stroke left its original surface and was cancelled"); |
| return; |
| } |
| const last = stroke.points.at(-1), distance = Math.hypot(h.point[0] - last[0], h.point[1] - last[1]); |
| if (distance > REGION_LIMITS.maxGap) { |
| interrupt("Tracking jumped; the stroke was cancelled"); |
| return; |
| } |
| if (distance < REGION_LIMITS.spacing) return; |
| if (stroke.points.length >= 1024) { |
| interrupt("The stroke is too long. Draw a smaller region."); |
| return; |
| } |
| stroke.points.push(h.point); |
| paint(); |
| }, |
| release(input) { |
| if (!enabled) return path.release(input); |
| if (owner !== input || !stroke) return false; |
| const raw = stroke; |
| stroke = null; |
| owner = null; |
| try { |
| const region = { schema: "vrbuild-region/1", id: "region-" + crypto.randomUUID(), objectId: door.id, ...raw.surface === "door-frame" ? { doorId: door.id } : {}, name: (raw.surface === "floor" ? "Floor trigger " : "Object source ") + (regions.length + 1), surface: raw.surface, points: closeRegionStroke(raw.points, raw.surface), ...raw.surface === "floor" ? { floorY: raw.floorY } : raw.surface === "object-surface" ? { frame: raw.frameData } : { side: raw.side } }; |
| validateRegions([...regions, region], scene); |
| regions.push(region); |
| message = `${regions.length} regions ready. Draw another loop or finish and describe the effect.`; |
| paint(); |
| return true; |
| } catch (error) { |
| message = error.message; |
| paint(); |
| return false; |
| } |
| }, |
| suspend(reason) { |
| if (enabled) interrupt(reason); |
| else path.suspend(reason); |
| }, |
| undo() { |
| if (!enabled) return path.undo(); |
| if (stroke) interrupt(); |
| else { |
| regions.pop(); |
| message = "Last region undone"; |
| paint(); |
| } |
| }, |
| clear() { |
| if (!enabled) return path.clear(); |
| regions = []; |
| stroke = null; |
| owner = null; |
| message = "Regions cleared. Draw new regions."; |
| paint(); |
| }, |
| toggleSurface() { |
| if (!enabled || stroke) return; |
| forceFloor = !forceFloor; |
| message = forceFloor ? "Next stroke: floor trigger." : "Next stroke: object source, or a separate floor region."; |
| paint(); |
| }, |
| depth(delta) { |
| if (!enabled) path.depth(delta); |
| }, |
| cycleSmoothing() { |
| if (!enabled) path.cycleSmoothing(); |
| }, |
| summary: () => enabled ? { kind: "regions", mode: "regions", forceFloor, pointCount: regions.reduce((n, r) => n + r.points.length, 0), regionCount: regions.length, drawing: !!stroke, canUndo: !!stroke || regions.length > 0, length: 0, message, version } : path.summary(), |
| snapshot: () => enabled ? { kind: "regions", mode: "regions", regions: structuredClone(regions), objectId: door.id, doorId: isDoor(door) ? door.id : void 0, stroke: stroke ? structuredClone({ ...stroke, frame: void 0 }) : null, active: enabled, owner: owner === "mouse" ? "mouse" : owner ? "controller" : null } : path.snapshot() |
| }; |
| return api; |
| } |
| export { |
| createInteractionDraftTool |
| }; |
|
|
