pcb-scene3d-viewer 1.3.2 → 1.3.4

package/src/PcbScene3dExternalModelRepeatedOwnerPackageCenterRepair.mjs

@@ -41,6 +41,10 @@ export class PcbScene3dExternalModelRepeatedOwnerPackageCenterRepair {
                 sceneDescription,
                 placement
             )
+        if (siblingPlacements.length <= 1) {
+            return
+        }
+
         const packageRecords =
             PcbScene3dExternalModelRepeatedOwnerPackageCenterRepair.#packageRecords(
                 sceneDescription,
@@ -117,11 +121,7 @@ export class PcbScene3dExternalModelRepeatedOwnerPackageCenterRepair {
             String(placement?.projection?.source || '').toLowerCase() ===
                 'model-bounds' &&
             String(placement?.externalModel?.origin || '').toLowerCase() ===
-                'embedded' &&
-            PcbScene3dExternalModelRepeatedOwnerPackageCenterRepair.#siblingPlacements(
-                sceneDescription,
-                placement
-            ).length > 1
+                'embedded'
         )
     }
 
@@ -191,18 +191,29 @@ export class PcbScene3dExternalModelRepeatedOwnerPackageCenterRepair {
      * @returns {{ placement: object, padCenter: { x: number, y: number }, anchorOffset: { x: number, y: number } }[]}
      */
     static #packageRecords(sceneDescription, placements) {
+        // Reuse ownership indexes across the sibling group, while rebuilding
+        // them per application so edits to scene rows remain observable.
+        const componentsByDesignator =
+            PcbScene3dExternalModelRepeatedOwnerPackageCenterRepair.#componentsByDesignator(
+                sceneDescription
+            )
+        const padsByComponent =
+            PcbScene3dExternalModelRepeatedOwnerPackageCenterRepair.#padsByComponent(
+                sceneDescription
+            )
         return (Array.isArray(placements) ? placements : [])
             .map((placement) => {
                 const component =
                     PcbScene3dExternalModelRepeatedOwnerPackageCenterRepair.#resolveComponent(
-                        sceneDescription,
+                        componentsByDesignator,
                         placement
                     )
                 const padCenter =
                     PcbScene3dExternalModelRepeatedOwnerPackageCenterRepair.#ownedPackagePadCenter(
                         sceneDescription,
                         component,
-                        placement
+                        placement,
+                        padsByComponent
                     )
                 if (!padCenter) {
                     return null
@@ -225,9 +236,15 @@ export class PcbScene3dExternalModelRepeatedOwnerPackageCenterRepair {
      * @param {object | null | undefined} sceneDescription Scene description.
      * @param {object | null} component Scene component.
      * @param {object | null | undefined} placement External placement.
+     * @param {Map<number, object[]>} padsByComponent Pads indexed by owner.
      * @returns {{ x: number, y: number } | null}
      */
-    static #ownedPackagePadCenter(sceneDescription, component, placement) {
+    static #ownedPackagePadCenter(
+        sceneDescription,
+        component,
+        placement,
+        padsByComponent
+    ) {
         if (
             !PcbScene3dExternalModelRepeatedOwnerPackageCenterRepair.#isPackageComponent(
                 component
@@ -247,18 +264,12 @@ export class PcbScene3dExternalModelRepeatedOwnerPackageCenterRepair {
             PcbScene3dExternalModelRepeatedOwnerPackageCenterRepair.#isBottomPlacement(
                 placement
             )
-        const points = (
-            Array.isArray(sceneDescription?.detail?.pads)
-                ? sceneDescription.detail.pads
-                : []
-        )
-            .filter(
-                (pad) =>
-                    Number(pad?.componentIndex) === componentIndex &&
-                    PcbScene3dExternalModelRepeatedOwnerPackageCenterRepair.#isSurfacePad(
-                        pad,
-                        isBottom
-                    )
+        const points = (padsByComponent.get(componentIndex) || [])
+            .filter((pad) =>
+                PcbScene3dExternalModelRepeatedOwnerPackageCenterRepair.#isSurfacePad(
+                    pad,
+                    isBottom
+                )
             )
             .map((pad) => ({
                 x: Number(pad?.x || 0) - centerX,
@@ -482,23 +493,58 @@ export class PcbScene3dExternalModelRepeatedOwnerPackageCenterRepair {
     }
 
     /**
-     * Resolves the scene component for one placement.
+     * Indexes scene pads once for all owners in a repeated package group.
+     * @param {object | null | undefined} sceneDescription Scene description.
+     * @returns {Map<number, object[]>}
+     */
+    static #padsByComponent(sceneDescription) {
+        const index = new Map()
+        const pads = Array.isArray(sceneDescription?.detail?.pads)
+            ? sceneDescription.detail.pads
+            : []
+        for (const pad of pads) {
+            const componentIndex = Number(pad?.componentIndex)
+            if (!Number.isFinite(componentIndex)) {
+                continue
+            }
+            let ownedPads = index.get(componentIndex)
+            if (!ownedPads) {
+                ownedPads = []
+                index.set(componentIndex, ownedPads)
+            }
+            ownedPads.push(pad)
+        }
+        return index
+    }
+
+    /**
+     * Indexes the first component for each normalized owner designator.
      * @param {object | null | undefined} sceneDescription Scene description.
+     * @returns {Map<string, object>}
+     */
+    static #componentsByDesignator(sceneDescription) {
+        const index = new Map()
+        const components = Array.isArray(sceneDescription?.components)
+            ? sceneDescription.components
+            : []
+        for (const component of components) {
+            const designator = String(component?.designator || '').trim()
+            if (designator && !index.has(designator)) {
+                index.set(designator, component)
+            }
+        }
+        return index
+    }
+
+    /**
+     * Resolves the scene component for one placement.
+     * @param {Map<string, object>} componentsByDesignator Components indexed by owner.
      * @param {object | null | undefined} placement External placement.
      * @returns {object | null}
      */
-    static #resolveComponent(sceneDescription, placement) {
+    static #resolveComponent(componentsByDesignator, placement) {
         const designator = String(placement?.designator || '').trim()
-        if (!designator || !Array.isArray(sceneDescription?.components)) {
-            return null
-        }
-
-        return (
-            sceneDescription.components.find(
-                (component) =>
-                    String(component?.designator || '').trim() === designator
-            ) || null
-        )
+        return componentsByDesignator.get(designator) || null
     }
 
     /**

package/src/PcbScene3dExternalModelSourceOriginPolicy.mjs

@@ -6,12 +6,13 @@ export class PcbScene3dExternalModelSourceOriginPolicy {
      * Checks whether an explicit owner anchor should keep source-origin repair
      * disabled. Translucent cover-sized bodies use corner-origin STEP data, so
      * they still need the embedded source-origin correction.
-     * @param {{ bodyOpacity?: number | string, modelTransform?: { ownerAnchorOffsetMil?: object }, projection?: { boundsMil?: { width?: number, depth?: number } } }} placement Placement metadata.
+     * @param {{ bodyOpacity?: number | string, modelTransform?: { ownerAnchorOffsetMil?: object, preserveSourceAnchor?: boolean }, projection?: { boundsMil?: { width?: number, depth?: number } } }} placement Placement metadata.
      * @returns {boolean}
      */
     static shouldSkipOwnerAnchoredAdjustment(placement) {
         return (
-            Boolean(placement?.modelTransform?.ownerAnchorOffsetMil) &&
+            (Boolean(placement?.modelTransform?.ownerAnchorOffsetMil) ||
+                placement?.modelTransform?.preserveSourceAnchor === true) &&
             !PcbScene3dExternalModelSourceOriginPolicy.#isTransparentCoverSizedPlacement(
                 placement
             )

package/src/PcbScene3dExternalModels.mjs

@@ -362,7 +362,16 @@ export class PcbScene3dExternalModels {
             viewCompensationGroup
         )
         const modelTransform = placement?.modelTransform || {}
-        const modelRotation = modelTransform.rotationDeg || {}
+        const authoredModelRotation = modelTransform.rotationDeg || {}
+        const modelRotation =
+            PcbScene3dExternalModels.#resolveEmbeddedModelRotation(
+                placement,
+                modelGroup,
+                authoredModelRotation
+            )
+        if (modelRotation !== authoredModelRotation) {
+            modelGroup.userData.scene3dEmbeddedAxisTiltRepair = true
+        }
         const modelOffset =
             PcbScene3dExternalModels.#resolveModelOffset(modelTransform)
         const sourceOriginAdjustment =
@@ -595,6 +604,73 @@ export class PcbScene3dExternalModels {
         }
     }
 
+    /**
+     * Removes a duplicated quarter-turn when the imported STEP assembly has
+     * already exchanged its authored depth and height axes. Native STEP point
+     * envelopes describe pre-assembly coordinates, while OCCT returns the
+     * fully placed mesh, so comparing both frames is required before applying
+     * the separate Altium body tilt.
+     * @param {{ externalModel?: { origin?: string }, projection?: { source?: string, boundsMil?: { depth?: number, height?: number } } }} placement Placement metadata.
+     * @param {{ userData?: { scene3dSourceBoundsMil?: { sizeY?: number, sizeZ?: number } } }} modelGroup Loaded model group.
+     * @param {{ x?: number, y?: number, z?: number }} modelRotation Authored model rotation.
+     * @returns {{ x?: number, y?: number, z?: number }}
+     */
+    static #resolveEmbeddedModelRotation(placement, modelGroup, modelRotation) {
+        const sourceBounds = modelGroup?.userData?.scene3dSourceBoundsMil || {}
+        const projectionBounds = placement?.projection?.boundsMil || {}
+        const sourceY = Math.abs(Number(sourceBounds.sizeY || 0))
+        const sourceZ = Math.abs(Number(sourceBounds.sizeZ || 0))
+        const projectedDepth = Math.abs(Number(projectionBounds.depth || 0))
+        const projectedHeight = Math.abs(Number(projectionBounds.height || 0))
+        const tilt = PcbScene3dExternalModels.#normalizeAngle(modelRotation?.x)
+        const directError =
+            PcbScene3dExternalModels.#relativeDimensionError(
+                sourceY,
+                projectedDepth
+            ) +
+            PcbScene3dExternalModels.#relativeDimensionError(
+                sourceZ,
+                projectedHeight
+            )
+        const exchangedError =
+            PcbScene3dExternalModels.#relativeDimensionError(
+                sourceY,
+                projectedHeight
+            ) +
+            PcbScene3dExternalModels.#relativeDimensionError(
+                sourceZ,
+                projectedDepth
+            )
+
+        if (
+            String(placement?.externalModel?.origin || '').toLowerCase() !==
+                'embedded' ||
+            String(placement?.projection?.source || '').toLowerCase() !==
+                'model-bounds' ||
+            (tilt !== 90 && tilt !== 270) ||
+            Math.min(sourceY, sourceZ, projectedDepth, projectedHeight) <= 0 ||
+            Math.max(projectedDepth, projectedHeight) /
+                Math.min(projectedDepth, projectedHeight) <
+                1.25 ||
+            exchangedError > 0.2 ||
+            directError - exchangedError < 0.5
+        ) {
+            return modelRotation
+        }
+
+        return { ...modelRotation, x: 0 }
+    }
+
+    /**
+     * Measures a scale-independent dimension mismatch.
+     * @param {number} actual Imported dimension.
+     * @param {number} expected Authored dimension.
+     * @returns {number}
+     */
+    static #relativeDimensionError(actual, expected) {
+        return Math.abs(actual - expected) / Math.max(actual, expected, 1)
+    }
+
     /**
      * Checks whether source Z is the model's intentional edge-extension axis
      * instead of a square-package source-origin bias.

package/src/PcbScene3dGeneratedGeometryBuilder.mjs

@@ -0,0 +1,87 @@
+import { PcbScene3dBoardSolderMaskFactory } from './PcbScene3dBoardSolderMaskFactory.mjs'
+import { PcbScene3dCopperDetailGroupBuilder } from './PcbScene3dCopperDetailGroupBuilder.mjs'
+import { PcbScene3dDetailCoordinateNormalizer } from './PcbScene3dDetailCoordinateNormalizer.mjs'
+import { PcbScene3dDrillVoidFactory } from './PcbScene3dDrillVoidFactory.mjs'
+import { PcbScene3dRuntimeBoardMeshes } from './PcbScene3dRuntimeBoardMeshes.mjs'
+
+/** Runs the same exact generated-geometry factories on workers or the caller. */
+export class PcbScene3dGeneratedGeometryBuilder {
+    /**
+     * Builds one independent generated runtime stage.
+     * @param {any} THREE Three.js namespace.
+     * @param {'board' | 'copper'} kind Geometry stage.
+     * @param {object} sceneDescription Normalized scene description.
+     * @returns {any}
+     */
+    static build(THREE, kind, sceneDescription) {
+        const normalizePoint =
+            PcbScene3dDetailCoordinateNormalizer.create(sceneDescription)
+        const board = sceneDescription.board
+        if (kind === 'copper') {
+            return PcbScene3dCopperDetailGroupBuilder.build(
+                THREE,
+                sceneDescription,
+                board.thicknessMil / 2 + 0.05,
+                normalizePoint
+            )
+        }
+        if (kind !== 'board')
+            throw new Error('Unknown generated geometry stage: ' + kind)
+        const group = new THREE.Group()
+        group.add(
+            PcbScene3dRuntimeBoardMeshes.buildBoardMesh(
+                THREE,
+                sceneDescription,
+                normalizePoint
+            )
+        )
+        group.add(
+            PcbScene3dBoardSolderMaskFactory.buildGroup(
+                THREE,
+                sceneDescription,
+                normalizePoint
+            )
+        )
+        group.add(
+            PcbScene3dDrillVoidFactory.buildGroup(
+                THREE,
+                sceneDescription.detail,
+                board.thicknessMil / 2,
+                -board.thicknessMil / 2,
+                normalizePoint,
+                {
+                    enabled: true,
+                    board,
+                    hasBoardAssemblyModel: Boolean(
+                        sceneDescription.boardAssemblyModel
+                    ),
+                    sourceFormat: sceneDescription.sourceFormat
+                }
+            )
+        )
+        group.add(
+            PcbScene3dRuntimeBoardMeshes.buildBoardOutline(
+                THREE,
+                sceneDescription,
+                normalizePoint
+            )
+        )
+        return group
+    }
+
+    /**
+     * Keeps component model payloads outside geometry-worker messages.
+     * @param {object} sceneDescription Normalized scene description.
+     * @returns {object}
+     */
+    static workerInput(sceneDescription) {
+        return {
+            board: sceneDescription.board,
+            detail: sceneDescription.detail,
+            texts: sceneDescription.texts,
+            sourceFormat: sceneDescription.sourceFormat,
+            coordinateSystem: sceneDescription.coordinateSystem,
+            boardAssemblyModel: Boolean(sceneDescription.boardAssemblyModel)
+        }
+    }
+}