@pascal-app/editor 0.9.1 → 1.0.0-beta.1

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

@@ -3,9 +3,11 @@ import {
   type AnyNodeId,
   type DoorNode,
   getGarageVisibleOpeningRatio,
+  getLevelElevations,
   isOperationDoorType,
   nodeRegistry,
   sceneRegistry,
+  terrainFieldOf,
   useInteractive,
   useScene,
 } from '@pascal-app/core'
@@ -13,6 +15,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 { createTerrainColliderGeometry } from './terrain-collider'
 
 const SKIPPED_MESH_NAMES = new Set(['cutout', 'collision-mesh'])
 const COLLIDER_NODE_CATEGORIES = new Set(['structure', 'furnish'])
@@ -27,6 +30,7 @@ const OPERATION_DOOR_COLLIDER_OPEN_THRESHOLD = 0.85
 const LEVEL_FALLBACK_FLOOR_THICKNESS = 0.08
 const LEVEL_FALLBACK_FLOOR_PADDING = 2
 const LEVEL_FALLBACK_FLOOR_MIN_SIZE = 30
+const SITE_GROUND_COLLIDER_MIN_SIZE = 2000
 
 export const FIRST_PERSON_SPAWN_EYE_HEIGHT = SPAWN_EYE_HEIGHT
 
@@ -49,6 +53,22 @@ function isMesh(object: THREE.Object3D): object is THREE.Mesh {
   return 'isMesh' in object && (object as THREE.Mesh).isMesh
 }
 
+// Renderer-effective visibility: an invisible ancestor hides the whole
+// subtree at render time even when the object's own flag is true. The
+// collider world must match what's rendered — the roof keeps stale,
+// UNCUT per-segment CSG inside its hidden `segments-wrapper` (full-edit
+// exit hides the wrapper without stripping geometry), and cloning those
+// meshes would block the walkthrough player at openings the visible
+// merged shell has cut through.
+function isEffectivelyVisible(object: THREE.Object3D) {
+  let current: THREE.Object3D | null = object
+  while (current) {
+    if (!current.visible) return false
+    current = current.parent
+  }
+  return true
+}
+
 function isColliderMaterialVisible(material: THREE.Material | THREE.Material[]) {
   return Array.isArray(material) ? material.some((entry) => entry.visible) : material.visible
 }
