@tscircuit/3d-viewer 0.0.495 → 0.0.496

package/dist/index.js

@@ -30825,7 +30825,7 @@ import * as THREE16 from "three";
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.494",
+  version: "0.0.495",
   main: "./dist/index.js",
   module: "./dist/index.js",
   type: "module",
@@ -32663,6 +32663,149 @@ var platedHole = (plated_hole, ctx, options = {}) => {
       clipGeom
     );
     return (0, import_colors2.colorize)(colors.copper, finalCopper);
+  } else if (plated_hole.shape === "rotated_pill_hole_with_rect_pad") {
+    if (plated_hole.hole_shape && plated_hole.hole_shape !== "rotated_pill" || plated_hole.pad_shape && plated_hole.pad_shape !== "rect") {
+      throw new Error(
+        `Invalid hole_shape or pad_shape for rotated_pill_hole_with_rect_pad`
+      );
+    }
+    const holeOffsetX = plated_hole.hole_offset_x || 0;
+    const holeOffsetY = plated_hole.hole_offset_y || 0;
+    const holeWidth = plated_hole.hole_width;
+    const holeHeight = plated_hole.hole_height;
+    const isHorizontal = holeWidth >= holeHeight;
+    const longDim = isHorizontal ? holeWidth : holeHeight;
+    const shortDim = isHorizontal ? holeHeight : holeWidth;
+    const holeRadius = shortDim / 2;
+    const rectLength = Math.abs(longDim - shortDim);
+    const padWidth = plated_hole.rect_pad_width || holeWidth + 0.2;
+    const padHeight = plated_hole.rect_pad_height || holeHeight + 0.2;
+    const rectBorderRadius = extractRectBorderRadius(plated_hole);
+    const barrelMargin = 0.03;
+    const holeRotationRadians = (plated_hole.hole_ccw_rotation || 0) * Math.PI / 180;
+    const rectRotationRadians = (plated_hole.rect_ccw_rotation || 0) * Math.PI / 180;
+    const rotateHole = (geom) => {
+      const rotatedOffsetX = holeOffsetX * Math.cos(holeRotationRadians) - holeOffsetY * Math.sin(holeRotationRadians);
+      const rotatedOffsetY = holeOffsetX * Math.sin(holeRotationRadians) + holeOffsetY * Math.cos(holeRotationRadians);
+      const rotated = (0, import_transforms4.rotate)([0, 0, holeRotationRadians], geom);
+      return (0, import_transforms4.translate)(
+        [plated_hole.x + rotatedOffsetX, plated_hole.y + rotatedOffsetY, 0],
+        rotated
+      );
+    };
+    const rotateRectPad = (geom) => {
+      if (!rectRotationRadians) return geom;
+      const toOrigin = (0, import_transforms4.translate)([-plated_hole.x, -plated_hole.y, 0], geom);
+      const rotated = (0, import_transforms4.rotate)([0, 0, rectRotationRadians], toOrigin);
+      return (0, import_transforms4.translate)([plated_hole.x, plated_hole.y, 0], rotated);
+    };
+    const barrel = rotateHole(
+      (0, import_booleans2.union)(
+        (0, import_primitives4.cuboid)({
+          center: [0, 0, 0],
+          size: isHorizontal ? [
+            rectLength + 2 * barrelMargin,
+            shortDim + 2 * barrelMargin,
+            copperSpan
+          ] : [
+            shortDim + 2 * barrelMargin,
+            rectLength + 2 * barrelMargin,
+            copperSpan
+          ]
+        }),
+        (0, import_primitives4.cylinder)({
+          center: isHorizontal ? [-rectLength / 2, 0, 0] : [0, -rectLength / 2, 0],
+          radius: holeRadius + barrelMargin,
+          height: copperSpan
+        }),
+        (0, import_primitives4.cylinder)({
+          center: isHorizontal ? [rectLength / 2, 0, 0] : [0, rectLength / 2, 0],
+          radius: holeRadius + barrelMargin,
+          height: copperSpan
+        })
+      )
+    );
+    const holeCut = rotateHole(
+      (0, import_booleans2.union)(
+        (0, import_primitives4.cuboid)({
+          center: [0, 0, 0],
+          size: isHorizontal ? [rectLength, shortDim, throughDrillHeight * 1.1] : [shortDim, rectLength, throughDrillHeight * 1.1]
+        }),
+        (0, import_primitives4.cylinder)({
+          center: isHorizontal ? [-rectLength / 2, 0, 0] : [0, -rectLength / 2, 0],
+          radius: holeRadius,
+          height: throughDrillHeight * 1.1
+        }),
+        (0, import_primitives4.cylinder)({
+          center: isHorizontal ? [rectLength / 2, 0, 0] : [0, rectLength / 2, 0],
+          radius: holeRadius,
+          height: throughDrillHeight * 1.1
+        })
+      )
+    );
+    const copperTopPad = rotateRectPad(
+      createRectPadGeom({
+        width: padWidth,
+        height: padHeight,
+        thickness: platedHoleLipHeight,
+        center: [plated_hole.x, plated_hole.y, topSurfaceZ],
+        borderRadius: rectBorderRadius
+      })
+    );
+    const copperBottomPad = rotateRectPad(
+      createRectPadGeom({
+        width: padWidth,
+        height: padHeight,
+        thickness: platedHoleLipHeight,
+        center: [plated_hole.x, plated_hole.y, bottomSurfaceZ],
+        borderRadius: rectBorderRadius
+      })
+    );
+    const copperFill = rotateRectPad(
+      (() => {
+        const height10 = Math.max(copperSpan - platedHoleLipHeight * 2, M);
+        const topPadBottom = topSurfaceZ;
+        const bottomPadTop = bottomSurfaceZ;
+        const centerZ = (topPadBottom + bottomPadTop) / 2;
+        const rect2d = (0, import_primitives4.roundedRectangle)({
+          size: [padWidth, padHeight],
+          roundRadius: rectBorderRadius || 0,
+          segments: RECT_PAD_SEGMENTS
+        });
+        const extruded = (0, import_extrusions3.extrudeLinear)({ height: height10 }, rect2d);
+        return (0, import_transforms4.translate)(
+          [plated_hole.x, plated_hole.y, centerZ - height10 / 2],
+          extruded
+        );
+      })()
+    );
+    const copperTopPadCut = (0, import_booleans2.subtract)(copperTopPad, holeCut);
+    const copperBottomPadCut = (0, import_booleans2.subtract)(copperBottomPad, holeCut);
+    const copperFillCut = (0, import_booleans2.subtract)(copperFill, holeCut);
+    const barrelHoleCut = rotateHole(
+      (0, import_booleans2.union)(
+        (0, import_primitives4.cuboid)({
+          center: [0, 0, 0],
+          size: isHorizontal ? [rectLength - 2 * M, shortDim - 2 * M, throughDrillHeight * 1.1] : [shortDim - 2 * M, rectLength - 2 * M, throughDrillHeight * 1.1]
+        }),
+        (0, import_primitives4.cylinder)({
+          center: isHorizontal ? [-rectLength / 2, 0, 0] : [0, -rectLength / 2, 0],
+          radius: holeRadius - M,
+          height: throughDrillHeight * 1.1
+        }),
+        (0, import_primitives4.cylinder)({
+          center: isHorizontal ? [rectLength / 2, 0, 0] : [0, rectLength / 2, 0],
+          radius: holeRadius - M,
+          height: throughDrillHeight * 1.1
+        })
+      )
+    );
+    const barrelWithHole = (0, import_booleans2.subtract)(barrel, barrelHoleCut);
+    const finalCopper = maybeClip(
+      (0, import_booleans2.union)(copperTopPadCut, copperBottomPadCut, copperFillCut, barrelWithHole),
+      clipGeom
+    );
+    return (0, import_colors2.colorize)(colors.copper, finalCopper);
   } else if (plated_hole.shape === "hole_with_polygon_pad") {
     const padOutline = plated_hole.pad_outline;
     if (!Array.isArray(padOutline) || padOutline.length < 3) {
@@ -33313,6 +33456,53 @@ var BoardGeomBuilder = class {
         clipGeom: this.boardClipGeom
       });
       this.platedHoleGeoms.push(platedHoleGeom);
+    } else if (ph.shape === "rotated_pill_hole_with_rect_pad") {
+      if (ph.hole_shape && ph.hole_shape !== "rotated_pill" || ph.pad_shape && ph.pad_shape !== "rect") {
+        return;
+      }
+      const rphHoleWidth = ph.hole_width;
+      const rphHoleHeight = ph.hole_height;
+      const rphIsHorizontal = rphHoleWidth >= rphHoleHeight;
+      const rphLongDim = rphIsHorizontal ? rphHoleWidth : rphHoleHeight;
+      const rphShortDim = rphIsHorizontal ? rphHoleHeight : rphHoleWidth;
+      const rphHoleRadius = rphShortDim / 2;
+      const rphRectLength = Math.abs(rphLongDim - rphShortDim);
+      const rphHoleOffsetX = ph.hole_offset_x || 0;
+      const rphHoleOffsetY = ph.hole_offset_y || 0;
+      let rphPillHole = (0, import_booleans5.union)(
+        (0, import_primitives7.cuboid)({
+          center: [0, 0, 0],
+          size: rphIsHorizontal ? [rphRectLength, rphShortDim, this.ctx.pcbThickness * 1.5] : [rphShortDim, rphRectLength, this.ctx.pcbThickness * 1.5]
+        }),
+        (0, import_primitives7.cylinder)({
+          center: rphIsHorizontal ? [-rphRectLength / 2, 0, 0] : [0, -rphRectLength / 2, 0],
+          radius: rphHoleRadius,
+          height: this.ctx.pcbThickness * 1.5
+        }),
+        (0, import_primitives7.cylinder)({
+          center: rphIsHorizontal ? [rphRectLength / 2, 0, 0] : [0, rphRectLength / 2, 0],
+          radius: rphHoleRadius,
+          height: this.ctx.pcbThickness * 1.5
+        })
+      );
+      const rphHoleRotationRadians = (ph.hole_ccw_rotation || 0) * Math.PI / 180;
+      const rphRotatedOffsetX = rphHoleOffsetX * Math.cos(rphHoleRotationRadians) - rphHoleOffsetY * Math.sin(rphHoleRotationRadians);
+      const rphRotatedOffsetY = rphHoleOffsetX * Math.sin(rphHoleRotationRadians) + rphHoleOffsetY * Math.cos(rphHoleRotationRadians);
+      rphPillHole = (0, import_transforms6.rotateZ)(rphHoleRotationRadians, rphPillHole);
+      const pillHole = (0, import_transforms6.translate)(
+        [ph.x + rphRotatedOffsetX, ph.y + rphRotatedOffsetY, 0],
+        rphPillHole
+      );
+      if (!opts.dontCutBoard) {
+        this.boardGeom = (0, import_booleans5.subtract)(this.boardGeom, pillHole);
+      }
+      this.padGeoms = this.padGeoms.map(
+        (pg) => (0, import_colors3.colorize)(colors.copper, (0, import_booleans5.subtract)(pg, pillHole))
+      );
+      const platedHoleGeom = platedHole(ph, this.ctx, {
+        clipGeom: this.boardClipGeom
+      });
+      this.platedHoleGeoms.push(platedHoleGeom);
     } else if (ph.shape === "hole_with_polygon_pad") {
       const padOutline = ph.pad_outline;
       if (!Array.isArray(padOutline) || padOutline.length < 3) {
@@ -34270,6 +34460,42 @@ function createSoldermaskTextureForLayer({
         );
         ctx.fill();
       }
+    } else if (hole.shape === "rotated_pill_hole_with_rect_pad") {
+      const padWidth = (hole.rect_pad_width ?? hole.hole_width ?? 0) * traceTextureResolution;
+      const padHeight = (hole.rect_pad_height ?? hole.hole_height ?? 0) * traceTextureResolution;
+      const rawRadius = extractRectBorderRadius(hole);
+      const borderRadius = clampRectBorderRadius(
+        hole.rect_pad_width ?? hole.hole_width ?? 0,
+        hole.rect_pad_height ?? hole.hole_height ?? 0,
+        rawRadius
+      ) * traceTextureResolution;
+      const rectCcwRotationDeg = hole.rect_ccw_rotation || 0;
+      const rectRotation = -rectCcwRotationDeg;
+      if (rectRotation) {
+        ctx.save();
+        ctx.translate(canvasX, canvasY);
+        ctx.rotate(rectRotation * Math.PI / 180);
+        ctx.beginPath();
+        ctx.roundRect(
+          -padWidth / 2,
+          -padHeight / 2,
+          padWidth,
+          padHeight,
+          borderRadius
+        );
+        ctx.fill();
+        ctx.restore();
+      } else {
+        ctx.beginPath();
+        ctx.roundRect(
+          canvasX - padWidth / 2,
+          canvasY - padHeight / 2,
+          padWidth,
+          padHeight,
+          borderRadius
+        );
+        ctx.fill();
+      }
     }
   });
   const pcbHoles = su5(circuitJson).pcb_hole.list();
