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

package/src/components/editor/export-manager.tsx

@@ -1,32 +1,46 @@
 'use client'
 
 import { emitter, useScene } from '@pascal-app/core'
-import { useViewer } from '@pascal-app/viewer'
+import { disposeObject3DResources, snapLevelsToTruePositions, useViewer } from '@pascal-app/viewer'
 import { useThree } from '@react-three/fiber'
 import { useEffect } from 'react'
 import * as THREE from 'three'
 import { OBJExporter } from 'three/examples/jsm/exporters/OBJExporter.js'
 import { STLExporter } from 'three/examples/jsm/exporters/STLExporter.js'
 import { exportSceneToGlb, nextFrames, prepareSceneForExport } from '../../lib/glb-export'
+import { exportSceneLevelsForPrint } from '../../lib/level-print-export'
+import type { ModelExport, ModelExportArtifact } from '../../lib/model-export'
+import {
+  expandInstancedMeshes,
+  fixReflectedMeshWinding,
+  freezeDeformedMeshes,
+} from '../../lib/portable-export'
+import { exportSceneToPrint3mf } from '../../lib/print-3mf'
+import { filterPreparedSceneForPrintContent } from '../../lib/print-content-scope'
+import { exportSceneToPrintStl, mergePrintExportDiagnostics } from '../../lib/print-export'
+import { applySemanticPrintFeatureThickness } from '../../lib/print-feature-thickness'
+import { compileSemanticPrintShellWithManifold } from '../../lib/print-shell-compiler-manifold-worker'
+import { exportSceneToUsdz } from '../../lib/usdz-export'
+import useEditor from '../../store/use-editor'
 
 // prepareSceneForExport neutralises container meshes (door/window hitbox roots,
 // material-less renderables) with an attribute-less geometry — GLTFExporter
 // emits those as plain transform nodes, but STL/OBJExporter read
 // `position.count` unconditionally and crash. Swap in a geometry with an empty
-// (count-0) position so they iterate zero vertices instead. Shared: the export
-// scene is a throwaway clone, only its geometry *ref* is swapped.
-const EMPTY_POSITION_GEOMETRY = new THREE.BufferGeometry()
-EMPTY_POSITION_GEOMETRY.setAttribute(
-  'position',
-  new THREE.Float32BufferAttribute(new Float32Array(0), 3),
-)
+// (count-0) position so they iterate zero vertices instead. Each replacement
+// is export-owned and disposed with its prepared scene.
+function createEmptyPositionGeometry(): THREE.BufferGeometry {
+  const geometry = new THREE.BufferGeometry()
+  geometry.setAttribute('position', new THREE.Float32BufferAttribute(new Float32Array(0), 3))
+  return geometry
+}
 
 function ensurePositionAttributes(root: THREE.Object3D) {
   root.traverse((object) => {
     const renderable = object as THREE.Mesh & { isLine?: boolean; isPoints?: boolean }
     if (!(renderable.isMesh || renderable.isLine || renderable.isPoints)) return
     if (!renderable.geometry?.getAttribute('position')) {
-      renderable.geometry = EMPTY_POSITION_GEOMETRY
+      renderable.geometry = createEmptyPositionGeometry()
     }
   })
 }
