pcb-scene3d-viewer 1.1.49 → 1.2.0

package/src/PcbScene3dSilkscreenFactory.mjs

@@ -1,6 +1,4 @@
-import { PcbScene3dBoardEdgeCutoutBuilder } from './PcbScene3dBoardEdgeCutoutBuilder.mjs'
 import { PcbScene3dCopperTextFactory } from './PcbScene3dCopperTextFactory.mjs'
-import { PcbScene3dCutoutCircleDetector } from './PcbScene3dCutoutCircleDetector.mjs'
 import { PcbScene3dCutoutGeometryFilter } from './PcbScene3dCutoutGeometryFilter.mjs'
 import { PcbScene3dDrillCutoutFilter } from './PcbScene3dDrillCutoutFilter.mjs'
 import { PcbScene3dMaterialFinish } from './PcbScene3dMaterialFinish.mjs'
@@ -8,6 +6,7 @@ import { PcbScene3dPolygonOverlap } from './PcbScene3dPolygonOverlap.mjs'
 import { PcbScene3dShapeHoleMerger } from './PcbScene3dShapeHoleMerger.mjs'
 import { PcbScene3dShapePathFactory } from './PcbScene3dShapePathFactory.mjs'
 import { PcbScene3dShapeHoleGeometryCleaner } from './PcbScene3dShapeHoleGeometryCleaner.mjs'
+import { PcbScene3dSilkscreenCutoutContext } from './PcbScene3dSilkscreenCutoutContext.mjs'
 import { PcbScene3dSilkscreenFillSeamBuilder } from './PcbScene3dSilkscreenFillSeamBuilder.mjs'
 import { PcbScene3dSilkscreenStrokeWidthResolver } from './PcbScene3dSilkscreenStrokeWidthResolver.mjs'
 import { PcbScene3dStrokeGeometryBuilder } from './PcbScene3dStrokeGeometryBuilder.mjs'
