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

package/src/lib/print-3mf.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, test } from 'bun:test'
+import { XMLParser } from 'fast-xml-parser'
+import { strFromU8, unzipSync } from 'fflate'
+import * as THREE from 'three'
+import { exportSceneToPrint3mf } from './print-3mf'
+
+function asArray<T>(value: T | T[]): T[] {
+  return Array.isArray(value) ? value : [value]
+}
+
+describe('print 3MF export', () => {
+  test('writes a deterministic standards package with explicit millimeter units', () => {
+    const mesh = new THREE.Mesh(new THREE.BoxGeometry(10, 4, 6))
+    mesh.position.set(5, 2, -7)
+
+    const first = exportSceneToPrint3mf(mesh, { scale: 100 })
+    const second = exportSceneToPrint3mf(mesh, { scale: 100 })
+    const files = unzipSync(first.buffer)
+    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 item = asArray<Record<string, string>>(model.build.item)[0]!
+    const metadata = asArray<Record<string, string>>(model.metadata)
+    const partManifest = JSON.parse(
+      metadata.find((entry) => entry.name === 'Pascal.PartManifest')!['#text']!,
+    )
+    const objectMesh = object.mesh as {
+      vertices: { vertex: Record<string, string> | Record<string, string>[] }
+      triangles: { triangle: Record<string, string> | Record<string, string>[] }
+    }
+    const vertices = asArray(objectMesh.vertices.vertex)
+    const triangles = asArray(objectMesh.triangles.triangle)
+    const bounds = new THREE.Box3()
+    for (const vertex of vertices) {
+      bounds.expandByPoint(new THREE.Vector3(Number(vertex.x), Number(vertex.y), Number(vertex.z)))
+    }
+
+    expect(Object.keys(files)).toEqual(['[Content_Types].xml', '_rels/.rels', '3D/3dmodel.model'])
+    expect(strFromU8(files['_rels/.rels']!)).toContain('Target="/3D/3dmodel.model"')
+    expect(model.unit).toBe('millimeter')
+    expect(object.name).toBe('Pascal print model')
+    expect(vertices).toHaveLength(8)
+    expect(triangles).toHaveLength(12)
+    expect(item.objectid).toBe('1')
+    expect(item.transform).toBeUndefined()
+    expect(partManifest).toEqual([
+      {
+        name: 'Pascal print model',
+        vertexStart: 0,
+        vertexCount: 8,
+        triangleStart: 0,
+        triangleCount: 12,
+      },
+    ])
+    expect(bounds.min.toArray()).toEqual([0, 0, 0])
+    expect(bounds.max.toArray()).toEqual([100, 60, 40])
+    expect(first.report.format).toBe('3mf')
+    expect(first.report.bounds?.width).toBeCloseTo(100, 6)
+    expect(first.report.bounds?.depth).toBeCloseTo(60, 6)
+    expect(first.report.bounds?.height).toBeCloseTo(40, 6)
+    expect(first.buffer).toEqual(second.buffer)
+
+    for (const triangle of triangles) {
+      expect(Number(triangle.v1)).toBeLessThan(vertices.length)
+      expect(Number(triangle.v2)).toBeLessThan(vertices.length)
+      expect(Number(triangle.v3)).toBeLessThan(vertices.length)
+    }
+  })
+
+  test('returns a blocking report instead of serializing non-finite coordinates', () => {
+    const geometry = new THREE.BoxGeometry(1, 1, 1)
+    geometry.getAttribute('position').setX(0, Number.NaN)
+
+    const output = exportSceneToPrint3mf(new THREE.Mesh(geometry), { scale: 100 })
+    const model = strFromU8(unzipSync(output.buffer)['3D/3dmodel.model']!)
+
+    expect(output.report.status).toBe('blocked')
+    expect(output.report.invalidTriangleCount).toBeGreaterThan(0)
+    expect(output.report.diagnostics).toContainEqual(
+      expect.objectContaining({ code: 'non_finite_geometry', severity: 'error' }),
+    )
+    expect(model).not.toContain('<object ')
+  })
+})

package/src/lib/print-3mf.ts

