pcb-scene3d-viewer 1.1.47 → 1.1.49

package/src/PcbScene3dCopperFillPolygonBoolean.mjs

@@ -0,0 +1,235 @@
+import polygonClipping from 'polygon-clipping'
+
+/**
+ * Normalizes and subtracts copper fill loop sets with polygon booleans.
+ */
+export class PcbScene3dCopperFillPolygonBoolean {
+    static #AREA_EPSILON = 0.001
+
+    /**
+     * Resolves the remaining loop sets after subtracting already emitted
+     * copper areas.
+     * @param {{ outer: number[][], holes: number[][][], bounds: object }} loopSet Candidate loop set.
+     * @param {number[][][][]} emittedPolygons Already emitted polygon-clipping polygons.
+     * @returns {{ outer: number[][], holes: number[][][], bounds: object }[] | null}
+     */
+    static resolveRemainingLoopSets(loopSet, emittedPolygons) {
+        const subjectPolygons =
+            PcbScene3dCopperFillPolygonBoolean.resolveNormalizedPolygons(
+                loopSet
+            )
+        if (!subjectPolygons.length) {
+            return []
+        }
+
+        if (!emittedPolygons.length) {
+            return PcbScene3dCopperFillPolygonBoolean.#multiPolygonToLoopSets(
+                subjectPolygons
+            )
+        }
+
+        try {
+            return PcbScene3dCopperFillPolygonBoolean.#multiPolygonToLoopSets(
+                polygonClipping.difference(subjectPolygons, ...emittedPolygons)
+            )
+        } catch {
+            return null
+        }
+    }
+
+    /**
+     * Normalizes one loop set with polygon boolean semantics.
+     * @param {{ outer: number[][], holes: number[][][] }} loopSet Normalized loop set.
+     * @returns {number[][][][]}
+     */
+    static resolveNormalizedPolygons(loopSet) {
+        const subject =
+            PcbScene3dCopperFillPolygonBoolean.#loopSetToPolygon(loopSet)
+        if (!subject) {
+            return []
+        }
+
+        try {
+            return polygonClipping.union(subject)
+        } catch {
+            return [subject]
+        }
+    }
+
+    /**
+     * Converts one normalized loop set to a polygon-clipping polygon.
+     * @param {{ outer: number[][], holes: number[][][] }} loopSet Normalized loop set.
+     * @returns {number[][][] | null}
+     */
+    static #loopSetToPolygon(loopSet) {
+        const outer = PcbScene3dCopperFillPolygonBoolean.#closedRing(
+            loopSet?.outer
+        )
+        if (!outer.length) {
+            return null
+        }
+
+        return [
+            outer,
+            ...(loopSet?.holes || [])
+                .map((hole) =>
+                    PcbScene3dCopperFillPolygonBoolean.#closedRing(hole)
+                )
+                .filter((hole) => hole.length)
+        ]
+    }
+
+    /**
+     * Converts polygon-clipping output into normalized loop sets.
+     * @param {number[][][][]} multiPolygon Clipped multipolygon.
+     * @returns {{ outer: number[][], holes: number[][][], bounds: object }[]}
+     */
+    static #multiPolygonToLoopSets(multiPolygon) {
+        return (multiPolygon || [])
+            .map((polygon) => {
+                const outer = PcbScene3dCopperFillPolygonBoolean.#cleanLoop(
+                    polygon?.[0] || []
+                )
+                if (!PcbScene3dCopperFillPolygonBoolean.#isValidLoop(outer)) {
+                    return null
+                }
+
+                const holes = (polygon || [])
+                    .slice(1)
+                    .map((ring) =>
+                        PcbScene3dCopperFillPolygonBoolean.#cleanLoop(ring)
+                    )
+                    .filter((ring) =>
+                        PcbScene3dCopperFillPolygonBoolean.#isValidLoop(ring)
+                    )
+
+                return {
+                    outer,
+                    holes,
+                    bounds: PcbScene3dCopperFillPolygonBoolean.#loopBounds(
+                        outer
+                    )
+                }
+            })
+            .filter(Boolean)
+    }
+
+    /**
+     * Closes one loop for polygon boolean operations.
+     * @param {number[][]} loop Candidate loop.
+     * @returns {number[][]}
+     */
+    static #closedRing(loop) {
+        const cleanLoop = PcbScene3dCopperFillPolygonBoolean.#cleanLoop(loop)
+        if (!PcbScene3dCopperFillPolygonBoolean.#isValidLoop(cleanLoop)) {
+            return []
+        }
+
+        const first = cleanLoop[0]
+        const last = cleanLoop[cleanLoop.length - 1]
+        const closed = cleanLoop.map((point) => [point[0], point[1]])
+        if (
+            Math.abs(first[0] - last[0]) >=
+                PcbScene3dCopperFillPolygonBoolean.#AREA_EPSILON ||
+            Math.abs(first[1] - last[1]) >=
+                PcbScene3dCopperFillPolygonBoolean.#AREA_EPSILON
+        ) {
+            closed.push([first[0], first[1]])
+        }
+        return closed
+    }
+
+    /**
+     * Removes invalid and duplicate loop points.
+     * @param {number[][]} points Candidate points.
+     * @returns {number[][]}
+     */
+    static #cleanLoop(points) {
+        const loop = []
+        for (const point of points || []) {
+            const x = Number(point?.[0])
+            const y = Number(point?.[1])
+            if (!Number.isFinite(x) || !Number.isFinite(y)) {
+                continue
+            }
+
+            const previous = loop[loop.length - 1]
+            if (
+                previous &&
+                Math.abs(previous[0] - x) <
+                    PcbScene3dCopperFillPolygonBoolean.#AREA_EPSILON &&
+                Math.abs(previous[1] - y) <
+                    PcbScene3dCopperFillPolygonBoolean.#AREA_EPSILON
+            ) {
+                continue
+            }
+            loop.push([x, y])
+        }
+
+        const first = loop[0]
+        const last = loop[loop.length - 1]
+        if (
+            first &&
+            last &&
+            Math.abs(first[0] - last[0]) <
+                PcbScene3dCopperFillPolygonBoolean.#AREA_EPSILON &&
+            Math.abs(first[1] - last[1]) <
+                PcbScene3dCopperFillPolygonBoolean.#AREA_EPSILON
+        ) {
+            loop.pop()
+        }
+
+        return loop
+    }
+
+    /**
+     * Checks whether one loop has enough non-collinear area.
+     * @param {number[][]} loop Candidate loop.
+     * @returns {boolean}
+     */
+    static #isValidLoop(loop) {
+        return (
+            Array.isArray(loop) &&
+            loop.length >= 3 &&
+            Math.abs(PcbScene3dCopperFillPolygonBoolean.#signedArea(loop)) >
+                PcbScene3dCopperFillPolygonBoolean.#AREA_EPSILON
+        )
+    }
+
+    /**
+     * Computes axis-aligned bounds for one loop.
+     * @param {number[][]} loop Candidate loop.
+     * @returns {{ minX: number, minY: number, maxX: number, maxY: number }}
+     */
+    static #loopBounds(loop) {
+        return (loop || []).reduce(
+            (bounds, point) => ({
+                minX: Math.min(bounds.minX, Number(point?.[0])),
+                minY: Math.min(bounds.minY, Number(point?.[1])),
+                maxX: Math.max(bounds.maxX, Number(point?.[0])),
+                maxY: Math.max(bounds.maxY, Number(point?.[1]))
+            }),
+            {
+                minX: Infinity,
+                minY: Infinity,
+                maxX: -Infinity,
+                maxY: -Infinity
+            }
+        )
+    }
+
+    /**
+     * Computes signed loop area.
+     * @param {number[][]} loop Candidate loop.
+     * @returns {number}
+     */
+    static #signedArea(loop) {
+        let area = 0
+        for (let index = 0; index < loop.length; index += 1) {
+            const current = loop[index]
+            const next = loop[(index + 1) % loop.length]
+            area += current[0] * next[1] - next[0] * current[1]
+        }
+        return area / 2
+    }
+}

