circuit-json-to-gltf 0.0.57 → 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) {
@@ -14167,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);
@@ -14226,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) {
@@ -14286,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);
           }
@@ -14352,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);
           }

package/package.json

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