@@ -0,0 +1,161 @@
+import { strToU8, type Zippable, zipSync } from 'fflate'
+import type * as THREE from 'three'
+import type {
+  PrintExportBounds,
+  PrintExportOptions,
+  PrintExportReport,
+  PrintMeshData,
+} from './print-export'
+import { extractPreparedPrintMesh, prepareSceneForPrint } from './print-export'
+
+const ZIP_MTIME = new Date(2000, 0, 1, 0, 0, 0)
+const PART_GAP_MM = 5
+
+const CONTENT_TYPES = `<?xml version="1.0" encoding="UTF-8"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+  <Default Extension="model" ContentType="application/vnd.ms-package.3dmanufacturing-3dmodel+xml"/>
+</Types>
+`
+
+const ROOT_RELATIONSHIPS = `<?xml version="1.0" encoding="UTF-8"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Target="/3D/3dmodel.model" Id="rel-1" Type="http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel"/>
+</Relationships>
+`
+
+export type Print3mfPart = {
+  name: string
+  mesh: PrintMeshData
+  bounds: PrintExportBounds
+}
+
+export type Print3mfExport = {
+  buffer: Uint8Array<ArrayBuffer>
+  report: PrintExportReport
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;')
+}
+
+function decimal(value: number): string {
+  if (!Number.isFinite(value)) throw new RangeError('3MF coordinates must be finite.')
+  const rounded = Math.abs(value) < 5e-10 ? 0 : value
+  return rounded.toFixed(9).replace(/\.?0+$/, '')
+}
+
+type PlacedPrint3mfPart = {
+  part: Print3mfPart
+  translateX: number
+  translateY: number
+  vertexStart: number
+  triangleStart: number
+}
+
+function appendMeshObject(lines: string[], name: string, parts: PlacedPrint3mfPart[]) {
+  lines.push(`    <object id="1" type="model" name="${escapeXml(name)}">`)
+  lines.push('      <mesh>')
+  lines.push('        <vertices>')
+  for (const { part, translateX, translateY } of parts) {
+    for (let offset = 0; offset < part.mesh.positions.length; offset += 3) {
+      lines.push(
+        `          <vertex x="${decimal(part.mesh.positions[offset]! + translateX)}" y="${decimal(part.mesh.positions[offset + 1]! + translateY)}" z="${decimal(part.mesh.positions[offset + 2]!)}"/>`,
+      )
+    }
+  }
+  lines.push('        </vertices>')
+  lines.push('        <triangles>')
+  for (const { part, vertexStart } of parts) {
+    for (let offset = 0; offset < part.mesh.indices.length; offset += 3) {
+      lines.push(
+        `          <triangle v1="${part.mesh.indices[offset]! + vertexStart}" v2="${part.mesh.indices[offset + 1]! + vertexStart}" v3="${part.mesh.indices[offset + 2]! + vertexStart}"/>`,
+      )
+    }
+  }
+  lines.push('        </triangles>')
+  lines.push('      </mesh>')
+  lines.push('    </object>')
+}
+
+export function createPrint3mf(
+  parts: Print3mfPart[],
+  title = 'Pascal print export',
+): Uint8Array<ArrayBuffer> {
+  const placements: PlacedPrint3mfPart[] = []
+  let cursorX = 0
+  let vertexStart = 0
+  let triangleStart = 0
+  for (const part of parts) {
+    placements.push({
+      part,
+      translateX: cursorX - part.bounds.min.x,
+      translateY: -part.bounds.min.y,
+      vertexStart,
+      triangleStart,
+    })
+    cursorX += part.bounds.width + PART_GAP_MM
+    vertexStart += part.mesh.positions.length / 3
+    triangleStart += part.mesh.indices.length / 3
+  }
+  const partManifest = placements.map(({ part, vertexStart, triangleStart }) => ({
+    name: part.name,
+    vertexStart,
+    vertexCount: part.mesh.positions.length / 3,
+    triangleStart,
+    triangleCount: part.mesh.indices.length / 3,
+  }))
+  const lines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<model unit="millimeter" xml:lang="en-US" xmlns="http://schemas.microsoft.com/3dmanufacturing/core/2015/02">',
+    `  <metadata name="Title">${escapeXml(title)}</metadata>`,
+    '  <metadata name="Application">Pascal</metadata>',
+    `  <metadata name="Pascal.PartManifest">${escapeXml(JSON.stringify(partManifest))}</metadata>`,
+    '  <resources>',
+  ]
+
+  // CHITUBOX 1.3.0 recenters independent 3MF objects, so package the plate as one mesh.
+  if (placements.length > 0) {
+    appendMeshObject(lines, parts.length === 1 ? parts[0]!.name : title, placements)
+  }
+  lines.push('  </resources>')
+  lines.push('  <build>')
+
+  if (parts.length > 0) lines.push('    <item objectid="1"/>')
+  lines.push('  </build>')
+  lines.push('</model>')
+  lines.push('')
+
+  const files: Zippable = {
+    '[Content_Types].xml': [strToU8(CONTENT_TYPES), { level: 0, mtime: ZIP_MTIME }],
+    '_rels/.rels': [strToU8(ROOT_RELATIONSHIPS), { level: 0, mtime: ZIP_MTIME }],
+    '3D/3dmodel.model': [strToU8(lines.join('\n')), { level: 0, mtime: ZIP_MTIME }],
+  }
+  return zipSync(files, { level: 0 })
+}
+
+export function exportSceneToPrint3mf(
+  source: THREE.Object3D,
+  options: PrintExportOptions,
+): Print3mfExport {
+  const prepared = prepareSceneForPrint(source, { ...options, format: '3mf' })
+  const parts =
+    prepared.report.bounds && prepared.report.invalidTriangleCount === 0
+      ? [
+          {
+            name: 'Pascal print model',
+            mesh: extractPreparedPrintMesh(prepared.scene),
+            bounds: prepared.report.bounds,
+          },
+        ]
+      : []
+  return {
+    buffer: createPrint3mf(parts),
+    report: prepared.report,
+  }
+}