@@ -34,14 +48,15 @@ function ensurePositionAttributes(root: THREE.Object3D) {
 export function ExportManager() {
   const scene = useThree((state) => state.scene)
   const setExportScene = useViewer((state) => state.setExportScene)
+  const setModelExport = useEditor((state) => state.setModelExport)
 
   useEffect(() => {
-    const exportFn = async (format: 'glb' | 'stl' | 'obj' = 'glb') => {
+    const exportFn: ModelExport = async (format = 'glb', options = {}) => {
       // Find the scene renderer group by name
       const sceneGroup = scene.getObjectByName('scene-renderer')
       if (!sceneGroup) {
         console.error('scene-renderer group not found')
-        return
+        return null
       }
 
       const date = new Date().toISOString().split('T')[0]
@@ -55,10 +70,23 @@ export function ExportManager() {
         await nextFrames()
 
         if (format === 'glb') {
-          const buffer = await exportSceneToGlb(sceneGroup, useScene.getState().nodes)
+          const warnings: string[] = []
+          const buffer = await exportSceneToGlb(sceneGroup, useScene.getState().nodes, {
+            ...options,
+            onWarning: (warning) => warnings.push(warning),
+          })
           const blob = new Blob([buffer], { type: 'model/gltf-binary' })
-          downloadBlob(blob, `model_${date}.glb`)
-          return
+          return finishArtifact(blob, `model_${date}.glb`, options.download, undefined, warnings)
+        }
+
+        if (format === 'usdz') {
+          const warnings: string[] = []
+          const data = await exportSceneToUsdz(sceneGroup, useScene.getState().nodes, {
+            ...options,
+            onWarning: (warning) => warnings.push(warning),
+          })
+          const blob = new Blob([data], { type: 'model/vnd.usdz+zip' })
+          return finishArtifact(blob, `model_${date}.usdz`, options.download, undefined, warnings)
         }
 
         // Hide editor affordances that live on the scene layer (selection handles,
@@ -66,45 +94,159 @@ export function ExportManager() {
         // synchronous capture path thumbnails use. We clone the scene inside the
         // window, so the export snapshots the clean building, then restore.
         emitter.emit('thumbnail:before-capture', undefined)
+        const restoreLevels = snapLevelsToTruePositions()
+        const nodes = useScene.getState().nodes
         let prepared: ReturnType<typeof prepareSceneForExport>
         try {
-          prepared = prepareSceneForExport(sceneGroup, useScene.getState().nodes)
+          prepared = prepareSceneForExport(sceneGroup, nodes, {
+            ...options,
+            requireSynchronousBake: format === 'stl' || format === 'obj',
+          })
         } finally {
+          restoreLevels()
           emitter.emit('thumbnail:after-capture', undefined)
         }
-        const { scene: exportScene } = prepared
-        ensurePositionAttributes(exportScene)
-
-        if (format === 'stl') {
-          const exporter = new STLExporter()
-          const result = exporter.parse(exportScene, { binary: true })
-          const blob = new Blob([result], { type: 'model/stl' })
-          downloadBlob(blob, `model_${date}.stl`)
-          return
-        }
+        try {
+          let { scene: exportScene } = prepared
+          const printContent = options.printContent ?? 'structure'
+          const isPrintFormat = format === 'print-stl' || format === 'print-3mf'
+          if (isPrintFormat) {
+            exportScene = filterPreparedSceneForPrintContent(exportScene, nodes, printContent)
+          }
+          if (!isPrintFormat) {
+            expandInstancedMeshes(exportScene)
+            exportScene.updateMatrixWorld(true)
+            freezeDeformedMeshes(exportScene)
+            fixReflectedMeshWinding(exportScene)
+          }
+          ensurePositionAttributes(exportScene)
+
+          if (isPrintFormat) {
+            const printFormat = format === 'print-3mf' ? '3mf' : 'stl'
+            const scale = options.printScale ?? 100
+            const compileShells = printContent === 'structure'
+            const minimumFeatureMm = compileShells ? options.printMinimumFeatureMm : undefined
+            if (options.printScope === 'levels') {
+              const plinth =
+                options.printBase === 'plinth'
+                  ? {
+                      marginMm: options.printPlinthMarginMm ?? 2,
+                      thicknessMm: options.printPlinthThicknessMm ?? 2,
+                    }
+                  : undefined
+              const { data, report } = await exportSceneLevelsForPrint(exportScene, nodes, {
+                scale,
+                format: printFormat,
+                plinth,
+                minimumFeatureMm,
+                compileShells,
+                compileShell: compileShells ? compileSemanticPrintShellWithManifold : undefined,
+              })
+              const blob = new Blob([data], {
+                type: printFormat === '3mf' ? 'model/3mf' : 'application/zip',
+              })
+              return finishArtifact(
+                blob,
+                `print_levels_1-${scale}_${date}.${printFormat === '3mf' ? '3mf' : 'zip'}`,
+                options.download,
+                report,
+              )
+            }
+            if (options.printBase === 'plinth') {
+              throw new Error('Plinth generation is available only for per-level print packages.')
+            }
+            const compiled = compileShells
+              ? await compileSemanticPrintShellWithManifold(exportScene, nodes)
+              : null
+            try {
+              const printSource = compiled ? (compiled.scene ?? new THREE.Group()) : exportScene
+              const printOptions = {
+                scale,
+                compiled: compiled?.status === 'compiled',
+                indexedTopology: compiled?.backend === 'manifold-3d',
+              }
+              const output =
+                printFormat === '3mf'
+                  ? exportSceneToPrint3mf(printSource, printOptions)
+                  : exportSceneToPrintStl(printSource, printOptions)
+              let report = compiled
+                ? mergePrintExportDiagnostics(
+                    output.report,
+                    compiled.diagnostics,
+                    new Set(['compiler_pending']),
+                  )
+                : output.report
+              if (compiled) {
+                report = applySemanticPrintFeatureThickness(
+                  report,
+                  nodes,
+                  compiled.sourceNodeIds,
+                  minimumFeatureMm,
+                )
+              }
+              const { buffer } = output
+              const blob = new Blob([buffer], {
+                type: printFormat === '3mf' ? 'model/3mf' : 'model/stl',
+              })
+              return finishArtifact(
+                blob,
+                `print_model_1-${scale}_${date}.${printFormat}`,
+                options.download,
+                report,
+              )
+            } finally {
+              if (compiled?.scene) disposeObject3DResources(compiled.scene)
+            }
+          }
 
-        if (format === 'obj') {
-          const exporter = new OBJExporter()
-          const result = exporter.parse(exportScene)
-          const blob = new Blob([result], { type: 'model/obj' })
-          downloadBlob(blob, `model_${date}.obj`)
-          return
+          if (format === 'stl') {
+            const exporter = new STLExporter()
+            const result = exporter.parse(exportScene, { binary: true })
+            const blob = new Blob([result], { type: 'model/stl' })
+            return finishArtifact(blob, `model_${date}.stl`, options.download)
+          }
+
+          if (format === 'obj') {
+            const exporter = new OBJExporter()
+            const result = exporter.parse(exportScene)
+            const blob = new Blob([result], { type: 'model/obj' })
+            return finishArtifact(blob, `model_${date}.obj`, options.download)
+          }
+
+          return null
+        } finally {
+          prepared.dispose()
         }
       } finally {
         useViewer.getState().setExporting(false)
       }
     }
 
-    setExportScene(exportFn)
+    setModelExport(exportFn)
+    setExportScene(async (format = 'glb') => {
+      await exportFn(format, { onlyVisible: true })
+    })
 
     return () => {
+      setModelExport(null)
       setExportScene(null)
     }
-  }, [scene, setExportScene])
+  }, [scene, setExportScene, setModelExport])
 
   return null
 }
 
+function finishArtifact(
+  blob: Blob,
+  filename: string,
+  download: boolean | undefined,
+  metadata?: unknown,
+  warnings?: readonly string[],
+): ModelExportArtifact {
+  if (download !== false) downloadBlob(blob, filename)
+  return { blob, filename, metadata, warnings: warnings?.length ? warnings : undefined }
+}
+
 function downloadBlob(blob: Blob, filename: string) {
   const url = URL.createObjectURL(blob)
   const link = document.createElement('a')

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

@@ -15,9 +15,11 @@ import {
   registerNode,
   ShelfNode,
   SiteNode,
+  SlabNode,
   sceneRegistry,
   useScene,
 } from '@pascal-app/core'
+import { hideFromScene, STAND_CLEARANCE, showInScene } from '@pascal-app/viewer'
 import { BoxGeometry, Group, Mesh, MeshBasicMaterial, Raycaster, Vector3 } from 'three'
 import { buildFirstPersonColliderWorldFromRegistry } from './build-collider-world'
 
@@ -91,6 +93,34 @@ describe('buildFirstPersonColliderWorldFromRegistry', () => {
     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: [] })
+    setSceneNodes([slab])
+    mountNode(slab, [4, 0.2, 4], [0, 2, 0])
+    const source = sceneRegistry.nodes.get(slab.id)!.children[0] as Mesh
+    const raycaster = new Raycaster()
+    for (const batched of [false, true, false]) {
+      if (batched) hideFromScene(source, 'batched')
+      else showInScene(source, 'batched')
+      const world = buildFirstPersonColliderWorldFromRegistry()!
+      expect(world).not.toBeNull()
+      try {
+        raycaster.set(new Vector3(0, 3, 0), new Vector3(0, -1, 0))
+        raycaster.far = STAND_CLEARANCE
+        expect(raycaster.intersectObject(world.mesh, false)[0]!.point.y).toBeCloseTo(2.1)
+        raycaster.set(new Vector3(0, 1, 0), new Vector3(0, 1, 0))
+        expect(raycaster.intersectObjects([world.mesh], false)[0]!.point.y).toBeCloseTo(1.9)
+        raycaster.set(new Vector3(0, 2.5, 0), new Vector3(0, 1, 0))
+        expect(raycaster.intersectObjects([world.mesh], false)).toHaveLength(0)
+      } finally {
+        world.dispose()
+      }
+    }
+    source.geometry.dispose()
+    ;(source.material as MeshBasicMaterial).dispose()
+  })
+
   test('excludes ceiling surfaces so the walkthrough player passes through them', () => {
     registerColliderDefinition('column', ColumnNode, 'structure')
     registerColliderDefinition('ceiling', CeilingNode, 'structure', 'ceiling')