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

package/src/lib/print-golden-house.test.ts

@@ -0,0 +1,249 @@
+import { describe, expect, test } from 'bun:test'
+import { XMLParser } from 'fast-xml-parser'
+import { strFromU8, unzipSync } from 'fflate'
+import * as THREE from 'three'
+import { prepareSceneForExport } from './glb-export'
+import { exportSceneLevelsForPrint } from './level-print-export'
+import { filterPreparedSceneForPrintContent } from './print-content-scope'
+import {
+  createPrintGoldenHouseFixture,
+  PRINT_GOLDEN_HOUSE_IDS,
+} from './print-golden-house.test-fixture'
+import { compileManifoldMeshData } from './print-shell-compiler-manifold-core'
+import { compileSemanticPrintShellWithManifold } from './print-shell-compiler-manifold-worker'
+
+function identityIds(root: THREE.Object3D): string[] {
+  const ids: string[] = []
+  root.traverse((object) => {
+    if (typeof object.userData.pascalId === 'string') ids.push(object.userData.pascalId)
+  })
+  return ids.sort()
+}
+
+function objectByIdentity(root: THREE.Object3D, id: string): THREE.Object3D {
+  let match: THREE.Object3D | null = null
+  root.traverse((object) => {
+    if (object.userData.pascalId === id) match = object
+  })
+  if (!match) throw new Error(`Missing prepared object ${id}`)
+  return match
+}
+
+function rayIntersectionCount(
+  root: THREE.Object3D,
+  origin: THREE.Vector3,
+  direction: THREE.Vector3,
+  far: number,
+): number {
+  root.updateMatrixWorld(true)
+  const raycaster = new THREE.Raycaster(origin, direction.normalize(), 0, far)
+  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 asArray<T>(value: T | T[]): T[] {
+  return Array.isArray(value) ? value : [value]
+}
+
+function packageObjectSizes(data: Uint8Array): Array<{ name: string; size: THREE.Vector3 }> {
+  const files = unzipSync(data)
+  const xml = strFromU8(files['3D/3dmodel.model']!)
+  const model = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: '' }).parse(xml).model
+  const object = asArray<Record<string, unknown>>(model.resources.object)[0]!
+  const mesh = object.mesh as { vertices: { vertex: Record<string, string>[] } }
+  const vertices = asArray(mesh.vertices.vertex)
+  const metadata = asArray<Record<string, string>>(model.metadata)
+  const partManifest = JSON.parse(
+    metadata.find((entry) => entry.name === 'Pascal.PartManifest')!['#text']!,
+  ) as Array<{ name: string; vertexStart: number; vertexCount: number }>
+  return partManifest.map((part) => {
+    const bounds = new THREE.Box3()
+    for (const vertex of vertices.slice(part.vertexStart, part.vertexStart + part.vertexCount)) {
+      bounds.expandByPoint(new THREE.Vector3(Number(vertex.x), Number(vertex.y), Number(vertex.z)))
+    }
+    return { name: part.name, size: bounds.getSize(new THREE.Vector3()) }
+  })
+}
+
+const compileGoldenShell = (
+  source: THREE.Object3D,
+  nodes: Parameters<typeof exportSceneLevelsForPrint>[1],
+) => compileSemanticPrintShellWithManifold(source, nodes, { runner: compileManifoldMeshData })
+
+describe('print golden house', () => {
+  test('consolidates hidden-ancestor visibility and structure-only scope', () => {
+    const fixture = createPrintGoldenHouseFixture()
+    try {
+      const prepared = prepareSceneForExport(fixture.root, fixture.nodes, { onlyVisible: true })
+      const preparedIds = identityIds(prepared.scene)
+      expect(preparedIds).toContain(PRINT_GOLDEN_HOUSE_IDS.visibleFurniture)
+      expect(preparedIds).not.toContain(PRINT_GOLDEN_HOUSE_IDS.hiddenFurnitureParent)
+      expect(preparedIds).not.toContain(PRINT_GOLDEN_HOUSE_IDS.hiddenFurnitureChild)
+
+      const structure = filterPreparedSceneForPrintContent(
+        prepared.scene,
+        fixture.nodes,
+        'structure',
+      )
+      const structureIds = identityIds(structure)
+      expect(structureIds).not.toContain(PRINT_GOLDEN_HOUSE_IDS.visibleFurniture)
+      expect(structureIds).toEqual(
+        expect.arrayContaining([
+          PRINT_GOLDEN_HOUSE_IDS.groundLevel,
+          PRINT_GOLDEN_HOUSE_IDS.upperLevel,
+          ...fixture.structuralNodeIds,
+        ]),
+      )
+    } finally {
+      fixture.dispose()
+    }
+  })
+
+  test('preserves door and window voids in the final Manifold level shells', async () => {
+    const fixture = createPrintGoldenHouseFixture()
+    try {
+      const prepared = prepareSceneForExport(fixture.root, fixture.nodes, { onlyVisible: true })
+      const structure = filterPreparedSceneForPrintContent(
+        prepared.scene,
+        fixture.nodes,
+        'structure',
+      )
+      const ground = await compileGoldenShell(
+        objectByIdentity(structure, PRINT_GOLDEN_HOUSE_IDS.groundLevel),
+        fixture.nodes,
+      )
+      const upper = await compileGoldenShell(
+        objectByIdentity(structure, PRINT_GOLDEN_HOUSE_IDS.upperLevel),
+        fixture.nodes,
+      )
+
+      expect(ground.status).toBe('compiled')
+      expect(upper.status).toBe('compiled')
+      expect(ground.sourceNodeIds).toEqual(fixture.groundStructuralNodeIds)
+      expect(upper.sourceNodeIds).toEqual(fixture.upperStructuralNodeIds)
+      expect(
+        rayIntersectionCount(
+          ground.scene!,
+          new THREE.Vector3(0, 1.05, -2),
+          new THREE.Vector3(0, 0, 1),
+          0.8,
+        ),
+      ).toBe(0)
+      expect(
+        rayIntersectionCount(
+          ground.scene!,
+          new THREE.Vector3(1.5, 1.05, -2),
+          new THREE.Vector3(0, 0, 1),
+          0.8,
+        ),
+      ).toBeGreaterThanOrEqual(2)
+      expect(
+        rayIntersectionCount(
+          upper.scene!,
+          new THREE.Vector3(0, 3.9, 1),
+          new THREE.Vector3(0, 0, 1),
+          1,
+        ),
+      ).toBe(0)
+      expect(
+        rayIntersectionCount(
+          upper.scene!,
+          new THREE.Vector3(1.5, 3.9, 1),
+          new THREE.Vector3(0, 0, 1),
+          1,
+        ),
+      ).toBeGreaterThanOrEqual(2)
+    } finally {
+      fixture.dispose()
+    }
+  }, 15_000)
+
+  test('emits deterministic two-level 3MF parts and plinth from the same semantic house', async () => {
+    const fixture = createPrintGoldenHouseFixture()
+    try {
+      const prepared = prepareSceneForExport(fixture.root, fixture.nodes, { onlyVisible: true })
+      const structure = filterPreparedSceneForPrintContent(
+        prepared.scene,
+        fixture.nodes,
+        'structure',
+      )
+      const options = {
+        scale: 100,
+        format: '3mf' as const,
+        plinth: { marginMm: 2, thicknessMm: 3 },
+        compileShells: true,
+        compileShell: compileGoldenShell,
+      }
+      const first = await exportSceneLevelsForPrint(structure, fixture.nodes, options)
+      const second = await exportSceneLevelsForPrint(structure, fixture.nodes, {
+        ...options,
+        minimumFeatureMm: 1.8,
+      })
+
+      expect(first.report.status).toBe('pass')
+      expect(first.report.parts.map((part) => part.objectName)).toEqual([
+        '00 Plinth',
+        '01 Ground',
+        '02 Upper',
+      ])
+      expect(first.report.parts.map((part) => part.sourceBaseMeters)).toEqual([null, 0, 2.5])
+      expect(first.report.parts.map((part) => part.report.minimumFeatureThicknessMm)).toEqual([
+        3, 2, 1.5,
+      ])
+      for (const part of first.report.parts) {
+        expect(part.report.status).toBe('pass')
+        expect(part.report.degenerateTriangleCount).toBe(0)
+        expect(part.report.boundaryEdgeCount).toBe(0)
+        expect(part.report.nonManifoldEdgeCount).toBe(0)
+        expect(part.report.connectedComponentCount).toBe(1)
+        expect(part.report.solidComponentCount).toBe(1)
+        expect(part.report.invertedWinding).toBe(false)
+        expect(part.report.volumeMm3).toBeGreaterThan(0)
+        expect(part.report.bounds?.min.z).toBeCloseTo(0, 5)
+      }
+      expect(first.report.parts[1]?.report.diagnostics).toContainEqual(
+        expect.objectContaining({ nodeIds: fixture.groundStructuralNodeIds }),
+      )
+      expect(first.report.parts[2]?.report.diagnostics).toContainEqual(
+        expect.objectContaining({ nodeIds: fixture.upperStructuralNodeIds }),
+      )
+      expect(second.report.status).toBe('blocked')
+      expect(second.report.parts.map((part) => part.report.status)).toEqual([
+        'pass',
+        'pass',
+        'blocked',
+      ])
+      expect(second.report.parts[2]?.report.diagnostics).toContainEqual(
+        expect.objectContaining({
+          code: 'feature_below_target',
+          nodeIds: [PRINT_GOLDEN_HOUSE_IDS.roof],
+        }),
+      )
+
+      const objects = packageObjectSizes(first.data)
+      expect(objects.map((object) => object.name)).toEqual(['00 Plinth', '01 Ground', '02 Upper'])
+      expect(objects[0]?.size.x).toBeCloseTo(46, 4)
+      expect(objects[0]?.size.y).toBeCloseTo(36, 4)
+      expect(objects[0]?.size.z).toBeCloseTo(3, 4)
+      expect(objects[1]?.size.x).toBeCloseTo(42, 4)
+      expect(objects[1]?.size.y).toBeCloseTo(32, 4)
+      expect(objects[1]?.size.z).toBeCloseTo(25, 4)
+      expect(objects[2]?.size.x).toBeCloseTo(46.6962, 3)
+      expect(objects[2]?.size.y).toBeCloseTo(37.1962, 3)
+      expect(objects[2]?.size.z).toBeCloseTo(40.3923, 3)
+      expect(first.data).toEqual(second.data)
+    } finally {
+      fixture.dispose()
+    }
+  }, 30_000)
+})

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

