@pascal-app/editor 1.0.3 → 1.0.5

package/src/components/editor/first-person/build-collider-world.test.ts

@@ -7,16 +7,20 @@ import {
   CeilingNode,
   ColumnNode,
   createTerrainField,
+  DoorNode,
   ElevatorNode,
   encodeTerrainField,
   flattenPatch,
+  GeometryArtifactManifest,
   LevelNode,
   nodeRegistry,
   registerNode,
   ShelfNode,
   SiteNode,
   SlabNode,
+  StairNode,
   sceneRegistry,
+  useInteractive,
   useScene,
 } from '@pascal-app/core'
 import { hideFromScene, STAND_CLEARANCE, showInScene } from '@pascal-app/viewer'
@@ -93,6 +97,57 @@ describe('buildFirstPersonColliderWorldFromRegistry', () => {
     world?.dispose()
   })
 
+  test('keeps a procedural static body but excludes moving groups', () => {
+    registerColliderDefinition('shelf', ShelfNode, 'furnish')
+    const shelf = ShelfNode.parse({ id: 'shelf_motion_test' })
+    setSceneNodes([shelf])
+    mountNode(shelf, [1, 1, 1], [0, 0.5, 0])
+    const root = sceneRegistry.nodes.get(shelf.id)!
+    const motion = new Group()
+    motion.userData.proceduralMotion = { nodeId: shelf.id, partId: 'drawer' }
+    const movingMesh = new Mesh(new BoxGeometry(1, 1, 1), new MeshBasicMaterial())
+    movingMesh.position.set(5, 0.5, 0)
+    motion.add(movingMesh)
+    root.add(motion)
+    root.updateMatrixWorld(true)
+
+    const world = buildFirstPersonColliderWorldFromRegistry()!
+    expect(world.bounds?.min.x).toBeCloseTo(-0.5)
+    expect(world.bounds?.max.x).toBeCloseTo(0.5)
+    world.dispose()
+  })
+
+  test('an idle joint tree collides with its static split parts, not its merged rest pose', () => {
+    registerColliderDefinition('shelf', ShelfNode, 'furnish')
+    const shelf = ShelfNode.parse({ id: 'shelf_rest_test' })
+    setSceneNodes([shelf])
+    mountRegistryGroup(shelf)
+    const root = sceneRegistry.nodes.get(shelf.id)!
+    const box = (x: number) => {
+      const mesh = new Mesh(new BoxGeometry(1, 1, 1), new MeshBasicMaterial())
+      mesh.position.set(x, 0.5, 0)
+      return mesh
+    }
+    // The rest pose merges the body with the gate leaf at x = 5; the hidden split draws them apart.
+    const rest = new Group()
+    rest.userData.pascalProceduralRest = true
+    rest.add(box(0), box(5))
+    const split = new Group()
+    split.userData.pascalProceduralSplit = true
+    split.visible = false
+    const motion = new Group()
+    motion.userData.proceduralMotion = { nodeId: shelf.id, partId: 'gate' }
+    motion.add(box(5))
+    split.add(box(0), motion)
+    root.add(rest, split)
+    root.updateMatrixWorld(true)
+
+    const world = buildFirstPersonColliderWorldFromRegistry()!
+    expect(world.bounds?.min.x).toBeCloseTo(-0.5)
+    expect(world.bounds?.max.x).toBeCloseTo(0.5)
+    world.dispose()
+  })
+
   test('standing clearance and floor hits survive a slab source joining and leaving a batch', () => {
     registerColliderDefinition('slab', SlabNode, 'structure', 'floor')
     const slab = SlabNode.parse({ id: 'slab_clearance_batch', polygon: [] })
@@ -274,3 +329,268 @@ describe('buildFirstPersonColliderWorldFromRegistry', () => {
     world.dispose()
   })
 })
