pcb-scene3d-viewer 1.3.2 → 1.3.4

package/src/PcbScene3dRuntime.mjs

@@ -1,15 +1,14 @@
-import { PcbScene3dBoardSolderMaskFactory } from './PcbScene3dBoardSolderMaskFactory.mjs'
 import { PcbScene3dCameraRig } from './PcbScene3dCameraRig.mjs'
 import { PcbScene3dCircuitJsonAdapter } from './PcbScene3dCircuitJsonAdapter.mjs'
 import { PcbScene3dComponentVisibility } from './PcbScene3dComponentVisibility.mjs'
 import { PcbScene3dComponentAdjustment } from './PcbScene3dComponentAdjustment.mjs'
 import { PcbScene3dComponentAdjustmentRegistry } from './PcbScene3dComponentAdjustmentRegistry.mjs'
 import { PcbScene3dCompanionBasePlacementAdjuster } from './PcbScene3dCompanionBasePlacementAdjuster.mjs'
-import { PcbScene3dCopperDetailGroupBuilder } from './PcbScene3dCopperDetailGroupBuilder.mjs'
 import { PcbScene3dCopperFactory } from './PcbScene3dCopperFactory.mjs'
 import { PcbScene3dDetailCoordinateNormalizer } from './PcbScene3dDetailCoordinateNormalizer.mjs'
 import { PcbScene3dDeferredModelFinalizer } from './PcbScene3dDeferredModelFinalizer.mjs'
-import { PcbScene3dDrillVoidFactory } from './PcbScene3dDrillVoidFactory.mjs'
+import { PcbScene3dGeometryTransfer } from './PcbScene3dGeometryTransfer.mjs'
+import { PcbScene3dGeometryWorkerClient } from './PcbScene3dGeometryWorkerClient.mjs'
 import { PcbScene3dExternalCompanionFallback } from './PcbScene3dExternalCompanionFallback.mjs'
 import { PcbScene3dExternalModels } from './PcbScene3dExternalModels.mjs'
 import { PcbScene3dExternalPlacementDefaults } from './PcbScene3dExternalPlacementDefaults.mjs'
@@ -75,10 +74,11 @@ export class PcbScene3dRuntime {
     #hasSettledReady
     #renderScheduler
     #visibilityGraph
+    #geometryWorker
     /**
      * @param {HTMLElement} viewportNode
      * @param {any} sceneDescription Scene description or CircuitJSON model.
-     * @param {{ setDiagnostics?: (messages: string[]) => void, setSelection?: (selection: any | null) => void, loadRuntimeModules?: () => Promise<{ THREE: any, OrbitControls: any }>, translate?: ((key: string) => string) | null, modelLoaderOptions?: object }} [hooks]
+     * @param {{ setDiagnostics?: (messages: string[]) => void, setSelection?: (selection: any | null) => void, loadRuntimeModules?: () => Promise<{ THREE: any, OrbitControls: any }>, translate?: ((key: string) => string) | null, modelLoaderOptions?: object, geometryWorkerOptions?: object }} [hooks]
      */
     constructor(viewportNode, sceneDescription, hooks = {}) {
         const renderModel =
@@ -129,6 +129,9 @@ export class PcbScene3dRuntime {
             }
         })
         this.#visibilityGraph = new PcbScene3dVisibilityGraph()
+        this.#geometryWorker = new PcbScene3dGeometryWorkerClient(
+            hooks.geometryWorkerOptions
+        )
         this.#resolveReadyPromise = null
         this.#readyPromise = new Promise((resolve) => {
             this.#resolveReadyPromise = resolve