package/src/PcbScene3dCopperPrismBuilder.mjs

@@ -0,0 +1,92 @@
+/**
+ * Appends shallow copper-prism triangles to packed position buffers.
+ */
+export class PcbScene3dCopperPrismBuilder {
+    static #COPPER_THICKNESS_MIL = 2.2
+
+    /**
+     * Returns the visual copper extrusion thickness.
+     * @returns {number}
+     */
+    static thicknessMil() {
+        return PcbScene3dCopperPrismBuilder.#COPPER_THICKNESS_MIL
+    }
+
+    /**
+     * Returns half the visual copper extrusion thickness.
+     * @returns {number}
+     */
+    static halfThicknessMil() {
+        return PcbScene3dCopperPrismBuilder.#COPPER_THICKNESS_MIL / 2
+    }
+
+    /**
+     * Appends one shallow triangular prism into the position buffer.
+     * @param {number[]} positions Position buffer.
+     * @param {{ x: number, y: number }} a First point.
+     * @param {{ x: number, y: number }} b Second point.
+     * @param {{ x: number, y: number }} c Third point.
+     * @param {number} z Center Z position.
+     * @returns {void}
+     */
+    static appendTriangle(positions, a, b, c, z) {
+        const halfThickness = PcbScene3dCopperPrismBuilder.halfThicknessMil()
+        const topZ = z + halfThickness
+        const bottomZ = z - halfThickness
+        positions.push(
+            a.x,
+            a.y,
+            topZ,
+            b.x,
+            b.y,
+            topZ,
+            c.x,
+            c.y,
+            topZ,
+            c.x,
+            c.y,
+            bottomZ,
+            b.x,
+            b.y,
+            bottomZ,
+            a.x,
+            a.y,
+            bottomZ
+        )
+    }
+
+    /**
+     * Appends a side wall for one actual copper boundary edge.
+     * @param {number[]} positions Position buffer.
+     * @param {{ x: number, y: number }} start Wall start point.
+     * @param {{ x: number, y: number }} end Wall end point.
+     * @param {number} z Center Z position.
+     * @returns {void}
+     */
+    static appendBoundarySideTriangles(positions, start, end, z) {
+        const halfThickness = PcbScene3dCopperPrismBuilder.halfThicknessMil()
+        const topZ = z + halfThickness
+        const bottomZ = z - halfThickness
+
+        positions.push(
+            start.x,
+            start.y,
+            topZ,
+            end.x,
+            end.y,
+            topZ,
+            end.x,
+            end.y,
+            bottomZ,
+            start.x,
+            start.y,
+            topZ,
+            end.x,
+            end.y,
+            bottomZ,
+            start.x,
+            start.y,
+            bottomZ
+        )
+    }
+}

