altium-toolkit 1.1.35 → 1.1.37

package/src/ui/PcbScene3dStaticBodyPadOwnerPromotion.mjs

@@ -0,0 +1,378 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/**
+ * Promotes compact static bodies that sit exactly on component-owned pads.
+ */
+export class PcbScene3dStaticBodyPadOwnerPromotion {
+    static #PAD_OWNER_DISTANCE_MIL = 5
+    static #PAD_OWNER_AMBIGUITY_MARGIN_MIL = 0.25
+    static #COMPACT_BODY_MAX_SPAN_MIL = 40
+    static #AUTHORED_MECHANICAL_TOKENS = new Set([
+        'can',
+        'clip',
+        'cover',
+        'enclosure',
+        'frame',
+        'hardware',
+        'leg',
+        'mechanical',
+        'plate',
+        'shield'
+    ])
+
+    /**
+     * Applies exact pad ownership to mutable static placement rows.
+     * @param {{ placement: object, matchedComponent: object | null }[]} placementRows Mutable placement rows.
+     * @param {{ componentIndex?: number, designator?: string, layer?: string }[]} components PCB components.
+     * @param {{ componentIndex?: number, x?: number, y?: number, hasTopPasteMaskOpening?: boolean, hasBottomPasteMaskOpening?: boolean }[]} pads PCB pads.
+     * @returns {void}
+     */
+    static promote(placementRows, components = [], pads = []) {
+        const componentByIndex =
+            PcbScene3dStaticBodyPadOwnerPromotion.#componentByIndex(components)
+
+        placementRows.forEach((row) => {
+            if (!PcbScene3dStaticBodyPadOwnerPromotion.#canPromoteRow(row)) {
+                return
+            }
+
+            const owner =
+                PcbScene3dStaticBodyPadOwnerPromotion.#padOwnerForPlacement(
+                    row.placement,
+                    componentByIndex,
+                    pads
+                )
+            if (!owner) {
+                return
+            }
+
+            row.matchedComponent = owner
+            row.placement = PcbScene3dStaticBodyPadOwnerPromotion.#withOwner(
+                row.placement,
+                owner
+            )
+        })
+    }
+
+    /**
+     * Builds a component-index lookup.
+     * @param {object[]} components PCB components.
+     * @returns {Map<number, object>}
+     */
+    static #componentByIndex(components) {
+        const componentByIndex = new Map()
+
+        ;(Array.isArray(components) ? components : []).forEach((component) => {
+            const componentIndex = Number(component?.componentIndex)
+            if (
+                Number.isInteger(componentIndex) &&
+                String(component?.designator || '').trim()
+            ) {
+                componentByIndex.set(componentIndex, component)
+            }
+        })
+
+        return componentByIndex
+    }
+
+    /**
+     * Checks whether one static row is eligible for exact pad ownership.
+     * @param {{ placement?: object } | null} row Static placement row.
+     * @returns {boolean}
+     */
+    static #canPromoteRow(row) {
+        const placement = row?.placement
+
+        return (
+            placement &&
+            !placement.ownerLocked &&
+            !PcbScene3dStaticBodyPadOwnerPromotion.#hasAuthoredMechanicalIdentity(
+                placement
+            ) &&
+            PcbScene3dStaticBodyPadOwnerPromotion.#maxSpan(
+                placement.geometry
+            ) <=
+                PcbScene3dStaticBodyPadOwnerPromotion.#COMPACT_BODY_MAX_SPAN_MIL
+        )
+    }
+
+    /**
+     * Resolves the unique component whose surface pad owns a body anchor.
+     * @param {{ bodyPositionMil?: { x?: number, y?: number } }} placement Static placement.
+     * @param {Map<number, object>} componentByIndex Component lookup.
+     * @param {object[]} pads PCB pads.
+     * @returns {object | null}
+     */
+    static #padOwnerForPlacement(placement, componentByIndex, pads) {
+        const position =
+            PcbScene3dStaticBodyPadOwnerPromotion.#bodyPosition(placement)
+        if (!position) {
+            return null
+        }
+
+        const candidates = (Array.isArray(pads) ? pads : [])
+            .map((pad) =>
+                PcbScene3dStaticBodyPadOwnerPromotion.#padOwnerCandidate(
+                    pad,
+                    position,
+                    componentByIndex
+                )
+            )
+            .filter(Boolean)
+            .sort((left, right) => left.distance - right.distance)
+
+        return PcbScene3dStaticBodyPadOwnerPromotion.#unambiguousOwner(
+            candidates
+        )
+    }
+
+    /**
+     * Builds one exact pad-owner candidate.
+     * @param {object} pad PCB pad.
+     * @param {{ x: number, y: number }} position Body source position.
+     * @param {Map<number, object>} componentByIndex Component lookup.
+     * @returns {{ component: object, distance: number } | null}
+     */
+    static #padOwnerCandidate(pad, position, componentByIndex) {
+        const component = componentByIndex.get(Number(pad?.componentIndex))
+        if (
+            !component ||
+            !PcbScene3dStaticBodyPadOwnerPromotion.#isSurfacePadForComponent(
+                pad,
+                component
+            )
+        ) {
+            return null
+        }
+
+        const distance = Math.hypot(
+            Number(pad?.x || 0) - position.x,
+            Number(pad?.y || 0) - position.y
+        )
+
+        return Number.isFinite(distance) &&
+            distance <=
+                PcbScene3dStaticBodyPadOwnerPromotion.#PAD_OWNER_DISTANCE_MIL
+            ? { component, distance }
+            : null
+    }
+
+    /**
+     * Resolves an unambiguous owner from pad-distance candidates.
+     * @param {{ component: object, distance: number }[]} candidates Candidates.
+     * @returns {object | null}
+     */
+    static #unambiguousOwner(candidates) {
+        const nearest = candidates[0]
+        if (!nearest) {
+            return null
+        }
+
+        const nextDifferentOwner = candidates.find(
+            (candidate) =>
+                String(candidate.component?.designator || '') !==
+                String(nearest.component?.designator || '')
+        )
+
+        return nextDifferentOwner &&
+            nextDifferentOwner.distance - nearest.distance <=
+                PcbScene3dStaticBodyPadOwnerPromotion
+                    .#PAD_OWNER_AMBIGUITY_MARGIN_MIL
+            ? null
+            : nearest.component
+    }
+
+    /**
+     * Resolves the static body source position.
+     * @param {{ bodyPositionMil?: { x?: number, y?: number } }} placement Static placement.
+     * @returns {{ x: number, y: number } | null}
+     */
+    static #bodyPosition(placement) {
+        const x = Number(placement?.bodyPositionMil?.x)
+        const y = Number(placement?.bodyPositionMil?.y)
+
+        return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : null
+    }
+
+    /**
+     * Checks whether a pad belongs to the component's mounted PCB face.
+     * @param {object} pad PCB pad.
+     * @param {{ layer?: string }} component PCB component.
+     * @returns {boolean}
+     */
+    static #isSurfacePadForComponent(pad, component) {
+        return PcbScene3dStaticBodyPadOwnerPromotion.#componentMountSide(
+            component
+        ) === 'bottom'
+            ? Boolean(pad?.hasBottomPasteMaskOpening)
+            : Boolean(pad?.hasTopPasteMaskOpening)
+    }
+
+    /**
+     * Applies a component owner to a placement.
+     * @param {object} placement Static placement.
+     * @param {{ designator?: string, layer?: string }} owner Owner component.
+     * @returns {object}
+     */
+    static #withOwner(placement, owner) {
+        return {
+            ...PcbScene3dStaticBodyPadOwnerPromotion.#withMountSide(
+                placement,
+                PcbScene3dStaticBodyPadOwnerPromotion.#componentMountSide(owner)
+            ),
+            designator:
+                String(owner?.designator || '').trim() || placement?.designator
+        }
+    }
+
+    /**
+     * Applies a mount side while preserving the placement's XY anchor.
+     * @param {object} placement Static placement.
+     * @param {string | undefined} mountSide Owner mount side.
+     * @returns {object}
+     */
+    static #withMountSide(placement, mountSide) {
+        const currentSide =
+            PcbScene3dStaticBodyPadOwnerPromotion.#normalizeMountSide(
+                placement?.mountSide
+            )
+        const side = PcbScene3dStaticBodyPadOwnerPromotion.#normalizeMountSide(
+            mountSide || currentSide
+        )
+        const z = Math.abs(Number(placement?.positionMil?.z || 0))
+
+        return {
+            ...placement,
+            mountSide: side,
+            positionMil: {
+                ...(placement?.positionMil || {}),
+                z: side === 'bottom' ? -z : z
+            },
+            geometry:
+                currentSide === side
+                    ? placement?.geometry
+                    : PcbScene3dStaticBodyPadOwnerPromotion.#mirrorGeometry(
+                          placement
+                      )
+        }
+    }
+
+    /**
+     * Resolves the board side from one component layer.
+     * @param {{ layer?: string }} component PCB component.
+     * @returns {'top' | 'bottom'}
+     */
+    static #componentMountSide(component) {
+        return String(component?.layer || '')
+            .trim()
+            .toLowerCase()
+            .includes('bottom')
+            ? 'bottom'
+            : 'top'
+    }
+
+    /**
+     * Normalizes a mount-side token.
+     * @param {string | undefined} mountSide Candidate side.
+     * @returns {'top' | 'bottom'}
+     */
+    static #normalizeMountSide(mountSide) {
+        return String(mountSide || 'top')
+            .trim()
+            .toLowerCase() === 'bottom'
+            ? 'bottom'
+            : 'top'
+    }
+
+    /**
+     * Mirrors source-coordinate polygon geometry for a side change.
+     * @param {{ sourceCoordinateFrame?: boolean, geometry?: object }} placement Static placement.
+     * @returns {object | undefined}
+     */
+    static #mirrorGeometry(placement) {
+        const geometry = placement?.geometry
+        if (
+            !placement?.sourceCoordinateFrame ||
+            !Array.isArray(geometry?.verticesMil)
+        ) {
+            return geometry
+        }
+
+        return {
+            ...geometry,
+            verticesMil: geometry.verticesMil.map((vertex) => ({
+                x: PcbScene3dStaticBodyPadOwnerPromotion.#roundMil(
+                    Number(vertex?.x || 0)
+                ),
+                y: PcbScene3dStaticBodyPadOwnerPromotion.#roundMil(
+                    -Number(vertex?.y || 0)
+                )
+            }))
+        }
+    }
+
+    /**
+     * Checks whether a placement identity names authored board mechanics.
+     * @param {{ designator?: string, sourceIdentityKey?: string } | null} placement Static placement.
+     * @returns {boolean}
+     */
+    static #hasAuthoredMechanicalIdentity(placement) {
+        return PcbScene3dStaticBodyPadOwnerPromotion.#identityTokens(
+            placement
+        ).some((token) =>
+            PcbScene3dStaticBodyPadOwnerPromotion.#AUTHORED_MECHANICAL_TOKENS.has(
+                token
+            )
+        )
+    }
+
+    /**
+     * Collects normalized identity tokens from one placement.
+     * @param {{ designator?: string, sourceIdentityKey?: string } | null} placement Static placement.
+     * @returns {string[]}
+     */
+    static #identityTokens(placement) {
+        return [placement?.designator, placement?.sourceIdentityKey]
+            .join(' ')
+            .replace(/([a-z])([A-Z])/gu, '$1 $2')
+            .toLowerCase()
+            .split(/[^a-z0-9]+/g)
+            .flatMap((fragment) => fragment.match(/[a-z]+|\d+/g) || [])
+            .filter(Boolean)
+    }
+
+    /**
+     * Resolves the largest horizontal body span.
+     * @param {object | undefined} geometry Static geometry.
+     * @returns {number}
+     */
+    static #maxSpan(geometry) {
+        const vertices = Array.isArray(geometry?.verticesMil)
+            ? geometry.verticesMil
+            : []
+        if (vertices.length) {
+            const xs = vertices.map((vertex) => Number(vertex?.x || 0))
+            const ys = vertices.map((vertex) => Number(vertex?.y || 0))
+
+            return Math.max(
+                Math.max(...xs) - Math.min(...xs),
+                Math.max(...ys) - Math.min(...ys)
+            )
+        }
+
+        const radius = Number(geometry?.radiusMil)
+        return Number.isFinite(radius) && radius > 0 ? radius * 2 : 0
+    }
+
+    /**
+     * Rounds one mil value for stable promoted geometry output.
+     * @param {number} value Candidate value.
+     * @returns {number}
+     */
+    static #roundMil(value) {
+        const rounded = Math.round(Number(value) * 10000) / 10000
+        return Object.is(rounded, -0) ? 0 : rounded
+    }
+}

