@pascal-app/editor 1.0.0-beta.4 → 1.0.0

package/src/lib/print-shell-compiler.ts

@@ -0,0 +1,273 @@
+import {
+  type AnyNode,
+  getWallEffectiveHeightForNodes,
+  type RoofSegmentNode,
+  resolveLevelId,
+  spatialGridManager,
+  type WallNode,
+} from '@pascal-app/core'
+import { disposeObject3DResources } from '@pascal-app/viewer'
+import * as THREE from 'three'
+import { buildPrintableRoofSegmentSolids } from './print-roof-solids'
+import {
+  compilePrintShellBaseline,
+  type PrintShellCompileDiagnostic,
+  type PrintShellCompileResult,
+} from './print-shell-compiler-baseline'
+import { buildPrintableWallSolids } from './print-wall-solids'
+
+export type SemanticPrintCompileOptions = {
+  wallSolids?: boolean
+}
+
+export type SemanticPrintSourceResult =
+  | {
+      status: 'ready'
+      scene: THREE.Object3D
+      diagnostics: []
+      dispose: () => void
+    }
+  | {
+      status: 'blocked'
+      scene: null
+      inputMeshCount: number
+      sourceNodeIds: string[]
+      diagnostics: PrintShellCompileDiagnostic[]
+      dispose: () => void
+    }
+
+function meshCount(root: THREE.Object3D): number {
+  let count = 0
+  root.traverse((object) => {
+    const mesh = object as THREE.Mesh
+    const position = mesh.isMesh ? mesh.geometry?.getAttribute('position') : null
+    if (position && position.count > 0) count += 1
+  })
+  return count
+}
+
+function replaceChild(parent: THREE.Object3D, target: THREE.Object3D, replacement: THREE.Object3D) {
+  const targetIndex = parent.children.indexOf(target)
+  parent.remove(target)
+  parent.add(replacement)
+  const appendedIndex = parent.children.indexOf(replacement)
+  parent.children.splice(appendedIndex, 1)
+  parent.children.splice(targetIndex, 0, replacement)
+}
+
+function copyPreparedTransform(
+  source: THREE.Object3D,
+  target: THREE.Object3D,
+  printSource: 'canonical-roof' | 'canonical-wall',
+) {
+  target.name = source.name
+  target.position.copy(source.position)
+  target.quaternion.copy(source.quaternion)
+  target.scale.copy(source.scale)
+  target.matrix.copy(source.matrix)
+  target.matrixAutoUpdate = source.matrixAutoUpdate
+  target.visible = source.visible
+  target.layers.mask = source.layers.mask
+  target.userData = { ...source.userData, printSource }
+}
+
+function disposeGenerated(root: THREE.Object3D) {
+  disposeObject3DResources(root)
+}
+
+function exportedIdentityIds(root: THREE.Object3D): Set<string> {
+  const ids = new Set<string>()
+  root.traverse((object) => {
+    if (typeof object.userData.pascalId === 'string') ids.add(object.userData.pascalId)
+  })
+  return ids
+}
+
+function ownedLocalYBounds(root: THREE.Object3D): { min: number; max: number } | null {
+  root.updateMatrixWorld(true)
+  const inverseRoot = root.matrixWorld.clone().invert()
+  const point = new THREE.Vector3()
+  let min = Number.POSITIVE_INFINITY
+  let max = Number.NEGATIVE_INFINITY
+
+  const visit = (object: THREE.Object3D) => {
+    if (
+      object !== root &&
+      typeof object.userData.pascalId === 'string' &&
+      object.userData.pascalId !== root.userData.pascalId
+    ) {
+      return
+    }
+    const mesh = object as THREE.Mesh
+    const position = mesh.isMesh ? mesh.geometry.getAttribute('position') : null
+    if (position) {
+      const toRoot = inverseRoot.clone().multiply(object.matrixWorld)
+      for (let index = 0; index < position.count; index += 1) {
+        point.fromBufferAttribute(position, index).applyMatrix4(toRoot)
+        min = Math.min(min, point.y)
+        max = Math.max(max, point.y)
+      }
+    }
+    for (const child of object.children) visit(child)
+  }
+  visit(root)
+  return Number.isFinite(min) && Number.isFinite(max) ? { min, max } : null
+}
+
+function preparedWallHeight(
+  node: WallNode,
+  object: THREE.Object3D,
+  nodes: Record<string, AnyNode>,
+):
+  | { height: number; diagnostic: null }
+  | { height: null; diagnostic: PrintShellCompileDiagnostic } {
+  const levelId = resolveLevelId(node, nodes)
+  const support = spatialGridManager.getSlabSupportForWall(
+    levelId,
+    node.start,
+    node.end,
+    node.curveOffset ?? 0,
+    node.thickness,
+    node.supportSlabId ?? null,
+    undefined,
+    node.supportOffset,
+  )
+  const hasDisplacedBase =
+    Math.abs(support.baseElevation - support.elevation) > 1e-5 ||
+    support.baseSegments.some((segment) => Math.abs(segment.elevation - support.elevation) > 1e-5)
+  const bounds = ownedLocalYBounds(object)
+  if (hasDisplacedBase || (bounds && bounds.max > 1e-7 && Math.abs(bounds.min) > 1e-5)) {
+    return {
+      height: null,
+      diagnostic: {
+        severity: 'error',
+        code: 'unsupported_wall_print_base',
+        message: `Wall ${node.id} has a stepped or displaced local base that does not yet have a canonical printable solid.`,
+        nodeIds: [node.id],
+      },
+    }
+  }
+
+  const height = getWallEffectiveHeightForNodes(node, nodes)
+  if (!Number.isFinite(height) || height <= 1e-7) {
+    return {
+      height: null,
+      diagnostic: {
+        severity: 'error',
+        code: 'invalid_wall_print_dimensions',
+        message: `Wall ${node.id} has no finite semantic height for print compilation.`,
+        nodeIds: [node.id],
+      },
+    }
+  }
+  return { height, diagnostic: null }
+}
+
+export function prepareSemanticPrintShellSource(
+  source: THREE.Object3D,
+  nodes: Record<string, AnyNode>,
+  options: SemanticPrintCompileOptions = {},
+): SemanticPrintSourceResult {
+  const scene = new THREE.Group()
+  scene.name = 'semantic-print-source'
+  scene.add(source.clone(true))
+
+  const includedNodeIds = exportedIdentityIds(scene)
+  const roofTargets: { node: RoofSegmentNode; object: THREE.Object3D }[] = []
+  const wallTargets: { node: WallNode; object: THREE.Object3D }[] = []
+  scene.traverse((object) => {
+    const id = object.userData.pascalId
+    const node = typeof id === 'string' ? nodes[id] : undefined
+    if (node?.type === 'roof-segment') roofTargets.push({ node, object })
+    if (options.wallSolids && node?.type === 'wall') wallTargets.push({ node, object })
+  })
+
+  const diagnostics: PrintShellCompileDiagnostic[] = []
+  const replacements: { target: THREE.Object3D; replacement: THREE.Group }[] = []
+  for (const { node, object } of roofTargets) {
+    const result = buildPrintableRoofSegmentSolids(node, nodes)
+    if (result.status === 'blocked') {
+      diagnostics.push(...result.diagnostics)
+      continue
+    }
+    copyPreparedTransform(object, result.object, 'canonical-roof')
+    replacements.push({ target: object, replacement: result.object })
+  }
+  for (const { node, object } of wallTargets) {
+    const prepared = preparedWallHeight(node, object, nodes)
+    if (prepared.diagnostic) {
+      diagnostics.push(prepared.diagnostic)
+      continue
+    }
+    const result = buildPrintableWallSolids(
+      node,
+      { effectiveHeight: prepared.height, includedNodeIds },
+      nodes,
+    )
+    if (result.status === 'blocked') {
+      diagnostics.push(...result.diagnostics)
+      continue
+    }
+    copyPreparedTransform(object, result.object, 'canonical-wall')
+    replacements.push({ target: object, replacement: result.object })
+  }
+
+  if (diagnostics.length > 0) {
+    for (const { replacement } of replacements) disposeGenerated(replacement)
+    return {
+      status: 'blocked',
+      scene: null,
+      inputMeshCount: meshCount(scene),
+      sourceNodeIds: Array.from(
+        new Set(diagnostics.flatMap((diagnostic) => diagnostic.nodeIds)),
+      ).sort(),
+      diagnostics,
+      dispose: () => {},
+    }
+  }
+
+  for (const { target, replacement } of replacements) {
+    if (target.parent) replaceChild(target.parent, target, replacement)
+  }
+
+  let disposed = false
+  return {
+    status: 'ready',
+    scene,
+    diagnostics: [],
+    dispose: () => {
+      if (disposed) return
+      disposed = true
+      for (const { replacement } of replacements) disposeGenerated(replacement)
+    },
+  }
+}
+
+/**
+ * Compiles a semantic structural source instead of trusting display aggregates.
+ * Roof segments are replaced as complete identity subtrees so their hosted
+ * display CSG and accessory meshes cannot leak into the manufacturing shell.
+ */
+export function compileSemanticPrintShell(
+  source: THREE.Object3D,
+  nodes: Record<string, AnyNode>,
+  options: SemanticPrintCompileOptions = {},
+): PrintShellCompileResult {
+  const prepared = prepareSemanticPrintShellSource(source, nodes, options)
+  if (prepared.status === 'blocked') {
+    return {
+      backend: 'pascal-three-bvh-csg',
+      status: 'blocked',
+      scene: null,
+      inputMeshCount: prepared.inputMeshCount,
+      sourceNodeIds: prepared.sourceNodeIds,
+      diagnostics: prepared.diagnostics,
+    }
+  }
+
+  try {
+    return compilePrintShellBaseline(prepared.scene)
+  } finally {
+    prepared.dispose()
+  }
+}

