morgan/editor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

perfect wall mitering

Browse Source
This commit is contained in:
wass08
2026-01-26 18:17:46 +09:00
parent abd8e327fe
commit d4c3fe2afb
1 changed files with 111 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/core/src/systems/wall/wall-mitering.ts
+95 -13
View File
@@ -39,18 +39,52 @@ function createLineFromPointAndVector(p: Point2D, v: Point2D): LineEquation {
return { a, b, c }
}
/**
* Checks if a point lies on a wall segment (not at its endpoints)
*/
function pointOnWallSegment(point: Point2D, wall: WallNode, tolerance = TOLERANCE): boolean {
const start: Point2D = { x: wall.start[0], y: wall.start[1] }
const end: Point2D = { x: wall.end[0], y: wall.end[1] }
// Check if point is at endpoints (those are handled separately)
if (pointToKey(point, tolerance) === pointToKey(start, tolerance)) return false
if (pointToKey(point, tolerance) === pointToKey(end, tolerance)) return false
// Vector from start to end
const v = { x: end.x - start.x, y: end.y - start.y }
const L = Math.sqrt(v.x * v.x + v.y * v.y)
if (L < 1e-9) return false
// Vector from start to point
const w = { x: point.x - start.x, y: point.y - start.y }
// Project point onto wall line (t is parametric position along segment)
const t = (v.x * w.x + v.y * w.y) / (L * L)
// Check if projection is within segment (not at endpoints)
if (t < tolerance || t > 1 - tolerance) return false
// Check distance from point to line
const projX = start.x + t * v.x
const projY = start.y + t * v.y
const dist = Math.sqrt((point.x - projX) ** 2 + (point.y - projY) ** 2)
return dist < tolerance
}
// ============================================================================
// JUNCTION DETECTION (exactly like demo)
// ============================================================================
interface Junction {
meetingPoint: Point2D
connectedWalls: Array<{ wall: WallNode; endType: 'start' | 'end' }>
connectedWalls: Array<{ wall: WallNode; endType: 'start' | 'end' | 'passthrough' }>
}
function findJunctions(walls: WallNode[]): Map<string, Junction> {
const junctions = new Map<string, Junction>()
// First pass: group walls by their endpoints
for (const wall of walls) {
const startPt: Point2D = { x: wall.start[0], y: wall.start[1] }
const endPt: Point2D = { x: wall.end[0], y: wall.end[1] }
@@ -69,6 +103,19 @@ function findJunctions(walls: WallNode[]): Map<string, Junction> {
junctions.get(keyEnd)!.connectedWalls.push({ wall, endType: 'end' })
}
// Second pass: detect T-junctions (walls passing through junction points)
for (const [_key, junction] of junctions.entries()) {
for (const wall of walls) {
// Skip if wall already in this junction
if (junction.connectedWalls.some((cw) => cw.wall.id === wall.id)) continue
// Check if junction point lies on this wall's segment (not at endpoints)
if (pointOnWallSegment(junction.meetingPoint, wall)) {
junction.connectedWalls.push({ wall, endType: 'passthrough' })
}
}
}
// Filter to only junctions with 2+ walls
const actualJunctions = new Map<string, Junction>()
for (const [key, junction] of junctions.entries()) {
@@ -89,6 +136,7 @@ interface ProcessedWall {
angle: number
edgeA: LineEquation // Left edge
edgeB: LineEquation // Right edge
isPassthrough: boolean // True if wall passes through junction (T-junction)
}
function calculateJunctionIntersections(
@@ -101,7 +149,28 @@ function calculateJunctionIntersections(
for (const { wall, endType } of connectedWalls) {
const halfT = getThickness(wall) / 2
// Outgoing vector (pointing away from junction)
if (endType === 'passthrough') {
// For passthrough walls (T-junctions), add both directions
// This allows walls meeting the middle of this wall to miter against it
const v1 = { x: wall.end[0] - wall.start[0], y: wall.end[1] - wall.start[1] }
const v2 = { x: -v1.x, y: -v1.y }
for (const v of [v1, v2]) {
const L = Math.sqrt(v.x * v.x + v.y * v.y)
if (L < 1e-9) continue
const nUnit = { x: -v.y / L, y: v.x / L }
const pA = { x: meetingPoint.x + nUnit.x * halfT, y: meetingPoint.y + nUnit.y * halfT }
const pB = { x: meetingPoint.x - nUnit.x * halfT, y: meetingPoint.y - nUnit.y * halfT }
const edgeA = createLineFromPointAndVector(pA, v)
const edgeB = createLineFromPointAndVector(pB, v)
const angle = Math.atan2(v.y, v.x)
processedWalls.push({ wallId: wall.id, angle, edgeA, edgeB, isPassthrough: true })
}
} else {
// Normal wall endpoint (start or end)
const v =
endType === 'start'
? { x: wall.end[0] - wall.start[0], y: wall.end[1] - wall.start[1] }
@@ -110,21 +179,16 @@ function calculateJunctionIntersections(
const L = Math.sqrt(v.x * v.x + v.y * v.y)
if (L < 1e-9) continue
// Perpendicular unit vector (90° CCW = "left" of outgoing direction)
const nUnit = { x: -v.y / L, y: v.x / L }
// Points on left (A) and right (B) edges at the junction
const pA = { x: meetingPoint.x + nUnit.x * halfT, y: meetingPoint.y + nUnit.y * halfT }
const pB = { x: meetingPoint.x - nUnit.x * halfT, y: meetingPoint.y - nUnit.y * halfT }
// Edge lines (direction parallel to wall)
const edgeA = createLineFromPointAndVector(pA, v)
const edgeB = createLineFromPointAndVector(pB, v)
// Angle for sorting
const angle = Math.atan2(v.y, v.x)
processedWalls.push({ wallId: wall.id, angle, edgeA, edgeB })
processedWalls.push({ wallId: wall.id, angle, edgeA, edgeB, isPassthrough: false })
}
}
// Sort by outgoing angle
@@ -133,7 +197,7 @@ function calculateJunctionIntersections(
console.log(`\n=== Junction at (${meetingPoint.x.toFixed(2)}, ${meetingPoint.y.toFixed(2)}) ===`)
console.log('Walls sorted by angle:')
for (const w of processedWalls) {
console.log(` ${w.wallId}: angle=${((w.angle * 180) / Math.PI).toFixed(1)}°`)
console.log(` ${w.wallId}: angle=${((w.angle * 180) / Math.PI).toFixed(1)}°${w.isPassthrough ? ' (passthrough)' : ''}`)
}
const wallIntersections = new Map<string, { left?: Point2D; right?: Point2D }>()
@@ -161,19 +225,25 @@ function calculateJunctionIntersections(
}
console.log(`Intersection ${i}: wall1=${wall1.wallId}.edgeA ∩ wall2=${wall2.wallId}.edgeB = (${p.x.toFixed(3)}, ${p.y.toFixed(3)})`)
console.log(` -> ${wall1.wallId}.left = p, ${wall2.wallId}.right = p`)
// Assign intersection to both walls (exactly like demo)
// Only assign intersection to non-passthrough walls
// Passthrough walls don't receive junction data (their geometry doesn't change)
if (!wall1.isPassthrough) {
console.log(` -> ${wall1.wallId}.left = p`)
if (!wallIntersections.has(wall1.wallId)) {
wallIntersections.set(wall1.wallId, {})
}
wallIntersections.get(wall1.wallId)!.left = p
}
if (!wall2.isPassthrough) {
console.log(` -> ${wall2.wallId}.right = p`)
if (!wallIntersections.has(wall2.wallId)) {
wallIntersections.set(wall2.wallId, {})
}
wallIntersections.get(wall2.wallId)!.right = p
}
}
console.log('Final wall intersections:')
for (const [id, data] of wallIntersections) {
@@ -229,7 +299,7 @@ export function getAdjacentWallIds(allWalls: WallNode[], dirtyWallIds: Set<strin
const wallStart: Point2D = { x: wall.start[0], y: wall.start[1] }
const wallEnd: Point2D = { x: wall.end[0], y: wall.end[1] }
// Check corner connections
// Check corner connections (endpoints meeting)
const startKey = pointToKey(wallStart)
const endKey = pointToKey(wallEnd)
const dirtyStartKey = pointToKey(dirtyStart)
@@ -242,6 +312,18 @@ export function getAdjacentWallIds(allWalls: WallNode[], dirtyWallIds: Set<strin
endKey === dirtyEndKey
) {
adjacent.add(wall.id)
continue
}
// Check T-junction connections (dirty wall endpoint on other wall's segment)
if (pointOnWallSegment(dirtyStart, wall) || pointOnWallSegment(dirtyEnd, wall)) {
adjacent.add(wall.id)
continue
}
// Check reverse T-junction (other wall endpoint on dirty wall's segment)
if (pointOnWallSegment(wallStart, dirtyWall) || pointOnWallSegment(wallEnd, dirtyWall)) {
adjacent.add(wall.id)
}
}
}