package/src/ui/PcbScene3dStaticBodyPlacementBuilder.mjs

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 import { PcbScene3dPlacementSideResolver } from './PcbScene3dPlacementSideResolver.mjs'
+import { PcbScene3dStaticBodyOwnerPromotion } from './PcbScene3dStaticBodyOwnerPromotion.mjs'
 import { PcbScene3dStaticBodyRecovery } from './PcbScene3dStaticBodyRecovery.mjs'
 import { PcbScene3dStaticBodySelectionKeyBuilder } from './PcbScene3dStaticBodySelectionKeyBuilder.mjs'
 
@@ -21,6 +22,7 @@ export class PcbScene3dStaticBodyPlacementBuilder {
     static #SOURCE_COORDINATE_MIRROR_MIN_OFFSET_MIL = 20
     static #GENERIC_MECHANICAL_IDENTITY_TOKENS = new Set([
         'can',
+        'clip',
         'cover',
         'enclosure',
         'frame',
@@ -39,7 +41,7 @@ export class PcbScene3dStaticBodyPlacementBuilder {
      * @param {{ x: number, y: number, sizeTopX?: number, sizeTopY?: number, sizeMidX?: number, sizeMidY?: number, sizeBottomX?: number, sizeBottomY?: number }[]} pads Pads.
      * @param {{ centerX: number, centerY: number, minX?: number, minY?: number, widthMil?: number, heightMil?: number }} board Board.
      * @param {number} thicknessMil Board thickness.
-     * @returns {{ designator: string, selectionKey: string, sourceIdentityKey: string, mountSide: string, rotationDeg: number, positionMil: { x: number, y: number, z: number }, bodyPositionMil: { x: number, y: number }, geometry: object }[]}
+     * @returns {{ designator: string, selectionKey: string, sourceIdentityKey: string, mountSide: string, rotationDeg: number, positionMil: { x: number, y: number, z: number }, bodyPositionMil: { x: number, y: number }, ownerLocked?: boolean, geometry: object }[]}
      */
     static build(
         componentBodies,
@@ -66,16 +68,14 @@ export class PcbScene3dStaticBodyPlacementBuilder {
             )
             .filter(Boolean)
 
-        return PcbScene3dStaticBodySelectionKeyBuilder.assign(placementRows)
-    }
+        PcbScene3dStaticBodyOwnerPromotion.promote(
+            placementRows,
+            components,
+            board,
+            pads
+        )
 
-    /**
-     * Checks whether one static geometry is already complete.
-     * @param {object | undefined} geometry Static geometry.
-     * @returns {boolean}
-     */
-    static #isCompleteGeometry(geometry) {
-        return Boolean(geometry && geometry.status === 'complete')
+        return PcbScene3dStaticBodySelectionKeyBuilder.assign(placementRows)
     }
 
     /**
@@ -85,7 +85,7 @@ export class PcbScene3dStaticBodyPlacementBuilder {
      * @param {{ designator: string, x: number, y: number, layer?: string, pattern?: string, source?: string, modelPath?: string }[]} components Components.
      * @param {{ centerX: number, centerY: number, minX?: number, minY?: number, widthMil?: number, heightMil?: number }} board Board.
      * @param {number} thicknessMil Board thickness.
-     * @returns {{ placement: { designator: string, sourceIdentityKey: string, mountSide: string, rotationDeg: number, positionMil: { x: number, y: number, z: number }, bodyPositionMil: { x: number, y: number }, geometry: object }, matchedComponent: object | null } | null}
+     * @returns {{ placement: { designator: string, sourceIdentityKey: string, mountSide: string, rotationDeg: number, positionMil: { x: number, y: number, z: number }, bodyPositionMil: { x: number, y: number }, ownerLocked?: boolean, geometry: object }, matchedComponent: object | null } | null}
      */
     static #buildPlacementRow(
         componentBody,
@@ -117,7 +117,7 @@ export class PcbScene3dStaticBodyPlacementBuilder {
      * @param {{ designator: string, x: number, y: number, layer?: string, pattern?: string, source?: string, modelPath?: string }[]} components Components.
      * @param {{ centerX: number, centerY: number, minX?: number, minY?: number, widthMil?: number, heightMil?: number }} board Board.
      * @param {number} thicknessMil Board thickness.
-     * @returns {{ designator: string, sourceIdentityKey: string, mountSide: string, rotationDeg: number, positionMil: { x: number, y: number, z: number }, bodyPositionMil: { x: number, y: number }, geometry: object } | null}
+     * @returns {{ designator: string, sourceIdentityKey: string, mountSide: string, rotationDeg: number, positionMil: { x: number, y: number, z: number }, bodyPositionMil: { x: number, y: number }, ownerLocked?: boolean, geometry: object } | null}
      */
     static #buildPlacement(
         componentBody,
@@ -134,9 +134,7 @@ export class PcbScene3dStaticBodyPlacementBuilder {
             )
         const geometry = staticGeometry.geometry
 
-        if (
-            !PcbScene3dStaticBodyPlacementBuilder.#isCompleteGeometry(geometry)
-        ) {
+        if (geometry?.status !== 'complete') {
             return null
         }
         const sourcePosition =
@@ -183,6 +181,17 @@ export class PcbScene3dStaticBodyPlacementBuilder {
             Number(thicknessMil || 0) / 2 +
             (Number.isFinite(standoffMil) ? standoffMil : 0) +
             heightMil / 2
+        const renderGeometry =
+            PcbScene3dStaticBodyPlacementBuilder.#placementGeometry(
+                geometry,
+                staticGeometry,
+                mountSide
+            )
+        const ownerLocked =
+            PcbScene3dStaticBodyPlacementBuilder.#hasLockedOwner(
+                componentBody,
+                matchedComponent
+            )
 
         return {
             designator:
@@ -194,11 +203,23 @@ export class PcbScene3dStaticBodyPlacementBuilder {
                 PcbScene3dStaticBodyPlacementBuilder.#sourceIdentityKey(
                     componentBody
                 ),
-            mountSide,
-            rotationDeg: PcbScene3dStaticBodyPlacementBuilder.#normalizeAngle(
-                Number(componentBody.rotationDeg || 0) +
-                    Number(matchedComponent?.rotation || 0)
+            sourceCoordinateFrame: Boolean(
+                staticGeometry.sourceCoordinateFrame
             ),
+            ownerLocked,
+            mountSideLocked:
+                ownerLocked ||
+                PcbScene3dStaticBodyPlacementBuilder.#hasExplicitMountSide(
+                    componentBody,
+                    matchedComponent
+                ),
+            mountSide,
+            rotationDeg:
+                PcbScene3dStaticBodyPlacementBuilder.#placementRotationDeg(
+                    componentBody,
+                    matchedComponent,
+                    staticGeometry
+                ),
             positionMil: {
                 x: PcbScene3dStaticBodyPlacementBuilder.#roundMil(
                     Number(sourcePosition.x || 0) - Number(board.centerX || 0)
@@ -217,7 +238,126 @@ export class PcbScene3dStaticBodyPlacementBuilder {
             ...PcbScene3dStaticBodyPlacementBuilder.#displayMetadata(
                 componentBody
             ),
-            geometry
+            geometry: renderGeometry
+        }
+    }
+
+    /**
+     * Checks whether one body carries explicit top/bottom side evidence.
+     * @param {{ componentIndex?: number | string, layer?: string, standoffHeightMil?: number | string | null }} componentBody Component body.
+     * @param {{ layer?: string } | null} matchedComponent Matched owner component.
+     * @returns {boolean}
+     */
+    static #hasExplicitMountSide(componentBody, matchedComponent) {
+        if (
+            matchedComponent &&
+            Number.isInteger(Number(componentBody?.componentIndex))
+        ) {
+            return true
+        }
+
+        const layer = String(componentBody?.layer || '').trim()
+        if (!layer) {
+            const standoffMil = Number(componentBody?.standoffHeightMil)
+            return Number.isFinite(standoffMil) && standoffMil < 0
+        }
+
+        if (
+            !PcbScene3dStaticBodyPlacementBuilder.#isAuthoredMechanicalBody(
+                componentBody
+            )
+        ) {
+            return false
+        }
+
+        if (/(^|[^a-z])(top|bottom)([^a-z]|$)/i.test(layer)) {
+            return true
+        }
+
+        return /^MECHANICAL\s*\d+$/i.test(layer)
+    }
+
+    /**
+     * Checks whether a matched shield owner is deliberate enough to keep away
+     * from later nearest-neighbor fragment promotion.
+     * @param {{ identifier?: string, name?: string }} componentBody Component body.
+     * @param {{ pattern?: string, source?: string, description?: string, parameters?: object, provenance?: object } | null} matchedComponent Matched owner component.
+     * @returns {boolean}
+     */
+    static #hasLockedOwner(componentBody, matchedComponent) {
+        return Boolean(
+            matchedComponent &&
+            PcbScene3dStaticBodyPlacementBuilder.#hasGenericMechanicalIdentity(
+                componentBody
+            ) &&
+            PcbScene3dStaticBodyPlacementBuilder.#isShieldOwner(
+                matchedComponent
+            )
+        )
+    }
+
+    /**
+     * Checks whether one body identity looks like authored board mechanics.
+     * @param {{ identifier?: string, name?: string, modelTypeName?: string }} componentBody Component body.
+     * @returns {boolean}
+     */
+    static #isAuthoredMechanicalBody(componentBody) {
+        return PcbScene3dStaticBodyPlacementBuilder.#identityTokens(
+            componentBody
+        ).some((token) =>
+            PcbScene3dStaticBodyPlacementBuilder.#GENERIC_MECHANICAL_IDENTITY_TOKENS.has(
+                token
+            )
+        )
+    }
+
+    /**
+     * Resolves the rendered rotation for one static shape body.
+     * @param {{ rotationDeg?: number }} componentBody Component body.
+     * @param {{ rotation?: number } | null} matchedComponent Matched owner component.
+     * @param {{ sourceCoordinateFrame?: boolean }} normalizedStaticGeometry Normalized static geometry context.
+     * @returns {number}
+     */
+    static #placementRotationDeg(
+        componentBody,
+        matchedComponent,
+        normalizedStaticGeometry
+    ) {
+        const ownerRotation = normalizedStaticGeometry?.sourceCoordinateFrame
+            ? 0
+            : Number(matchedComponent?.rotation || 0)
+
+        return PcbScene3dStaticBodyPlacementBuilder.#normalizeAngle(
+            Number(componentBody.rotationDeg || 0) + ownerRotation
+        )
+    }
+
+    /**
+     * Converts normalized static geometry into the renderer mount-local frame.
+     * @param {object} geometry Normalized render geometry.
+     * @param {{ sourceCoordinateFrame?: boolean }} normalizedStaticGeometry Normalized static geometry context.
+     * @param {string} mountSide Resolved mount side.
+     * @returns {object}
+     */
+    static #placementGeometry(geometry, normalizedStaticGeometry, mountSide) {
+        if (
+            !normalizedStaticGeometry?.sourceCoordinateFrame ||
+            String(mountSide || 'top').toLowerCase() !== 'bottom' ||
+            !Array.isArray(geometry?.verticesMil)
+        ) {
+            return geometry
+        }
+
+        return {
+            ...geometry,
+            verticesMil: geometry.verticesMil.map((vertex) => ({
+                x: PcbScene3dStaticBodyPlacementBuilder.#roundMil(
+                    Number(vertex?.x || 0)
+                ),
+                y: PcbScene3dStaticBodyPlacementBuilder.#roundMil(
+                    -Number(vertex?.y || 0)
+                )
+            }))
         }
     }
 