package/src/PcbScene3dDrillVoidFactory.mjs

@@ -33,15 +33,13 @@ export class PcbScene3dDrillVoidFactory {
             return group
         }
 
-        const material = PcbScene3dDrillVoidFactory.#buildMaterial(
+        const material = PcbScene3dDrillVoidFactory.#buildInteriorMaterial(
             THREE,
             options
         )
         const geometryCache = new Map()
         const depth = Math.max(Math.abs(Number(topZ) - Number(bottomZ)), 1)
         const centerZ = (Number(topZ || 0) + Number(bottomZ || 0)) / 2
-        const platedDrillKeys =
-            PcbScene3dDrillVoidFactory.#buildPlatedDrillKeySet(detail)
         const edgeDrillKeys = PcbScene3dDrillVoidFactory.#buildEdgeDrillKeySet(
             THREE,
             detail,
@@ -52,9 +50,7 @@ export class PcbScene3dDrillVoidFactory {
         PcbScene3dDrillPathFactory.resolveBoardDrillSpecs(detail).forEach(
             (drillSpec) => {
                 if (
-                    platedDrillKeys.has(
-                        PcbScene3dDrillVoidFactory.#drillKey(drillSpec)
-                    ) ||
+                    PcbScene3dDrillVoidFactory.#isSlottedDrill(drillSpec) ||
                     edgeDrillKeys.has(
                         PcbScene3dDrillVoidFactory.#drillKey(drillSpec)
                     )
@@ -101,63 +97,6 @@ export class PcbScene3dDrillVoidFactory {
         )
     }
 
-    /**
-     * Builds a lookup for drill holes that already have copper barrel geometry.
-     * @param {{ pads?: any[], vias?: any[] }} detail
-     * @returns {Set<string>}
-     */
-    static #buildPlatedDrillKeySet(detail) {
-        const platedDrills = new Set()
-
-        for (const via of detail?.vias || []) {
-            if (PcbScene3dDrillVoidFactory.#hasViaCopperAnnulus(via)) {
-                platedDrills.add(PcbScene3dDrillVoidFactory.#drillKey(via))
-            }
-        }
-
-        for (const pad of detail?.pads || []) {
-            if (PcbScene3dDrillVoidFactory.#hasPadCopperAnnulus(pad)) {
-                platedDrills.add(PcbScene3dDrillVoidFactory.#drillKey(pad))
-            }
-        }
-
-        return platedDrills
-    }
-
-    /**
-     * Checks whether one via has a copper annulus around its drill.
-     * @param {any} via Via primitive.
-     * @returns {boolean}
-     */
-    static #hasViaCopperAnnulus(via) {
-        const holeDiameter = Number(via?.holeDiameter || 0)
-        return (
-            holeDiameter > 0 &&
-            Number(via?.diameter || 0) > holeDiameter + 0.001
-        )
-    }
-
-    /**
-     * Checks whether one pad has copper larger than its drill aperture.
-     * @param {any} pad Pad primitive.
-     * @returns {boolean}
-     */
-    static #hasPadCopperAnnulus(pad) {
-        const holeDiameter = Number(pad?.holeDiameter || 0)
-        if (holeDiameter <= 0) {
-            return false
-        }
-
-        return [
-            pad?.sizeTopX,
-            pad?.sizeTopY,
-            pad?.sizeMidX,
-            pad?.sizeMidY,
-            pad?.sizeBottomX,
-            pad?.sizeBottomY
-        ].some((size) => Number(size || 0) > holeDiameter + 0.001)
-    }
-
     /**
      * Builds a stable lookup key for one circular drill.
      * @param {{ x?: number, y?: number, holeDiameter?: number, diameter?: number }} drill
@@ -177,7 +116,7 @@ export class PcbScene3dDrillVoidFactory {
      * @param {{ color?: number }} options
      * @returns {any}
      */
-    static #buildMaterial(THREE, options) {
+    static #buildInteriorMaterial(THREE, options) {
         return new THREE.MeshStandardMaterial({
             color: Number.isInteger(options?.color)
                 ? options.color
@@ -188,6 +127,18 @@ export class PcbScene3dDrillVoidFactory {
         })
     }
 
+    /**
+     * Checks whether one drill is a routed slot.
+     * @param {{ diameter?: number, slotLength?: number | null }} drillSpec Drill spec.
+     * @returns {boolean}
+     */
+    static #isSlottedDrill(drillSpec) {
+        return (
+            Number(drillSpec?.slotLength || 0) >
+            Number(drillSpec?.diameter || 0) + 0.001
+        )
+    }
+
     /**
      * Builds one open circular drill-interior mesh.
      * @param {any} THREE
@@ -208,13 +159,6 @@ export class PcbScene3dDrillVoidFactory {
         material,
         normalizeBoardPoint
     ) {
-        if (
-            Number(drillSpec?.slotLength || 0) >
-            Number(drillSpec?.diameter || 0) + 0.001
-        ) {
-            return null
-        }
-
         const point = normalizeBoardPoint(
             Number(drillSpec?.x || 0),
             Number(drillSpec?.y || 0)

package/src/PcbScene3dExternalModels.mjs

@@ -281,7 +281,8 @@ export class PcbScene3dExternalModels {
             return PcbScene3dExternalModels.#buildBoardAssemblyWrapper(
                 THREE,
                 placement,
-                modelGroup
+                modelGroup,
+                sceneDescription
             )
         }
 
@@ -371,13 +372,25 @@ export class PcbScene3dExternalModels {
      * @param {any} THREE
      * @param {{ positionMil?: { x?: number, y?: number, z?: number }, board?: { widthMil?: number, heightMil?: number, thicknessMil?: number }, sourceFrameScale?: { y?: number } }} placement
      * @param {any} modelGroup
+     * @param {{ sourceFormat?: string } | null | undefined} sceneDescription Scene description.
      * @returns {any}
      */
-    static #buildBoardAssemblyWrapper(THREE, placement, modelGroup) {
+    static #buildBoardAssemblyWrapper(
+        THREE,
+        placement,
+        modelGroup,
+        sceneDescription
+    ) {
         const wrapperGroup = new THREE.Group()
         const positionMil = placement?.positionMil || {}
 
-        PcbScene3dBoardAssemblyPresentation.apply(modelGroup, placement?.board)
+        PcbScene3dBoardAssemblyPresentation.apply(
+            modelGroup,
+            placement?.board,
+            {
+                sourceFormat: sceneDescription?.sourceFormat
+            }
+        )
         PcbScene3dBoardAssemblyTransform.apply(modelGroup, placement)
         wrapperGroup.position.set(
             Number(positionMil.x || 0),

package/src/PcbScene3dGeometryZCompressor.mjs

@@ -9,13 +9,16 @@ export class PcbScene3dGeometryZCompressor {
      * Rewrites mask-covered copper relief below exposed copper height.
      * @param {any | null} mesh Mesh with a position attribute.
      * @param {number} sourceCenterZ Original geometry center Z.
+     * @param {{ centerOffsetMil?: number }} [options] Compression options.
      * @returns {void}
      */
-    static compressMaskCoveredCopperMesh(mesh, sourceCenterZ) {
+    static compressMaskCoveredCopperMesh(mesh, sourceCenterZ, options = {}) {
         PcbScene3dGeometryZCompressor.compressMesh(
             mesh,
             sourceCenterZ,
-            sourceCenterZ + MASK_COVERED_CENTER_OFFSET_MIL,
+            sourceCenterZ +
+                MASK_COVERED_CENTER_OFFSET_MIL +
+                Number(options?.centerOffsetMil || 0),
             MASK_COVERED_THICKNESS_MIL
         )
     }

package/src/PcbScene3dMaskCoveredCopperMaterial.mjs

@@ -6,7 +6,7 @@ import { PcbScene3dMaterialFinish } from './PcbScene3dMaterialFinish.mjs'
 export class PcbScene3dMaskCoveredCopperMaterial {
     static #COPPER_COLOR = 0xd9a61d
     static #DEFAULT_SOLDER_MASK_COLOR = 0x2a5f27
-    static #COPPER_BLEND = 0.2
+    static #COPPER_BLEND = 0.04
 
     /**
      * Builds a mask-covered copper material.