@tscircuit/3d-viewer 0.0.525 → 0.0.526

package/dist/index.js

@@ -28768,7 +28768,7 @@ import * as THREE16 from "three";
 // package.json
 var package_default = {
   name: "@tscircuit/3d-viewer",
-  version: "0.0.524",
+  version: "0.0.525",
   main: "./dist/index.js",
   module: "./dist/index.js",
   type: "module",
@@ -28798,7 +28798,7 @@ var package_default = {
     "@jscad/regl-renderer": "^2.6.12",
     "@jscad/stl-serializer": "^2.1.20",
     "circuit-json": "^0.0.372",
-    "circuit-to-canvas": "^0.0.81",
+    "circuit-to-canvas": "^0.0.83",
     "react-hot-toast": "^2.6.0",
     three: "^0.165.0",
     "three-stdlib": "^2.36.0",
@@ -31737,7 +31737,7 @@ import { su as su8 } from "@tscircuit/circuit-json-util";
 import { useEffect as useEffect23, useMemo as useMemo19 } from "react";
 
 // src/textures/create-combined-board-textures.ts
-import * as THREE28 from "three";
+import * as THREE27 from "three";
 
 // node_modules/@tscircuit/math-utils/dist/chunk-5N7UJNVK.js
 var getBoundsFromPoints = (points) => {
@@ -32233,227 +32233,11 @@ function createCopperTextTextureForLayer({
   return texture;
 }
 
-// src/textures/create-copper-pour-texture-for-layer.ts
-import * as THREE23 from "three";
-import { CircuitToCanvasDrawer as CircuitToCanvasDrawer2 } from "circuit-to-canvas";
-
-// src/geoms/brep-converter.ts
-var import_primitives7 = __toESM(require_primitives(), 1);
-var import_booleans5 = __toESM(require_booleans(), 1);
-function segmentToPoints(p1, p2, bulge, arcSegments) {
-  if (!bulge || Math.abs(bulge) < 1e-9) {
-    return [];
-  }
-  const theta = 4 * Math.atan(bulge);
-  const dx = p2[0] - p1[0];
-  const dy = p2[1] - p1[1];
-  const dist = Math.sqrt(dx * dx + dy * dy);
-  if (dist < 1e-9) return [];
-  const radius = Math.abs(dist / (2 * Math.sin(theta / 2)));
-  const m = Math.sqrt(Math.max(0, radius * radius - dist / 2 * (dist / 2)));
-  const midPoint = [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2];
-  const ux = dx / dist;
-  const uy = dy / dist;
-  const nx = -uy;
-  const ny = ux;
-  const centerX = midPoint[0] + nx * m * Math.sign(bulge);
-  const centerY = midPoint[1] + ny * m * Math.sign(bulge);
-  const startAngle = Math.atan2(p1[1] - centerY, p1[0] - centerX);
-  const points = [];
-  const numSteps = Math.max(
-    2,
-    Math.ceil(arcSegments * Math.abs(theta) / (Math.PI * 2) * 4)
-  );
-  const angleStep = theta / numSteps;
-  for (let i = 1; i < numSteps; i++) {
-    const angle = startAngle + angleStep * i;
-    points.push([
-      centerX + radius * Math.cos(angle),
-      centerY + radius * Math.sin(angle)
-    ]);
-  }
-  return points;
-}
-function ringToPoints(ring, arcSegments) {
-  const allPoints = [];
-  const vertices = ring.vertices;
-  for (let i = 0; i < vertices.length; i++) {
-    const p1 = vertices[i];
-    const p2 = vertices[(i + 1) % vertices.length];
-    allPoints.push([p1.x, p1.y]);
-    if (p1.bulge) {
-      const arcPoints = segmentToPoints(
-        [p1.x, p1.y],
-        [p2.x, p2.y],
-        p1.bulge,
-        arcSegments
-      );
-      allPoints.push(...arcPoints);
-    }
-  }
-  return allPoints;
-}
-
-// src/textures/create-copper-pour-texture-for-layer.ts
-function drawPolygon({
-  ctx,
-  points,
-  canvasXFromPcb,
-  canvasYFromPcb
-}) {
-  if (points.length < 3) return;
-  ctx.beginPath();
-  points.forEach((point, index2) => {
-    const canvasX = canvasXFromPcb(point[0]);
-    const canvasY = canvasYFromPcb(point[1]);
-    if (index2 === 0) {
-      ctx.moveTo(canvasX, canvasY);
-    } else {
-      ctx.lineTo(canvasX, canvasY);
-    }
-  });
-  ctx.closePath();
-  ctx.fill();
-}
-function drawBrepShape({
-  ctx,
-  pour,
-  canvasXFromPcb,
-  canvasYFromPcb
-}) {
-  const brepShape = pour.brep_shape;
-  if (!brepShape || !brepShape.outer_ring) return;
-  const outerRingPoints = ringToPoints(brepShape.outer_ring, 32);
-  if (outerRingPoints.length >= 3) {
-    drawPolygon({
-      ctx,
-      points: outerRingPoints,
-      canvasXFromPcb,
-      canvasYFromPcb
-    });
-  }
-  if (brepShape.inner_rings && brepShape.inner_rings.length > 0) {
-    ctx.globalCompositeOperation = "destination-out";
-    for (const innerRing of brepShape.inner_rings) {
-      const innerRingPoints = ringToPoints(innerRing, 32);
-      if (innerRingPoints.length >= 3) {
-        drawPolygon({
-          ctx,
-          points: innerRingPoints,
-          canvasXFromPcb,
-          canvasYFromPcb
-        });
-      }
-    }
-    ctx.globalCompositeOperation = "source-over";
-  }
-}
-function createCopperPourTextureForLayer({
-  layer,
-  circuitJson,
-  boardData,
-  traceTextureResolution = TRACE_TEXTURE_RESOLUTION
-}) {
-  const copperPours = circuitJson.filter(
-    (e) => e.type === "pcb_copper_pour"
-  );
-  const pcbRenderLayer = layer === "top" ? "top_copper" : "bottom_copper";
-  const poursOnLayer = copperPours.filter((p) => p.layer === layer);
-  if (poursOnLayer.length === 0) return null;
-  const boardOutlineBounds = calculateOutlineBounds(boardData);
-  const canvas = document.createElement("canvas");
-  const canvasWidth = Math.floor(
-    boardOutlineBounds.width * traceTextureResolution
-  );
-  const canvasHeight = Math.floor(
-    boardOutlineBounds.height * traceTextureResolution
-  );
-  canvas.width = canvasWidth;
-  canvas.height = canvasHeight;
-  const ctx = canvas.getContext("2d");
-  if (!ctx) return null;
-  if (layer === "bottom") {
-    ctx.translate(0, canvasHeight);
-    ctx.scale(1, -1);
-  }
-  const canvasXFromPcb = (pcbX) => (pcbX - boardOutlineBounds.minX) * traceTextureResolution;
-  const canvasYFromPcb = (pcbY) => (boardOutlineBounds.maxY - pcbY) * traceTextureResolution;
-  const rectAndPolygonPours = poursOnLayer.filter(
-    (pour) => pour.shape === "rect" || pour.shape === "polygon"
-  );
-  const brepPours = poursOnLayer.filter((pour) => pour.shape === "brep");
-  if (rectAndPolygonPours.length > 0) {
-    const drawer = new CircuitToCanvasDrawer2(ctx);
-    drawer.setCameraBounds({
-      minX: boardOutlineBounds.minX,
-      maxX: boardOutlineBounds.maxX,
-      minY: boardOutlineBounds.minY,
-      maxY: boardOutlineBounds.maxY
-    });
-    const coveredPours = rectAndPolygonPours.filter(
-      (p) => p.covered_with_solder_mask !== false
-    );
-    const uncoveredPours = rectAndPolygonPours.filter(
-      (p) => p.covered_with_solder_mask === false
-    );
-    const coveredColor = `rgb(${colors.fr4TracesWithMaskGreen.map((c) => c * 255).join(",")})`;
-    const uncoveredColor = `rgb(${colors.copper.map((c) => c * 255).join(",")})`;
-    if (coveredPours.length > 0) {
-      drawer.configure({
-        colorOverrides: {
-          copper: {
-            top: coveredColor,
-            bottom: coveredColor,
-            inner1: coveredColor,
-            inner2: coveredColor,
-            inner3: coveredColor,
-            inner4: coveredColor,
-            inner5: coveredColor,
-            inner6: coveredColor
-          }
-        }
-      });
-      drawer.drawElements(coveredPours, { layers: [pcbRenderLayer] });
-    }
-    if (uncoveredPours.length > 0) {
-      drawer.configure({
-        colorOverrides: {
-          copper: {
-            top: uncoveredColor,
-            bottom: uncoveredColor,
-            inner1: uncoveredColor,
-            inner2: uncoveredColor,
-            inner3: uncoveredColor,
-            inner4: uncoveredColor,
-            inner5: uncoveredColor,
-            inner6: uncoveredColor
-          }
-        }
-      });
-      drawer.drawElements(uncoveredPours, { layers: [pcbRenderLayer] });
-    }
-  }
-  for (const pour of brepPours) {
-    const covered = pour.covered_with_solder_mask !== false;
-    const colorArr = covered ? colors.fr4TracesWithMaskGreen : colors.copper;
-    const copperColor = `rgb(${colorArr[0] * 255}, ${colorArr[1] * 255}, ${colorArr[2] * 255})`;
-    ctx.fillStyle = copperColor;
-    drawBrepShape({ ctx, pour, canvasXFromPcb, canvasYFromPcb });
-  }
-  const texture = new THREE23.CanvasTexture(canvas);
-  texture.generateMipmaps = true;
-  texture.minFilter = THREE23.LinearMipmapLinearFilter;
-  texture.magFilter = THREE23.LinearFilter;
-  texture.anisotropy = 16;
-  texture.needsUpdate = true;
-  return texture;
-}
-
 // src/textures/create-fabrication-note-texture-for-layer.ts
-import * as THREE24 from "three";
+import * as THREE23 from "three";
 
 // src/textures/fabrication-note/fabrication-note-drawing.ts
-import { CircuitToCanvasDrawer as CircuitToCanvasDrawer3 } from "circuit-to-canvas";
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer2 } from "circuit-to-canvas";
 
 // src/utils/units.ts
 var MM_PER_INCH = 25.4;
@@ -32551,7 +32335,7 @@ var drawFabricationNoteLayer = ({
 }) => {
   const renderLayer = `${layer}_fabrication_note`;
   const normalizedElements = elements.map(normalizeFabricationElement);
-  const drawer = new CircuitToCanvasDrawer3(ctx);
+  const drawer = new CircuitToCanvasDrawer2(ctx);
   drawer.configure({
     colorOverrides: {
       copper: {
@@ -32677,20 +32461,20 @@ function createFabricationNoteTextureForLayer({
     bounds,
     elements
   });
-  const texture = new THREE24.CanvasTexture(canvas);
+  const texture = new THREE23.CanvasTexture(canvas);
   texture.generateMipmaps = true;
-  texture.minFilter = THREE24.LinearMipmapLinearFilter;
-  texture.magFilter = THREE24.LinearFilter;
+  texture.minFilter = THREE23.LinearMipmapLinearFilter;
+  texture.magFilter = THREE23.LinearFilter;
   texture.anisotropy = 16;
   texture.needsUpdate = true;
   return texture;
 }
 
 // src/textures/create-pcb-note-texture-for-layer.ts
-import * as THREE25 from "three";
+import * as THREE24 from "three";
 
 // src/textures/pcb-note/pcb-note-drawing.ts
-import { CircuitToCanvasDrawer as CircuitToCanvasDrawer4 } from "circuit-to-canvas";
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer3 } from "circuit-to-canvas";
 var TRANSPARENT2 = "rgba(0,0,0,0)";
 var setDrawerBounds3 = (drawer, bounds) => {
   drawer.setCameraBounds({
@@ -32769,7 +32553,7 @@ var drawPcbNoteLayer = ({
   elements
 }) => {
   const normalizedElements = elements.map(normalizePcbNoteElement);
-  const drawer = new CircuitToCanvasDrawer4(ctx);
+  const drawer = new CircuitToCanvasDrawer3(ctx);
   drawer.configure({
     colorOverrides: {
       copper: {
@@ -32838,20 +32622,20 @@ function createPcbNoteTextureForLayer({
     bounds,
     elements
   });
-  const texture = new THREE25.CanvasTexture(canvas);
+  const texture = new THREE24.CanvasTexture(canvas);
   texture.generateMipmaps = true;
-  texture.minFilter = THREE25.LinearMipmapLinearFilter;
-  texture.magFilter = THREE25.LinearFilter;
+  texture.minFilter = THREE24.LinearMipmapLinearFilter;
+  texture.magFilter = THREE24.LinearFilter;
   texture.anisotropy = 16;
   texture.needsUpdate = true;
   return texture;
 }
 
 // src/textures/create-silkscreen-texture-for-layer.ts
-import * as THREE26 from "three";
+import * as THREE25 from "three";
 
 // src/textures/silkscreen/silkscreen-drawing.ts
-import { CircuitToCanvasDrawer as CircuitToCanvasDrawer5 } from "circuit-to-canvas";
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer4 } from "circuit-to-canvas";
 var FABRICATION_NOTE_COLOR2 = "rgb(255,243,204)";
 var TRANSPARENT3 = "rgba(0,0,0,0)";
 var setDrawerBounds4 = (drawer, bounds) => {
@@ -32870,7 +32654,7 @@ var drawSilkscreenLayer = ({
   silkscreenColor
 }) => {
   const renderLayer = layer === "top" ? "top_silkscreen" : "bottom_silkscreen";
-  const drawer = new CircuitToCanvasDrawer5(ctx);
+  const drawer = new CircuitToCanvasDrawer4(ctx);
   drawer.configure({
     colorOverrides: {
       copper: {
@@ -32957,20 +32741,20 @@ function createSilkscreenTextureForLayer({
     elements,
     silkscreenColor
   });
-  const texture = new THREE26.CanvasTexture(canvas);
+  const texture = new THREE25.CanvasTexture(canvas);
   texture.generateMipmaps = true;
-  texture.minFilter = THREE26.LinearMipmapLinearFilter;
-  texture.magFilter = THREE26.LinearFilter;
+  texture.minFilter = THREE25.LinearMipmapLinearFilter;
+  texture.magFilter = THREE25.LinearFilter;
   texture.anisotropy = 16;
   texture.needsUpdate = true;
   return texture;
 }
 
 // src/textures/create-soldermask-texture-for-layer.ts
-import * as THREE27 from "three";
+import * as THREE26 from "three";
 
 // src/textures/soldermask/soldermask-drawing.ts
-import { CircuitToCanvasDrawer as CircuitToCanvasDrawer6 } from "circuit-to-canvas";
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer5 } from "circuit-to-canvas";
 var toRgb = (colorArr) => {
   const [r = 0, g = 0, b = 0] = colorArr;
   return `rgb(${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(
@@ -33006,7 +32790,7 @@ var drawSoldermaskLayer = ({
 }) => {
   const palette = getSoldermaskPalette(boardMaterial);
   const copperRenderLayer = layer === "top" ? "top_copper" : "bottom_copper";
-  const drawer = new CircuitToCanvasDrawer6(ctx);
+  const drawer = new CircuitToCanvasDrawer5(ctx);
   drawer.configure({
     colorOverrides: {
       copper: {
@@ -33050,7 +32834,7 @@ var drawSoldermaskLayer = ({
   if (uncoveredPours.length > 0) {
     ctx.save();
     ctx.globalCompositeOperation = "destination-out";
-    const cutoutDrawer = new CircuitToCanvasDrawer6(ctx);
+    const cutoutDrawer = new CircuitToCanvasDrawer5(ctx);
     cutoutDrawer.configure({
       colorOverrides: {
         copper: {
@@ -33099,10 +32883,10 @@ function createSoldermaskTextureForLayer({
     elements,
     boardMaterial: boardData.material
   });
-  const texture = new THREE27.CanvasTexture(canvas);
+  const texture = new THREE26.CanvasTexture(canvas);
   texture.generateMipmaps = true;
-  texture.minFilter = THREE27.LinearMipmapLinearFilter;
-  texture.magFilter = THREE27.LinearFilter;
+  texture.minFilter = THREE26.LinearMipmapLinearFilter;
+  texture.magFilter = THREE26.LinearFilter;
   texture.anisotropy = 16;
   texture.needsUpdate = true;
   return texture;
@@ -33140,10 +32924,10 @@ var createCombinedTexture = ({
     const image = texture.image;
     ctx.drawImage(image, 0, 0, canvasWidth, canvasHeight);
   });
-  const combinedTexture = new THREE28.CanvasTexture(canvas);
+  const combinedTexture = new THREE27.CanvasTexture(canvas);
   combinedTexture.generateMipmaps = false;
-  combinedTexture.minFilter = THREE28.LinearFilter;
-  combinedTexture.magFilter = THREE28.LinearFilter;
+  combinedTexture.minFilter = THREE27.LinearFilter;
+  combinedTexture.magFilter = THREE27.LinearFilter;
   combinedTexture.premultiplyAlpha = true;
   combinedTexture.anisotropy = 16;
   combinedTexture.needsUpdate = true;
@@ -33184,12 +32968,6 @@ function createCombinedBoardTextures({
       copperColor,
       traceTextureResolution
     }) : null;
-    const copperPourTexture = showCopper ? createCopperPourTextureForLayer({
-      layer,
-      circuitJson,
-      boardData,
-      traceTextureResolution
-    }) : null;
     const padTexture = showCopper ? createPadTextureForLayer({
       layer,
       circuitJson,
@@ -33224,7 +33002,6 @@ function createCombinedBoardTextures({
     }) : null;
     return createCombinedTexture({
       textures: [
-        copperPourTexture,
         traceTexture,
         padTexture,
         soldermaskTexture,
@@ -33245,6 +33022,14 @@ function createCombinedBoardTextures({
   };
 }
 
+// src/textures/create-copper-pour-texture-for-layer.ts
+import * as THREE28 from "three";
+import { CircuitToCanvasDrawer as CircuitToCanvasDrawer6 } from "circuit-to-canvas";
+
+// src/geoms/brep-converter.ts
+var import_primitives7 = __toESM(require_primitives(), 1);
+var import_booleans5 = __toESM(require_booleans(), 1);
+
 // src/textures/create-three-texture-meshes.ts
 import * as THREE29 from "three";
 function createTexturePlane(config, boardData) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/3d-viewer",
-  "version": "0.0.525",
+  "version": "0.0.526",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "type": "module",
@@ -30,7 +30,7 @@
     "@jscad/regl-renderer": "^2.6.12",
     "@jscad/stl-serializer": "^2.1.20",
     "circuit-json": "^0.0.372",
-    "circuit-to-canvas": "^0.0.81",
+    "circuit-to-canvas": "^0.0.83",
     "react-hot-toast": "^2.6.0",
     "three": "^0.165.0",
     "three-stdlib": "^2.36.0",