@@ -226,19 +366,24 @@ export class PcbScene3dStaticBodyPlacementBuilder {
      * @param {{ positionMil?: { x?: number, y?: number } }} componentBody Component body.
      * @param {object | undefined} geometry Static geometry.
      * @param {{ x?: number, y?: number } | null} matchedComponent Matched owner component.
-     * @returns {{ geometry: object | undefined, placementCenterMil?: { x: number, y: number } }}
+     * @returns {{ geometry: object | undefined, placementCenterMil?: { x: number, y: number }, sourceCoordinateFrame: boolean }}
      */
     static #normalizeStaticGeometry(componentBody, geometry, matchedComponent) {
         if (
             String(geometry?.kind || '').toLowerCase() !== 'extruded-polygon' ||
             !Array.isArray(geometry?.verticesMil) ||
-            geometry.verticesMil.length < 3 ||
+            geometry.verticesMil.length < 3
+        ) {
+            return { geometry, sourceCoordinateFrame: false }
+        }
+
+        if (
             !PcbScene3dStaticBodyPlacementBuilder.#usesSourceCoordinateFrame(
                 componentBody,
                 geometry.verticesMil
             )
         ) {
-            return { geometry }
+            return { geometry, sourceCoordinateFrame: false }
         }
 
         const center =
@@ -255,6 +400,7 @@ export class PcbScene3dStaticBodyPlacementBuilder {
 
         return {
             placementCenterMil: placementCenter,
+            sourceCoordinateFrame: true,
             geometry: {
                 ...geometry,
                 verticesMil: geometry.verticesMil.map((vertex) => {