@@ -35216,6 +35442,31 @@ function createTraceTextureForLayer({
       ctx.beginPath();
       ctx.arc(canvasX, canvasY, canvasRadius, 0, 2 * Math.PI, false);
       ctx.fill();
+    } else if (ph.layers.includes(layer) && ph.shape === "rotated_pill_hole_with_rect_pad") {
+      const canvasX = (ph.x - boardOutlineBounds.minX) * traceTextureResolution;
+      const canvasY = (boardOutlineBounds.maxY - ph.y) * traceTextureResolution;
+      const padWidth = (ph.rect_pad_width ?? ph.hole_width ?? 0) * traceTextureResolution;
+      const padHeight = (ph.rect_pad_height ?? ph.hole_height ?? 0) * traceTextureResolution;
+      const rectCcwRotationDeg = ph.rect_ccw_rotation || 0;
+      const rectRotation = -rectCcwRotationDeg;
+      if (rectRotation) {
+        ctx.save();
+        ctx.translate(canvasX, canvasY);
+        ctx.rotate(rectRotation * Math.PI / 180);
+        ctx.beginPath();
+        ctx.rect(-padWidth / 2, -padHeight / 2, padWidth, padHeight);
+        ctx.fill();
+        ctx.restore();
+      } else {
+        ctx.beginPath();
+        ctx.rect(
+          canvasX - padWidth / 2,
+          canvasY - padHeight / 2,
+          padWidth,
+          padHeight
+        );
+        ctx.fill();
+      }
     }
   });
   ctx.globalCompositeOperation = "source-over";