package/src/lib/print-content-scope.test.ts

@@ -0,0 +1,107 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { type AnyNode, registerNode, sceneRegistry } from '@pascal-app/core'
+import * as THREE from 'three'
+import { prepareSceneForExport } from './glb-export'
+import { filterPreparedSceneForPrintContent } from './print-content-scope'
+import { exportSceneToPrintStl } from './print-export'
+
+function registerFixtureKind(category: 'site' | 'structure' | 'furnish'): string {
+  const kind = `print-${category}-${crypto.randomUUID()}`
+  registerNode({
+    kind,
+    schemaVersion: 1,
+    category,
+    defaults: () => ({}),
+    capabilities: {},
+  } as never)
+  return kind
+}
+
+function printContentFixture() {
+  const root = new THREE.Group()
+  const building = new THREE.Group()
+  const level = new THREE.Group()
+  const wall = new THREE.Group()
+  const furniture = new THREE.Group()
+  wall.add(new THREE.Mesh(new THREE.BoxGeometry(4, 3, 2)))
+  furniture.add(new THREE.Mesh(new THREE.BoxGeometry(1, 1, 1)))
+  root.add(building)
+  building.add(level)
+  level.add(wall, furniture)
+
+  const buildingKind = registerFixtureKind('site')
+  const levelKind = registerFixtureKind('site')
+  const wallKind = registerFixtureKind('structure')
+  const furnitureKind = registerFixtureKind('furnish')
+
+  sceneRegistry.nodes.set('building_main', building)
+  sceneRegistry.nodes.set('level_ground', level)
+  sceneRegistry.nodes.set('wall_main', wall)
+  sceneRegistry.nodes.set('chair_main', furniture)
+
+  const nodes: Record<string, AnyNode> = {
+    building_main: {
+      object: 'node',
+      id: 'building_main',
+      type: buildingKind,
+      parentId: null,
+      children: ['level_ground'],
+    } as unknown as AnyNode,
+    level_ground: {
+      object: 'node',
+      id: 'level_ground',
+      type: levelKind,
+      parentId: 'building_main',
+      children: ['wall_main', 'chair_main'],
+    } as unknown as AnyNode,
+    wall_main: {
+      object: 'node',
+      id: 'wall_main',
+      type: wallKind,
+      parentId: 'level_ground',
+    } as unknown as AnyNode,
+    chair_main: {
+      object: 'node',
+      id: 'chair_main',
+      type: furnitureKind,
+      parentId: 'level_ground',
+    } as unknown as AnyNode,
+  }
+
+  return { root, nodes }
+}
+
+describe('print content scope', () => {
+  afterEach(() => {
+    sceneRegistry.nodes.clear()
+  })
+
+  test('keeps registered structure and its transform ancestors while removing visible furniture', () => {
+    const fixture = printContentFixture()
+    const prepared = prepareSceneForExport(fixture.root, fixture.nodes, { onlyVisible: true })
+
+    const structure = filterPreparedSceneForPrintContent(prepared.scene, fixture.nodes, 'structure')
+    const print = exportSceneToPrintStl(structure, { scale: 100 })
+
+    expect(structure.getObjectByName('building_main')).toBeDefined()
+    expect(structure.getObjectByName('level_ground')).toBeDefined()
+    expect(structure.getObjectByName('wall_main')).toBeDefined()
+    expect(structure.getObjectByName('chair_main')).toBeUndefined()
+    expect(print.report.triangleCount).toBe(12)
+  })
+
+  test('preserves all prepared semantic geometry in everything scope', () => {
+    const fixture = printContentFixture()
+    const prepared = prepareSceneForExport(fixture.root, fixture.nodes, { onlyVisible: true })
+
+    const everything = filterPreparedSceneForPrintContent(
+      prepared.scene,
+      fixture.nodes,
+      'everything',
+    )
+    const print = exportSceneToPrintStl(everything, { scale: 100 })
+
+    expect(everything.getObjectByName('chair_main')).toBeDefined()
+    expect(print.report.triangleCount).toBe(24)
+  })
+})

