pcb-scene3d-viewer 1.1.21 → 1.1.31

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]
+            )
+        }
+    }
 }

package/src/PcbAssemblyModelMeshLoader.mjs

@@ -1,3 +1,5 @@
+import { PcbAssemblyGltfModelMeshParser } from './PcbAssemblyGltfModelMeshParser.mjs'
+import { PcbAssemblyTextModelMeshParser } from './PcbAssemblyTextModelMeshParser.mjs'
 import { PcbScene3dStepLoader } from './PcbScene3dStepLoader.mjs'
 
 /**
@@ -31,6 +33,22 @@ export class PcbAssemblyModelMeshLoader {
             return this.#loadWrlMeshes(model)
         }
 
+        if (format === 'stl') {
+            return await PcbAssemblyTextModelMeshParser.parseStlModel(model)
+        }
+
+        if (format === 'obj') {
+            return await PcbAssemblyTextModelMeshParser.parseObjModel(model)
+        }
+
+        if (format === 'gltf') {
+            return await PcbAssemblyGltfModelMeshParser.parseGltfModel(model)
+        }
+
+        if (format === 'glb') {
+            return await PcbAssemblyGltfModelMeshParser.parseGlbModel(model)
+        }
+
         throw new Error('Unsupported model format: ' + (format || 'unknown'))
     }
 

package/src/PcbAssemblyPadMeshBuilder.mjs

@@ -0,0 +1,394 @@
+import { PcbAssemblyMeshUtils } from './PcbAssemblyMeshUtils.mjs'
+
+const GEOMETRY_EPSILON = 0.001
+
+/**
+ * Builds PCB assembly copper pad meshes.
+ */
+export class PcbAssemblyPadMeshBuilder {
+    /**
+     * Builds one pad mesh for an assembly export.
+     * @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.
+     * @param {number[]} color Mesh color.
+     * @returns {object | null}
+     */
+    static build(name, pad, side, z, thickness, color) {
+        const size = PcbAssemblyPadMeshBuilder.#padSize(pad, side)
+        if (!size) {
+            return null
+        }
+
+        const offset = PcbAssemblyPadMeshBuilder.#padOffset(pad, side)
+        const x = Number(pad?.x || 0) + offset.x
+        const y = Number(pad?.y || 0) + offset.y
+        const shape = PcbAssemblyPadMeshBuilder.#padShape(pad, side)
+        const isCircle =
+            Math.abs(size.width - size.height) < GEOMETRY_EPSILON && shape !== 2
+        const hole = PcbAssemblyPadMeshBuilder.#holeLoop(pad, x, y)
+        const mesh = hole
+            ? PcbAssemblyPadMeshBuilder.#drilledMesh(
+                  name,
+                  x,
+                  y,
+                  size,
+                  isCircle,
+                  hole,
+                  z,
+                  thickness,
+                  color
+              )
+            : PcbAssemblyPadMeshBuilder.#solidMesh(
+                  name,
+                  x,
+                  y,
+                  size,
+                  isCircle,
+                  z,
+                  thickness,
+                  color
+              )
+
+        return PcbAssemblyPadMeshBuilder.#rotateMeshAroundZ(
+            mesh,
+            Number(pad?.rotation || 0),
+            x,
+            y
+        )
+    }
+
+    /**
+     * Builds one solid pad mesh.
+     * @param {string} name Mesh name.
+     * @param {number} x Pad center X.
+     * @param {number} y Pad center Y.
+     * @param {{ width: number, height: number }} size Pad size.
+     * @param {boolean} isCircle Whether the pad is circular.
+     * @param {number} z Center Z.
+     * @param {number} thickness Extrusion thickness.
+     * @param {number[]} color Mesh color.
+     * @returns {object}
+     */
+    static #solidMesh(name, x, y, size, isCircle, z, thickness, color) {
+        return isCircle
+            ? PcbAssemblyMeshUtils.cylinder(name, {
+                  x,
+                  y,
+                  z,
+                  radius: size.width / 2,
+                  height: thickness,
+                  color
+              })
+            : PcbAssemblyMeshUtils.box(name, {
+                  x,
+                  y,
+                  z,
+                  width: size.width,
+                  depth: size.height,
+                  height: thickness,
+                  color
+              })
+    }
+
+    /**
+     * Builds one drilled pad mesh.
+     * @param {string} name Mesh name.
+     * @param {number} x Pad center X.
+     * @param {number} y Pad center Y.
+     * @param {{ width: number, height: number }} size Pad size.
+     * @param {boolean} isCircle Whether the pad is circular.
+     * @param {number[][]} hole Hole loop.
+     * @param {number} z Center Z.
+     * @param {number} thickness Extrusion thickness.
+     * @param {number[]} color Mesh color.
+     * @returns {object | null}
+     */
+    static #drilledMesh(name, x, y, size, isCircle, hole, z, thickness, color) {
+        if (
+            PcbAssemblyPadMeshBuilder.#holeConsumesPad(
+                x,
+                y,
+                size,
+                isCircle,
+                hole
+            )
+        ) {
+            return null
+        }
+
+        const outer = isCircle
+            ? PcbAssemblyMeshUtils.circlePoints(x, y, size.width / 2, 32)
+            : PcbAssemblyPadMeshBuilder.#rectanglePoints(x, y, size)
+
+        return PcbAssemblyMeshUtils.prismWithHoles(
+            name,
+            outer,
+            [hole],
+            z,
+            thickness,
+            color
+        )
+    }
+
+    /**
+     * Returns true when a drill leaves no meaningful copper surface.
+     * @param {number} x Pad center X.
+     * @param {number} y Pad center Y.
+     * @param {{ width: number, height: number }} size Pad size.
+     * @param {boolean} isCircle Whether the pad is circular.
+     * @param {number[][]} hole Hole loop.
+     * @returns {boolean}
+     */
+    static #holeConsumesPad(x, y, size, isCircle, hole) {
+        if (isCircle) {
+            const outerRadius = Math.min(size.width, size.height) / 2
+            const innerRadius = hole.reduce(
+                (minRadius, point) =>
+                    Math.min(minRadius, Math.hypot(point[0] - x, point[1] - y)),
+                Infinity
+            )
+            return innerRadius >= outerRadius - GEOMETRY_EPSILON
+        }
+
+        const outerArea = Math.max(size.width, 0) * Math.max(size.height, 0)
+        const holeArea = Math.abs(PcbAssemblyPadMeshBuilder.#polygonArea(hole))
+        return holeArea >= outerArea - GEOMETRY_EPSILON
+    }
+
+    /**
+     * Builds a drill loop when a pad has a usable hole.
+     * @param {object} pad Pad primitive.
+     * @param {number} x Pad center X.
+     * @param {number} y Pad center Y.
+     * @returns {number[][] | null}
+     */
+    static #holeLoop(pad, x, y) {
+        const diameter = PcbAssemblyPadMeshBuilder.#firstPositive([
+            pad?.holeDiameter,
+            pad?.drillDiameter,
+            pad?.holeSize,
+            pad?.drill,
+            pad?.holeGeometry?.diameter,
+            pad?.holeGeometry?.width
+        ])
+        if (!diameter) {
+            return null
+        }
+
+        const slotLength = PcbAssemblyPadMeshBuilder.#firstPositive([
+            pad?.holeSlotLength,
+            pad?.slotLength,
+            pad?.holeGeometry?.slotLength,
+            pad?.holeGeometry?.length
+        ])
+        if (slotLength > diameter + GEOMETRY_EPSILON) {
+            return PcbAssemblyPadMeshBuilder.#rotatedPoints(
+                PcbAssemblyMeshUtils.capsulePoints(
+                    x - (slotLength - diameter) / 2,
+                    y,
+                    x + (slotLength - diameter) / 2,
+                    y,
+                    diameter / 2
+                ),
+                x,
+                y,
+                Number(pad?.holeRotation ?? pad?.rotation ?? 0) -
+                    Number(pad?.rotation || 0)
+            )
+        }
+
+        return PcbAssemblyMeshUtils.circlePoints(x, y, diameter / 2, 24)
+    }
+
+    /**
+     * 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 = PcbAssemblyPadMeshBuilder.#firstPositive([
+            pad?.['size' + prefix + 'X']
+        ])
+        let height = PcbAssemblyPadMeshBuilder.#firstPositive([
+            pad?.['size' + prefix + 'Y']
+        ])
+
+        if (side === 'top' && !width) {
+            width = PcbAssemblyPadMeshBuilder.#firstPositive([
+                pad?.width,
+                pad?.sizeX,
+                pad?.diameter,
+                pad?.sizeMidX,
+                pad?.sizeBottomX
+            ])
+        }
+        if (side === 'top' && !height) {
+            height = PcbAssemblyPadMeshBuilder.#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 rectangle points for an axis-aligned pad.
+     * @param {number} x Center X.
+     * @param {number} y Center Y.
+     * @param {{ width: number, height: number }} size Pad size.
+     * @returns {number[][]}
+     */
+    static #rectanglePoints(x, y, size) {
+        const halfWidth = size.width / 2
+        const halfHeight = size.height / 2
+        return [
+            [x - halfWidth, y - halfHeight],
+            [x + halfWidth, y - halfHeight],
+            [x + halfWidth, y + halfHeight],
+            [x - halfWidth, y + halfHeight]
+        ]
+    }
+
+    /**
+     * Rotates points around a center.
+     * @param {number[][]} points Source points.
+     * @param {number} centerX Center X.
+     * @param {number} centerY Center Y.
+     * @param {number} rotationDeg Rotation in degrees.
+     * @returns {number[][]}
+     */
+    static #rotatedPoints(points, centerX, centerY, rotationDeg) {
+        if (Math.abs(Number(rotationDeg || 0)) < GEOMETRY_EPSILON) {
+            return points
+        }
+
+        const angle = (Number(rotationDeg || 0) * Math.PI) / 180
+        const cos = Math.cos(angle)
+        const sin = Math.sin(angle)
+        return points.map((point) => {
+            const dx = point[0] - centerX
+            const dy = point[1] - centerY
+            return [
+                centerX + dx * cos - dy * sin,
+                centerY + dx * sin + dy * cos
+            ]
+        })
+    }
+
+    /**
+     * Calculates polygon area using the shoelace formula.
+     * @param {number[][]} points Polygon points.
+     * @returns {number}
+     */
+    static #polygonArea(points) {
+        let area = 0
+        for (let index = 0; index < points.length; index += 1) {
+            const point = points[index]
+            const next = points[(index + 1) % points.length]
+            area += point[0] * next[1] - next[0] * point[1]
+        }
+
+        return area / 2
+    }
+
+    /**
+     * Rotates one mesh around a Z-axis origin.
+     * @param {object | null} mesh Mesh to rotate.
+     * @param {number} rotationDeg Rotation angle.
+     * @param {number} originX Origin X.
+     * @param {number} originY Origin Y.
+     * @returns {object | null}
+     */
+    static #rotateMeshAroundZ(mesh, rotationDeg, originX, originY) {
+        if (!mesh || Math.abs(Number(rotationDeg || 0)) < GEOMETRY_EPSILON) {
+            return mesh
+        }
+
+        const rotationRad = (Number(rotationDeg || 0) * Math.PI) / 180
+        const cos = Math.cos(rotationRad)
+        const sin = Math.sin(rotationRad)
+
+        return {
+            ...mesh,
+            vertices: mesh.vertices.map((vertex) => {
+                const dx = Number(vertex[0] || 0) - originX
+                const dy = Number(vertex[1] || 0) - originY
+                return [
+                    originX + dx * cos - dy * sin,
+                    originY + dx * sin + dy * cos,
+                    Number(vertex[2] || 0)
+                ]
+            })
+        }
+    }
+
+    /**
+     * Returns the first positive finite number.
+     * @param {unknown[]} values Candidate values.
+     * @returns {number}
+     */
+    static #firstPositive(values) {
+        for (const value of values) {
+            const number = Number(value)
+            if (Number.isFinite(number) && number > 0) {
+                return number
+            }
+        }
+
+        return 0
+    }
+}