+
+// A door built from a script is drawn by its model: the leaves are the model's own and its `open`
+// clip moves them. What the player is stopped by is a stand-in leaf box at the door's frame, and
+// that box has to follow the door's own open state, not the native `operationState` the clip
+// never touches.
+describe('a door built from a script', () => {
+  const source = {
+    kind: 'script' as const,
+    script: 'b'.repeat(64),
+    artifact: 'a'.repeat(64),
+    manifest: GeometryArtifactManifest.parse({
+      bounds: { min: [-0.6, 0, -0.11], max: [0.6, 2.55, 0.11] },
+      triangles: 12,
+      animations: [{ name: 'open', duration: 1.3 }],
+    }),
+  }
+  // The door mechanism's open state for a script: the first control toggle of the item.
+  const mechanism = {
+    verb: 'open',
+    icon: 'door',
+    has: (node: AnyNode) => Boolean((node as { source?: unknown }).source),
+    isOn: (node: AnyNode, state: ReturnType<typeof useInteractive.getState>) =>
+      Boolean(state.items[node.id as never]?.controlValues[0]),
+    set: () => {},
+  }
+
+  function mountScriptedDoor(language: 'three' | 'bpy' = 'three') {
+    registerNode({
+      kind: 'door',
+      schema: DoorNode,
+      schemaVersion: 1,
+      category: 'structure',
+      capabilities: { mechanism },
+    } as unknown as AnyNodeDefinition)
+    registerColliderDefinition('column', ColumnNode, 'structure')
+    const door = DoorNode.parse({
+      id: 'door_shoji',
+      doorType: 'sliding',
+      width: 1.2,
+      height: 2.55,
+      source: { ...source, language },
+    })
+    const column = ColumnNode.parse({ id: 'column_far' })
+    setSceneNodes([door, column])
+    mountNode(column, [1, 2, 1], [10, 1, 0])
+    // The door's registered group, as its renderer builds it: the compiled model under it, with
+    // the agent's 1 m deep `cutout` box and two leaves.
+    const group = new Group()
+    group.position.set(0, 1.275, 0)
+    const box = (name: string, size: [number, number, number], x: number, z: number) => {
+      const mesh = new Mesh(new BoxGeometry(...size), new MeshBasicMaterial())
+      mesh.name = name
+      mesh.position.set(x, 0, z)
+      group.add(mesh)
+    }
+    box('cutout', [1.2, 2.55, 1], 0, 0)
+    box('leaf_0', [0.5, 2.4, 0.02], -0.255, 0.025)
+    box('leaf_1', [0.5, 2.4, 0.02], 0.255, -0.025)
+    group.updateMatrixWorld(true)
+    sceneRegistry.nodes.set(door.id, group)
+    sceneRegistry.byType.door!.add(door.id)
+    return door
+  }
+
+  /** Walk straight at the doorway from the front, at hip height: where the first thing is hit. */
+  function firstHitAcrossDoorway() {
+    const world = buildFirstPersonColliderWorldFromRegistry()
+    if (!world) return null
+    const raycaster = new Raycaster(new Vector3(0, 1, -3), new Vector3(0, 0, 1))
+    const hit = raycaster.intersectObject(world.mesh, false)[0]
+    world.dispose()
+    return hit ? { z: hit.point.z } : null
+  }
+
+  afterEach(() => {
+    useInteractive.setState({ items: {} } as never)
+    sceneRegistry.clear()
+    nodeRegistry._reset()
+    useScene.setState({ nodes: {}, rootNodeIds: [] } as never)
+  })
+
+  test('a closed one stops the player at its leaf, not at the model’s cutout box', () => {
+    mountScriptedDoor()
+    useInteractive.setState({ items: { door_shoji: { controlValues: [false] } } } as never)
+
+    const hit = firstHitAcrossDoorway()
+    expect(hit).not.toBeNull()
+    // the stand-in leaf is 0.06 m deep at the frame; the cutout would stop the player at z = -0.5
+    expect(hit!.z).toBeCloseTo(-0.03, 3)
+  })
+
+  test('an open one can be walked through, and its cutout never collides', () => {
+    mountScriptedDoor()
+    useInteractive.setState({ items: { door_shoji: { controlValues: [true] } } } as never)
+
+    expect(firstHitAcrossDoorway()).toBeNull()
+  })
+  test('a Blender-built door follows its mechanism the same way: the language makes no difference', () => {
+    mountScriptedDoor('bpy')
+    useInteractive.setState({ items: { door_shoji: { controlValues: [false] } } } as never)
+    expect(firstHitAcrossDoorway()?.z).toBeCloseTo(-0.03, 3)
+
+    useInteractive.setState({ items: { door_shoji: { controlValues: [true] } } } as never)
+    expect(firstHitAcrossDoorway()).toBeNull()
+  })
+})
+
+// The ground is a sheet across the lot, and under a house with a basement the sheet ran across the
+// stairwell: a walker going down the stair met it at grade. The ground is drawn open over what the
+// house covers (`coveredBelowGradeFootprints`), and the walker's ground is cut open over the same.
+describe('a basement under the house', () => {
+  afterEach(() => {
+    sceneRegistry.clear()
+    nodeRegistry._reset()
+    useScene.setState({ nodes: {}, rootNodeIds: [] } as never)
+  })
+
+  type Box = { size: [number, number, number]; at: [number, number, number] }
+
+  function mountBoxes(node: AnyNode, boxes: Box[]) {
+    const group = new Group()
+    for (const { size, at } of boxes) {
+      const mesh = new Mesh(new BoxGeometry(...size), new MeshBasicMaterial())
+      mesh.position.set(...at)
+      group.add(mesh)
+    }
+    group.updateMatrixWorld(true)
+    sceneRegistry.nodes.set(node.id, group)
+    sceneRegistry.byType[node.type]!.add(node.id)
+  }
+
+  const rect = (x0: number, x1: number, z0: number, z1: number): Array<[number, number]> => [
+    [x0, z0],
+    [x1, z0],
+    [x1, z1],
+    [x0, z1],
+  ]
+  const TREADS = 14
+  const RISE = 0.2
+  const FLOOR_G = 0.05
+  const FLOOR_B = -2.95
+
+  /**
+   * An 8 m square house on a flat site (or a flat sculpted one) over a basement whose floor lies at
+   * -2.95 m, its plan 1.3..6.7 × 1.4..6.6. The ground floor is a slab with the stairwell cut out of
+   * it, and a stair of 14 treads, 0.2 m each, goes down along +x from x = 2 at z 3..4.
+   */
+  function house(sculpted: boolean) {
+    registerColliderDefinition('slab', SlabNode, 'structure', 'floor')
+    registerColliderDefinition('stair', StairNode, 'structure')
+    const field = createTerrainField({ cols: 21, rows: 21, spacing: 1, origin: [-6, -6] })
+    const site = SiteNode.parse({
+      id: 'site_test',
+      children: ['building_a'],
+      ...(sculpted ? { terrain: encodeTerrainField(field) } : {}),
+    })
+    const building = BuildingNode.parse({
+      id: 'building_a',
+      parentId: site.id,
+      children: ['level_b', 'level_g'],
+    })
+    const basement = LevelNode.parse({
+      id: 'level_b',
+      parentId: building.id,
+      level: -1,
+      baseElevation: -3,
+      height: 3,
+      children: ['slab_b'],
+    })
+    const ground = LevelNode.parse({
+      id: 'level_g',
+      parentId: building.id,
+      level: 0,
+      height: 3,
+      children: ['slab_g'],
+    })
+    const slabB = SlabNode.parse({
+      id: 'slab_b',
+      parentId: basement.id,
+      polygon: rect(1.3, 6.7, 1.4, 6.6),
+      elevation: 0.05,
+    })
+    const slabG = SlabNode.parse({
+      id: 'slab_g',
+      parentId: ground.id,
+      polygon: rect(0, 8, 0, 8),
+      elevation: FLOOR_G,
+    })
+    const stair = StairNode.parse({ id: 'stair_a', parentId: basement.id })
+    setSceneNodes([site, building, basement, ground, slabB, slabG, stair])
+    mountRegistryGroup(site)
+    mountBoxes(slabB, [{ size: [5.4, 0.1, 5.2], at: [4, FLOOR_B - 0.05, 4] }])
+    // The ground floor around the stairwell (x 2..5.4, z 3..4).
+    mountBoxes(slabG, [
+      { size: [2, 0.1, 8], at: [1, FLOOR_G - 0.05, 4] },
+      { size: [2.6, 0.1, 8], at: [6.7, FLOOR_G - 0.05, 4] },
+      { size: [3.4, 0.1, 3], at: [3.7, FLOOR_G - 0.05, 1.5] },
+      { size: [3.4, 0.1, 4], at: [3.7, FLOOR_G - 0.05, 6] },
+    ])
+    mountBoxes(
+      stair,
+      Array.from({ length: TREADS }, (_, i) => ({
+        size: [0.3, RISE, 1] as [number, number, number],
+        at: [2.15 + 0.3 * i, FLOOR_G - RISE * (i + 1) - RISE / 2, 3.5] as [number, number, number],
+      })),
+    )
+  }
+
+  const UP = new Vector3(0, 1, 0)
+  /** The first upward-facing surface under (x, z), looking down from `from`. */
+  function floorUnder(mesh: Mesh, x: number, z: number, from: number): number | null {
+    const raycaster = new Raycaster()
+    raycaster.set(new Vector3(x, from, z), new Vector3(0, -1, 0))
+    const hit = raycaster
+      .intersectObject(mesh, false)
+      .find(
+        (h) => !h.face || h.face.normal.clone().transformDirection(mesh.matrixWorld).dot(UP) > 0.2,
+      )
+    return hit ? hit.point.y : null
+  }
+
+  for (const sculpted of [false, true]) {
+    describe(sculpted ? 'on sculpted ground' : 'on flat ground', () => {
+      test('a walker goes down the stair from the ground floor to the basement', () => {
+        house(sculpted)
+        const world = buildFirstPersonColliderWorldFromRegistry()!
+        expect(world).not.toBeNull()
+
+        // Eye-level search from half a metre over the floor the walker stands on, a step at a time
+        // along the stair's run: the floor found is the next one he stands on.
+        let floor = floorUnder(world.mesh, 1, 3.5, 3)!
+        expect(floor).toBeCloseTo(FLOOR_G, 6)
+        const floors = [floor]
+        for (let x = 1.1; x < 6.5; x += 0.1) {
+          floor = floorUnder(world.mesh, x, 3.5, floor + 0.5) ?? Number.NaN
+          floors.push(floor)
+        }
+        // He never stands on the ground sheet (0 m) once past the stairwell's edge, and ends on
+        // the basement's floor; no step is deeper than a tread.
+        expect(Math.min(...floors)).toBeCloseTo(FLOOR_B, 6)
+        for (let i = 1; i < floors.length; i += 1)
+          expect(floors[i - 1]! - floors[i]!).toBeLessThanOrEqual(RISE + 1e-6)
+        world.dispose()
+      })
+
+      test('the ground is open over the part of the basement the house covers, and closed past it', () => {
+        house(sculpted)
+        const world = buildFirstPersonColliderWorldFromRegistry()!
+        // Under the ground floor's slab, looking down from just under it: the ground sheet is
+        // there outside the basement's plan and gone inside it, where the basement's floor is.
+        const under = (x: number, z: number) => floorUnder(world.mesh, x, z, FLOOR_G - 0.03)
+        expect(under(1.2, 5)).toBeCloseTo(0, 6)
+        expect(under(1.4, 5)).toBeCloseTo(FLOOR_B, 6)
+        expect(under(6.6, 5)).toBeCloseTo(FLOOR_B, 6)
+        expect(under(6.8, 5)).toBeCloseTo(0, 6)
+        expect(under(4, 1.3)).toBeCloseTo(0, 6)
+        expect(under(4, 1.5)).toBeCloseTo(FLOOR_B, 6)
+        // Outside the house: the garden is walked on as before.
+        expect(floorUnder(world.mesh, 12, 5, 3)).toBeCloseTo(0, 6)
+        expect(floorUnder(world.mesh, -3, -3, 3)).toBeCloseTo(0, 6)
+        world.dispose()
+      })
+    })
+  }
+})