package/src/lib/print-content-scope.ts

@@ -0,0 +1,90 @@
+import { type AnyNode, nodeRegistry } from '@pascal-app/core'
+import * as THREE from 'three'
+
+export type PrintContentScope = 'structure' | 'everything'
+
+const EMPTY_POSITION_GEOMETRY = new THREE.BufferGeometry()
+EMPTY_POSITION_GEOMETRY.setAttribute(
+  'position',
+  new THREE.Float32BufferAttribute(new Float32Array(0), 3),
+)
+
+function identityId(object: THREE.Object3D): string | null {
+  const id = object.userData.pascalId
+  return typeof id === 'string' ? id : null
+}
+
+function structureIds(nodes: Record<string, AnyNode>): Set<string> {
+  return new Set(
+    Object.values(nodes)
+      .filter((node) => nodeRegistry.get(node.type)?.category === 'structure')
+      .map((node) => node.id),
+  )
+}
+
+function retainedIds(
+  includedIds: ReadonlySet<string>,
+  nodes: Record<string, AnyNode>,
+): Set<string> {
+  const retained = new Set(includedIds)
+  for (const id of includedIds) {
+    const visited = new Set<string>([id])
+    let parentId = nodes[id]?.parentId ?? null
+    while (parentId && !visited.has(parentId)) {
+      retained.add(parentId)
+      visited.add(parentId)
+      parentId = nodes[parentId]?.parentId ?? null
+    }
+  }
+  return retained
+}
+
+function neutralizeRenderable(object: THREE.Object3D) {
+  const renderable = object as THREE.Mesh & { isLine?: boolean; isPoints?: boolean }
+  if (renderable.isMesh || renderable.isLine || renderable.isPoints) {
+    renderable.geometry = EMPTY_POSITION_GEOMETRY
+  }
+}
+
+/**
+ * Keep registered structural nodes plus the minimum semantic/Three ancestry
+ * needed to preserve their world transforms. Unknown, furnishing, analysis,
+ * utility, and site-owned geometry is removed unless it is only a transform
+ * container leading to retained structure.
+ */
+export function filterPreparedSceneForPrintContent(
+  source: THREE.Object3D,
+  nodes: Record<string, AnyNode>,
+  scope: PrintContentScope,
+): THREE.Object3D {
+  const scene = source.clone(true)
+  if (scope === 'everything') return scene
+
+  const includedIds = structureIds(nodes)
+  const retained = retainedIds(includedIds, nodes)
+
+  const prune = (object: THREE.Object3D, inheritedStructure: boolean, isRoot = false): boolean => {
+    const id = identityId(object)
+    let carriesStructure = inheritedStructure
+
+    if (id) {
+      if (includedIds.has(id)) carriesStructure = true
+      else if (retained.has(id)) carriesStructure = false
+      else return false
+    }
+
+    for (const child of [...object.children]) {
+      if (!prune(child, carriesStructure)) child.removeFromParent()
+    }
+
+    if (carriesStructure || isRoot) return true
+    if (object.children.length === 0) return false
+
+    neutralizeRenderable(object)
+    return true
+  }
+
+  prune(scene, false, true)
+  scene.name = 'print-content-structure'
+  return scene
+}