package/src/PcbAssemblyStepWriter.mjs

@@ -739,17 +739,39 @@ export class PcbAssemblyStepWriter {
     }
 
     /**
-     * Returns clamped RGB components for one mesh color.
+     * Returns display-space RGB components for one mesh color.
      * @param {number[] | undefined} color Mesh RGB color.
      * @returns {number[]}
      */
     static #colorComponents(color) {
         const normalized = Array.isArray(color) ? color : [0.55, 0.56, 0.58]
         return [0, 1, 2].map((index) =>
-            Math.max(Math.min(Number(normalized[index] || 0), 1), 0)
+            PcbAssemblyStepWriter.#linearToSrgb(
+                PcbAssemblyStepWriter.#clampColorChannel(normalized[index])
+            )
         )
     }
 
+    /**
+     * Clamps one color channel to the STEP RGB range.
+     * @param {unknown} value Candidate color channel.
+     * @returns {number}
+     */
+    static #clampColorChannel(value) {
+        return Math.max(Math.min(Number(value || 0), 1), 0)
+    }
+
+    /**
+     * Converts one linear RGB channel to display-space sRGB.
+     * @param {number} value Linear RGB channel.
+     * @returns {number}
+     */
+    static #linearToSrgb(value) {
+        return value <= 0.0031308
+            ? value * 12.92
+            : 1.055 * Math.pow(value, 1 / 2.4) - 0.055
+    }
+
     /**
      * Tests whether a vertex has finite coordinates.
      * @param {unknown} vertex Candidate vertex.