346 lines
12 KiB
TypeScript
346 lines
12 KiB
TypeScript
import {
|
|
type AnyNode,
|
|
type AnyNodeId,
|
|
type FloorplanAffordance,
|
|
type FloorplanAffordanceModifiers,
|
|
type FloorplanAffordanceSession,
|
|
useScene,
|
|
} from '@pascal-app/core'
|
|
import { snapPointToGrid, type WallPlanPoint } from '@pascal-app/editor'
|
|
|
|
/**
|
|
* Shared "edit polygon" floor-plan affordances. Used by kinds whose
|
|
* primary editable shape is a `polygon: [number, number][]` field
|
|
* (slab, ceiling, site, zone) with optional `holes: [number, number][][]`.
|
|
*
|
|
* Each affordance accepts an optional `holeIndex` in its payload — when
|
|
* present, the operation targets `node.holes[holeIndex]`; otherwise it
|
|
* targets the outer `node.polygon`. The same factory wires both
|
|
* boundary and hole interactions without duplicating the math.
|
|
*
|
|
* Three affordances available:
|
|
*
|
|
* - `move-vertex` — drag an existing vertex.
|
|
* - `add-vertex` — insert a new vertex at an edge midpoint, then drag
|
|
* it (click-without-drag reverts to the snapshot).
|
|
* - `move-edge` — drag a whole edge perpendicular to itself (both
|
|
* endpoints translate by `normal * projection`).
|
|
*/
|
|
|
|
export type PolygonVertexPayload = {
|
|
/** Target a hole's polygon instead of the boundary. */
|
|
holeIndex?: number
|
|
vertexIndex: number
|
|
}
|
|
|
|
export type AddVertexPayload = {
|
|
holeIndex?: number
|
|
edgeIndex: number
|
|
}
|
|
|
|
export type EdgeDragPayload = {
|
|
holeIndex?: number
|
|
edgeIndex: number
|
|
}
|
|
|
|
type PolygonAffordanceMode = 'move-vertex' | 'add-vertex' | 'move-edge'
|
|
|
|
export type PolygonAffordanceSnapContext<N extends PolygonShape & { id: AnyNodeId }> = {
|
|
node: N
|
|
nodes: Record<AnyNodeId, AnyNode>
|
|
rawPoint: WallPlanPoint
|
|
fallbackPoint: WallPlanPoint
|
|
modifiers: FloorplanAffordanceModifiers
|
|
holeIndex?: number
|
|
mode: PolygonAffordanceMode
|
|
}
|
|
|
|
type PolygonAffordanceOptions<N extends PolygonShape & { id: AnyNodeId }> = {
|
|
resolvePlanPoint?: (context: PolygonAffordanceSnapContext<N>) => WallPlanPoint
|
|
}
|
|
|
|
type PolygonShape = {
|
|
polygon: ReadonlyArray<readonly [number, number]>
|
|
holes?: ReadonlyArray<ReadonlyArray<readonly [number, number]>>
|
|
}
|
|
|
|
function getRing(node: PolygonShape, holeIndex: number | undefined): [number, number][] | null {
|
|
if (holeIndex === undefined) {
|
|
return node.polygon.map(([x, y]) => [x, y] as [number, number])
|
|
}
|
|
const hole = node.holes?.[holeIndex]
|
|
if (!hole) return null
|
|
return hole.map(([x, y]) => [x, y] as [number, number])
|
|
}
|
|
|
|
/**
|
|
* Returns a patch object that, when applied to the node, updates the
|
|
* targeted ring (boundary polygon or specific hole) to `nextRing`. The
|
|
* cast through `unknown → Partial<unknown> → never` satisfies the
|
|
* generic `updateNodes` patch type without forcing every variant of
|
|
* the kind union into scope here.
|
|
*/
|
|
function buildRingPatch(
|
|
node: PolygonShape,
|
|
holeIndex: number | undefined,
|
|
nextRing: ReadonlyArray<[number, number]>,
|
|
): unknown {
|
|
if (holeIndex === undefined) {
|
|
return { polygon: nextRing }
|
|
}
|
|
const nextHoles = (node.holes ?? []).map((hole, i) =>
|
|
i === holeIndex ? nextRing : hole.map(([x, y]) => [x, y] as [number, number]),
|
|
)
|
|
return { holes: nextHoles }
|
|
}
|
|
|
|
function resolveAffordancePlanPoint<N extends PolygonShape & { id: AnyNodeId }>(
|
|
options: PolygonAffordanceOptions<N> | undefined,
|
|
context: PolygonAffordanceSnapContext<N>,
|
|
): WallPlanPoint {
|
|
return options?.resolvePlanPoint?.(context) ?? context.fallbackPoint
|
|
}
|
|
|
|
export function createPolygonVertexAffordance<N extends PolygonShape & { id: AnyNodeId }>(
|
|
kind: string,
|
|
options?: PolygonAffordanceOptions<N>,
|
|
): FloorplanAffordance<N> {
|
|
return {
|
|
start({ node, payload, nodes }): FloorplanAffordanceSession {
|
|
const { vertexIndex, holeIndex } = payload as PolygonVertexPayload
|
|
const originalRing = getRing(node, holeIndex)
|
|
if (!originalRing) {
|
|
return {
|
|
affectedIds: [node.id],
|
|
apply() {},
|
|
canCommit() {
|
|
return false
|
|
},
|
|
}
|
|
}
|
|
|
|
return {
|
|
affectedIds: [node.id],
|
|
apply({ planPoint, modifiers }) {
|
|
const rawPoint: WallPlanPoint = [planPoint[0], planPoint[1]]
|
|
const fallbackPoint = modifiers.shiftKey ? rawPoint : snapPointToGrid(rawPoint)
|
|
const snapped = resolveAffordancePlanPoint(options, {
|
|
node,
|
|
nodes,
|
|
rawPoint,
|
|
fallbackPoint,
|
|
modifiers,
|
|
holeIndex,
|
|
mode: 'move-vertex',
|
|
})
|
|
const nextRing: [number, number][] = originalRing.map((p, i) =>
|
|
i === vertexIndex ? [snapped[0], snapped[1]] : p,
|
|
)
|
|
const patch = buildRingPatch(node, holeIndex, nextRing)
|
|
useScene
|
|
.getState()
|
|
.updateNodes([{ id: node.id, data: patch as Partial<unknown> as never }])
|
|
},
|
|
canCommit() {
|
|
const final = useScene.getState().nodes[node.id] as N | undefined
|
|
if (!final || (final as unknown as { type: string }).type !== kind) return false
|
|
const finalRing = holeIndex === undefined ? final.polygon : (final.holes ?? [])[holeIndex]
|
|
return !!finalRing && finalRing.length >= 3
|
|
},
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Companion to `createPolygonVertexAffordance`. Inserts a new vertex at
|
|
* the midpoint of edge `edgeIndex` (between vertices i and i+1) and
|
|
* then drags that new vertex with the pointer. The dispatcher's
|
|
* snapshot was taken **before** `start()` ran, so a pointer-up without
|
|
* movement reverts to the pre-insert ring — "click without drag" is a
|
|
* no-op, matching the legacy slab boundary editor.
|
|
*/
|
|
export function createPolygonAddVertexAffordance<N extends PolygonShape & { id: AnyNodeId }>(
|
|
kind: string,
|
|
options?: PolygonAffordanceOptions<N>,
|
|
): FloorplanAffordance<N> {
|
|
return {
|
|
start({ node, payload, nodes }): FloorplanAffordanceSession {
|
|
const { edgeIndex, holeIndex } = payload as AddVertexPayload
|
|
const originalRing = getRing(node, holeIndex)
|
|
if (!originalRing) {
|
|
return {
|
|
affectedIds: [node.id],
|
|
apply() {},
|
|
canCommit() {
|
|
return false
|
|
},
|
|
}
|
|
}
|
|
const a = originalRing[edgeIndex]
|
|
const b = originalRing[(edgeIndex + 1) % originalRing.length]
|
|
if (!a || !b) {
|
|
return {
|
|
affectedIds: [node.id],
|
|
apply() {},
|
|
canCommit() {
|
|
return false
|
|
},
|
|
}
|
|
}
|
|
const midpoint: [number, number] = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]
|
|
const newVertexIndex = edgeIndex + 1
|
|
const initialRing: [number, number][] = [
|
|
...originalRing.slice(0, newVertexIndex),
|
|
midpoint,
|
|
...originalRing.slice(newVertexIndex),
|
|
]
|
|
|
|
// Apply the insert immediately so the user sees the new vertex
|
|
// before they even move.
|
|
const initialPatch = buildRingPatch(node, holeIndex, initialRing)
|
|
useScene
|
|
.getState()
|
|
.updateNodes([{ id: node.id, data: initialPatch as Partial<unknown> as never }])
|
|
|
|
return {
|
|
affectedIds: [node.id],
|
|
apply({ planPoint, modifiers }) {
|
|
const rawPoint: WallPlanPoint = [planPoint[0], planPoint[1]]
|
|
const fallbackPoint = modifiers.shiftKey ? rawPoint : snapPointToGrid(rawPoint)
|
|
const snapped = resolveAffordancePlanPoint(options, {
|
|
node,
|
|
nodes,
|
|
rawPoint,
|
|
fallbackPoint,
|
|
modifiers,
|
|
holeIndex,
|
|
mode: 'add-vertex',
|
|
})
|
|
const nextRing: [number, number][] = initialRing.map((p, i) =>
|
|
i === newVertexIndex ? [snapped[0], snapped[1]] : p,
|
|
)
|
|
const patch = buildRingPatch(node, holeIndex, nextRing)
|
|
useScene
|
|
.getState()
|
|
.updateNodes([{ id: node.id, data: patch as Partial<unknown> as never }])
|
|
},
|
|
canCommit() {
|
|
const final = useScene.getState().nodes[node.id] as N | undefined
|
|
if (!final || (final as unknown as { type: string }).type !== kind) return false
|
|
const finalRing = holeIndex === undefined ? final.polygon : (final.holes ?? [])[holeIndex]
|
|
return !!finalRing && finalRing.length >= 3
|
|
},
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Edge-drag: move a whole edge perpendicular to itself. Both endpoints
|
|
* translate by `edgeNormal * projectedDelta`. The other vertices of
|
|
* the ring stay put — adjacent edges effectively pivot around their
|
|
* far endpoints.
|
|
*
|
|
* Snap is grid-aligned on the projected scalar (so a Shift-free drag
|
|
* lands on grid lines along the edge normal).
|
|
*/
|
|
export function createPolygonMoveEdgeAffordance<N extends PolygonShape & { id: AnyNodeId }>(
|
|
kind: string,
|
|
options?: PolygonAffordanceOptions<N>,
|
|
): FloorplanAffordance<N> {
|
|
return {
|
|
start({ node, payload, initialPlanPoint, nodes }): FloorplanAffordanceSession {
|
|
const { edgeIndex, holeIndex } = payload as EdgeDragPayload
|
|
const originalRing = getRing(node, holeIndex)
|
|
if (!originalRing) {
|
|
return {
|
|
affectedIds: [node.id],
|
|
apply() {},
|
|
canCommit() {
|
|
return false
|
|
},
|
|
}
|
|
}
|
|
const startVertex = originalRing[edgeIndex]
|
|
const endVertex = originalRing[(edgeIndex + 1) % originalRing.length]
|
|
if (!startVertex || !endVertex) {
|
|
return {
|
|
affectedIds: [node.id],
|
|
apply() {},
|
|
canCommit() {
|
|
return false
|
|
},
|
|
}
|
|
}
|
|
const dx = endVertex[0] - startVertex[0]
|
|
const dy = endVertex[1] - startVertex[1]
|
|
const len = Math.hypot(dx, dy)
|
|
if (len < 1e-6) {
|
|
return {
|
|
affectedIds: [node.id],
|
|
apply() {},
|
|
canCommit() {
|
|
return false
|
|
},
|
|
}
|
|
}
|
|
// Perpendicular unit normal (rotate 90° CCW).
|
|
const normalX = -dy / len
|
|
const normalY = dx / len
|
|
const startX = initialPlanPoint[0]
|
|
const startY = initialPlanPoint[1]
|
|
const edgeStartIndex = edgeIndex
|
|
const edgeEndIndex = (edgeIndex + 1) % originalRing.length
|
|
|
|
return {
|
|
affectedIds: [node.id],
|
|
apply({ planPoint, modifiers }) {
|
|
// Project the pointer delta onto the edge normal — that's the
|
|
// signed perpendicular distance the edge should travel.
|
|
const rawPoint: WallPlanPoint = [planPoint[0], planPoint[1]]
|
|
const deltaX = rawPoint[0] - startX
|
|
const deltaY = rawPoint[1] - startY
|
|
let projection = deltaX * normalX + deltaY * normalY
|
|
if (!modifiers.shiftKey) {
|
|
// Snap the projection scalar to a 0.5m grid (legacy uses the
|
|
// same half-meter snap for slab edges).
|
|
projection = Math.round(projection * 2) / 2
|
|
}
|
|
const fallbackPoint: WallPlanPoint = [
|
|
startX + normalX * projection,
|
|
startY + normalY * projection,
|
|
]
|
|
const snappedPoint = resolveAffordancePlanPoint(options, {
|
|
node,
|
|
nodes,
|
|
rawPoint,
|
|
fallbackPoint,
|
|
modifiers,
|
|
holeIndex,
|
|
mode: 'move-edge',
|
|
})
|
|
const normalDistance =
|
|
(snappedPoint[0] - startX) * normalX + (snappedPoint[1] - startY) * normalY
|
|
const nextRing: [number, number][] = originalRing.map((p, i) => {
|
|
if (i === edgeStartIndex || i === edgeEndIndex) {
|
|
return [p[0] + normalX * normalDistance, p[1] + normalY * normalDistance]
|
|
}
|
|
return [p[0], p[1]] as [number, number]
|
|
})
|
|
const patch = buildRingPatch(node, holeIndex, nextRing)
|
|
useScene
|
|
.getState()
|
|
.updateNodes([{ id: node.id, data: patch as Partial<unknown> as never }])
|
|
},
|
|
canCommit() {
|
|
const final = useScene.getState().nodes[node.id] as N | undefined
|
|
if (!final || (final as unknown as { type: string }).type !== kind) return false
|
|
const finalRing = holeIndex === undefined ? final.polygon : (final.holes ?? [])[holeIndex]
|
|
return !!finalRing && finalRing.length >= 3
|
|
},
|
|
}
|
|
},
|
|
}
|
|
}
|