@@ -0,0 +1,133 @@
+import { describe, expect, test } from 'bun:test'
+import { DoorNode, RoofSegmentNode, type RoofType } from '@pascal-app/core'
+import * as THREE from 'three'
+import { buildPrintableRoofSegmentSolids } from './print-roof-solids'
+
+const ROOF_TYPES: RoofType[] = [
+  'gable',
+  'hip',
+  'shed',
+  'gambrel',
+  'mansard',
+  'flat',
+  'dutch',
+  'conical',
+]
+
+function fixture(roofType: RoofType, overrides: Partial<RoofSegmentNode> = {}): RoofSegmentNode {
+  return RoofSegmentNode.parse({
+    id: `rseg_print-${roofType}`,
+    roofType,
+    width: 4,
+    depth: roofType === 'conical' ? 4 : 3,
+    wallHeight: 0.5,
+    pitch: 30,
+    wallThickness: 0.15,
+    deckThickness: 0.1,
+    overhang: 0.3,
+    shingleThickness: 0.05,
+    ...overrides,
+  })
+}
+
+function onlyMesh(root: THREE.Group): THREE.Mesh<THREE.BufferGeometry> {
+  expect(root.children).toHaveLength(1)
+  const mesh = root.children[0]
+  expect(mesh).toBeInstanceOf(THREE.Mesh)
+  return mesh as THREE.Mesh<THREE.BufferGeometry>
+}
+
+describe('buildPrintableRoofSegmentSolids', () => {
+  test('builds deterministic indexed print shells for every canonical roof type', () => {
+    for (const roofType of ROOF_TYPES) {
+      const first = buildPrintableRoofSegmentSolids(fixture(roofType))
+      const second = buildPrintableRoofSegmentSolids(fixture(roofType))
+
+      expect(first.status).toBe('ready')
+      expect(second.status).toBe('ready')
+      expect(first.diagnostics).toEqual([])
+      expect(second.diagnostics).toEqual([])
+      expect(first.object).not.toBeNull()
+      expect(second.object).not.toBeNull()
+
+      const firstMesh = onlyMesh(first.object!)
+      const secondMesh = onlyMesh(second.object!)
+      expect(firstMesh.geometry.index).not.toBeNull()
+      expect(Array.from(firstMesh.geometry.getAttribute('position').array)).toEqual(
+        Array.from(secondMesh.geometry.getAttribute('position').array),
+      )
+      expect(Array.from(firstMesh.geometry.index!.array)).toEqual(
+        Array.from(secondMesh.geometry.index!.array),
+      )
+      expect(
+        Array.from(firstMesh.geometry.getAttribute('position').array).every(Number.isFinite),
+      ).toBe(true)
+
+      firstMesh.geometry.dispose()
+      secondMesh.geometry.dispose()
+    }
+  })
+
+  test('preserves segment provenance and local transform', () => {
+    const node = fixture('gable', { position: [1, 2, 3], rotation: Math.PI / 3 })
+    const result = buildPrintableRoofSegmentSolids(node)
+
+    expect(result.status).toBe('ready')
+    expect(result.object?.userData.pascalId).toBe(node.id)
+    expect(result.object?.position.toArray()).toEqual(node.position)
+    expect(result.object?.rotation.y).toBeCloseTo(node.rotation)
+
+    onlyMesh(result.object!).geometry.dispose()
+  })
+
+  test('blocks trims and unsupported accessories until manifold fixtures exist', () => {
+    const unregisteredChild = DoorNode.parse({
+      id: 'door_print-roof-cut',
+      wallId: 'wall_print-roof-host',
+    })
+    const trimmed = buildPrintableRoofSegmentSolids(
+      fixture('gable', { trim: { left: 0.25 } as RoofSegmentNode['trim'] }),
+    )
+    const unresolvedCut = buildPrintableRoofSegmentSolids(
+      fixture('gable', { children: ['door_missing-print-roof-cut'] }),
+    )
+    const unregisteredCut = buildPrintableRoofSegmentSolids(
+      fixture('gable', { children: [unregisteredChild.id] }),
+      { [unregisteredChild.id]: unregisteredChild },
+    )
+
+    expect(trimmed).toEqual(
+      expect.objectContaining({
+        status: 'blocked',
+        object: null,
+        diagnostics: [expect.objectContaining({ code: 'unsupported_roof_print_trim' })],
+      }),
+    )
+    expect(unresolvedCut).toEqual(
+      expect.objectContaining({
+        status: 'blocked',
+        object: null,
+        diagnostics: [expect.objectContaining({ code: 'unsupported_roof_print_cut' })],
+      }),
+    )
+    expect(unregisteredCut).toEqual(
+      expect.objectContaining({
+        status: 'blocked',
+        object: null,
+        diagnostics: [expect.objectContaining({ code: 'unsupported_roof_print_cut' })],
+      }),
+    )
+  })
+
+  test('blocks zero structural thickness', () => {
+    const result = buildPrintableRoofSegmentSolids(fixture('gable', { wallThickness: 0 }))
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        status: 'blocked',
+        object: null,
+        diagnostics: [expect.objectContaining({ code: 'invalid_roof_print_dimensions' })],
+      }),
+    )
+  })
+})