@@ -218,6 +221,10 @@ export class PcbScene3dRuntime {
     /** @returns {void} */
     dispose() {
         this.#isDisposed = true
+        this.#geometryWorker.dispose()
+        ;['board', 'copper'].forEach((kind) =>
+            PcbScene3dGeometryTransfer.dispose(this.#groups.get(kind))
+        )
         this.#renderScheduler.cancel()
         this.#listeners.forEach(({ node, type, listener }) => {
             node.removeEventListener?.(type, listener)
@@ -283,9 +290,13 @@ export class PcbScene3dRuntime {
             this.#bindSelectionInteraction()
             this.#applyToggleVisibility()
             this.#render()
+            await this.#loadGeneratedGeometry('board')
+            if (this.#isDisposed) return
+            this.#render()
             await this.#loadDeferredDetail()
             this.#settleReady()
         } catch (error) {
+            if (this.#isDisposed) return
             this.#hooks.setDiagnostics?.([
                 '3D preview could not start: ' +
                     String(error?.message || error || 'Unknown error.')
@@ -342,44 +353,6 @@ export class PcbScene3dRuntime {
             .multiplyScalar(this.#initialRadius * 0.8)
         this.#scene.add(ambientLight, keyLight, fillLight)
         const boardGroup = new THREE.Group()
-        boardGroup.add(
-            PcbScene3dRuntimeBoardMeshes.buildBoardMesh(
-                THREE,
-                this.#sceneDescription,
-                (x, y) => this.#normalizeDetailPoint(x, y)
-            )
-        )
-        boardGroup.add(
-            PcbScene3dBoardSolderMaskFactory.buildGroup(
-                THREE,
-                this.#sceneDescription,
-                (x, y) => this.#normalizeDetailPoint(x, y)
-            )
-        )
-        boardGroup.add(
-            PcbScene3dDrillVoidFactory.buildGroup(
-                THREE,
-                this.#sceneDescription.detail,
-                board.thicknessMil / 2,
-                -board.thicknessMil / 2,
-                (x, y) => this.#normalizeDetailPoint(x, y),
-                {
-                    enabled: true,
-                    board,
-                    hasBoardAssemblyModel: Boolean(
-                        this.#sceneDescription.boardAssemblyModel
-                    ),
-                    sourceFormat: this.#sceneDescription.sourceFormat
-                }
-            )
-        )
-        boardGroup.add(
-            PcbScene3dRuntimeBoardMeshes.buildBoardOutline(
-                THREE,
-                this.#sceneDescription,
-                (x, y) => this.#normalizeDetailPoint(x, y)
-            )
-        )
         this.#groups.set('board', boardGroup)
         PcbScene3dRuntimeBoardMeshes.applyBoardFaceSide(
             this.#three,
@@ -536,7 +509,8 @@ export class PcbScene3dRuntime {
             if (this.#isDisposed) {
                 return
             }
-            this.#loadDeferredCopper()
+            await this.#loadGeneratedGeometry('copper')
+            if (this.#isDisposed) return
             this.#applyToggleVisibility()
             this.#render()
             this.#settleReady()
@@ -596,24 +570,29 @@ export class PcbScene3dRuntime {
     }
 
     /**
-     * Builds and attaches copper and via detail once after the first frame.
-     * @returns {void}
+     * Attaches exact worker-built geometry only while its runtime is alive.
+     * @param {'board' | 'copper'} kind Generated detail stage.
+     * @returns {Promise<void>}
      */
-    #loadDeferredCopper() {
-        const copperGroup = this.#groups.get('copper')
-        if (!copperGroup || copperGroup.children.length) {
+    async #loadGeneratedGeometry(kind) {
+        const group = this.#groups.get(kind)
+        if (!group || group.children.length || this.#isDisposed) {
             return
         }
-        const topZ = this.#sceneDescription.board.thicknessMil / 2 + 0.05
-        const detailGroup = PcbScene3dCopperDetailGroupBuilder.build(
+        const detailGroup = await this.#geometryWorker.build(
             this.#three,
-            this.#sceneDescription,
-            topZ,
-            (x, y) => this.#normalizeDetailPoint(x, y)
+            kind,
+            this.#sceneDescription
         )
+        if (this.#isDisposed) {
+            PcbScene3dGeometryTransfer.dispose(detailGroup)
+            return
+        }
         if (detailGroup.children.length) {
-            copperGroup.add(detailGroup)
+            if (kind === 'board') group.add(...[...detailGroup.children])
+            else group.add(detailGroup)
             this.#applyViewScale(this.#presetState.get())
+            this.#applyToggleVisibility()
         }
     }
     /**

package/src/PcbScene3dSilkscreenChunkedFactory.mjs

@@ -41,6 +41,7 @@ export class PcbScene3dSilkscreenChunkedFactory {
         }
 
         const group = new THREE.Group()
+        const cutoutContexts = {}
         for (const side of ['top', 'bottom']) {
             for (const recordKey of PcbScene3dSilkscreenChunkedFactory
                 .#RECORD_KEYS) {
@@ -53,7 +54,8 @@ export class PcbScene3dSilkscreenChunkedFactory {
                     topZ,
                     bottomZ,
                     normalizeBoardPoint,
-                    options
+                    options,
+                    cutoutContexts
                 )
             }
         }
@@ -72,6 +74,7 @@ export class PcbScene3dSilkscreenChunkedFactory {
      * @param {number} bottomZ
      * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint
      * @param {{ yieldToMain?: () => Promise<void> | void, shouldContinue?: () => boolean }} options
+     * @param {object} cutoutContexts Build-scoped side preparations.
      * @returns {Promise<void>}
      */
     static async #appendRecordChunks(
@@ -83,7 +86,8 @@ export class PcbScene3dSilkscreenChunkedFactory {
         topZ,
         bottomZ,
         normalizeBoardPoint,
-        options
+        options,
+        cutoutContexts
     ) {
         const sideSilkscreen = silkscreen?.[side] || {}
         const records = Array.isArray(sideSilkscreen[recordKey])
@@ -98,6 +102,13 @@ export class PcbScene3dSilkscreenChunkedFactory {
             PcbScene3dSilkscreenChunkedFactory.#shouldContinue(options);
             index += batchSize
         ) {
+            // Prepare lazily so cancelled or empty sides incur no cutout work.
+            cutoutContexts[side] ||=
+                PcbScene3dSilkscreenFactory.prepareCutoutContext(
+                    sideSilkscreen,
+                    normalizeBoardPoint,
+                    side === 'bottom'
+                )
             const chunkGroup = PcbScene3dSilkscreenFactory.buildGroup(
                 THREE,
                 PcbScene3dSilkscreenChunkedFactory.#buildChunkSilkscreen(
@@ -108,7 +119,8 @@ export class PcbScene3dSilkscreenChunkedFactory {
                 ),
                 topZ,
                 bottomZ,
-                normalizeBoardPoint
+                normalizeBoardPoint,
+                cutoutContexts
             )
             if (chunkGroup.children.length) {
                 group.add(chunkGroup)

package/src/PcbScene3dSilkscreenCutoutContext.mjs

@@ -66,6 +66,41 @@ export class PcbScene3dSilkscreenCutoutContext {
         this.#prepareNormalizedCutout(cutout)
     )
 
+    /** @type {{ x: number, y: number }[][]} */
+    #surfaceCutouts
+
+    /** @type {WeakMap<any[], object>} */
+    #preparedCutoutCache = new WeakMap()
+
+    /**
+     * Owns detached normalized cutouts for one side of a build. Callers must
+     * keep these coordinates unchanged for the lifetime of this context.
+     * @param {{ x: number, y: number }[][]} [surfaceCutouts] Normalized cutouts.
+     */
+    constructor(surfaceCutouts = []) {
+        this.#surfaceCutouts = surfaceCutouts
+    }
+
+    /**
+     * Returns the normalized surface cutouts shared by every side batch.
+     * @returns {{ x: number, y: number }[][]}
+     */
+    get surfaceCutouts() {
+        return this.#surfaceCutouts
+    }
+
+    /**
+     * Returns build-scoped caches for exact clipping consumers. Weak keys
+     * allow temporary fill-specific cutout lists to be released after use.
+     * @returns {{ preparedPolygonCache: Map, preparedCutoutCache: WeakMap }}
+     */
+    get geometryFilterOptions() {
+        return {
+            preparedPolygonCache: this.#preparedPolygonCache,
+            preparedCutoutCache: this.#preparedCutoutCache
+        }
+    }
+
     /**
      * Returns the lazy cache shared by exact geometry consumers.
      * @returns {Map<any, PcbScene3dPreparedPolygon>}

package/src/PcbScene3dSilkscreenFactory.mjs

@@ -31,23 +31,33 @@ export class PcbScene3dSilkscreenFactory {
      * @param {number} topZ
      * @param {number} bottomZ
      * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint
+     * @param {{ top?: PcbScene3dSilkscreenCutoutContext, bottom?: PcbScene3dSilkscreenCutoutContext }} [cutoutContexts] Internal build-scoped side preparations.
      * @returns {any}
      */
-    static buildGroup(THREE, silkscreen, topZ, bottomZ, normalizeBoardPoint) {
+    static buildGroup(
+        THREE,
+        silkscreen,
+        topZ,
+        bottomZ,
+        normalizeBoardPoint,
+        cutoutContexts = {}
+    ) {
         const group = new THREE.Group()
         const topGroup = PcbScene3dSilkscreenFactory.#buildSideGroup(
             THREE,
             silkscreen?.top,
             Math.abs(Number(topZ || 0)),
             normalizeBoardPoint,
-            false
+            false,
+            cutoutContexts.top
         )
         const bottomGroup = PcbScene3dSilkscreenFactory.#buildSideGroup(
             THREE,
             silkscreen?.bottom,
             Math.abs(Number(bottomZ || 0)),
             normalizeBoardPoint,
-            true
+            true,
+            cutoutContexts.bottom
         )
 
         if (topGroup.children.length) {
@@ -60,6 +70,30 @@ export class PcbScene3dSilkscreenFactory {
         return group
     }
 
+    /**
+     * Normalizes detached cutouts once for all batches on one board side.
+     * The returned context must not be reused across separate scene builds.
+     * @param {{ drillCutouts?: object[][], copperCutouts?: object[][] } | undefined} silkscreen Side artwork.
+     * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint Board normalizer.
+     * @param {boolean} mirrorY Whether the side is mirrored.
+     * @returns {PcbScene3dSilkscreenCutoutContext}
+     */
+    static prepareCutoutContext(silkscreen, normalizeBoardPoint, mirrorY) {
+        const drillCutouts = PcbScene3dSilkscreenFactory.#normalizeCutouts(
+            silkscreen?.drillCutouts,
+            normalizeBoardPoint,
+            mirrorY
+        )
+        const copperCutouts = PcbScene3dSilkscreenFactory.#normalizeCutouts(
+            silkscreen?.copperCutouts,
+            normalizeBoardPoint,
+            mirrorY
+        )
+        return new PcbScene3dSilkscreenCutoutContext(
+            drillCutouts.concat(copperCutouts)
+        )
+    }
+
     /**
      * Builds one side-specific silkscreen group.
      * @param {any} THREE
@@ -67,9 +101,17 @@ export class PcbScene3dSilkscreenFactory {
      * @param {number} z
      * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint
      * @param {boolean} mirrorY
+     * @param {PcbScene3dSilkscreenCutoutContext} [preparedCutoutContext] Shared side preparation.
      * @returns {any}
      */
-    static #buildSideGroup(THREE, silkscreen, z, normalizeBoardPoint, mirrorY) {
+    static #buildSideGroup(
+        THREE,
+        silkscreen,
+        z,
+        normalizeBoardPoint,
+        mirrorY,
+        preparedCutoutContext
+    ) {
         const group = new THREE.Group()
         const strokeColor = PcbScene3dSilkscreenFactory.#resolveMaterialColor(
             silkscreen?.strokeColor
@@ -89,18 +131,14 @@ export class PcbScene3dSilkscreenFactory {
               ? fillColor
               : textMaterialColor
         const strokeZ = z + PcbScene3dSilkscreenFactory.#STROKE_Z_OFFSET
-        const drillCutouts = PcbScene3dSilkscreenFactory.#normalizeCutouts(
-            silkscreen?.drillCutouts,
-            normalizeBoardPoint,
-            mirrorY
-        )
-        const copperCutouts = PcbScene3dSilkscreenFactory.#normalizeCutouts(
-            silkscreen?.copperCutouts,
-            normalizeBoardPoint,
-            mirrorY
-        )
-        const surfaceCutouts = drillCutouts.concat(copperCutouts)
-        const cutoutContext = new PcbScene3dSilkscreenCutoutContext()
+        const cutoutContext =
+            preparedCutoutContext ||
+            PcbScene3dSilkscreenFactory.prepareCutoutContext(
+                silkscreen,
+                normalizeBoardPoint,
+                mirrorY
+            )
+        const surfaceCutouts = cutoutContext.surfaceCutouts
         const strokeMaterial = PcbScene3dSilkscreenFactory.#buildMaterial(
             THREE,
             strokeColor
@@ -147,9 +185,7 @@ export class PcbScene3dSilkscreenFactory {
             mirrorY,
             fillMaterial,
             surfaceCutouts,
-            {
-                preparedPolygonCache: cutoutContext.preparedPolygonCache
-            }
+            cutoutContext.geometryFilterOptions
         )
         const texts = Array.isArray(silkscreen?.texts) ? silkscreen.texts : []
         const renderableTexts = texts.filter(
@@ -179,7 +215,7 @@ export class PcbScene3dSilkscreenFactory {
                     fog: false
                 },
                 mirrorY,
-                preparedPolygonCache: cutoutContext.preparedPolygonCache,
+                ...cutoutContext.geometryFilterOptions,
                 side: mirrorY ? 'bottom' : 'top'
             }
         )
@@ -534,7 +570,7 @@ export class PcbScene3dSilkscreenFactory {
                 maxDepth: 12,
                 maxEdgeLength:
                     PcbScene3dSilkscreenFactory.#CUTOUT_MAX_EDGE_LENGTH,
-                preparedPolygonCache: cutoutContext.preparedPolygonCache
+                ...cutoutContext.geometryFilterOptions
             }
         )
         const mesh = new THREE.Mesh(geometry, material)
@@ -823,7 +859,7 @@ export class PcbScene3dSilkscreenFactory {
                     maxDepth: 12,
                     maxEdgeLength:
                         PcbScene3dSilkscreenFactory.#CUTOUT_MAX_EDGE_LENGTH,
-                    preparedPolygonCache: cutoutContext?.preparedPolygonCache
+                    ...cutoutContext?.geometryFilterOptions
                 }
             ),
             material

package/src/PcbScene3dSilkscreenFillSeamBuilder.mjs

@@ -22,7 +22,7 @@ export class PcbScene3dSilkscreenFillSeamBuilder {
      * @param {boolean} mirrorY Whether the side is mirrored.
      * @param {any} material Shared fill material.
      * @param {{ x: number, y: number }[][]} [cutouts] Cutouts that should remain uncovered.
-     * @param {{ preparedPolygonCache?: Map }} [options] Request-scoped options.
+     * @param {{ preparedPolygonCache?: Map, preparedCutoutCache?: WeakMap }} [options] Request-scoped options.
      * @returns {any[]}
      */
     static buildMeshes(
@@ -117,7 +117,7 @@ export class PcbScene3dSilkscreenFillSeamBuilder {
      * @param {number[]} positions Position buffer.
      * @param {any} material Shared material.
      * @param {{ x: number, y: number }[][]} cutouts Cutout polygons.
-     * @param {{ preparedPolygonCache?: Map }} options Request-scoped options.
+     * @param {{ preparedPolygonCache?: Map, preparedCutoutCache?: WeakMap }} options Request-scoped options.
      * @returns {void}
      */
     static #appendMesh(meshes, THREE, positions, material, cutouts, options) {
@@ -139,7 +139,8 @@ export class PcbScene3dSilkscreenFillSeamBuilder {
             PcbScene3dCutoutGeometryFilter.filter(THREE, geometry, cutouts, {
                 maxDepth: 12,
                 maxEdgeLength: 2,
-                preparedPolygonCache: options?.preparedPolygonCache
+                preparedPolygonCache: options?.preparedPolygonCache,
+                preparedCutoutCache: options?.preparedCutoutCache
             }),
             material
         )

package/src/PcbScene3dWorkerClient.mjs

@@ -40,12 +40,18 @@ export class PcbScene3dWorkerClient {
 
             const requestId = 'scene3d-request-' + this.#requestSequence++
             this.#pendingRequests.set(requestId, { resolve, reject })
-            this.#worker.postMessage({
-                type: 'scene3d:prepare',
-                requestId,
-                documentModel,
-                sessionAssets
-            })
+            try {
+                this.#worker.postMessage({
+                    type: 'scene3d:prepare',
+                    requestId,
+                    documentModel,
+                    sessionAssets
+                })
+            } catch (error) {
+                // A synchronous clone failure will never receive a response.
+                this.#pendingRequests.delete(requestId)
+                reject(error)
+            }
         })
     }