@@ -36775,6 +37026,134 @@ function processPlatedHolesForManifold(Manifold, CrossSection, circuitJson, pcbT
         geometry: threeGeom,
         color: COPPER_COLOR
       });
+    } else if (ph.shape === "rotated_pill_hole_with_rect_pad") {
+      if (ph.hole_shape && ph.hole_shape !== "rotated_pill" || ph.pad_shape && ph.pad_shape !== "rect") {
+        return;
+      }
+      const holeW = ph.hole_width;
+      const holeH = ph.hole_height;
+      const holeOffsetX = ph.hole_offset_x || 0;
+      const holeOffsetY = ph.hole_offset_y || 0;
+      const padWidth = ph.rect_pad_width;
+      const padHeight = ph.rect_pad_height;
+      const rectBorderRadius = extractRectBorderRadius(ph);
+      const padThickness = DEFAULT_SMT_PAD_THICKNESS;
+      const drillW = holeW + 2 * MANIFOLD_Z_OFFSET;
+      const drillH = holeH + 2 * MANIFOLD_Z_OFFSET;
+      const drillDepth = pcbThickness * 1.2;
+      let boardPillDrillOp = createPillOp(drillW, drillH, drillDepth).translate(
+        [holeOffsetX, holeOffsetY, 0]
+      );
+      if (ph.hole_ccw_rotation) {
+        const rotatedDrill = boardPillDrillOp.rotate([
+          0,
+          0,
+          ph.hole_ccw_rotation
+        ]);
+        manifoldInstancesForCleanup.push(rotatedDrill);
+        boardPillDrillOp = rotatedDrill;
+      }
+      const translatedBoardPillDrill = boardPillDrillOp.translate([
+        ph.x,
+        ph.y,
+        0
+      ]);
+      manifoldInstancesForCleanup.push(translatedBoardPillDrill);
+      platedHoleBoardDrills.push(translatedBoardPillDrill);
+      let mainFill = createRoundedRectPrism({
+        Manifold,
+        width: padWidth,
+        height: padHeight,
+        thickness: pcbThickness - 2 * padThickness - 2 * BOARD_SURFACE_OFFSET.copper + 0.1,
+        // Fill between pads
+        borderRadius: rectBorderRadius
+      });
+      manifoldInstancesForCleanup.push(mainFill);
+      if (ph.rect_ccw_rotation) {
+        const rotatedMainFill = mainFill.rotate([0, 0, ph.rect_ccw_rotation]);
+        manifoldInstancesForCleanup.push(rotatedMainFill);
+        mainFill = rotatedMainFill;
+      }
+      let topPad = createRoundedRectPrism({
+        Manifold,
+        width: padWidth,
+        height: padHeight,
+        thickness: padThickness,
+        borderRadius: rectBorderRadius
+      }).translate([0, 0, pcbThickness / 2 / 2 + BOARD_SURFACE_OFFSET.copper]);
+      if (ph.rect_ccw_rotation) {
+        const rotatedTopPad = topPad.rotate([0, 0, ph.rect_ccw_rotation]);
+        manifoldInstancesForCleanup.push(rotatedTopPad);
+        topPad = rotatedTopPad;
+      }
+      let bottomPad = createRoundedRectPrism({
+        Manifold,
+        width: padWidth,
+        height: padHeight,
+        thickness: padThickness,
+        borderRadius: rectBorderRadius
+      }).translate([0, 0, -pcbThickness / 2 / 2 - BOARD_SURFACE_OFFSET.copper]);
+      if (ph.rect_ccw_rotation) {
+        const rotatedBottomPad = bottomPad.rotate([0, 0, ph.rect_ccw_rotation]);
+        manifoldInstancesForCleanup.push(rotatedBottomPad);
+        bottomPad = rotatedBottomPad;
+      }
+      manifoldInstancesForCleanup.push(topPad, bottomPad);
+      const barrelPill = createPillOp(
+        holeW,
+        holeH,
+        pcbThickness * 1.02
+        // Slightly taller than board
+      ).translate([holeOffsetX, holeOffsetY, 0]);
+      if (ph.hole_ccw_rotation) {
+        const rotatedDrill = boardPillDrillOp.rotate([
+          0,
+          0,
+          ph.hole_ccw_rotation
+        ]);
+        manifoldInstancesForCleanup.push(rotatedDrill);
+        boardPillDrillOp = rotatedDrill;
+      }
+      manifoldInstancesForCleanup.push(barrelPill);
+      const copperUnion = Manifold.union([
+        mainFill,
+        topPad,
+        bottomPad,
+        barrelPill
+      ]);
+      manifoldInstancesForCleanup.push(copperUnion);
+      let holeCutOp = createPillOp(
+        Math.max(holeW - 2 * PLATED_HOLE_LIP_HEIGHT, 0.01),
+        Math.max(holeH - 2 * PLATED_HOLE_LIP_HEIGHT, 0.01),
+        pcbThickness * 1.2
+        // Ensure it cuts through
+      ).translate([holeOffsetX, holeOffsetY, 0]);
+      if (ph.hole_ccw_rotation) {
+        const rotatedHoleCut = holeCutOp.rotate([0, 0, ph.hole_ccw_rotation]);
+        manifoldInstancesForCleanup.push(rotatedHoleCut);
+        holeCutOp = rotatedHoleCut;
+      }
+      manifoldInstancesForCleanup.push(holeCutOp);
+      const finalCopper = copperUnion.subtract(holeCutOp);
+      manifoldInstancesForCleanup.push(finalCopper);
+      const translatedCopper = finalCopper.translate([ph.x, ph.y, 0]);
+      manifoldInstancesForCleanup.push(translatedCopper);
+      let finalCopperOp = translatedCopper;
+      if (boardClipVolume) {
+        const clipped = Manifold.intersection([
+          translatedCopper,
+          boardClipVolume
+        ]);
+        manifoldInstancesForCleanup.push(clipped);
+        finalCopperOp = clipped;
+      }
+      platedHoleCopperOpsForSubtract.push(finalCopperOp);
+      const threeGeom = manifoldMeshToThreeGeometry(finalCopperOp.getMesh());
+      platedHoleCopperGeoms.push({
+        key: `ph-${ph.pcb_plated_hole_id || index2}`,
+        geometry: threeGeom,
+        color: COPPER_COLOR
+      });
     } else if (ph.shape === "hole_with_polygon_pad") {
       const padOutline = ph.pad_outline;
       if (!Array.isArray(padOutline) || padOutline.length < 3) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/3d-viewer",
-  "version": "0.0.495",
+  "version": "0.0.496",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "type": "module",