pcb-scene3d-viewer 1.1.20 → 1.1.22

package/package.json

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

package/src/PcbAssemblyBoardSubstrateBuilder.mjs

@@ -145,11 +145,13 @@ export class PcbAssemblyBoardSubstrateBuilder {
      * @returns {number[][][]}
      */
     static #boardHoleLoops(sceneDescription, outer) {
-        const contourLoops =
-            PcbAssemblyBoardSubstrateBuilder.#drillCutoutLoops(sceneDescription)
-        const rawLoops = contourLoops.length
-            ? contourLoops
-            : PcbAssemblyBoardSubstrateBuilder.#primitiveHoleLoops(
+        const primitiveLoops =
+            PcbAssemblyBoardSubstrateBuilder.#primitiveHoleLoops(
+                sceneDescription
+            )
+        const rawLoops = primitiveLoops.length
+            ? primitiveLoops
+            : PcbAssemblyBoardSubstrateBuilder.#drillCutoutLoops(
                   sceneDescription
               )
         const seen = new Set()

package/src/PcbAssemblyGeometryBuilder.mjs

@@ -1,5 +1,6 @@
 import { PcbAssemblyBoardSubstrateBuilder } from './PcbAssemblyBoardSubstrateBuilder.mjs'
 import { PcbAssemblyMeshUtils } from './PcbAssemblyMeshUtils.mjs'
+import { PcbAssemblyPadMeshBuilder } from './PcbAssemblyPadMeshBuilder.mjs'
 
 const COPPER_THICKNESS_MIL = 2.2
 const SILKSCREEN_THICKNESS_MIL = 0.8