package/src/components/editor/first-person/build-collider-world.ts

@@ -1,10 +1,12 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  coveredBelowGradeFootprints,
   type DoorNode,
   getGarageVisibleOpeningRatio,
   getLevelElevations,
   isOperationDoorType,
+  nodeMechanism,
   nodeRegistry,
   sceneRegistry,
   terrainFieldOf,
@@ -15,6 +17,7 @@ import * as THREE from 'three'
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js'
 import { acceleratedRaycast, computeBoundsTree, disposeBoundsTree } from 'three-mesh-bvh'
 import { computeSceneBoundsXZ } from '../../../lib/scene-bounds'
+import { cutGroundCollider } from './ground-holes'
 import { createTerrainColliderGeometry } from './terrain-collider'
 
 const SKIPPED_MESH_NAMES = new Set(['cutout', 'collision-mesh'])
@@ -160,19 +163,28 @@ function collectLevelFallbackFloorGeometries(nodes: SceneNodes) {
 // player at the datum inside an excavation and bury them inside a hill. Derived
 // from the field rather than the rendered terrain mesh for the same
 // mount-timing reason as the flat slab.
+//
+// Either way the ground is cut open over what the house covers of its basement
+// (`coveredBelowGradeFootprints`, the rings the ground is drawn open over): a sheet
+// across the stairwell would hold the player at grade on the way down, with the
+// stair and the basement's floor below it. The house covers that part, so it is cut
+// whatever the view does with the ground; past it the ground is walked on as before.
 function createSiteGroundColliderGeometry(site: SiteNode, nodes: SceneNodes) {
   if (site.visible === false) return null
 
   const siteObject = sceneRegistry.nodes.get(site.id)
   if (!siteObject?.visible) return null
 
+  const covered = coveredBelowGradeFootprints(nodes)
+
   const field = terrainFieldOf(site)
   if (field) {
     const terrainGeometry = createTerrainColliderGeometry(field)
     if (terrainGeometry) {
+      const cut = cutGroundCollider(terrainGeometry, covered)
       siteObject.updateWorldMatrix(true, false)
-      terrainGeometry.applyMatrix4(siteObject.matrixWorld)
-      return terrainGeometry
+      cut.applyMatrix4(siteObject.matrixWorld)
+      return cut
     }
   }
 
@@ -194,8 +206,9 @@ function createSiteGroundColliderGeometry(site: SiteNode, nodes: SceneNodes) {
   geometry.applyMatrix4(
     new THREE.Matrix4().makeTranslation(centerX, -LEVEL_FALLBACK_FLOOR_THICKNESS / 2, centerZ),
   )
-  geometry.applyMatrix4(siteObject.matrixWorld)
-  return geometry
+  const cut = cutGroundCollider(geometry, covered)
+  cut.applyMatrix4(siteObject.matrixWorld)
+  return cut
 }
 
 function collectSiteGroundColliderGeometries(nodes: SceneNodes) {
@@ -281,6 +294,10 @@ function createDoorLeafColliderGeometry(root: THREE.Object3D, node: DoorNode) {
   const hasLeafContent = node.segments.some((segment) => segment.type !== 'empty')
   if (!hasLeafContent) return null
 
+  // A door built from a script opens by its model's `open` clip, which the mechanism runs through
+  // its own control: the native `operationState` below never moves for it, so open is read there.
+  if (node.source && nodeMechanism(node)?.isOn(node, useInteractive.getState())) return null
+
   const leafW = node.width - 2 * node.frameThickness
   const leafH = node.height - node.frameThickness
   if (leafW <= 0 || leafH <= 0) return null
@@ -356,8 +373,12 @@ function collectColliderGeometriesFromNode(
     visitedMeshes.add(object)
 
     // Prune hidden subtrees — children of an invisible group never render,
-    // so they must not collide either (see isEffectivelyVisible).
-    if (!object.visible) return
+    // so they must not collide either (see isEffectivelyVisible). An idle joint
+    // tree draws a merged rest pose that includes its moving parts; its hidden
+    // split group holds the same static parts apart from them.
+    if (object.userData.pascalProceduralRest) return
+    if (!object.visible && !object.userData.pascalProceduralSplit) return
+    if (object.userData.proceduralMotion) return
 
     if (
       isMesh(object) &&
@@ -453,7 +474,7 @@ export function buildFirstPersonColliderWorldFromRegistry(): FirstPersonCollider
   ;(bvhGeometry as any).computeBoundsTree = computeBoundsTree
   ;(bvhGeometry as any).disposeBoundsTree = disposeBoundsTree
   bvhGeometry.computeBoundsTree?.({
-    maxLeafSize: 12,
+    targetLeafSize: 12,
     strategy: 0,
   } as never)
   bvhGeometry.computeBoundingBox()

package/src/components/editor/first-person/ground-holes.test.ts

@@ -0,0 +1,128 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  BoxGeometry,
+  BufferAttribute,
+  BufferGeometry,
+  Mesh,
+  MeshBasicMaterial,
+  Raycaster,
+  Vector3,
+} from 'three'
+import { cutGroundCollider } from './ground-holes'
+
+/** A 10 × 10 m square on the plane y = 0.1 x (two triangles, facing up), plan 0..10 × 0..10. */
+function slopedSquare(flip = false) {
+  const corner = (x: number, z: number): [number, number, number] => [x, 0.1 * x, z]
+  const up = [
+    corner(0, 0),
+    corner(0, 10),
+    corner(10, 0),
+    corner(10, 0),
+    corner(0, 10),
+    corner(10, 10),
+  ]
+  const vertices = flip ? [...up].reverse() : up
+  const geometry = new BufferGeometry()
+  geometry.setAttribute('position', new BufferAttribute(new Float32Array(vertices.flat()), 3))
+  const slope = new Vector3(-0.1, 1, 0).normalize()
+  const normal = flip ? slope.clone().negate() : slope
+  geometry.setAttribute(
+    'normal',
+    new BufferAttribute(
+      new Float32Array(vertices.flatMap(() => [normal.x, normal.y, normal.z])),
+      3,
+    ),
+  )
+  return geometry
+}
+
+const HOLE: Array<[number, number]> = [
+  [3, 3],
+  [7, 3],
+  [7, 6],
+  [3, 6],
+]
+
+/** The up (1) or down (-1) facing of every triangle of a non-indexed geometry. */
+function triangles(geometry: BufferGeometry) {
+  const position = geometry.getAttribute('position')
+  const out: Array<{ facing: number }> = []
+  for (let i = 0; i < position.count; i += 3) {
+    const [a, b, c] = [0, 1, 2].map(
+      (k) => new Vector3(position.getX(i + k), position.getY(i + k), position.getZ(i + k)),
+    ) as [Vector3, Vector3, Vector3]
+    const normal = b.clone().sub(a).cross(c.clone().sub(a))
+    out.push({ facing: Math.sign(normal.y) })
+  }
+  return out
+}
+
+function hitUnder(geometry: BufferGeometry, x: number, z: number): number | null {
+  const mesh = new Mesh(geometry, new MeshBasicMaterial())
+  mesh.updateMatrixWorld(true)
+  const raycaster = new Raycaster()
+  raycaster.set(new Vector3(x, 50, z), new Vector3(0, -1, 0))
+  return raycaster.intersectObject(mesh, false)[0]?.point.y ?? null
+}
+
+describe('cutGroundCollider', () => {
+  test('without holes the geometry is returned as it is', () => {
+    const geometry = slopedSquare()
+    expect(cutGroundCollider(geometry, [])).toBe(geometry)
+  })
+
+  test('the ground is gone over the hole and is the same surface everywhere else', () => {
+    const cut = cutGroundCollider(slopedSquare(), [HOLE])
+    expect(hitUnder(cut, 5, 4)).toBeNull()
+    expect(hitUnder(cut, 3.2, 3.2)).toBeNull()
+    expect(hitUnder(cut, 6.8, 5.8)).toBeNull()
+    // Past the rim, on the slope the uncut triangle had: y = 0.1 x.
+    for (const [x, z] of [
+      [2.8, 4],
+      [7.2, 4],
+      [5, 2.8],
+      [5, 6.2],
+      [1, 1],
+      [9, 9],
+    ] as const)
+      expect(hitUnder(cut, x, z)).toBeCloseTo(0.1 * x, 5)
+  })
+
+  test('what is left has the area of the ground less the hole, and faces as the ground did', () => {
+    for (const flip of [false, true]) {
+      const cut = cutGroundCollider(slopedSquare(flip), [HOLE])
+      const pieces = triangles(cut)
+      // The slope stretches the surface, so compare in plan: 100 - 12 m².
+      const position = cut.getAttribute('position')
+      let plan = 0
+      for (let i = 0; i < position.count; i += 3) {
+        const [a, b, c] = [0, 1, 2].map((k) => [position.getX(i + k), position.getZ(i + k)]) as [
+          [number, number],
+          [number, number],
+          [number, number],
+        ]
+        plan += Math.abs((b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])) / 2
+      }
+      expect(plan).toBeCloseTo(100 - 12, 3)
+      for (const piece of pieces) expect(piece.facing).toBe(flip ? -1 : 1)
+    }
+  })
+
+  test('the normals follow the ground and stay unit length', () => {
+    const cut = cutGroundCollider(slopedSquare(), [HOLE])
+    const normal = cut.getAttribute('normal')
+    for (let i = 0; i < normal.count; i += 1) {
+      expect(Math.hypot(normal.getX(i), normal.getY(i), normal.getZ(i))).toBeCloseTo(1, 5)
+      expect(normal.getX(i)).toBeCloseTo(-0.1 / Math.hypot(0.1, 1), 5)
+    }
+  })
+
+  test('a triangle wholly inside the hole is dropped, vertical faces are kept', () => {
+    const box = new BoxGeometry(2, 2, 2).toNonIndexed()
+    box.translate(5, 0, 4.5)
+    const before = box.getAttribute('position').count
+    const cut = cutGroundCollider(box, [HOLE])
+    // Top and bottom faces lie wholly inside the hole and go; the four sides (no plan area) stay.
+    expect(cut.getAttribute('position').count).toBe(before - 12)
+  })
+})