@pascal-app/editor 1.0.0 → 1.0.3

package/src/lib/glb-export.test.ts

@@ -27,6 +27,7 @@ import {
   prepareSceneForExportAsync,
   writeTextureReferenceExtras,
 } from './glb-export'
+import { createUsdzScene } from './portable-export'
 
 // The reference module reads the storage origin lazily on first use, so
 // setting the env here (before any validation call) pins it for the file.
@@ -99,6 +100,29 @@ describe('prepareSceneForExport', () => {
     expect(material.color.getHexString()).toBe('cc3300')
   })
 
+  test('clones userData that holds runtime resources and functions', () => {
+    const root = new THREE.Group()
+    root.name = 'scene-renderer'
+    const effectMaterial = new THREE.MeshStandardMaterial()
+    effectMaterial.addEventListener('dispose', () => {})
+    const pool = meshWithNodeMaterial(nodeMaterial())
+    pool.userData = { waterEffect: { material: effectMaterial, onFrame: () => {} } }
+    const overlay = meshWithNodeMaterial(nodeMaterial())
+    overlay.userData = { pascalExport: 'strip', mesh: pool }
+    root.add(pool, overlay)
+    expect(() => structuredClone(pool.userData)).toThrow()
+
+    const { scene } = prepareSceneForExport(root, {})
+
+    const meshes: THREE.Mesh[] = []
+    scene.traverse((object) => {
+      if ((object as THREE.Mesh).isMesh) meshes.push(object as THREE.Mesh)
+    })
+    expect(meshes).toHaveLength(1)
+    expect(meshes[0]?.userData.waterEffect).toBeUndefined()
+    expect(pool.userData.waterEffect.material).toBe(effectMaterial)
+  })
+
   test('replaces only the cloned registered subtree with bake-only geometry', () => {
     const restoreRegistry = nodeRegistry._snapshot()
     try {
@@ -566,19 +590,64 @@ describe('prepareSceneForExport', () => {
     expect(animations).toHaveLength(0)
   })
 
-  test('inherits hidden Site visibility for detached declared children and their descendants', async () => {
+  test('keeps the buildings on a hidden Site and drops only the Site ground', () => {
+    // A layout authored outside the editor can hide the root Site (the
+    // renderer ignores that flag) while every node on it stays visible. The
+    // Site's own flag must stop at the Site: it is the parcel reference, not
+    // a container the building inherits visibility from.
+    const root = new THREE.Group()
+    const siteGroup = new THREE.Group()
+    const siteGround = meshWithNodeMaterial(nodeMaterial())
+    const buildingGroup = new THREE.Group()
+    const levelGroup = new THREE.Group()
+    const itemGroup = new THREE.Group()
+    itemGroup.add(meshWithNodeMaterial(nodeMaterial()))
+    levelGroup.add(itemGroup)
+    buildingGroup.add(levelGroup)
+    siteGroup.add(buildingGroup, siteGround)
+    root.add(siteGroup)
+
+    const siteId = 'site_hidden'
+    const buildingId = 'building_on_hidden_site'
+    const levelId = 'level_on_hidden_site'
+    const itemId = 'item_on_hidden_site'
+    sceneRegistry.nodes.set(siteId, siteGroup)
+    sceneRegistry.nodes.set(buildingId, buildingGroup)
+    sceneRegistry.nodes.set(levelId, levelGroup)
+    sceneRegistry.nodes.set(itemId, itemGroup)
+    const node = (id: string, type: string, parentId: string | null, visible: boolean) =>
+      ({ object: 'node', id, type, parentId, visible }) as unknown as AnyNode
+    const nodes: Record<string, AnyNode> = {
+      [siteId]: node(siteId, 'site', null, false),
+      [buildingId]: node(buildingId, 'building', siteId, true),
+      [levelId]: node(levelId, 'level', buildingId, true),
+      [itemId]: node(itemId, 'item', levelId, true),
+    }
+
+    const { scene } = prepareSceneForExport(root, nodes)
+
+    const meshes: THREE.Mesh[] = []
+    scene.traverse((object) => {
+      if ((object as THREE.Mesh).isMesh) meshes.push(object as THREE.Mesh)
+    })
+    expect(scene.getObjectByName(buildingId)).toBeDefined()
+    expect(scene.getObjectByName(itemId)).toBeDefined()
+    expect(meshes).toHaveLength(1)
+    expect(meshes[0]?.parent?.name).toBe(itemId)
+  })
+
+  test('keeps the nodes a hidden Site hosts, declared or detached, unless hidden themselves', async () => {
     const restoreRegistry = nodeRegistry._snapshot()
     try {
-      const kind = 'test:detached-site-visibility'
+      const kind = 'test:hidden-site-host'
       const childId = 'detached_site_child'
       const descendantId = 'detached_site_descendant'
       const explicitId = 'explicit_site_child'
-      const unownedId = 'unowned_site_child'
+      const hiddenChildId = 'hidden_site_child'
       const hiddenSite = SiteNode.parse({
         visible: false,
-        children: [childId, explicitId],
+        children: [childId, explicitId, hiddenChildId],
       })
-      const visibleSite = SiteNode.parse({ visible: true })
       registerNode({
         kind,
         schemaVersion: 1,
@@ -591,17 +660,19 @@ describe('prepareSceneForExport', () => {
       } as AnyNodeDefinition)
       const nodes = {
         [hiddenSite.id]: hiddenSite,
-        [visibleSite.id]: visibleSite,
         [childId]: { id: childId, type: kind, parentId: null, visible: true },
         [descendantId]: { id: descendantId, type: kind, parentId: childId, visible: true },
-        [explicitId]: { id: explicitId, type: kind, parentId: visibleSite.id, visible: true },
-        [unownedId]: { id: unownedId, type: kind, parentId: null, visible: true },
+        [explicitId]: { id: explicitId, type: kind, parentId: hiddenSite.id, visible: true },
+        [hiddenChildId]: { id: hiddenChildId, type: kind, parentId: hiddenSite.id, visible: false },
       } as unknown as Record<string, AnyNode>
-      const allIds = [childId, descendantId, explicitId, unownedId]
+      const allIds = [childId, descendantId, explicitId, hiddenChildId]
       const root = new THREE.Group()
-      for (const id of [hiddenSite.id, visibleSite.id, ...allIds]) {
+      const siteObject = new THREE.Group()
+      root.add(siteObject)
+      sceneRegistry.nodes.set(hiddenSite.id, siteObject)
+      for (const id of allIds) {
         const object = new THREE.Group()
-        root.add(object)
+        siteObject.add(object)
         sceneRegistry.nodes.set(id, object)
       }
       const exportedIds = async (onlyVisible?: boolean) => {
@@ -613,12 +684,8 @@ describe('prepareSceneForExport', () => {
         }
       }
 
-      expect(await exportedIds()).toEqual([explicitId, unownedId])
+      expect(await exportedIds()).toEqual([childId, descendantId, explicitId])
       expect(await exportedIds(false)).toEqual(allIds)
-      nodes[hiddenSite.id] = { ...hiddenSite, visible: true }
-      expect(await exportedIds()).toEqual(allIds)
-      nodes[hiddenSite.id] = hiddenSite
-      expect(await exportedIds()).toEqual([explicitId, unownedId])
     } finally {
       restoreRegistry()
     }
@@ -1685,6 +1752,21 @@ async function withCanvasCapture(
           putImageData: (image: ImageData) => {
             pixelsByCanvas.set(canvas, new Uint8ClampedArray(image.data))
           },
+          fillRect: (_x: number, _y: number, width: number, height: number) => {
+            pixelsByCanvas.set(canvas, new Uint8ClampedArray(width * height * 4).fill(255))
+          },
+          drawImage: (image: HTMLCanvasElement) => {
+            const pixels = pixelsByCanvas.get(image)
+            if (!pixels) throw new Error('Source canvas has no captured pixels')
+            pixelsByCanvas.set(canvas, new Uint8ClampedArray(pixels))
+          },
+          getImageData: (_x: number, _y: number, width: number, height: number) =>
+            ({
+              colorSpace: 'srgb',
+              data: pixelsByCanvas.get(canvas) ?? new Uint8ClampedArray(width * height * 4),
+              height,
+              width,
+            }) as ImageData,
         }),
       } as unknown as HTMLCanvasElement
       return canvas
@@ -1702,3 +1784,170 @@ async function withCanvasCapture(
     else delete globals.document
   }
 }
+
+describe('normal maps in async export preparation', () => {
+  test('decompresses a compressed normal map through the provided decompressor before baking its scale', async () => {
+    await withCanvasCapture(async () => {
+      const root = new THREE.Group()
+      const compressed = new THREE.CompressedTexture([], 2, 2)
+      compressed.name = 'NormalGL_3a132c5f'
+      const material = nodeMaterial({ normalMap: compressed }) as THREE.MeshStandardMaterial
+      material.normalScale.set(0.5, 0.5)
+      root.add(meshWithNodeMaterial(material))
+      let calls = 0
+
+      const prepared = await prepareSceneForExportAsync(
+        root,
+        {},
+        {
+          decompressTexture: async (texture) => {
+            calls += 1
+            expect(texture.name).toBe('NormalGL_3a132c5f')
+            return new THREE.DataTexture(
+              new Uint8Array(
+                [128, 128, 255, 255].concat(
+                  [128, 128, 255, 255],
+                  [128, 128, 255, 255],
+                  [128, 128, 255, 255],
+                ),
+              ),
+              2,
+              2,
+            )
+          },
+        },
+      )
+
+      const exported = (prepared.scene.children[0] as THREE.Mesh)
+        .material as THREE.MeshStandardMaterial
+      expect(calls).toBe(1)
+      expect((exported.normalMap as { isCanvasTexture?: boolean }).isCanvasTexture).toBe(true)
+      expect(exported.normalScale.toArray()).toEqual([1, 1])
+      expect(material.normalMap).toBe(compressed)
+      expect(material.normalScale.toArray()).toEqual([0.5, 0.5])
+    })
+  })
+
+  test('reference mode keeps a stamped normal-map placeholder and its scale for the packer', async () => {
+    await withCanvasCapture(async () => {
+      const root = new THREE.Group()
+      const stamped = new THREE.CompressedTexture([], 4, 4)
+      stamped.userData.pascalTextureRef = {
+        v: 1,
+        kind: 'library-material',
+        src: `${STORAGE_ORIGIN}/storage/v1/object/public/materials/user/material/oak_normal_512.ktx2`,
+        map: 'normal',
+        colorSpace: 'linear',
+      }
+      const material = nodeMaterial({ normalMap: stamped }) as THREE.MeshStandardMaterial
+      material.normalScale.set(1, -1)
+      root.add(meshWithNodeMaterial(material))
+
+      const prepared = await prepareSceneForExportAsync(
+        root,
+        {},
+        {
+          textures: 'reference',
+          purpose: 'viewer',
+          decompressTexture: async () => {
+            throw new Error('by-reference placeholders must not be decompressed')
+          },
+        },
+      )
+
+      const exported = (prepared.scene.children[0] as THREE.Mesh)
+        .material as THREE.MeshStandardMaterial
+      expect(exported.normalMap?.userData.pascalTextureRef).toEqual(
+        stamped.userData.pascalTextureRef,
+      )
+      expect(exported.normalScale.toArray()).toEqual([1, -1])
+    })
+  })
+})
+
+describe('portable glass', () => {
+  test('see-through untextured surfaces become transmission glass in portable exports only', async () => {
+    const root = new THREE.Group()
+    const glass = new MeshStandardNodeMaterial({
+      color: '#3d9ed4',
+      transparent: true,
+      opacity: 0.3,
+      roughness: 0.1,
+    })
+    const tintedPlastic = new MeshStandardNodeMaterial({
+      color: '#3d9ed4',
+      transparent: true,
+      opacity: 0.8,
+    })
+    root.add(meshWithNodeMaterial(glass), meshWithNodeMaterial(tintedPlastic))
+
+    const portable = await prepareSceneForExportAsync(root, {})
+    const [exportedGlass, exportedPlastic] = portable.scene.children.map(
+      (child) => (child as THREE.Mesh).material as THREE.MeshPhysicalMaterial,
+    )
+    expect(exportedGlass!.isMeshPhysicalMaterial).toBe(true)
+    expect(exportedGlass!.transmission).toBe(1)
+    expect(exportedGlass!.transparent).toBe(false)
+    expect(exportedGlass!.opacity).toBe(1)
+    expect(exportedGlass!.roughness).toBeCloseTo(0.1)
+    // 30% authored opacity keeps 30% of the (linear) tint.
+    const tint = new THREE.Color('#3d9ed4')
+    expect(exportedGlass!.color.r).toBeCloseTo(tint.r + (1 - tint.r) * 0.7, 4)
+    expect(exportedGlass!.color.b).toBeCloseTo(tint.b + (1 - tint.b) * 0.7, 4)
+    expect(exportedPlastic!.isMeshPhysicalMaterial).toBeUndefined()
+    expect(exportedPlastic!.transparent).toBe(true)
+
+    const viewer = prepareSceneForExport(root, {}, { purpose: 'viewer' })
+    const kept = (viewer.scene.children[0] as THREE.Mesh).material as THREE.MeshStandardMaterial
+    expect((kept as { isMeshPhysicalMaterial?: boolean }).isMeshPhysicalMaterial).toBeUndefined()
+    expect(kept.transparent).toBe(true)
+    expect(kept.opacity).toBeCloseTo(0.3)
+
+    // USDZ has no transmission: the same prep hands glass its opacity back.
+    const usdz = createUsdzScene(portable.scene)
+    const usdzGlass = (usdz.children[0] as THREE.Mesh).material as THREE.MeshPhysicalMaterial
+    expect(usdzGlass.transmission).toBe(0)
+    expect(usdzGlass.transparent).toBe(true)
+    expect(usdzGlass.opacity).toBeCloseTo(0.3)
+    expect(exportedGlass!.transmission).toBe(1)
+  })
+})
+
+describe('portable clips', () => {
+  function swingDoorScene() {
+    const root = new THREE.Group()
+    const doorGroup = new THREE.Group()
+    const leaf = new THREE.Group()
+    leaf.userData.pascalSwingLeaf = { axis: 'y', openRotationY: Math.PI / 2 }
+    leaf.add(meshWithNodeMaterial(nodeMaterial()))
+    doorGroup.add(leaf)
+    root.add(doorGroup)
+    const doorId = 'door_portable'
+    sceneRegistry.nodes.set(doorId, doorGroup)
+    const nodes: Record<string, AnyNode> = {
+      [doorId]: { object: 'node', id: doorId, type: 'door', name: 'Door' } as unknown as AnyNode,
+    }
+    return { root, nodes, doorId }
+  }
+
+  test('GLB downloads keep door clips when asked, USDZ passes none', async () => {
+    const { root, nodes, doorId } = swingDoorScene()
+
+    const glb = await prepareSceneForExportAsync(root, nodes, { animations: 'keep' })
+    expect(glb.animations).toHaveLength(1)
+    expect(glb.animations[0]!.name).toBe(`${doorId}: open`)
+    const track = glb.animations[0]!.tracks[0]!
+    const targetUuid = track.name.split('.')[0]
+    expect(glb.scene.getObjectByProperty('uuid', targetUuid)).toBeDefined()
+    expect(glb.scene.getObjectByProperty('name', doorId)?.userData.clips).toEqual([
+      `${doorId}: open`,
+    ])
+
+    const usdz = await prepareSceneForExportAsync(root, nodes, { animations: 'none' })
+    expect(usdz.animations).toEqual([])
+    expect(usdz.scene.getObjectByProperty('name', doorId)?.userData.clips).toBeUndefined()
+
+    const legacy = await prepareSceneForExportAsync(root, nodes)
+    expect(legacy.animations).toEqual([])
+  })
+})