package/src/lib/print-wall-solids.test.ts

@@ -0,0 +1,194 @@
+import { describe, expect, test } from 'bun:test'
+import { DoorNode, WallNode, WindowNode } from '@pascal-app/core'
+import * as THREE from 'three'
+import { buildPrintableWallSolids } from './print-wall-solids'
+
+function rayIntersectionCount(root: THREE.Object3D, x: number, y: number): number {
+  root.updateMatrixWorld(true)
+  const raycaster = new THREE.Raycaster(new THREE.Vector3(x, y, -1), new THREE.Vector3(0, 0, 1))
+  const material = new THREE.MeshBasicMaterial({ side: THREE.DoubleSide })
+  let count = 0
+  root.traverse((object) => {
+    const mesh = object as THREE.Mesh
+    if (!mesh.isMesh) return
+    const originalMaterial = mesh.material
+    mesh.material = material
+    count += raycaster.intersectObject(mesh, false).length
+    mesh.material = originalMaterial
+  })
+  material.dispose()
+  return count
+}
+
+function expectClosedBoxMeshes(root: THREE.Group) {
+  for (const object of root.children) {
+    const mesh = object as THREE.Mesh
+    expect(mesh.isMesh).toBe(true)
+    const index = mesh.geometry.getIndex()
+    expect(index).not.toBeNull()
+    const edges = new Map<string, number>()
+    const add = (a: number, b: number) => {
+      const key = a < b ? `${a}|${b}` : `${b}|${a}`
+      edges.set(key, (edges.get(key) ?? 0) + 1)
+    }
+    for (let offset = 0; offset + 2 < index!.count; offset += 3) {
+      const a = index!.getX(offset)
+      const b = index!.getX(offset + 1)
+      const c = index!.getX(offset + 2)
+      add(a, b)
+      add(b, c)
+      add(c, a)
+    }
+    expect(Array.from(edges.values()).every((uses) => uses === 2)).toBe(true)
+  }
+}
+
+function dispose(root: THREE.Group) {
+  root.traverse((object) => {
+    const mesh = object as THREE.Mesh
+    if (mesh.isMesh) mesh.geometry.dispose()
+  })
+}
+
+describe('buildPrintableWallSolids', () => {
+  test('builds deterministic closed solids around rectangular door and window voids', () => {
+    const door = DoorNode.parse({
+      id: 'door_print-wall',
+      wallId: 'wall_print-openings',
+      position: [1.5, 1.05, 0],
+      width: 0.9,
+      height: 2.1,
+    })
+    const window = WindowNode.parse({
+      id: 'window_print-wall',
+      wallId: 'wall_print-openings',
+      position: [4.5, 1.4, 0],
+      width: 1.2,
+      height: 1.0,
+    })
+    const wall = WallNode.parse({
+      id: 'wall_print-openings',
+      start: [0, 0],
+      end: [6, 0],
+      height: 2.5,
+      thickness: 0.2,
+      children: [door.id, window.id],
+    })
+    const nodes = { [door.id]: door, [window.id]: window }
+    const first = buildPrintableWallSolids(wall, { effectiveHeight: 2.5 }, nodes)
+    const second = buildPrintableWallSolids(wall, { effectiveHeight: 2.5 }, nodes)
+
+    expect(first.status).toBe('ready')
+    expect(second.status).toBe('ready')
+    expect(first.object).not.toBeNull()
+    expect(second.object).not.toBeNull()
+    expect(first.object!.userData.pascalId).toBe(wall.id)
+    expectClosedBoxMeshes(first.object!)
+
+    const bounds = new THREE.Box3().setFromObject(first.object!)
+    expect(bounds.min.x).toBeCloseTo(0, 6)
+    expect(bounds.min.y).toBeCloseTo(0, 6)
+    expect(bounds.min.z).toBeCloseTo(-0.1, 6)
+    expect(bounds.max.x).toBeCloseTo(6, 6)
+    expect(bounds.max.y).toBeCloseTo(2.5, 6)
+    expect(bounds.max.z).toBeCloseTo(0.1, 6)
+    expect(rayIntersectionCount(first.object!, 1.5, 1)).toBe(0)
+    expect(rayIntersectionCount(first.object!, 4.5, 1.4)).toBe(0)
+    expect(rayIntersectionCount(first.object!, 3, 1)).toBeGreaterThanOrEqual(2)
+
+    expect(first.object!.children.map((child) => child.position.toArray())).toEqual(
+      second.object!.children.map((child) => child.position.toArray()),
+    )
+    expect(
+      first.object!.children.map((child) =>
+        Array.from((child as THREE.Mesh).geometry.getAttribute('position').array),
+      ),
+    ).toEqual(
+      second.object!.children.map((child) =>
+        Array.from((child as THREE.Mesh).geometry.getAttribute('position').array),
+      ),
+    )
+
+    const hiddenOpenings = buildPrintableWallSolids(
+      wall,
+      { effectiveHeight: 2.5, includedNodeIds: new Set() },
+      nodes,
+    )
+    expect(hiddenOpenings.status).toBe('ready')
+    expect(rayIntersectionCount(hiddenOpenings.object!, 1.5, 1)).toBeGreaterThanOrEqual(2)
+
+    dispose(first.object!)
+    dispose(second.object!)
+    dispose(hiddenOpenings.object!)
+  })
+
+  test('preserves the authored wall-local transform', () => {
+    const wall = WallNode.parse({
+      id: 'wall_print-transform',
+      start: [1, 2],
+      end: [1, 6],
+      thickness: 0.2,
+    })
+    const result = buildPrintableWallSolids(wall, { effectiveHeight: 3 })
+
+    expect(result.status).toBe('ready')
+    expect(result.object?.position.toArray()).toEqual([1, 0, 2])
+    expect(result.object?.rotation.y).toBeCloseTo(-Math.PI / 2)
+    dispose(result.object!)
+  })
+
+  test('blocks unsupported wall forms and invalid opening contracts', () => {
+    const shaped = DoorNode.parse({
+      id: 'door_print-wall-arch',
+      wallId: 'wall_print-blocked',
+      position: [2, 1.05, 0],
+      openingShape: 'arch',
+    })
+    const wall = WallNode.parse({
+      id: 'wall_print-blocked',
+      start: [0, 0],
+      end: [4, 0],
+      children: [shaped.id],
+    })
+    const curved = buildPrintableWallSolids(
+      { ...wall, curveOffset: 0.5 },
+      { effectiveHeight: 2.5 },
+      { [shaped.id]: shaped },
+    )
+    const terrain = buildPrintableWallSolids(
+      { ...wall, children: [], fillToTerrain: true },
+      { effectiveHeight: 2.5 },
+    )
+    const shapedResult = buildPrintableWallSolids(
+      wall,
+      { effectiveHeight: 2.5 },
+      { [shaped.id]: shaped },
+    )
+    const unresolved = buildPrintableWallSolids(wall, { effectiveHeight: 2.5 }, {})
+
+    expect(curved).toEqual(
+      expect.objectContaining({
+        status: 'blocked',
+        diagnostics: [expect.objectContaining({ code: 'unsupported_wall_print_curve' })],
+      }),
+    )
+    expect(terrain).toEqual(
+      expect.objectContaining({
+        status: 'blocked',
+        diagnostics: [expect.objectContaining({ code: 'unsupported_wall_print_terrain' })],
+      }),
+    )
+    expect(shapedResult).toEqual(
+      expect.objectContaining({
+        status: 'blocked',
+        diagnostics: [expect.objectContaining({ code: 'unsupported_wall_print_opening_shape' })],
+      }),
+    )
+    expect(unresolved).toEqual(
+      expect.objectContaining({
+        status: 'blocked',
+        diagnostics: [expect.objectContaining({ code: 'unresolved_wall_print_child' })],
+      }),
+    )
+  })
+})