pcb-scene3d-viewer 1.1.11 → 1.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pcb-scene3d-viewer",
-    "version": "1.1.11",
+    "version": "1.1.18",
     "description": "Reusable Three.js PCB 3D scene viewer for normalized ECAD and CircuitJSON scene descriptions",
     "keywords": [
         "pcb",

package/src/PcbScene3dPadFactory.mjs

@@ -29,7 +29,10 @@ export class PcbScene3dPadFactory {
             color: 0xd9a61d,
             roughness: 0.38,
             metalness: 0.55,
-            side: THREE.DoubleSide
+            side: THREE.DoubleSide,
+            polygonOffset: true,
+            polygonOffsetFactor: -2,
+            polygonOffsetUnits: -2
         })
         const geometryCache = new Map()
         const side = PcbScene3dPadFactory.#normalizeSide(options?.side)
@@ -500,7 +503,7 @@ export class PcbScene3dPadFactory {
      * @returns {{ shape: any, shapeHoleCutouts: { x: number, y: number, diameter: number, slotLength?: number | null, rotationDeg?: number | null }[], clippingCutouts: { x: number, y: number }[][] }}
      */
     static #buildShapeCutoutPlan(THREE, spec, drillCutouts) {
-        const baseShape = PcbScene3dPadFactory.#buildOuterShape(THREE, spec)
+        let baseShape = PcbScene3dPadFactory.#buildOuterShape(THREE, spec)
         if (!drillCutouts.length) {
             return {
                 shape: baseShape,
@@ -509,7 +512,7 @@ export class PcbScene3dPadFactory {
             }
         }
 
-        const contourPoints =
+        let contourPoints =
             PcbScene3dBoardEdgeCutoutBuilder.resolveShapePoints(baseShape)
         const shapeHoleCutouts = []
         const clippingCutouts = []
@@ -529,6 +532,30 @@ export class PcbScene3dPadFactory {
                 continue
             }
 
+            const circularCutout =
+                PcbScene3dPadFactory.#resolveCircularDrillCutout(drillCutout)
+            if (circularCutout) {
+                const notchedContour =
+                    PcbScene3dBoardEdgeCutoutBuilder.applyCircularEdgeCutouts(
+                        contourPoints,
+                        [circularCutout]
+                    )
+                if (
+                    !PcbScene3dPadFactory.#sameContourPoints(
+                        contourPoints,
+                        notchedContour
+                    )
+                ) {
+                    contourPoints = notchedContour
+                    baseShape =
+                        PcbScene3dBoardEdgeCutoutBuilder.buildShapeFromPoints(
+                            THREE,
+                            contourPoints
+                        )
+                    continue
+                }
+            }
+
             clippingCutouts.push(cutoutPoints)
         }
 
@@ -559,6 +586,30 @@ export class PcbScene3dPadFactory {
         }
     }
 
