circuit-json-to-gltf 0.0.56 → 0.0.58

package/dist/index.js

@@ -14109,6 +14109,75 @@ function clearOBJCache() {
   objCache.clear();
 }
 
+// lib/utils/gltf-node-transforms.ts
+function applyQuaternion(p, q) {
+  const [qx, qy, qz, qw] = q;
+  const { x, y, z } = p;
+  const ix = qw * x + qy * z - qz * y;
+  const iy = qw * y + qz * x - qx * z;
+  const iz = qw * z + qx * y - qy * x;
+  const iw = -qx * x - qy * y - qz * z;
+  return {
+    x: ix * qw + iw * -qx + iy * -qz - iz * -qy,
+    y: iy * qw + iw * -qy + iz * -qx - ix * -qz,
+    z: iz * qw + iw * -qz + ix * -qy - iy * -qx
+  };
+}
+function applyNodeTransform(p, node) {
+  let result = { ...p };
+  if (node.scale) {
+    result = {
+      x: result.x * node.scale[0],
+      y: result.y * node.scale[1],
+      z: result.z * node.scale[2]
+    };
+  }
+  if (node.rotation) {
+    result = applyQuaternion(
+      result,
+      node.rotation
+    );
+  }
+  if (node.translation) {
+    result = {
+      x: result.x + node.translation[0],
+      y: result.y + node.translation[1],
+      z: result.z + node.translation[2]
+    };
+  }
+  return result;
+}
+function buildMeshTransforms(gltf) {
+  const meshTransforms = /* @__PURE__ */ new Map();
+  if (!gltf.nodes) return meshTransforms;
+  function processNode(nodeIndex, parentTransforms) {
+    const node = gltf.nodes[nodeIndex];
+    if (!node) return;
+    const currentTransforms = [...parentTransforms];
+    if (node.translation || node.rotation || node.scale) {
+      currentTransforms.push({
+        translation: node.translation,
+        rotation: node.rotation,
+        scale: node.scale
+      });
+    }
+    if (node.mesh !== void 0) {
+      meshTransforms.set(node.mesh, currentTransforms);
+    }
+    if (node.children) {
+      for (const childIndex of node.children) {
+        processNode(childIndex, currentTransforms);
+      }
+    }
+  }
+  if (gltf.scenes && gltf.scenes[0]?.nodes) {
+    for (const rootNodeIndex of gltf.scenes[0].nodes) {
+      processNode(rootNodeIndex, []);
+    }
+  }
+  return meshTransforms;
+}
+
 // lib/loaders/glb.ts
 var glbCache = /* @__PURE__ */ new Map();
 async function loadGLB(url, transform) {
@@ -14117,6 +14186,11 @@ async function loadGLB(url, transform) {
     return glbCache.get(cacheKey);
   }
   const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch GLB: ${response.status} ${response.statusText}`
+    );
+  }
   const buffer = await response.arrayBuffer();
   const mesh = parseGLB(buffer, transform);
   glbCache.set(cacheKey, mesh);
@@ -14162,7 +14236,7 @@ function parseGLB(buffer, transform) {
   const finalConfig = transform ?? {
     axisMapping: { x: "x", y: "z", z: "y" }
   };
-  const transformedTriangles = transformTriangles(triangles, finalConfig);
+  let transformedTriangles = transformTriangles(triangles, finalConfig);
   const hasColors = transformedTriangles.some((t) => t.color !== void 0);
   if (hasColors) {
     return convertToOBJMesh(transformedTriangles);
@@ -14221,7 +14295,10 @@ function extractTrianglesFromGLTF(gltf, binaryBuffer) {
   if (!gltf.meshes || !gltf.accessors || !gltf.bufferViews) {
     return triangles;
   }
-  for (const mesh of gltf.meshes) {
+  const meshTransforms = buildMeshTransforms(gltf);
+  for (let meshIndex = 0; meshIndex < gltf.meshes.length; meshIndex++) {
+    const mesh = gltf.meshes[meshIndex];
+    const transforms = meshTransforms.get(meshIndex) || [];
     for (const primitive of mesh.primitives) {
       const mode = primitive.mode ?? 4;
       if (mode !== 4) {
@@ -14273,20 +14350,7 @@ function extractTrianglesFromGLTF(gltf, binaryBuffer) {
       let indices;
       if (primitive.indices !== void 0) {
         const indexAccessor = gltf.accessors[primitive.indices];
-        const indexData = getAccessorData(
-          indexAccessor,
-          gltf.bufferViews,
-          binaryBuffer
-        );
-        indices = indexAccessor.componentType === 5123 ? new Uint16Array(
-          indexData.buffer,
-          indexData.byteOffset,
-          indexData.length
-        ) : new Uint32Array(
-          indexData.buffer,
-          indexData.byteOffset,
-          indexData.length
-        );
+        indices = getAccessorData(indexAccessor, gltf.bufferViews, binaryBuffer);
       }
       const vertexCount = positions.length / 3;
       if (indices) {
@@ -14294,28 +14358,42 @@ function extractTrianglesFromGLTF(gltf, binaryBuffer) {
           const i0 = indices[i];
           const i1 = indices[i + 1];
           const i2 = indices[i + 2];
-          const v0 = {
+          let v0 = {
             x: positions[i0 * 3],
             y: positions[i0 * 3 + 1],
             z: positions[i0 * 3 + 2]
           };
-          const v1 = {
+          let v1 = {
             x: positions[i1 * 3],
             y: positions[i1 * 3 + 1],
             z: positions[i1 * 3 + 2]
           };
-          const v2 = {
+          let v2 = {
             x: positions[i2 * 3],
             y: positions[i2 * 3 + 1],
             z: positions[i2 * 3 + 2]
           };
+          for (const transform of transforms) {
+            v0 = applyNodeTransform(v0, transform);
+            v1 = applyNodeTransform(v1, transform);
+            v2 = applyNodeTransform(v2, transform);
+          }
           let normal;
           if (normals) {
-            normal = {
+            let n = {
               x: (normals[i0 * 3] + normals[i1 * 3] + normals[i2 * 3]) / 3,
               y: (normals[i0 * 3 + 1] + normals[i1 * 3 + 1] + normals[i2 * 3 + 1]) / 3,
               z: (normals[i0 * 3 + 2] + normals[i1 * 3 + 2] + normals[i2 * 3 + 2]) / 3
             };
+            for (const transform of transforms) {
+              if (transform.rotation) {
+                n = applyQuaternion(
+                  n,
+                  transform.rotation
+                );
+              }
+            }
+            normal = n;
           } else {
             normal = computeNormal(v0, v1, v2);
           }
@@ -14360,28 +14438,42 @@ function extractTrianglesFromGLTF(gltf, binaryBuffer) {
         }
       } else {
         for (let i = 0; i < vertexCount; i += 3) {
-          const v0 = {
+          let v0 = {
             x: positions[i * 3],
             y: positions[i * 3 + 1],
             z: positions[i * 3 + 2]
           };
-          const v1 = {
+          let v1 = {
             x: positions[(i + 1) * 3],
             y: positions[(i + 1) * 3 + 1],
             z: positions[(i + 1) * 3 + 2]
           };
-          const v2 = {
+          let v2 = {
             x: positions[(i + 2) * 3],
             y: positions[(i + 2) * 3 + 1],
             z: positions[(i + 2) * 3 + 2]
           };
+          for (const transform of transforms) {
+            v0 = applyNodeTransform(v0, transform);
+            v1 = applyNodeTransform(v1, transform);
+            v2 = applyNodeTransform(v2, transform);
+          }
           let normal;
           if (normals) {
-            normal = {
+            let n = {
               x: (normals[i * 3] + normals[(i + 1) * 3] + normals[(i + 2) * 3]) / 3,
               y: (normals[i * 3 + 1] + normals[(i + 1) * 3 + 1] + normals[(i + 2) * 3 + 1]) / 3,
               z: (normals[i * 3 + 2] + normals[(i + 1) * 3 + 2] + normals[(i + 2) * 3 + 2]) / 3
             };
+            for (const transform of transforms) {
+              if (transform.rotation) {
+                n = applyQuaternion(
+                  n,
+                  transform.rotation
+                );
+              }
+            }
+            normal = n;
           } else {
             normal = computeNormal(v0, v1, v2);
           }
@@ -14725,20 +14817,18 @@ async function convertSvgToCanvasBrowser(svgString, resolution, backgroundColor)
   });
 }
 async function renderBoardTextures(circuitJson, resolution = 1024) {
-  const [top, bottom] = await Promise.all([
-    renderBoardLayer(circuitJson, {
-      layer: "top",
-      resolution,
-      backgroundColor: "#0F3812"
-      // Green PCB background
-    }),
-    renderBoardLayer(circuitJson, {
-      layer: "bottom",
-      resolution,
-      backgroundColor: "#0F3812"
-      // Darker green for bottom layer
-    })
-  ]);
+  const top = await renderBoardLayer(circuitJson, {
+    layer: "top",
+    resolution,
+    backgroundColor: "#0F3812"
+    // Green PCB background
+  });
+  const bottom = await renderBoardLayer(circuitJson, {
+    layer: "bottom",
+    resolution,
+    backgroundColor: "#0F3812"
+    // Darker green for bottom layer
+  });
   return { top, bottom };
 }
 
@@ -15187,7 +15277,11 @@ async function convertCircuitJsonTo3D(circuitJson, options = {}) {
     } else if (model_obj_url) {
       box.mesh = await loadOBJ(model_obj_url, defaultTransform);
     } else if (model_glb_url) {
-      box.mesh = await loadGLB(model_glb_url, defaultTransform);
+      try {
+        box.mesh = await loadGLB(model_glb_url, defaultTransform);
+      } catch (err) {
+        console.error(`Failed to load GLB from ${model_glb_url}:`, err);
+      }
     } else if (model_gltf_url) {
       box.mesh = await loadGLTF(model_gltf_url, defaultTransform);
     } else if (hasFootprinterModel && cad.footprinter_string) {
@@ -15914,7 +16008,8 @@ var GLTFBuilder = class {
       },
       alphaMode: "BLEND"
     });
-    for (const box of scene3D.boxes) {
+    for (let i = 0; i < scene3D.boxes.length; i++) {
+      const box = scene3D.boxes[i];
       await this.addBox(box, defaultMaterialIndex);
     }
   }
@@ -15998,9 +16093,8 @@ var GLTFBuilder = class {
     }
     const primitives = [];
     for (const { meshData, materialIndex } of meshDataArray) {
-      const transformedMeshData = convertMeshToGLTFOrientation(
-        transformMesh(meshData, box.center, box.rotation)
-      );
+      const translatedMesh = transformMesh(meshData, box.center, box.rotation);
+      const transformedMeshData = convertMeshToGLTFOrientation(translatedMesh);
       const positionAccessorIndex = this.addAccessor(
         transformedMeshData.positions,
         "VEC3",

package/package.json

@@ -2,7 +2,7 @@
   "name": "circuit-json-to-gltf",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.56",
+  "version": "0.0.58",
   "scripts": {
     "test": "bun test tests/",
     "format": "biome format --write .",