423 lines
15 KiB
TypeScript
423 lines
15 KiB
TypeScript
import {
|
|
type AnyNode,
|
|
type AnyNodeId,
|
|
type CeilingNode,
|
|
collectAlignmentAnchors,
|
|
type FloorplanMoveTarget,
|
|
type FloorplanMoveTargetSession,
|
|
getRoofWallFaceFrame,
|
|
getScaledDimensions,
|
|
type ItemNode,
|
|
movingFootprintAnchors,
|
|
type RoofSegmentNode,
|
|
roofFacePointToSegment,
|
|
useScene,
|
|
} from '@pascal-app/core'
|
|
import {
|
|
applyFloorplanAlignment,
|
|
isGridSnapActive,
|
|
isMagneticSnapActive,
|
|
useEditor,
|
|
type WallPlanPoint,
|
|
} from '@pascal-app/editor'
|
|
import { createFloorplanCursorResolver } from '../shared/floorplan-cursor'
|
|
import { findClosestWallInPlan, snapLocalXToNeighbors } from '../shared/wall-attach-target'
|
|
|
|
/**
|
|
* 2D floor-plan move handler for item. Branches on `asset.attachTo`:
|
|
*
|
|
* - `'wall'` / `'wall-side'`: pointer snaps to nearest wall (same
|
|
* math as door / window via `findClosestWallInPlan`). Position
|
|
* local-X is snapped to 0.5m grid; the wall-local Y carries over
|
|
* from the source position (2D has no vertical signal).
|
|
* - `'ceiling'`: pointer is point-in-polygon-tested against every
|
|
* ceiling on the level. If hit, the item reparents to that
|
|
* ceiling at the snapped local plan position.
|
|
* - undefined (floor): pointer is point-in-polygon-tested against
|
|
* every slab on the level. If hit, the item reparents to that
|
|
* slab; otherwise it stays parented to the level (free-floating)
|
|
* at the snapped plan position.
|
|
*
|
|
* Skipped vs the 3D `MoveItemContent` for now: attachTo *transitions*
|
|
* (drop a wall lamp on a ceiling and have it switch to ceiling-attach).
|
|
* The 3D path remains canonical for that — 2D only re-anchors within
|
|
* the item's current attach family.
|
|
*/
|
|
|
|
type ItemPlanTransform = {
|
|
point: [number, number]
|
|
rotation: number
|
|
}
|
|
|
|
function rotateVec(x: number, z: number, rotationY: number): [number, number] {
|
|
const c = Math.cos(rotationY)
|
|
const s = Math.sin(rotationY)
|
|
return [x * c + z * s, -x * s + z * c]
|
|
}
|
|
|
|
function resolveItemPlanTransform(
|
|
item: ItemNode,
|
|
nodes: Record<AnyNodeId, AnyNode>,
|
|
cache = new Map<AnyNodeId, ItemPlanTransform>(),
|
|
): ItemPlanTransform {
|
|
const cached = cache.get(item.id as AnyNodeId)
|
|
if (cached) return cached
|
|
|
|
const localRotation = item.rotation[1] ?? 0
|
|
let result: ItemPlanTransform = {
|
|
point: [item.position[0], item.position[2]],
|
|
rotation: localRotation,
|
|
}
|
|
const parent = item.parentId ? nodes[item.parentId as AnyNodeId] : null
|
|
if (parent?.type === 'wall') {
|
|
const wallRotation = -Math.atan2(
|
|
parent.end[1] - parent.start[1],
|
|
parent.end[0] - parent.start[0],
|
|
)
|
|
const wallLocalZ =
|
|
item.asset.attachTo === 'wall-side'
|
|
? ((parent.thickness ?? 0.1) / 2) * (item.side === 'front' ? 1 : -1)
|
|
: item.position[2]
|
|
const [offsetX, offsetZ] = rotateVec(item.position[0], wallLocalZ, wallRotation)
|
|
result = {
|
|
point: [parent.start[0] + offsetX, parent.start[1] + offsetZ],
|
|
rotation: wallRotation + localRotation,
|
|
}
|
|
} else if (parent?.type === 'shelf') {
|
|
const shelf = parent as AnyNode & {
|
|
position: [number, number, number]
|
|
rotation: [number, number, number]
|
|
}
|
|
const [offsetX, offsetZ] = rotateVec(item.position[0], item.position[2], shelf.rotation[1] ?? 0)
|
|
result = {
|
|
point: [shelf.position[0] + offsetX, shelf.position[2] + offsetZ],
|
|
rotation: (shelf.rotation[1] ?? 0) + localRotation,
|
|
}
|
|
} else if (parent?.type === 'item') {
|
|
const parentTransform = resolveItemPlanTransform(parent as ItemNode, nodes, cache)
|
|
const [offsetX, offsetZ] = rotateVec(
|
|
item.position[0],
|
|
item.position[2],
|
|
parentTransform.rotation,
|
|
)
|
|
result = {
|
|
point: [parentTransform.point[0] + offsetX, parentTransform.point[1] + offsetZ],
|
|
rotation: parentTransform.rotation + localRotation,
|
|
}
|
|
} else if (parent?.type === 'roof-segment') {
|
|
// Roof-hosted wall item: FACE-LOCAL position mapped through the face
|
|
// frame, then composed through the segment's and roof's yaw +
|
|
// position into level-local plan coords — without this the drag seed
|
|
// jumps off the roof at move start.
|
|
const segment = parent as RoofSegmentNode
|
|
const roof = segment.parentId
|
|
? (nodes[segment.parentId as AnyNodeId] as
|
|
| (AnyNode & { position: [number, number, number]; rotation: number })
|
|
| undefined)
|
|
: undefined
|
|
if (roof?.type === 'roof' && item.roofFace) {
|
|
const frame = getRoofWallFaceFrame(segment, item.roofFace)
|
|
const segLocal = roofFacePointToSegment(segment, item.roofFace, item.position)
|
|
const [sx, sz] = rotateVec(segLocal[0], segLocal[2], segment.rotation ?? 0)
|
|
const [rx, rz] = rotateVec(
|
|
sx + segment.position[0],
|
|
sz + segment.position[2],
|
|
roof.rotation ?? 0,
|
|
)
|
|
result = {
|
|
point: [rx + roof.position[0], rz + roof.position[2]],
|
|
rotation: (roof.rotation ?? 0) + (segment.rotation ?? 0) + frame.yaw + localRotation,
|
|
}
|
|
}
|
|
}
|
|
|
|
cache.set(item.id as AnyNodeId, result)
|
|
return result
|
|
}
|
|
|
|
function resolveItemPlanPoint(
|
|
item: ItemNode,
|
|
nodes: Record<AnyNodeId, AnyNode>,
|
|
cache = new Map<AnyNodeId, ItemPlanTransform>(),
|
|
): [number, number] {
|
|
return resolveItemPlanTransform(item, nodes, cache).point
|
|
}
|
|
|
|
function createPlanarMovePointResolver(originalPlanPoint: [number, number], node: ItemNode) {
|
|
const resolveCursor = createFloorplanCursorResolver({
|
|
original: originalPlanPoint,
|
|
metadata: node.metadata,
|
|
})
|
|
|
|
return (planPoint: readonly [number, number]): WallPlanPoint => {
|
|
// Grid snap is mode-driven (matching 3D): quantize only when grid mode is
|
|
// active; in lines/off mode the cursor passes through unsnapped.
|
|
const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0
|
|
const snap = (value: number) => (step <= 0 ? value : Math.round(value / step) * step)
|
|
return resolveCursor(planPoint, { snap }) as WallPlanPoint
|
|
}
|
|
}
|
|
|
|
export const itemFloorplanMoveTarget: FloorplanMoveTarget<ItemNode> = ({ node, nodes }) => {
|
|
const attachTo = node.asset.attachTo
|
|
const startLevelId: AnyNodeId | null = (() => {
|
|
// Walk to the owning level depending on the item's current parent:
|
|
// - wall / ceiling parent → parent.parentId is the level
|
|
// - level parent (floor items) → parent.id IS the level
|
|
// - item / shelf parent → walk up until we hit a level
|
|
// Without the `parent.type === 'level'` short-circuit, floor items
|
|
// (whose immediate parent is the level itself) get `level.parentId`,
|
|
// which is the *building* — `findContainingSurface` would then
|
|
// iterate the building's children (levels, not slabs) and the
|
|
// fallback `parentId: startLevelId` would reparent the item to the
|
|
// building. The item drops out of the level→children DFS the floor
|
|
// plan walks and disappears mid-drag.
|
|
const nodes = useScene.getState().nodes
|
|
let current = nodes[node.parentId as AnyNodeId]
|
|
while (current) {
|
|
if (current.type === 'level') return current.id as AnyNodeId
|
|
if (!current.parentId) return null
|
|
current = nodes[current.parentId as AnyNodeId]
|
|
}
|
|
return null
|
|
})()
|
|
|
|
if (attachTo === 'wall' || attachTo === 'wall-side') {
|
|
return buildWallItemSession(node, startLevelId)
|
|
}
|
|
if (attachTo === 'ceiling') {
|
|
return buildSurfaceItemSession(node, startLevelId, 'ceiling')
|
|
}
|
|
return buildFloorItemSession(node, startLevelId, nodes)
|
|
}
|
|
|
|
function buildWallItemSession(
|
|
node: ItemNode,
|
|
startLevelId: AnyNodeId | null,
|
|
): FloorplanMoveTargetSession {
|
|
// Wall items use the same local-X snap pipeline as doors / windows.
|
|
// local-Y carries over from the source item's position (2D can't
|
|
// express vertical movement).
|
|
const startLocalY = node.position[1]
|
|
const resolveCursor = createFloorplanCursorResolver({
|
|
original: resolveItemPlanPoint(node, useScene.getState().nodes),
|
|
metadata: node.metadata,
|
|
})
|
|
|
|
return {
|
|
affectedIds: [node.id as AnyNodeId],
|
|
apply({ planPoint }) {
|
|
const nodes = useScene.getState().nodes
|
|
const resolvedPlanPoint = resolveCursor(planPoint)
|
|
const hit = findClosestWallInPlan(resolvedPlanPoint, nodes, startLevelId)
|
|
if (!hit) return
|
|
|
|
const [width] = getScaledDimensions(node)
|
|
|
|
// Figma-style along-wall alignment (edge-to-edge with other openings /
|
|
// wall items / wall ends), winning over the grid snap; falls back to grid
|
|
// when nothing aligns. Both are mode-driven (matching 3D): alignment only in
|
|
// lines/magnetic mode, grid quantization only in grid mode.
|
|
const neighborX = isMagneticSnapActive()
|
|
? snapLocalXToNeighbors({
|
|
wall: hit.wall,
|
|
localX: hit.localX,
|
|
width,
|
|
selfId: node.id as AnyNodeId,
|
|
nodes,
|
|
})
|
|
: null
|
|
const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0
|
|
const snappedLocalX =
|
|
neighborX ?? (step <= 0 ? hit.localX : Math.round(hit.localX / step) * step)
|
|
|
|
const halfW = width / 2
|
|
const clampedX = Math.max(halfW, Math.min(hit.wallLength - halfW, snappedLocalX))
|
|
|
|
useScene.getState().updateNodes([
|
|
{
|
|
id: node.id as AnyNodeId,
|
|
data: {
|
|
position: [clampedX, startLocalY, 0],
|
|
rotation: [0, hit.itemRotation, 0],
|
|
side: hit.side,
|
|
parentId: hit.wall.id,
|
|
// Re-anchoring to a wall ends any roof-segment hosting; the
|
|
// overlay's snapshot restores it if the move is reverted.
|
|
roofSegmentId: undefined,
|
|
roofFace: undefined,
|
|
},
|
|
},
|
|
])
|
|
},
|
|
canCommit() {
|
|
const live = useScene.getState().nodes[node.id as AnyNodeId] as ItemNode | undefined
|
|
return !!live && live.type === 'item' && !!live.parentId
|
|
},
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Floor items live as level children — the slab is *not* a parent (slabs
|
|
* have no `children` field; only ceilings and the level itself do).
|
|
* Reparenting a floor item to a slab corrupts the parent-children
|
|
* bookkeeping and the item drops out of the level→children DFS the
|
|
* floor-plan layer walks → the polygon stops rendering mid-drag.
|
|
*
|
|
* For the 2D move we just translate `position` in level-local coords and
|
|
* leave the parent as the level (matching the 3D `detachItemSurfaceToFloor`
|
|
* in `use-placement-coordinator.tsx`). Snap to the 0.5m grid unless the
|
|
* user holds Shift.
|
|
*/
|
|
function buildFloorItemSession(
|
|
node: ItemNode,
|
|
startLevelId: AnyNodeId | null,
|
|
nodes: Record<AnyNodeId, AnyNode>,
|
|
): FloorplanMoveTargetSession {
|
|
const rotationY = node.rotation[1] ?? 0
|
|
const resolvePlanPoint = createPlanarMovePointResolver(resolveItemPlanPoint(node, nodes), node)
|
|
// Alignment candidates gathered once — scene is stable during the drag.
|
|
const candidates = collectAlignmentAnchors(nodes, node.id)
|
|
return {
|
|
affectedIds: [node.id as AnyNodeId],
|
|
apply({ planPoint }) {
|
|
const gridSnapped = resolvePlanPoint(planPoint)
|
|
// Figma-style alignment layered on the grid snap, mode-driven (matching 3D):
|
|
// guides are DISPLAYED in every snapping mode; the magnetic pull onto them
|
|
// is applied only in "lines" mode (`applySnap`).
|
|
const { point: snapped } = applyFloorplanAlignment(
|
|
gridSnapped,
|
|
movingFootprintAnchors(
|
|
node as unknown as AnyNode,
|
|
gridSnapped[0],
|
|
gridSnapped[1],
|
|
rotationY,
|
|
),
|
|
candidates,
|
|
{ applySnap: isMagneticSnapActive() },
|
|
)
|
|
|
|
const sourceY = node.position[1]
|
|
const nextPosition: [number, number, number] = [snapped[0], sourceY, snapped[1]]
|
|
|
|
useScene.getState().updateNodes([
|
|
{
|
|
id: node.id as AnyNodeId,
|
|
data: {
|
|
position: nextPosition,
|
|
// Keep parent as the level we resolved at session-start. If
|
|
// somehow it's null (e.g. orphaned item), fall back to the
|
|
// existing parent so we don't write `null` and detach.
|
|
parentId: startLevelId ?? node.parentId,
|
|
},
|
|
},
|
|
])
|
|
},
|
|
canCommit() {
|
|
const live = useScene.getState().nodes[node.id as AnyNodeId] as ItemNode | undefined
|
|
return !!live && live.type === 'item'
|
|
},
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ceiling items reparent to whichever ceiling polygon contains the
|
|
* pointer. Ceilings carry a `children` field on their schema so the
|
|
* parent-children bookkeeping in `updateNodes` works correctly when the
|
|
* item moves between ceilings. If the cursor drifts off every ceiling,
|
|
* the original parent is preserved (no detach back to the level — there
|
|
* is no canonical "free-floating ceiling item").
|
|
*/
|
|
function buildSurfaceItemSession(
|
|
node: ItemNode,
|
|
startLevelId: AnyNodeId | null,
|
|
targetKind: 'ceiling',
|
|
): FloorplanMoveTargetSession {
|
|
const resolvePlanPoint = createPlanarMovePointResolver(
|
|
resolveItemPlanPoint(node, useScene.getState().nodes),
|
|
node,
|
|
)
|
|
return {
|
|
affectedIds: [node.id as AnyNodeId],
|
|
apply({ planPoint }) {
|
|
const nodes = useScene.getState().nodes
|
|
const snapped = resolvePlanPoint(planPoint)
|
|
|
|
const surface = findContainingSurface(snapped, nodes, startLevelId, targetKind)
|
|
|
|
const sourceY = node.position[1]
|
|
const nextPosition: [number, number, number] = [snapped[0], sourceY, snapped[1]]
|
|
|
|
useScene.getState().updateNodes([
|
|
{
|
|
id: node.id as AnyNodeId,
|
|
data: {
|
|
position: nextPosition,
|
|
parentId: surface ? surface.id : node.parentId,
|
|
},
|
|
},
|
|
])
|
|
},
|
|
canCommit() {
|
|
const live = useScene.getState().nodes[node.id as AnyNodeId] as ItemNode | undefined
|
|
return !!live && live.type === 'item'
|
|
},
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Walk every ceiling under the level and return the first one whose
|
|
* polygon contains the pointer. Holes are honoured — a point inside a
|
|
* hole counts as not inside the surface. Slabs are intentionally NOT a
|
|
* valid target: floor items are parented to the level, not the slab,
|
|
* because slabs don't carry a `children` field on their schema.
|
|
*/
|
|
function findContainingSurface(
|
|
point: readonly [number, number],
|
|
nodes: Record<AnyNodeId, AnyNode>,
|
|
parentLevelId: AnyNodeId | null,
|
|
targetKind: 'ceiling',
|
|
): CeilingNode | null {
|
|
if (!parentLevelId) return null
|
|
const level = nodes[parentLevelId]
|
|
const childIds = (level as unknown as { children?: AnyNodeId[] })?.children
|
|
if (!Array.isArray(childIds)) return null
|
|
|
|
for (const childId of childIds) {
|
|
const node = nodes[childId]
|
|
if (!node || node.type !== targetKind) continue
|
|
const surface = node as CeilingNode
|
|
const polygon = surface.polygon
|
|
if (!polygon || polygon.length < 3) continue
|
|
if (!pointInRing(point, polygon)) continue
|
|
const holes = surface.holes ?? []
|
|
let inHole = false
|
|
for (const hole of holes) {
|
|
if (hole.length >= 3 && pointInRing(point, hole)) {
|
|
inHole = true
|
|
break
|
|
}
|
|
}
|
|
if (!inHole) return surface
|
|
}
|
|
return null
|
|
}
|
|
|
|
/** Standard ray-cast point-in-polygon. Treats edges as inside. */
|
|
function pointInRing(
|
|
point: readonly [number, number],
|
|
ring: ReadonlyArray<readonly [number, number]>,
|
|
): boolean {
|
|
let inside = false
|
|
const [px, py] = point
|
|
for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
|
|
const ax = ring[i]![0]
|
|
const ay = ring[i]![1]
|
|
const bx = ring[j]![0]
|
|
const by = ring[j]![1]
|
|
const intersects = ay > py !== by > py && px < ((bx - ax) * (py - ay)) / (by - ay) + ax
|
|
if (intersects) inside = !inside
|
|
}
|
|
return inside
|
|
}
|