+ {`${guide.label} · Y ${elevationText}`}
+
+
+
+
+ )
+}
diff --git a/packages/editor/src/components/ui/helpers/helper-manager.tsx b/packages/editor/src/components/ui/helpers/helper-manager.tsx
index 83b1c2e3b..ff1f2af62 100644
--- a/packages/editor/src/components/ui/helpers/helper-manager.tsx
+++ b/packages/editor/src/components/ui/helpers/helper-manager.tsx
@@ -4,6 +4,7 @@ import {
type AnyNode,
type AnyNodeId,
nodeRegistry,
+ type TerrainVerb,
useScene,
} from '@pascal-app/core'
import { useViewer } from '@pascal-app/viewer'
@@ -53,6 +54,35 @@ function reshapingHints(reshape: ReshapeKind): ContextualShortcutHint[] {
]
}
+// Sculpt mode's HUD. The verb is named rather than described because it is the one
+// piece of state a user loses track of between strokes. This stays even though the
+// brush ring now carries the verb in colour (`brushRingColor`): the ring says
+// *which* verb only to someone who already knows the mapping, and the HUD is what
+// teaches it.
+function terrainSculptHints(verb: TerrainVerb, sampling: boolean): ContextualShortcutHint[] {
+ if (sampling) {
+ return [
+ { keys: ['Click'], label: 'Pick target height' },
+ { keys: ['Esc'], label: 'Cancel picking' },
+ ]
+ }
+ const action =
+ verb === 'raise'
+ ? 'Raise ground'
+ : verb === 'lower'
+ ? 'Lower ground'
+ : verb === 'flatten'
+ ? 'Level ground'
+ : 'Smooth ground'
+ return [
+ { keys: ['Drag'], label: action },
+ // Nested, so the two render as alternatives ("[ / ]") rather than a chord —
+ // a flat `['[', ']']` joins with "+" and would read as "press both".
+ { keys: [['[', ']']], label: 'Brush size' },
+ { keys: ['Esc'], label: 'Cancel stroke' },
+ ]
+}
+
type ActiveModifierKeys = {
command: boolean
shift: boolean
@@ -95,6 +125,8 @@ function useActiveModifierKeys(): ActiveModifierKeys {
export function HelperManager() {
const mode = useEditor((s) => s.mode)
const tool = useEditor((s) => s.tool)
+ const terrainVerb = useEditor((s) => s.terrainVerb)
+ const terrainSampling = useEditor((s) => s.terrainSampling)
const isFirstPersonMode = useEditor((s) => s.isFirstPersonMode)
const measurementToolKind = useEditor((s) => s.toolDefaults.measurement?.kind)
const workspaceMode = useEditor((s) => s.workspaceMode)
@@ -214,6 +246,15 @@ export function HelperManager() {
return
+ setTerrainVerb(next)}
+ options={VERB_OPTIONS.map(({ value, iconSrc, hint }) => ({
+ value,
+ label: (
+
+ 
+ {hint}
+
+ ),
+ }))}
+ value={verb}
+ />
+
+
+ {VERB_HINTS[verb]}
+
+ {/*
+ Range from `brushRadiusRange`, shared with the `[`/`]` keys. The low end
+ is not a preference: it tracks the field's sample spacing, and a brush
+ under it lands between samples and paints nothing at all.
+ */}
+ setTerrainBrush({ radius })}
+ precision={1}
+ step={0.5}
+ unit="m"
+ value={brush.radius}
+ />
+ setTerrainBrush({ strength })}
+ precision={2}
+ step={0.05}
+ value={brush.strength}
+ />
+ setTerrainBrush({ falloff })}
+ precision={2}
+ step={0.05}
+ value={brush.falloff}
+ />
+ setTerrainBrush({ shape })}
+ options={[
+ { value: 'round', label: 'Round' },
+ { value: 'square', label: 'Square' },
+ ]}
+ value={brush.shape}
+ />
+
+
+ {verb === 'flatten' && (
+
+
+ )}
+
+
+
+
+
+
+ + {sampling + ? 'Click the ground to pick its height as the target.' + : flattenTarget === null + ? 'No target yet — the first click samples the ground under it.' + : 'Every flatten stroke levels toward this height.'} +
+
+
+
+
+
+ Foundation
+
+
+ Extends the perimeter down to terrain. The flat surface, base, and thickness stay
+ unchanged.
+
+ )}
+
+ )}
+
{elevationPresets.map((preset) => (
): Map {
@@ -49,6 +49,15 @@ function levelSlabContextSignatures(nodes: Record): Map()
for (const [levelId, parts] of partsByLevel.entries()) {
signatures.set(levelId, parts.sort().join('||'))
diff --git a/packages/nodes/src/slab/tool.tsx b/packages/nodes/src/slab/tool.tsx
index ba54c3c1a..80a432618 100644
--- a/packages/nodes/src/slab/tool.tsx
+++ b/packages/nodes/src/slab/tool.tsx
@@ -5,23 +5,33 @@ import {
emitter,
type GridEvent,
type LevelNode,
+ resolveSlabPlacementElevation,
snapPointAlongAngleRay,
snapPointToGrid,
useScene,
} from '@pascal-app/core'
import {
CursorSphere,
+ clearPlacementSurface,
clearSlabSnapFeedback,
EDITOR_LAYER,
+ type HorizontalConstructionPlane,
isAngleSnapActive,
isGridSnapActive,
markToolCancelConsumed,
+ publishHorizontalConstructionPlane,
+ publishPlacementSurface,
+ resampleTerrainConstructionPlane,
+ resolveEventConstructionPlane,
+ resolveLevelConstructionPlane,
+ resolvePointerSupportSurface,
resolveSlabPlanPointSnap,
triggerSFX,
useEditor,
useFloorplanDraftPreview,
} from '@pascal-app/editor'
import { useViewer } from '@pascal-app/viewer'
+import { useThree } from '@react-three/fiber'
import { useEffect, useMemo, useRef, useState } from 'react'
import { BufferGeometry, DoubleSide, type Group, type Line, Shape, Vector3 } from 'three'
import { type SlabCompletionTrigger, shouldRegistryCommitSlab } from './placement-ownership'
@@ -40,15 +50,25 @@ import { SlabNode } from './schema'
*/
const Y_OFFSET = 0.02
+const SURFACE_UP = new Vector3(0, 1, 0)
+const surfacePointScratch = new Vector3()
-function commitSlabDrawing(levelId: LevelNode['id'], points: Array<[number, number]>): string {
+function commitSlabDrawing(
+ levelId: LevelNode['id'],
+ points: Array<[number, number]>,
+ baseElevation: number | null,
+): string {
const { createNode, nodes } = useScene.getState()
const slabCount = Object.values(nodes).filter((n) => n.type === 'slab').length
const name = `Slab ${slabCount + 1}`
// A placed slab preset seeds `toolDefaults.slab` (thickness, material, …)
// before the tool activates; the drawn polygon always wins.
const defaults = useEditor.getState().toolDefaults.slab ?? {}
- const slab = SlabNode.parse({ ...defaults, name, polygon: points })
+ const authored = SlabNode.parse({ ...defaults, name, polygon: points })
+ const slab = {
+ ...authored,
+ elevation: resolveSlabPlacementElevation(authored, baseElevation),
+ }
createNode(slab, levelId)
triggerSFX('sfx:structure-build')
return slab.id
@@ -60,18 +80,30 @@ export const SlabTool: React.FC = () => {
const closingLineRef = useRef(null!)
const currentLevelId = useViewer((s) => s.selection.levelId)
const setSelection = useViewer((s) => s.setSelection)
+ const slabDefaults = useEditor((s) => s.toolDefaults.slab)
+ const isRecessed = slabDefaults?.recessed === true
+ const camera = useThree((state) => state.camera)
+ const cameraRef = useRef(camera)
+ cameraRef.current = camera
const [points, setPoints] = useState>([])
const [cursorPosition, setCursorPosition] = useState<[number, number]>([0, 0])
const [snappedCursorPosition, setSnappedCursorPosition] = useState<[number, number]>([0, 0])
const [levelY, setLevelY] = useState(0)
const previousSnappedPointRef = useRef<[number, number] | null>(null)
+ const constructionPlaneRef = useRef(null)
// Clear preset-seeded defaults on deactivation so a later manual slab draw
// isn't built with a stale preset's parameters. Unmount-only.
useEffect(() => () => useEditor.getState().setToolDefaults('slab', null), [])
- useEffect(() => () => clearSlabSnapFeedback(), [])
+ useEffect(
+ () => () => {
+ clearSlabSnapFeedback()
+ clearPlacementSurface()
+ },
+ [],
+ )
// Publish the live vertex count so the HUD shows "Finish" only at ≥ 3 points.
useEffect(() => {
@@ -96,15 +128,40 @@ export const SlabTool: React.FC = () => {
useEffect(() => {
if (!currentLevelId) return
+ const pointedSurfaceFor = (event: GridEvent) =>
+ event.nativeEvent?.target instanceof HTMLCanvasElement
+ ? resolvePointerSupportSurface(cameraRef.current, event.position)
+ : null
+
+ const resetDraft = () => {
+ setPoints([])
+ constructionPlaneRef.current = null
+ previousSnappedPointRef.current = null
+ clearSlabSnapFeedback()
+ clearPlacementSurface()
+ }
+
const onGridMove = (event: GridEvent) => {
if (!cursorRef.current) return
- const rawPoint: [number, number] = [event.localPosition[0], event.localPosition[2]]
+ const pointed = points.length === 0 && !isRecessed ? pointedSurfaceFor(event) : null
+ const plane =
+ constructionPlaneRef.current ?? (isRecessed ? resolveLevelConstructionPlane() : null)
+ if (plane) {
+ publishHorizontalConstructionPlane(event, plane)
+ } else if (pointed) {
+ publishPlacementSurface(
+ surfacePointScratch.set(event.position[0], pointed.worldY, event.position[2]),
+ SURFACE_UP,
+ )
+ }
+
+ const localPosition = pointed?.localPoint ?? event.localPosition
+ const rawPoint: [number, number] = [localPosition[0], localPosition[2]]
// Slab drafting is the 'polygon' snap context (grid / lines / off — no
// angle, no Shift bypass; Shift cycles the mode, Off is the bypass).
const gridStep = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0
const gridPosition: [number, number] = [...snapPointToGrid(rawPoint, gridStep)]
setCursorPosition(gridPosition)
- setLevelY(event.localPosition[1])
const lastPoint = points[points.length - 1]
// Angle lock only when the mode asks for it (polygon never does today, but
// honour the flag so the behaviour follows the HUD).
@@ -117,6 +174,13 @@ export const SlabTool: React.FC = () => {
fallbackPoint: orthoPoint,
levelId: currentLevelId,
}).point
+ const hoverPlane =
+ plane ??
+ resampleTerrainConstructionPlane(
+ resolveEventConstructionPlane(event, pointed),
+ displayPoint,
+ )
+ setLevelY(hoverPlane.localY)
useFloorplanDraftPreview.getState().setCursorPoint(displayPoint)
setSnappedCursorPosition(displayPoint)
if (
@@ -128,10 +192,10 @@ export const SlabTool: React.FC = () => {
triggerSFX('sfx:grid-snap')
}
previousSnappedPointRef.current = displayPoint
- cursorRef.current.position.set(displayPoint[0], event.localPosition[1], displayPoint[1])
+ cursorRef.current.position.set(displayPoint[0], hoverPlane.localY, displayPoint[1])
}
- const onGridClick = (_event: GridEvent) => {
+ const onGridClick = (event: GridEvent) => {
if (!currentLevelId) return
const clickPoint = previousSnappedPointRef.current ?? cursorPosition
const firstPoint = points[0]
@@ -142,12 +206,26 @@ export const SlabTool: React.FC = () => {
Math.abs(clickPoint[1] - firstPoint[1]) < 0.25
) {
if (shouldRegistryCommitSlab(useEditor.getState().viewMode, 'grid')) {
- const slabId = commitSlabDrawing(currentLevelId, points)
+ const slabId = commitSlabDrawing(
+ currentLevelId,
+ points,
+ constructionPlaneRef.current?.elevation ?? null,
+ )
setSelection({ selectedIds: [slabId] })
}
- setPoints([])
- clearSlabSnapFeedback()
+ resetDraft()
} else {
+ if (points.length === 0) {
+ const plane = isRecessed
+ ? (resolveLevelConstructionPlane() ?? resolveEventConstructionPlane(event, null))
+ : resampleTerrainConstructionPlane(
+ resolveEventConstructionPlane(event, pointedSurfaceFor(event)),
+ clickPoint,
+ )
+ constructionPlaneRef.current = plane
+ setLevelY(plane.localY)
+ publishHorizontalConstructionPlane(event, plane)
+ }
// Every non-closing vertex is a "start" tick; the closing click above
// fires the structure-build (end) cue.
triggerSFX('sfx:structure-build-start')
@@ -160,11 +238,14 @@ export const SlabTool: React.FC = () => {
const finishDrawing = (trigger: SlabCompletionTrigger) => {
if (points.length < 3) return
if (shouldRegistryCommitSlab(useEditor.getState().viewMode, trigger)) {
- const slabId = commitSlabDrawing(currentLevelId, points)
+ const slabId = commitSlabDrawing(
+ currentLevelId,
+ points,
+ constructionPlaneRef.current?.elevation ?? null,
+ )
setSelection({ selectedIds: [slabId] })
}
- setPoints([])
- clearSlabSnapFeedback()
+ resetDraft()
}
const onGridDoubleClick = (_event: GridEvent) => {
@@ -173,8 +254,7 @@ export const SlabTool: React.FC = () => {
const onCancel = () => {
if (points.length > 0) markToolCancelConsumed()
- setPoints([])
- clearSlabSnapFeedback()
+ resetDraft()
}
const onKeyDown = (e: KeyboardEvent) => {
@@ -197,7 +277,7 @@ export const SlabTool: React.FC = () => {
emitter.off('grid:double-click', onGridDoubleClick)
emitter.off('tool:cancel', onCancel)
}
- }, [currentLevelId, points, cursorPosition, setSelection])
+ }, [currentLevelId, points, cursorPosition, isRecessed, setSelection])
useEffect(() => {
if (!(mainLineRef.current && closingLineRef.current)) return
diff --git a/packages/nodes/src/stair/floor-stack.test.ts b/packages/nodes/src/stair/floor-stack.test.ts
index 4a822512b..b6477693e 100644
--- a/packages/nodes/src/stair/floor-stack.test.ts
+++ b/packages/nodes/src/stair/floor-stack.test.ts
@@ -3,15 +3,17 @@ import {
type AnyNode,
type AnyNodeDefinition,
getFloorPlacedElevation,
+ getFloorStackedPosition,
nodeRegistry,
registerNode,
+ resolveSupportSlabPatch,
type SlabNode,
StairNode,
StairSegmentNode,
spatialGridManager,
} from '@pascal-app/core'
import { stairDefinition } from './definition'
-import { getStairSegmentFloorPlacedFootprints } from './floor-stack'
+import { getStairFloorPlacedFootprints, getStairSegmentFloorPlacedFootprints } from './floor-stack'
const LEVEL_ID = 'level_test'
@@ -112,6 +114,82 @@ describe('stair floor-stack footprints', () => {
expect(footprints[1]?.rotation[1]).toBeCloseTo(Math.PI / 2)
})
+ test('derives spiral footprints from the parent instead of retained straight segments', () => {
+ const retainedSegment = StairSegmentNode.parse({
+ id: 'sseg_retained_after_spiral_conversion',
+ width: 1,
+ length: 4,
+ height: 2.8,
+ })
+ const spiral = StairNode.parse({
+ id: 'stair_spiral_preset',
+ parentId: LEVEL_ID,
+ stairType: 'spiral',
+ position: [3, 0, 4],
+ innerRadius: 0.3,
+ width: 1,
+ stepCount: 12,
+ sweepAngle: Math.PI * 2,
+ children: [retainedSegment.id],
+ })
+ const footprints = getStairFloorPlacedFootprints(spiral, {
+ [spiral.id]: spiral,
+ [retainedSegment.id]: retainedSegment,
+ })
+
+ expect(footprints.length).toBeGreaterThanOrEqual(24)
+ expect(
+ footprints.some((footprint) => (footprint.position?.[0] ?? 0) < spiral.position[0]),
+ ).toBe(true)
+ expect(
+ footprints.some((footprint) => (footprint.position?.[2] ?? 0) < spiral.position[2]),
+ ).toBe(true)
+ })
+
+ test('keeps a columnless spiral center hole out of the support footprint', () => {
+ registerNode(stairDefinition as unknown as AnyNodeDefinition)
+ addSlab(
+ [
+ [-0.08, -0.08],
+ [0.08, -0.08],
+ [0.08, 0.08],
+ [-0.08, 0.08],
+ ],
+ 0.8,
+ 'slab_inside_spiral_hole',
+ )
+
+ const level = makeLevel()
+ const spiral = StairNode.parse({
+ id: 'stair_spiral_hole',
+ parentId: LEVEL_ID,
+ stairType: 'spiral',
+ position: [0, 0, 0],
+ innerRadius: 0.5,
+ width: 0.8,
+ stepCount: 16,
+ showCenterColumn: false,
+ })
+ const footprints = getStairFloorPlacedFootprints(spiral, { [spiral.id]: spiral })
+
+ expect(
+ footprints.some((footprint) => {
+ const position = footprint.position ?? spiral.position
+ const radialDistance = Math.hypot(position[0], position[2])
+ return radialDistance < spiral.innerRadius
+ }),
+ ).toBe(false)
+ expect(
+ getFloorPlacedElevation({
+ node: spiral,
+ nodes: { [level.id]: level, [spiral.id]: spiral },
+ position: spiral.position,
+ rotation: spiral.rotation,
+ levelId: LEVEL_ID,
+ }),
+ ).toBeCloseTo(0)
+ })
+
test('uses the max slab elevation across stair segment footprints', () => {
registerNode(stairDefinition as unknown as AnyNodeDefinition)
@@ -174,4 +252,108 @@ describe('stair floor-stack footprints', () => {
}),
).toBeCloseTo(0.75)
})
+
+ test('persists the pointer-elected base across stacked slabs', () => {
+ registerNode(stairDefinition as unknown as AnyNodeDefinition)
+
+ const polygon: Array<[number, number]> = [
+ [-2, -1],
+ [2, -1],
+ [2, 5],
+ [-2, 5],
+ ]
+ addSlab(polygon, 0, 'slab_floor')
+ addSlab(polygon, 0.8, 'slab_deck')
+
+ const level = makeLevel()
+ const segment = StairSegmentNode.parse({
+ id: 'sseg_pointer_support',
+ width: 1,
+ length: 3,
+ height: 2.8,
+ })
+ const stair = StairNode.parse({
+ id: 'stair_pointer_support',
+ parentId: LEVEL_ID,
+ position: [0, 0, 0],
+ rotation: 0,
+ children: [segment.id],
+ })
+ const nodes = {
+ [level.id]: level,
+ [stair.id]: stair,
+ [segment.id]: { ...segment, parentId: stair.id },
+ }
+
+ const underDeckPatch = resolveSupportSlabPatch(stair, nodes, { maxElevation: 0 })
+ const onDeckPatch = resolveSupportSlabPatch(stair, nodes, { maxElevation: 0.8 })
+
+ expect(underDeckPatch.supportSlabId).toBe('slab_floor')
+ expect(onDeckPatch.supportSlabId).toBe('slab_deck')
+ expect(
+ getFloorStackedPosition({
+ node: { ...stair, ...underDeckPatch },
+ nodes,
+ position: stair.position,
+ rotation: stair.rotation,
+ })[1],
+ ).toBeCloseTo(0)
+ expect(
+ getFloorStackedPosition({
+ node: { ...stair, ...onDeckPatch },
+ nodes,
+ position: stair.position,
+ rotation: stair.rotation,
+ })[1],
+ ).toBeCloseTo(0.8)
+ })
+
+ test('elects a raised slab under a spiral preset footprint', () => {
+ registerNode(stairDefinition as unknown as AnyNodeDefinition)
+
+ addSlab(
+ [
+ [0.65, -0.35],
+ [1.35, -0.35],
+ [1.35, 0.35],
+ [0.65, 0.35],
+ ],
+ 0.8,
+ 'slab_under_spiral',
+ )
+
+ const level = makeLevel()
+ const retainedSegment = StairSegmentNode.parse({
+ id: 'sseg_spiral_support_retained',
+ width: 0.4,
+ length: 0.4,
+ height: 2.8,
+ })
+ const spiral = StairNode.parse({
+ id: 'stair_spiral_support',
+ parentId: LEVEL_ID,
+ stairType: 'spiral',
+ position: [0, 0, 0],
+ innerRadius: 0.3,
+ width: 1,
+ stepCount: 12,
+ sweepAngle: Math.PI * 2,
+ children: [retainedSegment.id],
+ })
+ const nodes = {
+ [level.id]: level,
+ [spiral.id]: spiral,
+ [retainedSegment.id]: { ...retainedSegment, parentId: spiral.id },
+ }
+
+ expect(
+ getFloorPlacedElevation({
+ node: spiral,
+ nodes,
+ position: spiral.position,
+ rotation: spiral.rotation,
+ levelId: LEVEL_ID,
+ }),
+ ).toBeCloseTo(0.8)
+ })
})
diff --git a/packages/nodes/src/stair/floor-stack.ts b/packages/nodes/src/stair/floor-stack.ts
index c21d4c85d..85c5a335f 100644
--- a/packages/nodes/src/stair/floor-stack.ts
+++ b/packages/nodes/src/stair/floor-stack.ts
@@ -15,6 +15,10 @@ export function getStairFloorPlacedFootprints(
stair: StairNode,
nodes: Readonly>,
): FloorPlacedFootprint[] {
+ if ((stair.stairType ?? 'straight') !== 'straight') {
+ return getArcStairFloorPlacedFootprints(stair)
+ }
+
const segments = (stair.children ?? [])
.map((childId) => nodes[childId as AnyNodeId])
.filter((node): node is StairSegmentNode => node?.type === 'stair-segment')
@@ -22,6 +26,51 @@ export function getStairFloorPlacedFootprints(
return getStairSegmentFloorPlacedFootprints(stair, segments)
}
+const MAX_ARC_FOOTPRINT_SWEEP = Math.PI / 12
+
+function getArcStairFloorPlacedFootprints(stair: StairNode): FloorPlacedFootprint[] {
+ const isSpiral = stair.stairType === 'spiral'
+ const innerRadius = Math.max(isSpiral ? 0.05 : 0.2, stair.innerRadius ?? (isSpiral ? 0.2 : 0.9))
+ const outerRadius = innerRadius + Math.max(stair.width ?? 1, 0.4)
+ const sweepAngle = stair.sweepAngle ?? (isSpiral ? Math.PI * 2 : Math.PI / 2)
+ const stepCount = Math.max(2, Math.round(stair.stepCount ?? 10))
+ const sliceCount = Math.max(stepCount, Math.ceil(Math.abs(sweepAngle) / MAX_ARC_FOOTPRINT_SWEEP))
+ const footprints: FloorPlacedFootprint[] = []
+
+ for (let index = 0; index < sliceCount; index += 1) {
+ const startAngle = -sweepAngle / 2 + (sweepAngle * index) / sliceCount
+ const endAngle = -sweepAngle / 2 + (sweepAngle * (index + 1)) / sliceCount
+ const midAngle = (startAngle + endAngle) / 2
+ const halfSweep = Math.abs(endAngle - startAngle) / 2
+ const projectedInnerRadius = innerRadius * Math.cos(halfSweep)
+ const radialSize = outerRadius - projectedInnerRadius
+ const tangentialSize = 2 * outerRadius * Math.sin(halfSweep)
+ const centerRadius = (outerRadius + projectedInnerRadius) / 2
+ const [offsetX, offsetZ] = rotateXZ(
+ Math.cos(midAngle) * centerRadius,
+ Math.sin(midAngle) * centerRadius,
+ stair.rotation,
+ )
+
+ footprints.push({
+ position: [stair.position[0] + offsetX, stair.position[1], stair.position[2] + offsetZ],
+ dimensions: [Math.max(radialSize, 0.01), 0.01, Math.max(tangentialSize, 0.01)],
+ rotation: [0, midAngle - stair.rotation, 0],
+ })
+ }
+
+ if (isSpiral && (stair.showCenterColumn ?? true)) {
+ const columnRadius = Math.max(0.05, Math.min(innerRadius * 0.72, innerRadius - 0.03))
+ footprints.push({
+ position: stair.position,
+ dimensions: [columnRadius * 2, 0.01, columnRadius * 2],
+ rotation: [0, 0, 0],
+ })
+ }
+
+ return footprints
+}
+
export function getStairSegmentFloorPlacedFootprints(
stair: StairNode,
segments: readonly StairSegmentNode[],
diff --git a/packages/nodes/src/wall/move-endpoint-tool.tsx b/packages/nodes/src/wall/move-endpoint-tool.tsx
index d81d8d8d9..199df4fdb 100644
--- a/packages/nodes/src/wall/move-endpoint-tool.tsx
+++ b/packages/nodes/src/wall/move-endpoint-tool.tsx
@@ -5,11 +5,12 @@ import {
collectAlignmentAnchors,
emitter,
type GridEvent,
+ getWallBaseElevationForNodes,
getWallCurveLength,
getWallThickness,
pauseSceneHistory,
resolveAlignment,
- resolveWallSupportSlabPatch,
+ resolveMovedWallSupportSlabPatch,
resumeSceneHistory,
runAsSingleSceneHistoryStep,
useLiveNodeOverrides,
@@ -39,6 +40,7 @@ import {
import { useViewer } from '@pascal-app/viewer'
import { Html } from '@react-three/drei'
import { useCallback, useEffect, useRef, useState } from 'react'
+import { LevelOffsetGroup } from '../shared/level-offset-group'
import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling'
/**
@@ -209,6 +211,12 @@ export const MoveWallEndpointTool: React.FC<{ target: MovingWallEndpoint }> = ({
})
const [altPressed, setAltPressed] = useState(false)
const unit = useViewer((s) => s.unit)
+ const nodes = useScene((state) => state.nodes)
+ const liveOverride = useLiveNodeOverrides((state) => state.overrides.get(target.wall.id))
+ const effectiveWall = liveOverride
+ ? ({ ...target.wall, ...liveOverride } as WallNode)
+ : target.wall
+ const wallBaseElevation = getWallBaseElevationForNodes(effectiveWall, nodes)
// Alt-detach only affects walls sharing the moving endpoint; walls linked
// solely to the fixed endpoint never move, so the hint would be noise.
@@ -564,7 +572,7 @@ export const MoveWallEndpointTool: React.FC<{ target: MovingWallEndpoint }> = ({
affectedIds.flatMap((id) => {
const wall = committedNodes[id]
return wall?.type === 'wall'
- ? [{ id, data: resolveWallSupportSlabPatch(wall, committedNodes) }]
+ ? [{ id, data: resolveMovedWallSupportSlabPatch(wall, committedNodes) }]
: []
}),
)
@@ -661,48 +669,52 @@ export const MoveWallEndpointTool: React.FC<{ target: MovingWallEndpoint }> = ({
end: previewEnd,
curveOffset: target.wall.curveOffset,
})
- const wallHeight = resolveWallOpeningCeiling(target.wall, useScene.getState().nodes)
+ const wallHeight = resolveWallOpeningCeiling(effectiveWall, nodes)
const dimMidX = (previewStart[0] + previewEnd[0]) / 2
const dimMidZ = (previewStart[1] + previewEnd[1]) / 2
return (
-
-
+
+
+ {canDetachCorner && (
+
+
+
)
}
diff --git a/packages/nodes/src/wall/move-tool.tsx b/packages/nodes/src/wall/move-tool.tsx
index 95744fa7f..293b40c4a 100644
--- a/packages/nodes/src/wall/move-tool.tsx
+++ b/packages/nodes/src/wall/move-tool.tsx
@@ -17,7 +17,7 @@ import {
planAutoCeilingsForLevel,
planAutoSlabsForLevel,
planWallMoveJunctions,
- resolveWallSupportSlabPatch,
+ resolveMovedWallSupportSlabPatch,
resumeSceneHistory,
type SlabNode,
useLiveNodeOverrides,
@@ -608,7 +608,7 @@ export const MoveWallTool: React.FC<{ node: WallNode }> = ({ node }) => {
affectedWallIds.flatMap((id) => {
const wall = committedNodes[id]
return wall?.type === 'wall'
- ? [{ id, data: resolveWallSupportSlabPatch(wall, committedNodes) }]
+ ? [{ id, data: resolveMovedWallSupportSlabPatch(wall, committedNodes) }]
: []
}),
)
diff --git a/packages/nodes/src/wall/panel.tsx b/packages/nodes/src/wall/panel.tsx
index 0144af7d5..0841857d8 100644
--- a/packages/nodes/src/wall/panel.tsx
+++ b/packages/nodes/src/wall/panel.tsx
@@ -22,7 +22,6 @@ import {
ActionButton,
ActionGroup,
curveReshapeScope,
- formatLinearMeasurement,
getLinearUnitLabel,
linearControlValueToMeters,
metersToLinearUnit,
@@ -106,12 +105,12 @@ export default function WallPanel() {
})
})
- // Effective height while the wall is plane-bound (`height` absent): the
- // storey plane minus the elected slab base — what the wall currently
- // renders at. `undefined` for walls with an explicit custom height.
- const planeBoundHeightMeters = useScene((s) => {
+ // Existing plane-bound walls have no stored height. Resolve their current
+ // body height for display and materialize it if the user edits height or
+ // enables terrain infill.
+ const resolvedHeightMeters = useScene((s) => {
const wall = selectedId ? (s.nodes[selectedId as AnyNodeId] as WallNode | undefined) : undefined
- if (wall?.type !== 'wall' || wall.height != null) return undefined
+ if (wall?.type !== 'wall') return undefined
return resolveWallOpeningCeiling(wall, s.nodes)
})
@@ -156,20 +155,15 @@ export default function WallPanel() {
[handleUpdate],
)
- const handleTopModeChange = useCallback(
- (mode: 'storey' | 'custom') => {
+ const handleBaseModeChange = useCallback(
+ (mode: 'terrain' | 'fixed') => {
const n = nodeRef.current
if (!n) return
- const isCustom = n.height != null
- if (mode === 'custom' && !isCustom) {
- // Seed from the current effective height so the geometry doesn't
- // jump at the moment of detaching from the storey plane.
- const seeded = resolveWallOpeningCeiling(n, useScene.getState().nodes)
- handleUpdate({ height: Math.max(0.1, seeded) })
- } else if (mode === 'storey' && isCustom) {
- // Absent `height` = plane-bound; the store strips undefined keys.
- handleUpdate({ height: undefined })
- }
+ const height = n.height ?? resolveWallOpeningCeiling(n, useScene.getState().nodes)
+ handleUpdate({
+ height: Math.max(0.1, height),
+ fillToTerrain: mode === 'terrain' ? true : undefined,
+ })
},
[handleUpdate],
)
@@ -189,8 +183,8 @@ export default function WallPanel() {
const length = getWallCurveLength(node)
- const isPlaneBound = node.height == null
- const height = node.height ?? planeBoundHeightMeters ?? 2.5
+ const followsTerrain = node.fillToTerrain === true
+ const height = node.height ?? resolvedHeightMeters ?? 2.5
const thickness = node.thickness ?? 0.1
const curveOffset = getClampedWallCurveOffset(node)
const maxCurveOffset = getMaxWallCurveOffset(node)
@@ -229,36 +223,35 @@ export default function WallPanel() {
unit={unitLabel}
value={displayLength}
/>
+
+ handleUpdate({
+ height: linearControlValueToMeters(v, unit, { maxMeters: 6, minMeters: 0.1 }),
+ })
+ }
+ precision={2}
+ step={0.1}
+ unit={unitLabel}
+ value={Math.round(displayHeight * 100) / 100}
+ />
- handleUpdate({
- height: linearControlValueToMeters(v, unit, { maxMeters: 6, minMeters: 0.1 }),
- })
- }
- precision={2}
- step={0.1}
- unit={unitLabel}
- value={Math.round(displayHeight * 100) / 100}
- />
)}
{
// the "segment tees into an existing wall" chain-termination test, so
// snapping onto the chain's own segments never reads as a join.
const chainWallIds = useRef([])
+ const constructionPlane = useRef(null)
const buildingState = useRef(0)
const [draftMeasurement, setDraftMeasurement] = useState(null)
const [axisGuide, setAxisGuide] = useState(null)
@@ -537,11 +546,67 @@ export const WallTool: React.FC = () => {
// grid plane alone.
const pointedSurfaceFor = (event: GridEvent) =>
event.nativeEvent?.target instanceof HTMLCanvasElement
- ? resolvePointerSupportSurface(cameraRef.current, event.position)
+ ? resolvePointerSupportSurface(cameraRef.current, event.position, {
+ includeNodeTopSurfaces: true,
+ })
: null
+ const snappedWallConstructionPlane = (
+ targetWallIds: string[],
+ walls: WallNode[],
+ ): HorizontalConstructionPlane | null => {
+ const activeWallIds = new Set(walls.map((wall) => wall.id))
+ const targetIds = targetWallIds.filter((id) => activeWallIds.has(id as WallNode['id']))
+ if (targetIds.length === 0) return null
+
+ const buildingId = useViewer.getState().selection.buildingId
+ const buildingMesh = buildingId ? sceneRegistry.nodes.get(buildingId as AnyNodeId) : undefined
+ const currentLevelId = useViewer.getState().selection.levelId
+ const levelMesh = currentLevelId
+ ? sceneRegistry.nodes.get(currentLevelId as AnyNodeId)
+ : undefined
+ let resolved: HorizontalConstructionPlane | null = null
+
+ for (const id of targetIds) {
+ const targetWall = walls.find((wall) => wall.id === id)
+ if (!targetWall) continue
+ const wallMesh = sceneRegistry.nodes.get(id as AnyNodeId)
+ if (!wallMesh) continue
+ wallMesh.getWorldPosition(wallSurfaceWorldScratch)
+ const worldY = wallSurfaceWorldScratch.y
+
+ wallSurfaceLocalScratch.copy(wallSurfaceWorldScratch)
+ if (buildingMesh) buildingMesh.worldToLocal(wallSurfaceLocalScratch)
+ const localY = wallSurfaceLocalScratch.y
+
+ wallSurfaceLocalScratch.copy(wallSurfaceWorldScratch)
+ if (levelMesh) levelMesh.worldToLocal(wallSurfaceLocalScratch)
+ const elevation = wallSurfaceLocalScratch.y
+
+ if (
+ resolved &&
+ (Math.abs(resolved.worldY - worldY) > 1e-4 ||
+ Math.abs((resolved.elevation ?? elevation) - elevation) > 1e-4 ||
+ resolved.supportSlabId !== (targetWall.supportSlabId ?? null))
+ ) {
+ // An ambiguous junction at different elevations transfers no plane.
+ return null
+ }
+ resolved = {
+ localY,
+ worldY,
+ elevation,
+ supportSlabId: targetWall.supportSlabId ?? null,
+ sourceNodeId: targetWall.id as AnyNodeId,
+ }
+ }
+
+ return resolved
+ }
+
const stopDrafting = () => {
buildingState.current = 0
+ constructionPlane.current = null
chainFirstVertex.current = null
chainWallIds.current = []
const draftPreview = useFloorplanDraftPreview.getState()
@@ -555,6 +620,7 @@ export const WallTool: React.FC = () => {
useAlignmentGuides.getState().clear()
useWallSnapIndicator.getState().clear()
useSegmentDraftChain.getState().clear('wall')
+ clearPlacementSurface()
}
const onGridMove = (event: GridEvent) => {
@@ -565,8 +631,10 @@ export const WallTool: React.FC = () => {
// lands where the cursor points and the preview/cursor Y
// (`event.localPosition[1]`) sits at the base the committed wall
// will elect. Aiming past the deck edge drops it back to the floor.
- const pointed = pointedSurfaceFor(event)
- if (pointed) {
+ const pointed = buildingState.current === 0 ? pointedSurfaceFor(event) : null
+ if (constructionPlane.current) {
+ publishHorizontalConstructionPlane(event, constructionPlane.current)
+ } else if (pointed) {
publishPlacementSurface(
surfacePointScratch.set(event.position[0], pointed.worldY, event.position[2]),
SURFACE_UP,
@@ -578,7 +646,9 @@ export const WallTool: React.FC = () => {
// can align with the level beneath it. Kept separate from `walls` so the
// measurement HUD only reports against the active level.
const snapWalls = [...walls, ...getBelowLevelWalls()]
- const localPoint: WallPlanPoint = [event.localPosition[0], event.localPosition[2]]
+ const localPoint: WallPlanPoint = pointed?.localPoint
+ ? [pointed.localPoint[0], pointed.localPoint[2]]
+ : [event.localPosition[0], event.localPosition[2]]
// Snapping is governed entirely by the snapping mode (grid / lines /
// angles / off). `'off'` is the bypass — there is no Shift hold-to-bypass.
const angleLocked = buildingState.current === 1 && isAngleSnapActive()
@@ -602,7 +672,8 @@ export const WallTool: React.FC = () => {
if (buildingState.current === 1) {
const snappedLocal = gridPosition
- endingPoint.current.set(snappedLocal[0], event.localPosition[1], snappedLocal[1])
+ const draftY = constructionPlane.current?.localY ?? event.localPosition[1]
+ endingPoint.current.set(snappedLocal[0], draftY, snappedLocal[1])
const draftPreview = useFloorplanDraftPreview.getState()
draftPreview.setWallDraftStart([startingPoint.current.x, startingPoint.current.z])
draftPreview.setWallDraftEnd(snappedLocal)
@@ -645,7 +716,11 @@ export const WallTool: React.FC = () => {
),
)
} else {
- cursorRef.current.position.set(gridPosition[0], event.localPosition[1], gridPosition[1])
+ const hoverPlane = resampleTerrainConstructionPlane(
+ resolveEventConstructionPlane(event, pointed),
+ gridPosition,
+ )
+ cursorRef.current.position.set(gridPosition[0], hoverPlane.localY, gridPosition[1])
setDraftMeasurement(null)
setAxisGuide(null)
}
@@ -661,18 +736,29 @@ export const WallTool: React.FC = () => {
const walls = getCurrentLevelWalls()
const snapWalls = [...walls, ...getBelowLevelWalls()]
- const localClick: WallPlanPoint = [event.localPosition[0], event.localPosition[2]]
+ const pointed = buildingState.current === 0 ? pointedSurfaceFor(event) : null
+ const localClick: WallPlanPoint = pointed?.localPoint
+ ? [pointed.localPoint[0], pointed.localPoint[2]]
+ : [event.localPosition[0], event.localPosition[2]]
if (buildingState.current === 0) {
- const snappedStart = alignPoint(
- snapWallDraftPointDetailed({
- point: localClick,
- walls: snapWalls,
- magnetic: isMagneticSnapActive(),
- }).point,
- )
+ const snapResult = snapWallDraftPointDetailed({
+ point: localClick,
+ walls: snapWalls,
+ magnetic: isMagneticSnapActive(),
+ })
+ const snappedStart = alignPoint(snapResult.point)
+ const resolvedPlane =
+ (pointed?.sourceNodeId
+ ? resolveEventConstructionPlane(event, pointed)
+ : pointMatches(snappedStart, snapResult.point)
+ ? snappedWallConstructionPlane(snapResult.targetWallIds, walls)
+ : null) ?? resolveEventConstructionPlane(event, pointed)
+ const plane = resampleTerrainConstructionPlane(resolvedPlane, snappedStart)
+ constructionPlane.current = plane
+ publishHorizontalConstructionPlane(event, plane)
gridPosition = snappedStart
- startingPoint.current.set(snappedStart[0], event.localPosition[1], snappedStart[1])
+ startingPoint.current.set(snappedStart[0], plane.localY, snappedStart[1])
chainFirstVertex.current = startingPoint.current.clone()
endingPoint.current.copy(startingPoint.current)
buildingState.current = 1
@@ -682,7 +768,7 @@ export const WallTool: React.FC = () => {
setAxisGuide({
origin: snappedStart,
endOrigin: null,
- y: event.localPosition[1],
+ y: plane.localY,
angleLabel: null,
})
triggerSFX('sfx:structure-build-start')
@@ -709,12 +795,16 @@ export const WallTool: React.FC = () => {
const dx = snappedEnd[0] - startingPoint.current.x
const dz = snappedEnd[1] - startingPoint.current.z
if (dx * dx + dz * dz < 0.01 * 0.01) return
- const pointed = pointedSurfaceFor(event)
// Both start and end are building-local ✓
const createdWall = createWallOnCurrentLevel(
[startingPoint.current.x, startingPoint.current.z],
snappedEnd,
- { supportCap: pointed ? pointed.elevation : null },
+ {
+ supportCap: constructionPlane.current?.elevation ?? null,
+ preferredSupportSlabId: constructionPlane.current?.supportSlabId ?? null,
+ constructionElevation: constructionPlane.current?.elevation ?? null,
+ constructionHeight: previewHeightRef.current,
+ },
)
if (!createdWall) return
chainWallIds.current.push(createdWall.id)
@@ -757,7 +847,8 @@ export const WallTool: React.FC = () => {
// chains its next segment from the same point (its own snap
// pipeline can resolve a slightly different endpoint).
useSegmentDraftChain.getState().setChainStart('wall', [nextStart[0], nextStart[1]])
- startingPoint.current.set(nextStart[0], event.localPosition[1], nextStart[1])
+ const draftY = constructionPlane.current?.localY ?? event.localPosition[1]
+ startingPoint.current.set(nextStart[0], draftY, nextStart[1])
endingPoint.current.copy(startingPoint.current)
const draftPreview = useFloorplanDraftPreview.getState()
draftPreview.setWallDraftEnd(null)
@@ -768,7 +859,7 @@ export const WallTool: React.FC = () => {
setAxisGuide({
origin: nextStart,
endOrigin: null,
- y: event.localPosition[1],
+ y: draftY,
angleLabel: null,
})
// Hide the preview until the next `onGridMove` writes the
diff --git a/packages/viewer/src/index.ts b/packages/viewer/src/index.ts
index 316d3a46c..fad3a529c 100644
--- a/packages/viewer/src/index.ts
+++ b/packages/viewer/src/index.ts
@@ -137,6 +137,10 @@ export {
THUMBNAIL_HEIGHT,
THUMBNAIL_WIDTH,
} from './lib/snapshot-pipeline'
+export {
+ buildTerrainPerimeterFillGeometry,
+ type TerrainPerimeterPoint,
+} from './lib/terrain-perimeter-fill'
export {
getPascalTextureRef,
type PascalTextureColorSpace,
diff --git a/packages/viewer/src/lib/terrain-perimeter-fill.ts b/packages/viewer/src/lib/terrain-perimeter-fill.ts
new file mode 100644
index 000000000..2f1d03890
--- /dev/null
+++ b/packages/viewer/src/lib/terrain-perimeter-fill.ts
@@ -0,0 +1,86 @@
+import { BufferGeometry, Float32BufferAttribute, ShapeUtils, Vector2 } from 'three'
+import { ensureRenderableGeometryAttributes } from './csg-utils'
+
+export type TerrainPerimeterPoint = { x: number; z: number }
+
+export function buildTerrainPerimeterFillGeometry(
+ points: readonly TerrainPerimeterPoint[],
+ bottomY: readonly number[],
+ topY: number,
+ epsilon = 1e-6,
+): BufferGeometry | null {
+ if (points.length < 3 || bottomY.length !== points.length) return null
+ if (bottomY.every((y) => y >= topY - epsilon)) return null
+
+ let signedArea = 0
+ for (let index = 0; index < points.length; index += 1) {
+ const a = points[index]!
+ const b = points[(index + 1) % points.length]!
+ signedArea += a.x * b.z - b.x * a.z
+ }
+ const counterClockwise = signedArea > 0
+ const positions: number[] = []
+ const push = (point: TerrainPerimeterPoint, y: number) => {
+ positions.push(point.x, y, point.z)
+ }
+
+ for (let index = 0; index < points.length; index += 1) {
+ const next = (index + 1) % points.length
+ const a = points[index]!
+ const b = points[next]!
+ const ay = bottomY[index]!
+ const by = bottomY[next]!
+ if (ay >= topY - epsilon && by >= topY - epsilon) continue
+
+ if (counterClockwise) {
+ push(a, topY)
+ push(b, by)
+ push(a, ay)
+ push(a, topY)
+ push(b, topY)
+ push(b, by)
+ } else {
+ push(a, topY)
+ push(a, ay)
+ push(b, by)
+ push(a, topY)
+ push(b, by)
+ push(b, topY)
+ }
+ }
+
+ const faces = ShapeUtils.triangulateShape(
+ points.map((point) => new Vector2(point.x, point.z)),
+ [],
+ )
+ for (const face of faces) {
+ const [ia, ib, ic] = face
+ if (ia == null || ib == null || ic == null) continue
+ if (
+ bottomY[ia]! >= topY - epsilon &&
+ bottomY[ib]! >= topY - epsilon &&
+ bottomY[ic]! >= topY - epsilon
+ ) {
+ continue
+ }
+ const a = points[ia]!
+ const b = points[ib]!
+ const c = points[ic]!
+ const cross = (b.x - a.x) * (c.z - a.z) - (b.z - a.z) * (c.x - a.x)
+ push(a, bottomY[ia]!)
+ if (cross >= 0) {
+ push(b, bottomY[ib]!)
+ push(c, bottomY[ic]!)
+ } else {
+ push(c, bottomY[ic]!)
+ push(b, bottomY[ib]!)
+ }
+ }
+
+ if (positions.length === 0) return null
+ const geometry = new BufferGeometry()
+ geometry.setAttribute('position', new Float32BufferAttribute(positions, 3))
+ geometry.computeVertexNormals()
+ ensureRenderableGeometryAttributes(geometry)
+ return geometry
+}
diff --git a/packages/viewer/src/systems/slab/slab-system.tsx b/packages/viewer/src/systems/slab/slab-system.tsx
index 00ba8c88e..b265b2296 100644
--- a/packages/viewer/src/systems/slab/slab-system.tsx
+++ b/packages/viewer/src/systems/slab/slab-system.tsx
@@ -186,8 +186,8 @@ function generateSolidSlabGeometry(
}
/**
- * Pool / recessed slab: floor cap at Y=0 (local) + inner walls up to Y=|elevation|.
- * No top cap — the opening at ground level is handled by the ground occluder hole.
+ * Pool / recessed slab: floor cap at Y=0 (local) + inner walls up to the rim.
+ * No top cap — the opening at the rim is handled by the ground occluder hole.
* mesh.position.y must be set to elevation so the floor sits at the correct world Y.
*
* Geometry is built directly in 3D (Y-up) to avoid rotation confusion:
@@ -199,7 +199,8 @@ function generatePoolGeometry(
context: SlabPolygonContext,
): THREE.BufferGeometry {
const polygon = ensureCounterClockwisePolygon(getRenderableSlabPolygon(slabNode, context))
- const depth = Math.abs(slabNode.elevation ?? 0.05)
+ const floor = slabNode.elevation ?? 0.05
+ const depth = Math.max(0, (slabNode.recessedRimElevation ?? 0) - floor)
const holePolygons = mergeSurfaceHolePolygons(slabNode.holes ?? [])
if (polygon.length < 3) return new THREE.BufferGeometry()
diff --git a/packages/viewer/src/systems/stair/stair-system.tsx b/packages/viewer/src/systems/stair/stair-system.tsx
index 7581b2c05..e63b75fe1 100644
--- a/packages/viewer/src/systems/stair/stair-system.tsx
+++ b/packages/viewer/src/systems/stair/stair-system.tsx
@@ -118,7 +118,7 @@ export const StairSystem = () => {
if (group) {
const mergedMesh = group.getObjectByName('merged-stair') as THREE.Mesh | undefined
if (mergedMesh?.visible !== false) {
- updateMergedStairGeometry(node as StairNode, group, nodes)
+ updateMergedStairGeometry(getEffectiveNode(node as StairNode), group, nodes)
stairsProcessed++
}
}
diff --git a/packages/viewer/src/systems/wall/wall-system.tsx b/packages/viewer/src/systems/wall/wall-system.tsx
index 754b02efb..06eb8c5a7 100644
--- a/packages/viewer/src/systems/wall/wall-system.tsx
+++ b/packages/viewer/src/systems/wall/wall-system.tsx
@@ -22,6 +22,7 @@ import {
resolveWallTop,
sceneRegistry,
spatialGridManager,
+ terrainSupportLift,
useLiveNodeOverrides,
useLiveTransforms,
useScene,
@@ -34,9 +35,11 @@ import {
} from '@pascal-app/core'
import { useFrame } from '@react-three/fiber'
import * as THREE from 'three'
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js'
import { Brush, Evaluator, SUBTRACTION } from 'three-bvh-csg'
import { computeBoundsTree } from 'three-mesh-bvh'
import { ensureRenderableGeometryAttributes, prepareBrushForCSG } from '../../lib/csg-utils'
+import { buildTerrainPerimeterFillGeometry } from '../../lib/terrain-perimeter-fill'
import {
buildOpeningCutoutGeometry,
getOpeningCutoutBottomPadding,
@@ -714,8 +717,13 @@ function updateWallGeometry(wallId: string, miterData: WallMiterData) {
node.curveOffset ?? 0,
node.thickness,
node.supportSlabId,
+ undefined,
+ node.supportOffset,
)
const slabElevation = slabSupport.elevation
+ const terrainBottomAt = node.fillToTerrain
+ ? (x: number, z: number) => terrainSupportLift(nodes, levelId, x, z)
+ : undefined
const childrenIds = node.children || []
// Merge live overrides into door / window children so cutouts track an
@@ -745,6 +753,7 @@ function updateWallGeometry(wallId: string, miterData: WallMiterData) {
slabSupport.baseElevation,
slabSupport.baseSegments,
planeTop,
+ terrainBottomAt,
)
const wallAngle = Math.atan2(node.end[1] - node.start[1], node.end[0] - node.start[0])
// World transform the render mesh will apply (position + Y-rotation below).
@@ -770,6 +779,7 @@ function updateWallGeometry(wallId: string, miterData: WallMiterData) {
slabSupport.baseElevation,
slabSupport.baseSegments,
planeTop,
+ terrainBottomAt,
)
collisionMesh.geometry.dispose()
collisionMesh.geometry = collisionGeo
@@ -851,6 +861,72 @@ function applyWorldPlanarWallUVs(
* Key insight from demo: polygon is built in WORLD coordinates first,
* then we transform to wall-local for the 3D mesh.
*/
+const WALL_TERRAIN_SAMPLE_STEP = 0.25
+
+type WallTerrainBottomSampler = (x: number, z: number) => number | null
+
+function densifyClosedWallPerimeter(points: Point2D[]): Point2D[] {
+ const dense: Point2D[] = []
+ for (let index = 0; index < points.length; index += 1) {
+ const start = points[index]!
+ const end = points[(index + 1) % points.length]!
+ const length = Math.hypot(end.x - start.x, end.y - start.y)
+ const segments = Math.max(1, Math.ceil(length / WALL_TERRAIN_SAMPLE_STEP))
+ for (let segment = 0; segment < segments; segment += 1) {
+ const t = segment / segments
+ dense.push({
+ x: start.x + (end.x - start.x) * t,
+ y: start.y + (end.y - start.y) * t,
+ })
+ }
+ }
+ return dense
+}
+
+function buildWallTerrainFillGeometry(
+ perimeter: Point2D[],
+ worldToLocal: (point: Point2D) => { x: number; z: number },
+ wallBaseElevation: number,
+ terrainBottomAt: WallTerrainBottomSampler,
+): THREE.BufferGeometry | null {
+ const worldPoints = densifyClosedWallPerimeter(perimeter)
+ if (worldPoints.length < 3) return null
+
+ const localPoints = worldPoints.map(worldToLocal)
+ const bottomY = worldPoints.map((point) => {
+ const terrainElevation = terrainBottomAt(point.x, point.y)
+ return terrainElevation == null ? 0 : Math.min(0, terrainElevation - wallBaseElevation)
+ })
+ return buildTerrainPerimeterFillGeometry(localPoints, bottomY, 0)
+}
+
+function mergeWallTerrainFill(
+ body: THREE.BufferGeometry,
+ fill: THREE.BufferGeometry | null,
+ wall: WallNode,
+ boundaryEdges: TaggedWallBoundaryEdge[],
+ effectiveWallHeight: number,
+): THREE.BufferGeometry {
+ if (!fill) return body
+
+ const bodyGeometry = body.index ? body.toNonIndexed() : body
+ if (bodyGeometry !== body) body.dispose()
+ ensureRenderableGeometryAttributes(bodyGeometry)
+ ensureRenderableGeometryAttributes(fill)
+ const merged = mergeGeometries([bodyGeometry, fill], false)
+ if (!merged) {
+ fill.dispose()
+ return bodyGeometry
+ }
+
+ bodyGeometry.dispose()
+ fill.dispose()
+ merged.computeVertexNormals()
+ assignWallMaterialGroups(merged, wall, boundaryEdges, effectiveWallHeight)
+ ensureRenderableGeometryAttributes(merged)
+ return merged
+}
+
export function generateExtrudedWall(
wallNode: WallNode,
childrenNodes: AnyNode[],
@@ -861,6 +937,7 @@ export function generateExtrudedWall(
{ start: 0, end: 1, elevation: baseElevation },
],
storeyHeight = DEFAULT_LEVEL_HEIGHT,
+ terrainBottomAt?: WallTerrainBottomSampler,
): THREE.BufferGeometry {
const wallStart: Point2D = { x: wallNode.start[0], y: wallNode.start[1] }
const wallEnd: Point2D = { x: wallNode.end[0], y: wallNode.end[1] }
@@ -913,6 +990,9 @@ export function generateExtrudedWall(
// Convert polygon to local coordinates
const localPoints = polyPoints.map(worldToLocal)
const boundaryEdges = buildTaggedWallBoundaryEdges(wallNode, localPoints, miterData)
+ const terrainFill = terrainBottomAt
+ ? buildWallTerrainFillGeometry(polyPoints, worldToLocal, slabElevation, terrainBottomAt)
+ : null
// Build THREE.js shape
// Shape uses (x, y) where we map: shape.x = local.x, shape.y = -local.z
@@ -1041,7 +1121,13 @@ export function generateExtrudedWall(
splitGeometry.computeVertexNormals()
assignWallMaterialGroups(splitGeometry, wallNode, boundaryEdges, effectiveWallHeight)
ensureRenderableGeometryAttributes(splitGeometry)
- return splitGeometry
+ return mergeWallTerrainFill(
+ splitGeometry,
+ terrainFill,
+ wallNode,
+ boundaryEdges,
+ effectiveWallHeight,
+ )
}
// Create wall brush from geometry
@@ -1079,7 +1165,13 @@ export function generateExtrudedWall(
assignWallMaterialGroups(splitResultGeometry, wallNode, boundaryEdges, effectiveWallHeight)
ensureRenderableGeometryAttributes(splitResultGeometry)
- return splitResultGeometry
+ return mergeWallTerrainFill(
+ splitResultGeometry,
+ terrainFill,
+ wallNode,
+ boundaryEdges,
+ effectiveWallHeight,
+ )
}
/**
diff --git a/packages/viewer/src/systems/wall/wall-terrain-bottom.test.ts b/packages/viewer/src/systems/wall/wall-terrain-bottom.test.ts
new file mode 100644
index 000000000..ee510e52d
--- /dev/null
+++ b/packages/viewer/src/systems/wall/wall-terrain-bottom.test.ts
@@ -0,0 +1,44 @@
+// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
+// depend on @types/bun so the import type is unresolved at compile time.
+import { describe, expect, test } from 'bun:test'
+import { calculateLevelMiters, WallNode } from '@pascal-app/core'
+import { generateExtrudedWall } from './wall-system'
+
+describe('wall terrain bottom', () => {
+ test('samples both faces independently without changing the authored body height', () => {
+ const wall = WallNode.parse({
+ start: [0, 0],
+ end: [4, 0],
+ height: 2.5,
+ thickness: 1,
+ supportSlabId: 'ground',
+ fillToTerrain: true,
+ })
+ const geometry = generateExtrudedWall(
+ wall,
+ [],
+ calculateLevelMiters([wall]),
+ 1.5,
+ 1.5,
+ undefined,
+ 4,
+ (_x, z) => (z >= 0 ? 0.2 : 0.8),
+ )
+ geometry.computeBoundingBox()
+
+ const position = geometry.getAttribute('position')
+ let positiveFaceMinY = Number.POSITIVE_INFINITY
+ let negativeFaceMinY = Number.POSITIVE_INFINITY
+ for (let index = 0; index < position.count; index += 1) {
+ const z = position.getZ(index)
+ const y = position.getY(index)
+ if (z > 0.49) positiveFaceMinY = Math.min(positiveFaceMinY, y)
+ if (z < -0.49) negativeFaceMinY = Math.min(negativeFaceMinY, y)
+ }
+
+ expect(positiveFaceMinY).toBeCloseTo(-1.3)
+ expect(negativeFaceMinY).toBeCloseTo(-0.7)
+ expect(geometry.boundingBox?.max.y).toBeCloseTo(2.5)
+ geometry.dispose()
+ })
+})
diff --git a/wiki/architecture/tools.md b/wiki/architecture/tools.md
index 883c5b467..5269d612c 100644
--- a/wiki/architecture/tools.md
+++ b/wiki/architecture/tools.md
@@ -100,6 +100,12 @@ export function MyTool() {
a wall segment's 45° lock while in `angles` mode — the tool may still publish passive dashed
alignment/proximity guides as long as it does not apply the guide snap delta. Use this for chained
wall segments: users keep the fast constrained draft but still see proximity feedback for later points.
+- **Vertical structural datums use their own ephemeral guide channel.** Slab, ceiling, wall-base,
+ and fence-base elevation handles resolve same-level structural Y targets through scalar snap
+ callbacks, then publish a short horizontal datum + elevation readout only while exactly aligned.
+ The payload is owner-scoped and cleared through the handle descriptor's `onDragEnd`; it is editor
+ feedback, never a scene node. Do not encode Y datums into the floor-plane XZ alignment store or
+ the wall-opening guide store — their coordinate and lifecycle contracts differ.
- **Help mirrors the model.** The shortcut dialog and the contextual HUD are part of the interaction
contract: they describe the always-visible mode chip + `Alt` = force, **not** a hidden Shift bypass.
The HUD is driven by the active interaction scope, so it shows only the current context's controls.
diff --git a/wiki/architecture/vertical-model.md b/wiki/architecture/vertical-model.md
index 757aa7760..80c588215 100644
--- a/wiki/architecture/vertical-model.md
+++ b/wiki/architecture/vertical-model.md
@@ -6,9 +6,10 @@ Applies to: anything that reads or writes vertical geometry — levels, walls, s
The invariant, in one sentence:
-> Wall tops are pinned to the level plane; floors and platforms move what stands on
-> them, never the walls or the storey above; anything that doesn't fit is clamped,
-> never asked.
+> Ordinary plane-bound wall tops are pinned to the level plane. A wall drafted on
+> terrain or another raised support preserves the ghost's body height by materializing
+> that height and translating the wall from its elected base. Optional terrain infill
+> extends only the bottom; it never changes the authored wall height or top.
**Sources**: `packages/core/src/services/storey.ts`, `packages/core/src/systems/wall/wall-top.ts`, `packages/core/src/systems/slab/slab-support.ts`, `packages/core/src/systems/stair/stair-rise.ts`, `packages/core/src/store/use-scene.ts` (migration Pass 3)
@@ -17,19 +18,24 @@ The invariant, in one sentence:
| Field | Meaning | Absent means |
|---|---|---|
| `level.height` | Storey height in meters, floor-to-floor. Level world Y = per-building prefix sum of stored heights, ordered by the `level` ordinal (`getLevelElevations`). | Unmigrated legacy data (never seen post-load; the migration writes it). Consumers fall back to `DEFAULT_LEVEL_HEIGHT` (2.5). |
-| `wall.height` | Explicit custom height (half wall, parapet). Top = elected base + height. | **Plane-bound** (the default): the top follows `getWallPlaneTop` — `min(level height, lowest covering-slab underside over the span)`. Slabs lift only the base. |
+| `wall.height` | Explicit body height (half wall, parapet, or a raised-support draft whose ghost height must remain invariant). Ground-hosted walls always resolve top = elected base + height, including below datum; other legacy sunken supports retain their absolute-top constraint. | **Plane-bound** (the default for ordinary datum placement): the top follows `getWallPlaneTop` — `min(level height, lowest covering-slab underside over the span)`. |
| `ceiling.height` | Explicit custom height, write-clamped to the bound. | **Follows the level**: resolves live to `getCeilingClampBound` = `min(level height, covering underside) − 0.01`. |
| `slab.elevation` | The walking surface (top), level-local. | Default 0.05. |
| `slab.thickness` | Grows **downward**: the solid occupies `[elevation − thickness, elevation]`. | Default 0.05. |
-| `slab.recessed` | Pool intent: open shell, floor at (negative) `elevation`, inner walls up to the plane. Excluded from "covering" queries and wall-face adoption. | Solid slab. |
+| `slab.recessed` | Recess intent: open shell whose floor is `elevation` and whose rim is `recessedRimElevation`. Excluded from "covering" queries and wall-face adoption. | Solid slab. |
+| `slab.recessedRimElevation` | Optional rim anchor for a raised/lowered recess. Relative presets preserve this anchor while changing depth. | Level plane (`0`), preserving legacy pools. |
+| `slab.fillToTerrain` | Adds a terrain-following perimeter foundation below a solid slab's fixed underside. The walking surface and authored structural thickness stay flat. | No terrain foundation. |
| `supportSlabId` | Persisted support host on walls and all floor-placed kinds. Written at commit **only when overlapping supports disagree on elevation**; `'ground'` sentinel pins bare ground under a deck. | Support is elected per query (coverage election for walls, footprint max for items). |
+| `wall.supportOffset` | Optional level-local delta from the elected support. Terrain wall chains use it to keep every segment on the first point's construction plane while storing only one number, never terrain samples. | Zero offset: the wall sits directly on its elected slab or sculpted ground source. |
+| `fence.supportOffset` | Optional level-local delta from the fence's slab host or level plane. It translates the complete fence while preserving height. | Zero offset: the fence sits directly on its host or level plane. |
+| `wall.fillToTerrain` | Extends the wall downward from its authored base to the terrain with independently sampled left/right faces. The wall body height and top stay unchanged. | Fixed base with no terrain infill. |
| `stair.deckSlabId` | Destination deck: rise follows `deck.elevation − the stair's own elected base` live; cutout sync disabled while attached. | Destination is a level. |
| `stair.totalRise` | Explicit custom rise (wins over everything). | Follows: derived from the deck or the containing level; `syncStairRises` converges straight-stair segments to the resolved rise. |
Two schema rules protect these semantics:
- **No Zod defaults on meaning-bearing fields.** `level.height`, `wall.height`, `ceiling.height`, `stair.totalRise` are `.optional()` with no `.default()` — absence is data. Creation sites write values explicitly; `migrateNodes` output is cast, not parsed, so a schema default would never materialize on legacy load anyway.
-- **The store deletes explicit-`undefined` keys.** `updateNode(id, { height: undefined })` removes the key (see `mergeNodeUpdate` in `node-actions.ts`); that is how "Follows level/deck" mode switches work. UI mode controls derive state from field presence — no persisted mode enums.
+- **The store deletes explicit-`undefined` keys.** `updateNode(id, { height: undefined })` removes the key (see `mergeNodeUpdate` in `node-actions.ts`). Legacy plane-bound walls may still omit `height`; the wall panel resolves and materializes their current body height before enabling terrain infill. Ceiling and stair follow modes continue to derive from field presence — no persisted mode enums.
## Resolution helpers (use these, never `?? 2.5`)
@@ -38,24 +44,44 @@ Two schema rules protect these semantics:
| `getStoredLevelHeight`, `getLevelElevations`, `getLevelAbove/Below` | `services/storey.ts` | Level heights, per-building stacking, neighbors |
| `getWallPlaneTop` | `services/storey.ts` | A plane-bound wall's top: level height clamped to covering-slab undersides, span-sampled with boundary-inclusive band overlap |
| `resolveWallTop`, `resolveWallEffectiveHeight`, `MIN_WALL_HEIGHT` | `systems/wall/wall-top.ts` | A wall's top / effective height given plane + elected base |
-| `getWallEffectiveHeightForNodes` | spatial-grid manager | The above with the real slab election, for UI overlays |
+| `getWallBaseElevationForNodes`, `getWallEffectiveHeightForNodes` | spatial-grid manager | The elected base and body height with terrain/support offsets, for UI overlays |
| `getCeilingClampBound`, `getCoveringSlabUndersideAt` | `services/storey.ts` | Ceiling bound; the cross-level covering query (level above, non-recessed slabs) |
| `resolveCeilingHeight` | `services/level-height.ts` | A ceiling's effective height (explicit or follows) |
| `resolveStairTotalRise`, `syncStairRises` | `systems/stair/stair-rise.ts` | Stair rise precedence + straight-flight convergence |
| `computeWallSlabSupport`, `getSlabSupportForItem`, `getSupportCandidatesForFootprint` | `systems/slab/slab-support.ts` + spatial-grid manager | Support election (rendered polygons, host-preferring, optional `maxElevation` cap) |
-| `clampSlabElevationForWalls`, `applySlabTopChange`, `SLAB_UNSTICK_THRESHOLD` | slab-support + `nodes/slab/elevation-limit.ts` | Slab edit clamps and the adaptive drag/panel rules |
+| `resolveSlabPlacementElevation` | `systems/slab/slab-placement.ts` | Translates a solid slab's authored top/thickness interval onto a captured base plane; recessed slabs stay level-relative |
+| `getSlabBaseElevation`, `applySlabBaseElevationChange`, `applySlabThicknessChange` | `nodes/slab/elevation-limit.ts` | Separates whole-body underside placement from fixed-base thickness editing |
+| `resolveFenceLiftElevation` | `nodes/fence/lift.ts` | Fence slab-host elevation plus its optional manual support offset |
+| `clampSlabElevationForWalls` | slab-support + `nodes/slab/elevation-limit.ts` | Slab top clamp under plane-bound walls |
## Clamp rules (clamp, never ask)
- A slab under plane-bound walls clamps its elevation to `level height − MIN_WALL_HEIGHT` (0.5).
- Ceilings clamp (at write time, and reactively downward via space-detection) to `min(level top, covering-slab underside) − 0.01`.
- Plane-bound wall tops clamp to covering-slab undersides — a thick or flush upper-level slab shortens the walls below it (Revit's attach-to-floor-bottom, automatic). Explicit-height walls are exempt.
-- Slab vertical editing is adaptive: the panel moves placement (thickness untouched); the viewport drag stretches a grounded slab (elevation and thickness together) up to `SLAB_UNSTICK_THRESHOLD` (0.4), then unsticks it into a 0.05-thick deck; floating decks move with thickness preserved and re-ground at underside 0; pools keep the drag-through-zero gesture.
+- Solid slab controls have non-overlapping contracts: the cube translates the occupied interval while preserving `thickness`; the chevron and panel thickness control hold the underside fixed and move the walking surface by writing `thickness` and `elevation` together. Panel elevation translates the body while preserving thickness. Recesses store their rim separately so floor/rim/depth controls and presets remain relative to the same anchor.
+- Structural elevation trackers move the reference base, not the body dimensions. A slab tracker moves its underside and keeps `thickness`; a wall tracker writes `supportOffset` and materializes its current body `height`; a fence tracker writes `supportOffset` and keeps `height`. Recessed slabs retain their separate rim/depth control.
- Wall-face adoption in `getRenderableSlabPolygon` applies only to grounded slabs (`elevation − thickness ≤ 0.01`, not recessed) — floating decks keep their drawn polygon and are skipped as seam candidates.
## Pointer-decided placement
-Grid events intersect a plane that rides the ghost's elevation, so any stacked-surface decision must come from the true camera ray, not the plane hit: `getPointedSupportSurface` returns the nearest slab plane the ray crosses inside its rendered polygon plus the crossing point, and both the support-election cap (`maxElevation`) and the cursor XZ derive from that single computation. Pointing under a deck elects the floor; pointing at the deck top elects the deck; commits persist the capped winner (or `'ground'`). 2D floorplan placement has no camera ray and keeps max-election.
+Grid events intersect a plane that rides the ghost's elevation, so any stacked-surface decision must come from the true camera ray, not the plane hit: `getPointedSupportSurface` returns the nearest eligible surface plus the crossing point, and both the support-election cap (`maxElevation`) and the cursor XZ derive from that single computation. Pointing under a deck elects the floor; pointing at the deck top elects the deck. Wall drafting may additionally include upward-facing wall, stackable-item, and column meshes. Those node-top hits freeze a scalar construction plane for the throw; they are not a persistent hosting edge and do not follow later host edits. Commits persist the elected slab/ground source plus `wall.supportOffset`. 2D floorplan placement has no camera ray and keeps max-election.
+
+Wall and slab drafting share the horizontal construction-plane resolver. A slab freezes the
+first snapped vertex's plane, keeps later vertices on that flat plane, and translates its authored
+vertical interval onto the captured base at commit. It never drapes thickness or individual
+vertices over terrain. Optional terrain following is a separate perimeter foundation from the
+fixed underside; it never changes the slab interval. Recessed slabs keep an explicit rim anchor. A locked
+construction plane is tagged `fixed-plane` so a plane at world Y=0 cannot be mistaken for the
+terrain query plane on later pointer moves.
+
+Auto-room surfaces derive their vertical placement from the enclosing walls when every boundary
+wall agrees on one base and top plane. The floor keeps its established 0.05 m walking-surface
+offset above that base; the ceiling sits 0.01 m below the common wall top. Existing
+`autoFromWalls` surfaces reconcile with later wall support-offset changes. Manual surfaces are
+never rewritten, and a mixed-elevation enclosure keeps its existing/fallback placement rather
+than choosing an arbitrary wall. Auto slabs are excluded from this wall-base election so a
+derived floor cannot recursively lift its own walls and then itself.
## Load migration (lives in `migrateNodes` Pass 3, indefinitely)
@@ -72,7 +98,7 @@ Because community autosave only persists after the first post-load edit, the mig
- **Ordinals are semantic.** `level < 0` renders "Basement N"; `level === 0` is the ground-floor lookup. Never renumber without the zero anchor.
- **Boundary geometry.** Auto slabs derive polygons from wall centerlines, so wall/ceiling clamp samples sit exactly on polygon edges — always use the boundary-inclusive band-overlap helpers (`wallOverlapsSlabFootprint`, `slabCoversPoint`), never raw ray-cast point-in-polygon on those paths.
- **Straight stairs build from stored segment heights**, not the resolved rise — any rise change must go through `syncStairRises` (applied by `StairOpeningSystem`, history-paused, one microtask after store updates so the spatial grid has settled).
-- **Reactivity is explicit.** A `level.height` change dirties that level's walls/stairs/ceilings/fences; a slab change dirties the level below's walls/ceilings and deck-attached stairs (`spatial-grid-sync.ts`). If a new consumer reads these bounds, wire its dirty rule there.
+- **Reactivity is explicit.** A `level.height` change dirties that level's walls/stairs/ceilings/fences; a slab change dirties overlapping same-level supports, the level below's walls/ceilings, and deck-attached stairs. Every live terrain dab dirties ground-hosted structures and `fillToTerrain` walls/slabs through the transient `useLiveTerrain` subscription in `spatial-grid-sync.ts`; the scene graph and undo history are still written only once when the stroke commits. Ending or canceling a stroke runs the same sweep so dependents settle back onto the persisted field. Slab handles reuse the slab-change dependency helper for live previews. If a new consumer reads these bounds, wire its dirty rule there.
- **Host lifecycle.** Deleting a slab strips `supportSlabId`/`deckSlabId` from survivors in the same undo commit; a host merely reshaped away falls back silently and resumes if the slab returns.
- **Clone paths differ.** `clone-scene-graph.ts` remaps `supportSlabId`/`deckSlabId`; the editor clipboard (`scene-clipboard.ts`) intentionally does not (it re-elects); room placement remaps them (fixed in the private repo's `room-placement.ts`). When adding a new clone/instantiation path, remap both fields.
-
+
- {altPressed ? 'Detaching corner' : 'Alt to detach'}
-
-
+
+
+ )}
+ {angleLabel && (
+
+ {altPressed ? 'Detaching corner' : 'Alt to detach'}
+
+
- Top
+ Base
- Currently {formatLinearMeasurement(height, unit)}
+ Extends downward to meet the terrain. Height and top stay unchanged.
- ) : (
-