+    /**
+     * Checks whether two sampled contours have the same vertices.
+     * @param {{ x: number, y: number }[]} first
+     * @param {{ x: number, y: number }[]} second
+     * @returns {boolean}
+     */
+    static #sameContourPoints(first, second) {
+        if (!Array.isArray(first) || !Array.isArray(second)) {
+            return false
+        }
+
+        if (first.length !== second.length) {
+            return false
+        }
+
+        return first.every(
+            (point, index) =>
+                Math.hypot(
+                    Number(point?.x || 0) - Number(second[index]?.x || 0),
+                    Number(point?.y || 0) - Number(second[index]?.y || 0)
+                ) <= 0.001
+        )
+    }
+
     /**
      * Resolves polygon points for one local drill cutout.
      * @param {any} THREE

package/src/PcbScene3dPadSurfaceStack.mjs

@@ -3,13 +3,15 @@
  */
 export class PcbScene3dPadSurfaceStack {
     static #COPLANAR_PAD_LIFT_MIL = 0.04
+    static #SURFACE_Z_PRIORITY_DEFAULT = 0
+    static #SURFACE_Z_PRIORITY_DRILLED = 1
 
     /**
      * Resolves a small lift for a pad face that overlaps previous pad faces.
-     * @param {{ bounds: { minX: number, maxX: number, minY: number, maxY: number }, zIndex: number }[]} stack
+     * @param {{ bounds: { minX: number, maxX: number, minY: number, maxY: number }, zIndex: number, priority?: number }[]} stack
      * @param {{ x: number, y: number }} point Normalized pad anchor.
-     * @param {{ rotation?: number | null }} pad Source pad.
-     * @param {{ width: number, height: number, kind: 'circle' | 'rect' | 'rounded-rect', radius: number, offsetX: number, offsetY: number }} spec Pad face spec.
+     * @param {{ rotation?: number | null, holeDiameter?: number | null }} pad Source pad.
+     * @param {{ width: number, height: number, kind: 'circle' | 'rect' | 'rounded-rect', radius: number, offsetX: number, offsetY: number, hasHole?: boolean, holeDiameter?: number | null }} spec Pad face spec.
      * @param {boolean} mirrorY Whether underside coordinates are mirrored.
      * @returns {number}
      */
@@ -20,23 +22,50 @@ export class PcbScene3dPadSurfaceStack {
             spec,
             mirrorY
         )
-        let zIndex = 0
+        const priority = PcbScene3dPadSurfaceStack.#resolveSurfacePriority(
+            pad,
+            spec
+        )
+        let zIndex = priority
 
         for (const previous of stack) {
             if (
                 PcbScene3dPadSurfaceStack.#boundsOverlap(
                     surface.bounds,
                     previous.bounds
-                )
+                ) &&
+                priority >=
+                    Number(
+                        previous.priority ??
+                            PcbScene3dPadSurfaceStack
+                                .#SURFACE_Z_PRIORITY_DEFAULT
+                    )
             ) {
                 zIndex = Math.max(zIndex, previous.zIndex + 1)
             }
         }
 
-        stack.push({ bounds: surface.bounds, zIndex })
+        stack.push({ bounds: surface.bounds, zIndex, priority })
         return zIndex * PcbScene3dPadSurfaceStack.#COPLANAR_PAD_LIFT_MIL
     }
 
+    /**
+     * Resolves stable visual priority for overlapping pad surfaces.
+     * @param {{ holeDiameter?: number | null }} pad Source pad.
+     * @param {{ hasHole?: boolean, holeDiameter?: number | null }} spec Pad face spec.
+     * @returns {number}
+     */
+    static #resolveSurfacePriority(pad, spec) {
+        if (
+            spec?.hasHole === true ||
+            Number(spec?.holeDiameter || pad?.holeDiameter || 0) > 0
+        ) {
+            return PcbScene3dPadSurfaceStack.#SURFACE_Z_PRIORITY_DRILLED
+        }
+
+        return PcbScene3dPadSurfaceStack.#SURFACE_Z_PRIORITY_DEFAULT
+    }
+
     /**
      * Resolves the projected board-space footprint for one pad face.
      * @param {{ x: number, y: number }} point Normalized pad anchor.

package/src/PcbScene3dShapeHoleMerger.mjs

@@ -205,8 +205,8 @@ export class PcbScene3dShapeHoleMerger {
 
         for (const point of Array.isArray(points) ? points : []) {
             const normalizedPoint = {
-                x: Number(point?.x),
-                y: Number(point?.y)
+                x: PcbScene3dShapeHoleMerger.#snapCoordinate(point?.x),
+                y: PcbScene3dShapeHoleMerger.#snapCoordinate(point?.y)
             }
 
             if (
@@ -228,6 +228,17 @@ export class PcbScene3dShapeHoleMerger {
         return uniquePoints
     }
 
+    /**
+     * Snaps one coordinate to the duplicate-detection precision.
+     * @param {unknown} value Coordinate value.
+     * @returns {number}
+     */
+    static #snapCoordinate(value) {
+        const number = Number(value)
+
+        return Number.isFinite(number) ? Number(number.toFixed(6)) : number
+    }
+
     /**
      * Builds an axis-aligned polygon bounds box.
      * @param {{ x: number, y: number }[]} polygon Source polygon.