@@ -19,7 +18,6 @@ import { PcbScene3dTrueTypeTextFactory } from './PcbScene3dTrueTypeTextFactory.m
 export class PcbScene3dSilkscreenFactory {
     static #DEFAULT_SILKSCREEN_COLOR = 0xf8f6ef
     static #FILL_THICKNESS_MIL = 0.8
-    static #GEOMETRY_EPSILON = 0.001
     static #FULL_CIRCLE_EPSILON = 0.001
     static #MIN_STROKE_WIDTH_MIL = 0.04
     static #STROKE_MESH_POSITION_CHUNK_SIZE = 24000
@@ -102,6 +100,7 @@ export class PcbScene3dSilkscreenFactory {
             mirrorY
         )
         const surfaceCutouts = drillCutouts.concat(copperCutouts)
+        const cutoutContext = new PcbScene3dSilkscreenCutoutContext()
         const strokeMaterial = PcbScene3dSilkscreenFactory.#buildMaterial(
             THREE,
             strokeColor
@@ -117,7 +116,8 @@ export class PcbScene3dSilkscreenFactory {
             normalizeBoardPoint,
             mirrorY,
             strokeMaterial,
-            surfaceCutouts
+            surfaceCutouts,
+            cutoutContext
         )
         const arcMesh = PcbScene3dSilkscreenFactory.#buildArcMesh(
             THREE,
@@ -126,7 +126,8 @@ export class PcbScene3dSilkscreenFactory {
             normalizeBoardPoint,
             mirrorY,
             strokeMaterial,
-            surfaceCutouts
+            surfaceCutouts,
+            cutoutContext
         )
         const fillMeshes = PcbScene3dSilkscreenFactory.#buildFillMeshes(
             THREE,
@@ -135,7 +136,8 @@ export class PcbScene3dSilkscreenFactory {
             normalizeBoardPoint,
             mirrorY,
             fillMaterial,
-            surfaceCutouts
+            surfaceCutouts,
+            cutoutContext
         )
         const fillSeamMeshes = PcbScene3dSilkscreenFillSeamBuilder.buildMeshes(
             THREE,
@@ -144,7 +146,10 @@ export class PcbScene3dSilkscreenFactory {
             normalizeBoardPoint,
             mirrorY,
             fillMaterial,
-            surfaceCutouts
+            surfaceCutouts,
+            {
+                preparedPolygonCache: cutoutContext.preparedPolygonCache
+            }
         )
         const texts = Array.isArray(silkscreen?.texts) ? silkscreen.texts : []
         const renderableTexts = texts.filter(
@@ -174,6 +179,7 @@ export class PcbScene3dSilkscreenFactory {
                     fog: false
                 },
                 mirrorY,
+                preparedPolygonCache: cutoutContext.preparedPolygonCache,
                 side: mirrorY ? 'bottom' : 'top'
             }
         )
@@ -237,6 +243,7 @@ export class PcbScene3dSilkscreenFactory {
      * @param {boolean} mirrorY
      * @param {any} material
      * @param {{ x: number, y: number }[][]} drillCutouts
+     * @param {PcbScene3dSilkscreenCutoutContext} cutoutContext
      * @returns {any[]}
      */
     static #buildTrackMeshes(
@@ -246,7 +253,8 @@ export class PcbScene3dSilkscreenFactory {
         normalizeBoardPoint,
         mirrorY,
         material,
-        drillCutouts
+        drillCutouts,
+        cutoutContext
     ) {
         const meshes = []
         let positions = []
@@ -289,7 +297,8 @@ export class PcbScene3dSilkscreenFactory {
                     THREE,
                     positions,
                     material,
-                    drillCutouts
+                    drillCutouts,
+                    cutoutContext
                 )
                 positions = []
             }
@@ -300,7 +309,8 @@ export class PcbScene3dSilkscreenFactory {
             THREE,
             positions,
             material,
-            drillCutouts
+            drillCutouts,
+            cutoutContext
         )
 
         return meshes
@@ -315,6 +325,7 @@ export class PcbScene3dSilkscreenFactory {
      * @param {boolean} mirrorY
      * @param {any} material
      * @param {{ x: number, y: number }[][]} drillCutouts
+     * @param {PcbScene3dSilkscreenCutoutContext} cutoutContext
      * @returns {any | null}
      */
     static #buildArcMesh(
@@ -324,7 +335,8 @@ export class PcbScene3dSilkscreenFactory {
         normalizeBoardPoint,
         mirrorY,
         material,
-        drillCutouts
+        drillCutouts,
+        cutoutContext
     ) {
         const positions = []
 
@@ -353,7 +365,8 @@ export class PcbScene3dSilkscreenFactory {
             THREE,
             positions,
             material,
-            drillCutouts
+            drillCutouts,
+            cutoutContext
         )
     }
 
@@ -366,6 +379,7 @@ export class PcbScene3dSilkscreenFactory {
      * @param {boolean} mirrorY
      * @param {any} material
      * @param {{ x: number, y: number }[][]} drillCutouts
+     * @param {PcbScene3dSilkscreenCutoutContext} cutoutContext
      * @returns {any[]}
      */
     static #buildFillMeshes(
@@ -375,7 +389,8 @@ export class PcbScene3dSilkscreenFactory {
         normalizeBoardPoint,
         mirrorY,
         material,
-        drillCutouts
+        drillCutouts,
+        cutoutContext
     ) {
         return fills.map((fill) => {
             const points = PcbScene3dSilkscreenFactory.#normalizeFillPoints(
@@ -402,7 +417,8 @@ export class PcbScene3dSilkscreenFactory {
                     fillHoles,
                     drillCutouts,
                     z,
-                    material
+                    material,
+                    cutoutContext
                 )
             }
 
@@ -425,6 +441,7 @@ export class PcbScene3dSilkscreenFactory {
      * @param {{ x: number, y: number }[][]} drillCutouts Normalized drill cutouts.
      * @param {number} z
      * @param {any} material
+     * @param {PcbScene3dSilkscreenCutoutContext} cutoutContext
      * @returns {any}
      */
     static #buildShapeFillMesh(
@@ -433,15 +450,17 @@ export class PcbScene3dSilkscreenFactory {
         fillHoles,
         drillCutouts,
         z,
-        material
+        material,
+        cutoutContext
     ) {
         const { authoredHoles, drillHoles, uncoveredCutouts } =
             PcbScene3dDrillCutoutFilter.partitionFillHoles(
                 drillCutouts,
-                fillHoles
+                fillHoles,
+                { preparedPolygonCache: cutoutContext.preparedPolygonCache }
             )
         const { points: contourPoints, appliedCutouts: edgeCutouts } =
-            PcbScene3dSilkscreenFactory.#applyCircularEdgeCutouts(
+            cutoutContext.applyCircularEdgeCutouts(
                 points,
                 drillHoles.concat(uncoveredCutouts)
             )
@@ -461,33 +480,41 @@ export class PcbScene3dSilkscreenFactory {
             clippingHoles: copiedClippingHoles
         } = PcbScene3dSilkscreenFactory.#partitionDrillCutouts(
             remainingDrillHoles,
-            contourPoints
+            contourPoints,
+            cutoutContext
         )
         const { shapeHoles, clippingHoles } =
             PcbScene3dSilkscreenFactory.#partitionDrillCutouts(
                 remainingUncoveredCutouts,
-                contourPoints
+                contourPoints,
+                cutoutContext
             )
         const physicalShapeCutoutHoles =
             PcbScene3dShapeHoleMerger.mergeOverlapping(
                 PcbScene3dDrillCutoutFilter.removeNestedCutouts(
-                    copiedShapeHoles.concat(shapeHoles)
+                    copiedShapeHoles.concat(shapeHoles),
+                    {
+                        preparedPolygonCache: cutoutContext.preparedPolygonCache
+                    }
                 )
             )
         const shapeCutoutHoles = PcbScene3dShapeHoleMerger.mergeOverlapping(
             PcbScene3dDrillCutoutFilter.removeNestedCutouts(
-                authoredHoles.concat(copiedShapeHoles, shapeHoles)
+                authoredHoles.concat(copiedShapeHoles, shapeHoles),
+                { preparedPolygonCache: cutoutContext.preparedPolygonCache }
             )
         )
         const fallbackClippingHoles =
             PcbScene3dDrillCutoutFilter.removeNestedCutouts(
-                copiedClippingHoles.concat(clippingHoles)
+                copiedClippingHoles.concat(clippingHoles),
+                { preparedPolygonCache: cutoutContext.preparedPolygonCache }
             )
         PcbScene3dSilkscreenFactory.#appendShapeHoles(
             THREE,
             shape,
             shapeCutoutHoles,
-            contourPoints
+            contourPoints,
+            cutoutContext
         )
 
         const shapeFilterHoles =
@@ -496,7 +523,8 @@ export class PcbScene3dSilkscreenFactory {
             PcbScene3dShapeHoleGeometryCleaner.removeCoveredHoleCenters(
                 THREE,
                 new THREE.ShapeGeometry(shape),
-                physicalShapeCutoutHoles
+                physicalShapeCutoutHoles,
+                { preparedPolygonCache: cutoutContext.preparedPolygonCache }
             )
         const geometry = PcbScene3dCutoutGeometryFilter.filter(
             THREE,
@@ -505,7 +533,8 @@ export class PcbScene3dSilkscreenFactory {
             {
                 maxDepth: 12,
                 maxEdgeLength:
-                    PcbScene3dSilkscreenFactory.#CUTOUT_MAX_EDGE_LENGTH
+                    PcbScene3dSilkscreenFactory.#CUTOUT_MAX_EDGE_LENGTH,
+                preparedPolygonCache: cutoutContext.preparedPolygonCache
             }
         )
         const mesh = new THREE.Mesh(geometry, material)
@@ -513,94 +542,19 @@ export class PcbScene3dSilkscreenFactory {
         return mesh
     }
 
-    /**
-     * Converts circular edge cutouts into the fill contour before triangulation.
-     * @param {{ x: number, y: number }[]} contourPoints Fill contour points.
-     * @param {{ x: number, y: number }[][]} drillCutouts Candidate cutouts.
-     * @returns {{ points: { x: number, y: number }[], appliedCutouts: { x: number, y: number }[][] }}
-     */
-    static #applyCircularEdgeCutouts(contourPoints, drillCutouts) {
-        let points = contourPoints
-        const appliedCutouts = []
-        const candidates = PcbScene3dDrillCutoutFilter.removeNestedCutouts(
-            (Array.isArray(drillCutouts) ? drillCutouts : []).filter(
-                (cutout) =>
-                    PcbScene3dCutoutCircleDetector.resolve(cutout) &&
-                    !PcbScene3dSilkscreenFactory.#isHoleInsideContour(
-                        cutout,
-                        contourPoints
-                    )
-            )
-        )
-
-        for (const cutout of candidates) {
-            const circularCutout =
-                PcbScene3dCutoutCircleDetector.resolve(cutout)
-            if (
-                !circularCutout ||
-                PcbScene3dSilkscreenFactory.#isHoleInsideContour(cutout, points)
-            ) {
-                continue
-            }
-
-            const nextPoints =
-                PcbScene3dBoardEdgeCutoutBuilder.applyCircularEdgeCutouts(
-                    points,
-                    [circularCutout]
-                )
-            if (
-                PcbScene3dSilkscreenFactory.#samePointList(points, nextPoints)
-            ) {
-                continue
-            }
-
-            points = nextPoints
-            appliedCutouts.push(cutout)
-        }
-
-        return { points, appliedCutouts }
-    }
-
-    /**
-     * Returns true when two point lists share identical coordinates.
-     * @param {{ x: number, y: number }[]} first First point list.
-     * @param {{ x: number, y: number }[]} second Second point list.
-     * @returns {boolean}
-     */
-    static #samePointList(first, second) {
-        return (
-            Array.isArray(first) &&
-            Array.isArray(second) &&
-            first.length === second.length &&
-            first.every((point, index) => {
-                const otherPoint = second[index]
-
-                return (
-                    Math.abs(point.x - otherPoint.x) <=
-                        PcbScene3dSilkscreenFactory.#GEOMETRY_EPSILON &&
-                    Math.abs(point.y - otherPoint.y) <=
-                        PcbScene3dSilkscreenFactory.#GEOMETRY_EPSILON
-                )
-            })
-        )
-    }
     /**
      * Splits drill cutouts into safe shape holes and fallback clip polygons.
      * @param {{ x: number, y: number }[][]} drillCutouts
      * @param {{ x: number, y: number }[]} contourPoints
+     * @param {PcbScene3dSilkscreenCutoutContext} cutoutContext
      * @returns {{ shapeHoles: { x: number, y: number }[][], clippingHoles: { x: number, y: number }[][] }}
      */
-    static #partitionDrillCutouts(drillCutouts, contourPoints) {
+    static #partitionDrillCutouts(drillCutouts, contourPoints, cutoutContext) {
         const shapeHoles = []
         const clippingHoles = []
 
         for (const cutout of Array.isArray(drillCutouts) ? drillCutouts : []) {
-            if (
-                PcbScene3dSilkscreenFactory.#isHoleInsideContour(
-                    cutout,
-                    contourPoints
-                )
-            ) {
+            if (cutoutContext.isHoleInsideContour(cutout, contourPoints)) {
                 shapeHoles.push(cutout)
                 continue
             }
@@ -617,20 +571,22 @@ export class PcbScene3dSilkscreenFactory {
      * @param {{ holes: any[] }} shape
      * @param {{ x: number, y: number }[][]} holes
      * @param {{ x: number, y: number }[]} contourPoints
+     * @param {PcbScene3dSilkscreenCutoutContext} cutoutContext
      * @returns {void}
      */
-    static #appendShapeHoles(THREE, shape, holes, contourPoints) {
+    static #appendShapeHoles(
+        THREE,
+        shape,
+        holes,
+        contourPoints,
+        cutoutContext
+    ) {
         if (!Array.isArray(holes) || !Array.isArray(shape.holes)) {
             return
         }
 
         for (const points of holes) {
-            if (
-                !PcbScene3dSilkscreenFactory.#isHoleInsideContour(
-                    points,
-                    contourPoints
-                )
-            ) {
+            if (!cutoutContext.isHoleInsideContour(points, contourPoints)) {
                 continue
             }
 
@@ -640,19 +596,6 @@ export class PcbScene3dSilkscreenFactory {
         }
     }
 
-    /**
-     * Returns true when a cutout can safely be added as a shape hole.
-     * @param {{ x: number, y: number }[]} hole
-     * @param {{ x: number, y: number }[]} contour
-     * @returns {boolean}
-     */
-    static #isHoleInsideContour(hole, contour) {
-        return PcbScene3dBoardEdgeCutoutBuilder.isHoleInsideContour(
-            hole,
-            contour
-        )
-    }
-
     /**
      * Builds one rectangular fallback fill mesh.
      * @param {any} THREE
@@ -851,9 +794,16 @@ export class PcbScene3dSilkscreenFactory {
      * @param {number[]} positions
      * @param {any} material
      * @param {{ x: number, y: number }[][]} [drillCutouts]
+     * @param {PcbScene3dSilkscreenCutoutContext | null} [cutoutContext]
      * @returns {any | null}
      */
-    static #buildStrokeMesh(THREE, positions, material, drillCutouts = []) {
+    static #buildStrokeMesh(
+        THREE,
+        positions,
+        material,
+        drillCutouts = [],
+        cutoutContext = null
+    ) {
         if (!positions.length) {
             return null
         }
@@ -872,7 +822,8 @@ export class PcbScene3dSilkscreenFactory {
                 {
                     maxDepth: 12,
                     maxEdgeLength:
-                        PcbScene3dSilkscreenFactory.#CUTOUT_MAX_EDGE_LENGTH
+                        PcbScene3dSilkscreenFactory.#CUTOUT_MAX_EDGE_LENGTH,
+                    preparedPolygonCache: cutoutContext?.preparedPolygonCache
                 }
             ),
             material
@@ -886,14 +837,23 @@ export class PcbScene3dSilkscreenFactory {
      * @param {number[]} positions
      * @param {any} material
      * @param {{ x: number, y: number }[][]} drillCutouts
+     * @param {PcbScene3dSilkscreenCutoutContext} cutoutContext
      * @returns {void}
      */
-    static #appendStrokeMesh(meshes, THREE, positions, material, drillCutouts) {
+    static #appendStrokeMesh(
+        meshes,
+        THREE,
+        positions,
+        material,
+        drillCutouts,
+        cutoutContext
+    ) {
         const mesh = PcbScene3dSilkscreenFactory.#buildStrokeMesh(
             THREE,
             positions,
             material,
-            drillCutouts
+            drillCutouts,
+            cutoutContext
         )
 
         if (mesh) {

package/src/PcbScene3dSilkscreenFillSeamBuilder.mjs

@@ -22,6 +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.
      * @returns {any[]}
      */
     static buildMeshes(
@@ -31,7 +32,8 @@ export class PcbScene3dSilkscreenFillSeamBuilder {
         normalizeBoardPoint,
         mirrorY,
         material,
-        cutouts = []
+        cutouts = [],
+        options = {}
     ) {
         const meshes = []
         let positions = []
@@ -55,7 +57,8 @@ export class PcbScene3dSilkscreenFillSeamBuilder {
                     THREE,
                     positions,
                     material,
-                    cutouts
+                    cutouts,
+                    options
                 )
                 positions = []
             }
@@ -66,7 +69,8 @@ export class PcbScene3dSilkscreenFillSeamBuilder {
             THREE,
             positions,
             material,
-            cutouts
+            cutouts,
+            options
         )
 
         return meshes
@@ -113,9 +117,10 @@ 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.
      * @returns {void}
      */
-    static #appendMesh(meshes, THREE, positions, material, cutouts) {
+    static #appendMesh(meshes, THREE, positions, material, cutouts, options) {
         if (
             !positions.length ||
             !THREE?.BufferGeometry ||
@@ -133,7 +138,8 @@ export class PcbScene3dSilkscreenFillSeamBuilder {
         const mesh = new THREE.Mesh(
             PcbScene3dCutoutGeometryFilter.filter(THREE, geometry, cutouts, {
                 maxDepth: 12,
-                maxEdgeLength: 2
+                maxEdgeLength: 2,
+                preparedPolygonCache: options?.preparedPolygonCache
             }),
             material
         )

package/src/PcbScene3dStepLoader.mjs

@@ -1,3 +1,5 @@
+import { PcbScene3dModelIdentity } from './PcbScene3dModelIdentity.mjs'
+
 /**
  * Browser-side STEP mesh loader backed by occt-import-js.
  */
@@ -76,7 +78,7 @@ export class PcbScene3dStepLoader {
 
     /**
      * Loads one STEP model and normalizes it into triangle payloads.
-     * @param {{ origin?: string, name?: string, sourceStream?: string, relativePath?: string, payloadText?: string, payloadBytes?: any, bytes?: any, data?: any, file?: Blob | File | Uint8Array | ArrayBuffer | null }} model
+     * @param {{ origin?: string, name?: string, sourceStream?: string, relativePath?: string, payloadText?: string, text?: string, payloadBytes?: any, bytes?: any, data?: any, file?: Blob | File | Uint8Array | ArrayBuffer | null }} model
      * @returns {Promise<{ meshPayloads: { name: string, color: number[] | null, positions: ArrayLike<number>, normals: ArrayLike<number>, indices: ArrayLike<number>, faceColors: { first: number, last: number, color: number[] | null }[] }[] }>}
      */
     async loadModel(model) {
@@ -99,7 +101,7 @@ export class PcbScene3dStepLoader {
 
     /**
      * Loads one uncached STEP model.
-     * @param {{ origin?: string, name?: string, sourceStream?: string, relativePath?: string, payloadText?: string, payloadBytes?: any, bytes?: any, data?: any, file?: Blob | File | Uint8Array | ArrayBuffer | null }} model
+     * @param {{ origin?: string, name?: string, sourceStream?: string, relativePath?: string, payloadText?: string, text?: string, payloadBytes?: any, bytes?: any, data?: any, file?: Blob | File | Uint8Array | ArrayBuffer | null }} model
      * @returns {Promise<{ meshPayloads: { name: string, color: number[] | null, positions: ArrayLike<number>, normals: ArrayLike<number>, indices: ArrayLike<number>, faceColors: { first: number, last: number, color: number[] | null }[] }[] }>}
      */
     async #loadModelUncached(model) {
@@ -290,12 +292,7 @@ export class PcbScene3dStepLoader {
      * @returns {string}
      */
     static #resolveCacheKey(model) {
-        return [
-            String(model?.origin || 'unknown'),
-            String(model?.sourceStream || ''),
-            String(model?.relativePath || ''),
-            String(model?.name || '')
-        ].join('|')
+        return PcbScene3dModelIdentity.resolve(model)
     }
 
     /**
@@ -311,12 +308,16 @@ export class PcbScene3dStepLoader {
 
     /**
      * Reads one STEP model into bytes from embedded text, bytes, or a session file.
-     * @param {{ payloadText?: string, payloadBytes?: any, bytes?: any, data?: any, file?: Blob | File | Uint8Array | ArrayBuffer | null }} model
+     * @param {{ payloadText?: string, text?: string, payloadBytes?: any, bytes?: any, data?: any, file?: Blob | File | Uint8Array | ArrayBuffer | null }} model
      * @returns {Promise<Uint8Array>}
      */
     static async #readModelContent(model) {
         const payloadText =
-            typeof model?.payloadText === 'string' ? model.payloadText : ''
+            typeof model?.payloadText === 'string'
+                ? model.payloadText
+                : typeof model?.text === 'string'
+                  ? model.text
+                  : ''
         if (payloadText) {
             return new TextEncoder().encode(payloadText)
         }

package/src/PcbScene3dText.mjs

@@ -34,7 +34,7 @@ const FALLBACK_MESSAGES = {
     'scene3d.mountSide': 'Mount side',
     'scene3d.noMetadataFor': 'No metadata is available for',
     'scene3d.noModelsForExport':
-        'No STEP or WRL models were resolved for export.',
+        'No resolved 3D models were available for export.',
     'scene3d.noPcb': '3D preview is available after loading a PCB document.',
     'scene3d.pattern': 'Pattern',
     'scene3d.picked': 'Picked',