114 lines
4.2 KiB
TypeScript
114 lines
4.2 KiB
TypeScript
// Editing wire routes. A route is the full point list from the output pin
|
|
// to the input pin; a wire stores only the corners in between (`pts`).
|
|
|
|
import { simplify, type Pt } from './geometry'
|
|
|
|
const sign = (n: number) => (n > 0 ? 1 : n < 0 ? -1 : 0)
|
|
const copy = (pts: Pt[]) => pts.map(p => [p[0], p[1]] as Pt)
|
|
|
|
/** Axis a segment moves along when dragged: x (0) for vertical segments, y (1) for horizontal ones. */
|
|
export function dragAxis(a: Pt, b: Pt): 0 | 1 {
|
|
return a[0] === b[0] ? 0 : 1
|
|
}
|
|
|
|
/**
|
|
* Prepares dragging segment `i` sideways. A segment that touches a pin gets
|
|
* a one-unit stub at that end, so the pin stays where it is and the wire
|
|
* jogs right next to it. Returns null for segments too short to move.
|
|
*/
|
|
export function segmentDrag(route: Pt[], i: number): { base: Pt[]; k: number; axis: 0 | 1 } | null {
|
|
const last = route.length - 1
|
|
const a = route[i]!
|
|
const b = route[i + 1]!
|
|
const axis = dragAxis(a, b)
|
|
const u: Pt = [sign(b[0] - a[0]), sign(b[1] - a[1])]
|
|
const len = Math.abs(b[0] - a[0]) + Math.abs(b[1] - a[1])
|
|
const base = copy(route)
|
|
const fromPin = i === 0
|
|
const toPin = i + 1 === last
|
|
if (fromPin && toPin) {
|
|
if (len < 2) return null
|
|
base.splice(1, 0, [a[0] + u[0], a[1] + u[1]], [b[0] - u[0], b[1] - u[1]])
|
|
return { base, k: 1, axis }
|
|
}
|
|
if (toPin) base.splice(last, 0, [b[0] - u[0], b[1] - u[1]])
|
|
if (fromPin) {
|
|
base.splice(1, 0, [a[0] + u[0], a[1] + u[1]])
|
|
return { base, k: 1, axis }
|
|
}
|
|
return { base, k: i, axis }
|
|
}
|
|
|
|
/** Corner points after shifting segment `k` of `base` by `delta` along `axis`. */
|
|
export function moveSegment(base: Pt[], k: number, axis: 0 | 1, delta: number): Pt[] {
|
|
const pts = copy(base)
|
|
pts[k]![axis] += delta
|
|
pts[k + 1]![axis] += delta
|
|
return simplify(pts).slice(1, -1)
|
|
}
|
|
|
|
/**
|
|
* Corner points after moving corner `i` of a route. Its neighbours follow
|
|
* so the wire stays square; next to a pin, a one-unit stub keeps the wire
|
|
* leaving the pin straight.
|
|
*/
|
|
export function moveCorner(route: Pt[], i: number, to: Pt): Pt[] {
|
|
const pts = copy(route)
|
|
const last = route.length - 1
|
|
const old = route[i]!
|
|
pts[i] = [to[0], to[1]]
|
|
for (const j of [i - 1, i + 1]) {
|
|
if (j <= 0 || j >= last) continue
|
|
if (route[j]![1] === old[1]) pts[j]![1] = to[1]
|
|
else pts[j]![0] = to[0]
|
|
}
|
|
const off = to[1] !== old[1]
|
|
if (off && i === last - 1 && route[last]![1] === old[1]) {
|
|
const [px, py] = route[last]!
|
|
pts.splice(last, 0, [px - 1, to[1]], [px - 1, py])
|
|
}
|
|
if (off && i === 1 && route[0]![1] === old[1]) {
|
|
const [px, py] = route[0]!
|
|
pts.splice(1, 0, [px + 1, py], [px + 1, to[1]])
|
|
}
|
|
return simplify(pts).slice(1, -1)
|
|
}
|
|
|
|
/** The grid point on segment `i` closest to `at`. */
|
|
export function pointOnSegment(route: Pt[], i: number, at: Pt): Pt {
|
|
const a = route[i]!
|
|
const b = route[i + 1]!
|
|
const clamp = (v: number, p: number, q: number) => Math.min(Math.max(v, Math.min(p, q)), Math.max(p, q))
|
|
return a[0] === b[0] ? [a[0], clamp(Math.round(at[1]), a[1], b[1])] : [clamp(Math.round(at[0]), a[0], b[0]), a[1]]
|
|
}
|
|
|
|
/**
|
|
* Splits segment `i` at the grid point nearest `at` and prepares to drag the
|
|
* part after it sideways, which pulls a new step into the wire.
|
|
*/
|
|
export function splitDrag(route: Pt[], i: number, at: Pt) {
|
|
const c = pointOnSegment(route, i, at)
|
|
const b = route[i + 1]!
|
|
if (c[0] === b[0] && c[1] === b[1]) return segmentDrag(route, i)
|
|
const pts = [...copy(route.slice(0, i + 1)), c, [c[0], c[1]] as Pt, ...copy(route.slice(i + 1))]
|
|
return segmentDrag(pts, i + 2)
|
|
}
|
|
|
|
/**
|
|
* Finishes a branch toward its target pin: a branch that leaves a vertical
|
|
* segment steps sideways first, so it forms a clear T instead of running on
|
|
* along the wire it came from.
|
|
*/
|
|
export function branchTo(corners: Pt[], from: Pt, to: Pt): Pt[] {
|
|
const c = corners[corners.length - 1]
|
|
const prev = corners[corners.length - 2] ?? from
|
|
if (!c || prev[0] !== c[0] || c[1] === to[1]) return corners
|
|
return [...corners, [Math.round((c[0] + to[0]) / 2), c[1]]]
|
|
}
|
|
|
|
/** Corners for a new wire that leaves an existing route at the point nearest `at` on segment `i`. */
|
|
export function branchCorners(route: Pt[], i: number, at: Pt): Pt[] {
|
|
const c = pointOnSegment(route, i, at)
|
|
return simplify([...copy(route.slice(0, i + 1)), c]).slice(1)
|
|
}
|