@@ -112,10 +132,12 @@ function createLevelFallbackFloorGeometry(level: LevelNode, nodes: SceneNodes) {
 
 function collectLevelFallbackFloorGeometries(nodes: SceneNodes) {
   const geometries: THREE.BufferGeometry[] = []
+  const levelElevations = getLevelElevations(nodes)
 
   for (const levelId of sceneRegistry.byType.level!) {
     const node = nodes[levelId as AnyNodeId]
     if (node?.type !== 'level') continue
+    if (levelElevations.get(node.id)?.baseY !== 0) continue
 
     const geometry = createLevelFallbackFloorGeometry(node, nodes)
     if (geometry) geometries.push(geometry)
@@ -129,24 +151,41 @@ function collectLevelFallbackFloorGeometries(nodes: SceneNodes) {
 // a dedicated collider, a spawn on the bare ground (no slab, or not parented to
 // a level that triggers the per-level fallback) has no floor to stand on and the
 // walkthrough player falls through. Derive a thin ground slab from node data (not
-// the rendered mesh) so it exists regardless of geometry-mount timing, sized to
-// cover the whole scene footprint at the site's ground plane.
+// the rendered mesh) so it exists regardless of geometry-mount timing. The slab
+// is effectively unbounded (not sized to the site polygon): the ground plane must
+// keep holding the player up even after they step past the site boundary,
+// otherwise they fall below the ground plane into the void.
+//
+// A sculpted site takes the terrain path instead: the flat slab would hold the
+// 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.
 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 field = terrainFieldOf(site)
+  if (field) {
+    const terrainGeometry = createTerrainColliderGeometry(field)
+    if (terrainGeometry) {
+      siteObject.updateWorldMatrix(true, false)
+      terrainGeometry.applyMatrix4(siteObject.matrixWorld)
+      return terrainGeometry
+    }
+  }
+
   const bounds = computeSceneBoundsXZ(nodes)
   const [centerX, centerZ] = bounds?.center ?? [0, 0]
   const [boundsWidth, boundsDepth] = bounds?.size ?? [0, 0]
   const width = Math.max(
     boundsWidth + LEVEL_FALLBACK_FLOOR_PADDING * 2,
-    LEVEL_FALLBACK_FLOOR_MIN_SIZE,
+    SITE_GROUND_COLLIDER_MIN_SIZE,
   )
   const depth = Math.max(
     boundsDepth + LEVEL_FALLBACK_FLOOR_PADDING * 2,
-    LEVEL_FALLBACK_FLOOR_MIN_SIZE,
+    SITE_GROUND_COLLIDER_MIN_SIZE,
   )
 
   const geometry = createBoxColliderGeometry(width, LEVEL_FALLBACK_FLOOR_THICKNESS, depth)
@@ -316,9 +355,12 @@ function collectColliderGeometriesFromNode(
     if (visitedMeshes.has(object)) return
     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
+
     if (
       isMesh(object) &&
-      object.visible &&
       isColliderMaterialVisible(object.material) &&
       !SKIPPED_MESH_NAMES.has(object.name)
     ) {
@@ -361,6 +403,11 @@ export function buildFirstPersonColliderWorldFromRegistry(): FirstPersonCollider
     const root = sceneRegistry.nodes.get(nodeId)
     if (!root) continue
 
+    // Registered objects can sit inside a hidden wrapper (roof segments
+    // under `segments-wrapper`) — the per-node traversal starts AT the
+    // object, so the ancestor chain must be checked here.
+    if (!isEffectivelyVisible(root)) continue
+
     if (node.type === 'door') {
       const doorGeometry = createDoorLeafColliderGeometry(root, node)
       if (doorGeometry) {

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

@@ -0,0 +1,132 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  applyHeightPatch,
+  createTerrainField,
+  flattenPatch,
+  heightAt,
+  type TerrainField,
+} from '@pascal-app/core'
+import { Mesh, MeshBasicMaterial, Raycaster, Vector3 } from 'three'
+import { createTerrainColliderGeometry } from './terrain-collider'
+
+const DOWN = new Vector3(0, -1, 0)
+const UP = new Vector3(0, 1, 0)
+
+/** A 2.5 m plateau over x,z ∈ [2,5] on an otherwise flat field. */
+function plateauField(): TerrainField {
+  const base = createTerrainField({ cols: 17, rows: 17, spacing: 1, origin: [-8, -8] })
+  const patch = flattenPatch(base, { minX: 2, minZ: 2, maxX: 5, maxZ: 5 }, 2.5)
+  return applyHeightPatch(base, patch as never)
+}
+
+/** A field sloping 0.1 m per metre along +x, so every sample differs. */
+function slopedField(): TerrainField {
+  const field = createTerrainField({ cols: 9, rows: 9, spacing: 1, origin: [-4, -4] })
+  const heights = new Int16Array(field.heights)
+  for (let r = 0; r < field.rows; r++) {
+    for (let c = 0; c < field.cols; c++) {
+      heights[r * field.cols + c] = Math.round((c * 0.1) /* m */ / field.step)
+    }
+  }
+  return { ...field, heights }
+}
+
+function colliderMesh(field: TerrainField) {
+  const geometry = createTerrainColliderGeometry(field)
+  if (!geometry) throw new Error('no collider geometry')
+  const mesh = new Mesh(geometry, new MeshBasicMaterial())
+  mesh.updateMatrixWorld(true)
+  return mesh
+}
+
+/** The height a downward ray finds — what the walkthrough player stands on. */
+function groundUnder(mesh: Mesh, x: number, z: number): number | null {
+  const raycaster = new Raycaster()
+  raycaster.set(new Vector3(x, 500, z), DOWN)
+  const hits = raycaster.intersectObject(mesh, false)
+  const floor = hits.find((hit) => {
+    if (!hit.face) return true
+    return hit.face.normal.clone().transformDirection(mesh.matrixWorld).dot(UP) > 0.2
+  })
+  return floor ? floor.point.y : null
+}
+
+describe('createTerrainColliderGeometry', () => {
+  test('the walkable surface is the field, not a plane', () => {
+    const field = plateauField()
+    const mesh = colliderMesh(field)
+
+    // On the plateau, off it, and on the slope between: the collider has to agree
+    // with `heightAt` at each, or what you see is not what you stand on.
+    for (const [x, z] of [
+      [3, 3],
+      [-3, -3],
+      [1.5, 3],
+      [4.5, 4.5],
+    ] as Array<[number, number]>) {
+      expect(groundUnder(mesh, x, z)).toBeCloseTo(heightAt(field, x, z), 4)
+    }
+  })
+
+  test('a sloped field is sampled per vertex, not averaged', () => {
+    const field = slopedField()
+    const mesh = colliderMesh(field)
+
+    // Sample midpoints, where a flat or decimated collider would disagree most.
+    for (const x of [-3.5, -0.5, 1.5, 3.5]) {
+      expect(groundUnder(mesh, x, 0)).toBeCloseTo(heightAt(field, x, 0), 4)
+    }
+  })
+
+  test('the skirt keeps holding the player far past the field', () => {
+    const field = slopedField()
+    const mesh = colliderMesh(field)
+
+    // Past every edge and past a corner: `heightAt` clamps to the border there, so
+    // the collider must too. Without the skirt these are null and the player falls.
+    for (const [x, z] of [
+      [400, 0],
+      [-400, 0],
+      [0, 400],
+      [0, -400],
+      [400, 400],
+      [-400, -400],
+    ] as Array<[number, number]>) {
+      expect(groundUnder(mesh, x, z)).toBeCloseTo(heightAt(field, x, z), 4)
+    }
+  })
+
+  test('every triangle carries a normal, and the surface faces up', () => {
+    const geometry = createTerrainColliderGeometry(plateauField())
+    if (!geometry) throw new Error('no collider geometry')
+
+    const position = geometry.getAttribute('position')
+    const normal = geometry.getAttribute('normal')
+    expect(normal).toBeDefined()
+    expect(normal.count).toBe(position.count)
+    // Non-indexed triangles — `mergeGeometries` needs every contributor to match.
+    expect(geometry.index).toBeNull()
+    expect(position.count % 3).toBe(0)
+
+    for (let i = 0; i < normal.count; i++) {
+      expect(normal.getY(i)).toBeGreaterThan(0)
+    }
+  })
+
+  test('decimates rather than exploding on an absurd field', () => {
+    // 1025² is inside the schema's decode-bomb guard but 1M cells — an exact
+    // collider would be 2M triangles for a surface nobody can walk that far across.
+    const field = createTerrainField({ cols: 1025, rows: 1025, spacing: 0.5 })
+    const geometry = createTerrainColliderGeometry(field)
+    if (!geometry) throw new Error('no collider geometry')
+
+    const triangles = geometry.getAttribute('position').count / 3
+    expect(triangles).toBeLessThan(200_000)
+    // Still a real surface, not an empty one.
+    expect(triangles).toBeGreaterThan(1000)
+  })
+
+  test('returns null for a degenerate field', () => {
+    expect(createTerrainColliderGeometry(createTerrainField({ cols: 1, rows: 1 }))).toBeNull()
+  })
+})

package/src/components/editor/first-person/terrain-collider.ts

@@ -0,0 +1,212 @@
+/**
+ * The sculpted ground as walkthrough collision geometry.
+ *
+ * The first-person collider world is a single merged BVH mesh, and before terrain
+ * the ground contributed one flat 2 km box to it. That box is wrong in both
+ * directions on a sculpted site: it holds the player up at the datum inside an
+ * excavation, and buries them inside a hill. This module replaces it.
+ *
+ * Two properties it has to hold, because the whole point is that walking agrees
+ * with every other consumer of the field:
+ *
+ * - **The surface is the field**, sampled at every vertex — the same
+ *   `heightAtSample`/`normalAt` the rendered mesh uses (`terrain-geometry.ts`),
+ *   so what you see is what you stand on. It is deliberately not a decimated
+ *   proxy at realistic field sizes.
+ * - **It extends past the field**, because `heightAt` clamps to the border
+ *   outside it. A collider that stopped at the field edge would drop the player
+ *   into the void one step past the site, which is exactly the bug the flat box
+ *   existed to prevent. The skirt extrudes each border sample outward at its own
+ *   height, so the collider and `heightAt` agree everywhere, not just inside.
+ *
+ * Non-indexed triangles with position + normal, matching what the other collider
+ * contributors emit — `mergeGeometries` requires every input to agree on both.
+ */
+
+import { heightAtSample, normalAt, type TerrainField } from '@pascal-app/core'
+import * as THREE from 'three'
+
+/**
+ * How far past the field the ground keeps holding the player, in metres. Matches
+ * the flat box's half-extent so a site's collider bounds do not change size when
+ * it gains terrain.
+ */
+const SKIRT_REACH = 1000
+
+/**
+ * Cell budget before the collider decimates.
+ *
+ * 66k cells is a 257² field — the largest anything realistic produces, and ~131k
+ * triangles, which the BVH builds in well under a frame's worth of budget. The
+ * schema allows up to 4097² (a decode-bomb guard, not a real terrain); at that
+ * size an exact collider would be 100M triangles, so past the budget this steps
+ * the sample grid and the collider becomes a faithful-but-coarser version of the
+ * same surface rather than an out-of-memory crash.
+ */
+const MAX_COLLIDER_CELLS = 66_000
+
+function colliderStride(field: TerrainField): number {
+  const cells = Math.max(1, (field.cols - 1) * (field.rows - 1))
+  if (cells <= MAX_COLLIDER_CELLS) return 1
+  return Math.ceil(Math.sqrt(cells / MAX_COLLIDER_CELLS))
+}
+
+/** The sample indices the collider walks: every `stride`-th, always including the border. */
+function sampleLine(count: number, stride: number): number[] {
+  const line: number[] = []
+  for (let i = 0; i < count - 1; i += stride) line.push(i)
+  line.push(count - 1)
+  return line
+}
+
+type Vertex = { x: number; y: number; z: number }
+
+class TriangleSink {
+  private readonly positions: number[] = []
+  private readonly normals: number[] = []
+
+  constructor(private readonly field: TerrainField) {}
+
+  private push(v: Vertex): void {
+    this.positions.push(v.x, v.y, v.z)
+    const [nx, ny, nz] = normalAt(this.field, v.x, v.z)
+    this.normals.push(nx, ny, nz)
+  }
+
+  /**
+   * One cell, given its four corners named by axis order. Winding matches
+   * `buildTerrainMesh`: `(p00, p01, p10)` and `(p10, p01, p11)` faces +Y, which is
+   * what the spawn resolver's `normal.dot(UP) > 0.2` floor test needs.
+   */
+  quad(p00: Vertex, p10: Vertex, p01: Vertex, p11: Vertex): void {
+    this.push(p00)
+    this.push(p01)
+    this.push(p10)
+    this.push(p10)
+    this.push(p01)
+    this.push(p11)
+  }
+
+  build(): THREE.BufferGeometry | null {
+    if (this.positions.length === 0) return null
+    const geometry = new THREE.BufferGeometry()
+    geometry.setAttribute(
+      'position',
+      new THREE.BufferAttribute(new Float32Array(this.positions), 3),
+    )
+    geometry.setAttribute('normal', new THREE.BufferAttribute(new Float32Array(this.normals), 3))
+    return geometry
+  }
+}
+
+/**
+ * Terrain collision geometry in the site's own frame — the caller applies the
+ * site's world matrix, exactly as it did for the flat box it replaces.
+ */
+export function createTerrainColliderGeometry(field: TerrainField): THREE.BufferGeometry | null {
+  if (field.cols < 2 || field.rows < 2) return null
+
+  const stride = colliderStride(field)
+  const cols = sampleLine(field.cols, stride)
+  const rows = sampleLine(field.rows, stride)
+  const sink = new TriangleSink(field)
+
+  const xAt = (col: number) => field.origin[0] + col * field.spacing
+  const zAt = (row: number) => field.origin[1] + row * field.spacing
+  const at = (col: number, row: number): Vertex => ({
+    x: xAt(col),
+    y: heightAtSample(field, col, row),
+    z: zAt(row),
+  })
+
+  for (let ri = 0; ri < rows.length - 1; ri++) {
+    const r0 = rows[ri] as number
+    const r1 = rows[ri + 1] as number
+    for (let ci = 0; ci < cols.length - 1; ci++) {
+      const c0 = cols[ci] as number
+      const c1 = cols[ci + 1] as number
+      sink.quad(at(c0, r0), at(c1, r0), at(c0, r1), at(c1, r1))
+    }
+  }
+
+  // The skirt: each border sample extruded outward at its own height, so stepping
+  // off the field lands on the border height rather than on nothing. This is the
+  // collider spelling of `heightAt`'s edge clamp.
+  const firstCol = 0
+  const lastCol = field.cols - 1
+  const firstRow = 0
+  const lastRow = field.rows - 1
+  const westX = xAt(firstCol) - SKIRT_REACH
+  const eastX = xAt(lastCol) + SKIRT_REACH
+  const northZ = zAt(firstRow) - SKIRT_REACH
+  const southZ = zAt(lastRow) + SKIRT_REACH
+
+  for (let ci = 0; ci < cols.length - 1; ci++) {
+    const c0 = cols[ci] as number
+    const c1 = cols[ci + 1] as number
+    const north0 = at(c0, firstRow)
+    const north1 = at(c1, firstRow)
+    sink.quad(
+      { x: north0.x, y: north0.y, z: northZ },
+      { x: north1.x, y: north1.y, z: northZ },
+      north0,
+      north1,
+    )
+    const south0 = at(c0, lastRow)
+    const south1 = at(c1, lastRow)
+    sink.quad(
+      south0,
+      south1,
+      { x: south0.x, y: south0.y, z: southZ },
+      {
+        x: south1.x,
+        y: south1.y,
+        z: southZ,
+      },
+    )
+  }
+
+  for (let ri = 0; ri < rows.length - 1; ri++) {
+    const r0 = rows[ri] as number
+    const r1 = rows[ri + 1] as number
+    const west0 = at(firstCol, r0)
+    const west1 = at(firstCol, r1)
+    sink.quad(
+      { x: westX, y: west0.y, z: west0.z },
+      west0,
+      { x: westX, y: west1.y, z: west1.z },
+      west1,
+    )
+    const east0 = at(lastCol, r0)
+    const east1 = at(lastCol, r1)
+    sink.quad(east0, { x: eastX, y: east0.y, z: east0.z }, east1, {
+      x: eastX,
+      y: east1.y,
+      z: east1.z,
+    })
+  }
+
+  // Corner quads, flat at the corner sample's height — the diagonal region no edge
+  // strip covers, and where `heightAt` also reports the corner value.
+  const corners: Array<[Vertex, number, number]> = [
+    [at(firstCol, firstRow), westX, northZ],
+    [at(lastCol, firstRow), eastX, northZ],
+    [at(firstCol, lastRow), westX, southZ],
+    [at(lastCol, lastRow), eastX, southZ],
+  ]
+  for (const [corner, farX, farZ] of corners) {
+    const minX = Math.min(corner.x, farX)
+    const maxX = Math.max(corner.x, farX)
+    const minZ = Math.min(corner.z, farZ)
+    const maxZ = Math.max(corner.z, farZ)
+    const y = corner.y
+    sink.quad(
+      { x: minX, y, z: minZ },
+      { x: maxX, y, z: minZ },
+      { x: minX, y, z: maxZ },
+      { x: maxX, y, z: maxZ },
+    )
+  }
+
+  return sink.build()
+}