@@ -166,19 +167,21 @@ export class PcbAssemblyGeometryBuilder {
         const pads = PcbAssemblyGeometryBuilder.#array(detail.pads)
         for (let index = 0; index < pads.length; index += 1) {
             const pad = pads[index]
-            const topMesh = PcbAssemblyGeometryBuilder.#padMesh(
+            const topMesh = PcbAssemblyPadMeshBuilder.build(
                 'pad-top-' + (index + 1),
                 pad,
                 'top',
                 topZ,
-                COPPER_THICKNESS_MIL
+                COPPER_THICKNESS_MIL,
+                COPPER_COLOR
             )
-            const bottomMesh = PcbAssemblyGeometryBuilder.#padMesh(
+            const bottomMesh = PcbAssemblyPadMeshBuilder.build(
                 'pad-bottom-' + (index + 1),
                 pad,
                 'bottom',
                 bottomZ,
-                COPPER_THICKNESS_MIL
+                COPPER_THICKNESS_MIL,
+                COPPER_COLOR
             )
             if (topMesh) meshes.push(topMesh)
             await progress?.advance?.(
@@ -583,136 +586,6 @@ export class PcbAssemblyGeometryBuilder {
         )
     }
 
-    /**
-     * Builds one pad mesh.
-     * @param {string} name Mesh name.
-     * @param {object} pad Pad primitive.
-     * @param {'top' | 'bottom'} side Pad side.
-     * @param {number} z Center Z.
-     * @param {number} thickness Extrusion thickness.
-     * @returns {object | null}
-     */
-    static #padMesh(name, pad, side, z, thickness) {
-        const size = PcbAssemblyGeometryBuilder.#padSize(pad, side)
-        if (!size) {
-            return null
-        }
-
-        const offset = PcbAssemblyGeometryBuilder.#padOffset(pad, side)
-        const x = Number(pad?.x || 0) + offset.x
-        const y = Number(pad?.y || 0) + offset.y
-        const shape = PcbAssemblyGeometryBuilder.#padShape(pad, side)
-        const isCircle =
-            Math.abs(size.width - size.height) < 0.001 && shape !== 2
-        const mesh = isCircle
-            ? PcbAssemblyMeshUtils.cylinder(name, {
-                  x,
-                  y,
-                  z,
-                  radius: size.width / 2,
-                  height: thickness,
-                  color: COPPER_COLOR
-              })
-            : PcbAssemblyMeshUtils.box(name, {
-                  x,
-                  y,
-                  z,
-                  width: size.width,
-                  depth: size.height,
-                  height: thickness,
-                  color: COPPER_COLOR
-              })
-
-        return PcbAssemblyGeometryBuilder.#rotateMeshAroundZ(
-            mesh,
-            Number(pad?.rotation || 0),
-            x,
-            y
-        )
-    }
-
-    /**
-     * Resolves side-specific pad dimensions.
-     * @param {object} pad Pad primitive.
-     * @param {'top' | 'bottom'} side Pad side.
-     * @returns {{ width: number, height: number } | null}
-     */
-    static #padSize(pad, side) {
-        const prefix = side === 'bottom' ? 'Bottom' : 'Top'
-        let width = PcbAssemblyGeometryBuilder.#firstPositive([
-            pad?.['size' + prefix + 'X']
-        ])
-        let height = PcbAssemblyGeometryBuilder.#firstPositive([
-            pad?.['size' + prefix + 'Y']
-        ])
-
-        if (side === 'top' && !width) {
-            width = PcbAssemblyGeometryBuilder.#firstPositive([
-                pad?.width,
-                pad?.sizeX,
-                pad?.diameter,
-                pad?.sizeMidX,
-                pad?.sizeBottomX
-            ])
-        }
-        if (side === 'top' && !height) {
-            height = PcbAssemblyGeometryBuilder.#firstPositive([
-                pad?.height,
-                pad?.sizeY,
-                pad?.diameter,
-                pad?.sizeMidY,
-                pad?.sizeBottomY,
-                width
-            ])
-        }
-        if (width && !height) {
-            height = width
-        }
-
-        return width && height
-            ? {
-                  width: Math.max(width, 1),
-                  height: Math.max(height, 1)
-              }
-            : null
-    }
-
-    /**
-     * Resolves side-specific pad center offset.
-     * @param {object} pad Pad primitive.
-     * @param {'top' | 'bottom'} side Pad side.
-     * @returns {{ x: number, y: number }}
-     */
-    static #padOffset(pad, side) {
-        const prefix = side === 'bottom' ? 'Bottom' : 'Top'
-
-        return {
-            x: Number(pad?.['offset' + prefix + 'X'] || 0),
-            y: Number(pad?.['offset' + prefix + 'Y'] || 0)
-        }
-    }
-
-    /**
-     * Resolves the renderer pad shape code for one side.
-     * @param {object} pad Pad primitive.
-     * @param {'top' | 'bottom'} side Pad side.
-     * @returns {number}
-     */
-    static #padShape(pad, side) {
-        const prefix = side === 'bottom' ? 'Bottom' : 'Top'
-        const rounded = pad?.['roundedRectShape' + prefix]
-        if (Number.isInteger(Number(rounded))) {
-            return Number(rounded)
-        }
-
-        return Number(
-            pad?.['shape' + prefix] ||
-                pad?.shapeMid ||
-                (side === 'top' ? pad?.shapeBottom : pad?.shapeTop) ||
-                0
-        )
-    }
-
     /**
      * Builds one via mesh.
      * @param {string} name Mesh name.

package/src/PcbAssemblyMeshUtils.mjs

@@ -1,3 +1,5 @@
+import earcut from 'earcut'
+
 const FULL_CIRCLE_DEGREES = 360
 
 /**
@@ -88,6 +90,100 @@ export class PcbAssemblyMeshUtils {
         }
     }
 
+    /**
+     * Builds an extruded polygon mesh with inner cutout loops.
+     * @param {string} name Mesh name.
+     * @param {number[][]} outerPoints Outer polygon points in mils.
+     * @param {number[][][]} holeLoops Inner cutout loops in mils.
+     * @param {number} z Center Z in mils.
+     * @param {number} thickness Extrusion thickness in mils.
+     * @param {number[] | undefined} color Optional RGB color.
+     * @returns {{ name: string, vertices: number[][], faces: number[][], color?: number[] } | null}
+     */
+    static prismWithHoles(
+        name,
+        outerPoints,
+        holeLoops,
+        z,
+        thickness,
+        color = undefined
+    ) {
+        const outer = PcbAssemblyMeshUtils.cleanLoop(outerPoints)
+        const holes = (Array.isArray(holeLoops) ? holeLoops : [])
+            .map((loop) => PcbAssemblyMeshUtils.cleanLoop(loop))
+            .filter((loop) => loop.length >= 3)
+        if (outer.length < 3) {
+            return null
+        }
+        if (!holes.length) {
+            return PcbAssemblyMeshUtils.prism(name, outer, z, thickness, color)
+        }
+
+        const loops = [outer, ...holes]
+        const holeIndexes = []
+        const points = []
+        const flat = []
+        for (const loop of loops) {
+            if (points.length) {
+                holeIndexes.push(points.length)
+            }
+            for (const point of loop) {
+                points.push(point)
+                flat.push(point[0], point[1])
+            }
+        }
+
+        const triangles = earcut(flat, holeIndexes, 2)
+        if (!triangles.length) {
+            return PcbAssemblyMeshUtils.prism(name, outer, z, thickness, color)
+        }
+
+        const halfThickness = Math.max(Number(thickness || 0), 0.001) / 2
+        const bottomZ = Number(z || 0) - halfThickness
+        const topZ = Number(z || 0) + halfThickness
+        const topOffset = points.length
+        const vertices = [
+            ...points.map((point) => [point[0], point[1], bottomZ]),
+            ...points.map((point) => [point[0], point[1], topZ])
+        ]
+        const faces = []
+
+        for (let index = 0; index + 2 < triangles.length; index += 3) {
+            const a = triangles[index]
+            const b = triangles[index + 1]
+            const c = triangles[index + 2]
+            faces.push([c, b, a])
+            faces.push([a + topOffset, b + topOffset, c + topOffset])
+        }
+
+        let loopStart = 0
+        PcbAssemblyMeshUtils.#appendLoopWalls(
+            faces,
+            loopStart,
+            outer.length,
+            topOffset,
+            false
+        )
+        loopStart += outer.length
+        for (const hole of holes) {
+            PcbAssemblyMeshUtils.#appendLoopWalls(
+                faces,
+                loopStart,
+                hole.length,
+                topOffset,
+                true
+            )
+            loopStart += hole.length
+        }
+
+        return {
+            name,
+            vertices,
+            faces,
+            ...(Array.isArray(color) ? { color } : {})
+        }
+    }
+
     /**
      * Builds a cylinder mesh from polygonal rings.
      * @param {string} name Mesh name.
@@ -538,4 +634,25 @@ export class PcbAssemblyMeshUtils {
             .replace(/^-+|-+$/gu, '')
             .slice(0, 80)
     }
+
+    /**
+     * Appends side-wall faces for one loop.
+     * @param {number[][]} faces Mutable face list.
+     * @param {number} start Loop start index.
+     * @param {number} length Loop length.
+     * @param {number} topOffset Top vertex offset.
+     * @param {boolean} reverse Whether to reverse wall orientation.
+     * @returns {void}
+     */
+    static #appendLoopWalls(faces, start, length, topOffset, reverse) {
+        for (let index = 0; index < length; index += 1) {
+            const current = start + index
+            const next = start + ((index + 1) % length)
+            faces.push(
+                reverse
+                    ? [next, current, current + topOffset, next + topOffset]
+                    : [current, next, next + topOffset, current + topOffset]
+            )
+        }
+    }
 }