circuit-json-to-gltf 0.0.13 → 0.0.14

package/dist/index.d.ts

@@ -135,7 +135,7 @@ declare function clearSTLCache(): void;
 declare function loadOBJ(url: string, transform?: CoordinateTransformConfig): Promise<OBJMesh>;
 declare function clearOBJCache(): void;
 
-declare function loadGLB(url: string, transform?: CoordinateTransformConfig): Promise<STLMesh>;
+declare function loadGLB(url: string, transform?: CoordinateTransformConfig): Promise<STLMesh | OBJMesh>;
 declare function clearGLBCache(): void;
 
 declare function convertCircuitJsonTo3D(circuitJson: CircuitJson, options?: CircuitTo3DOptions): Promise<Scene3D>;

package/dist/index.js

@@ -534,11 +534,59 @@ function parseGLB(buffer, transform) {
     axisMapping: { x: "x", y: "z", z: "y" }
   };
   const transformedTriangles = transformTriangles(triangles, finalConfig);
+  const hasColors = transformedTriangles.some((t) => t.color !== void 0);
+  if (hasColors) {
+    return convertToOBJMesh(transformedTriangles);
+  }
   return {
     triangles: transformedTriangles,
     boundingBox: calculateBoundingBox3(transformedTriangles)
   };
 }
+function convertToOBJMesh(triangles) {
+  const colorGroups = /* @__PURE__ */ new Map();
+  for (const triangle of triangles) {
+    const colorKey = triangle.color ? JSON.stringify(triangle.color) : "default";
+    if (!colorGroups.has(colorKey)) {
+      colorGroups.set(colorKey, []);
+    }
+    colorGroups.get(colorKey).push(triangle);
+  }
+  const materials = /* @__PURE__ */ new Map();
+  const materialIndexMap = /* @__PURE__ */ new Map();
+  let materialIndex = 0;
+  const trianglesWithMaterialIndex = [];
+  for (const [colorKey, groupTriangles] of colorGroups) {
+    const materialName = `Material_${materialIndex}`;
+    materialIndexMap.set(materialName, materialIndex);
+    if (colorKey === "default") {
+      materials.set(materialName, {
+        name: materialName,
+        color: [179, 179, 179, 1]
+        // 0.7 * 255 = 179
+      });
+    } else {
+      const color = JSON.parse(colorKey);
+      materials.set(materialName, {
+        name: materialName,
+        color
+      });
+    }
+    for (const triangle of groupTriangles) {
+      trianglesWithMaterialIndex.push({
+        ...triangle,
+        materialIndex
+      });
+    }
+    materialIndex++;
+  }
+  return {
+    triangles: trianglesWithMaterialIndex,
+    boundingBox: calculateBoundingBox3(trianglesWithMaterialIndex),
+    materials,
+    materialIndexMap
+  };
+}
 function extractTrianglesFromGLTF(gltf, binaryBuffer) {
   const triangles = [];
   if (!gltf.meshes || !gltf.accessors || !gltf.bufferViews) {
@@ -570,6 +618,29 @@ function extractTrianglesFromGLTF(gltf, binaryBuffer) {
           binaryBuffer
         );
       }
+      let vertexColors;
+      const colorAccessorIndex = primitive.attributes.COLOR_0;
+      if (colorAccessorIndex !== void 0) {
+        const colorAccessor = gltf.accessors[colorAccessorIndex];
+        vertexColors = getAccessorData(
+          colorAccessor,
+          gltf.bufferViews,
+          binaryBuffer
+        );
+      }
+      let materialColor;
+      if (!vertexColors && primitive.material !== void 0 && gltf.materials) {
+        const material = gltf.materials[primitive.material];
+        if (material?.pbrMetallicRoughness?.baseColorFactor) {
+          const factor = material.pbrMetallicRoughness.baseColorFactor;
+          materialColor = [
+            Math.round(factor[0] * 255),
+            Math.round(factor[1] * 255),
+            Math.round(factor[2] * 255),
+            factor[3]
+          ];
+        }
+      }
       let indices;
       if (primitive.indices !== void 0) {
         const indexAccessor = gltf.accessors[primitive.indices];
@@ -619,7 +690,44 @@ function extractTrianglesFromGLTF(gltf, binaryBuffer) {
           } else {
             normal = computeNormal(v0, v1, v2);
           }
-          triangles.push({ vertices: [v0, v1, v2], normal });
+          let triangleColor;
+          if (vertexColors) {
+            const componentsPerColor = vertexColors.length / vertexCount;
+            if (componentsPerColor === 3) {
+              triangleColor = [
+                Math.round(
+                  (vertexColors[i0 * 3] + vertexColors[i1 * 3] + vertexColors[i2 * 3]) / 3 * 255
+                ),
+                Math.round(
+                  (vertexColors[i0 * 3 + 1] + vertexColors[i1 * 3 + 1] + vertexColors[i2 * 3 + 1]) / 3 * 255
+                ),
+                Math.round(
+                  (vertexColors[i0 * 3 + 2] + vertexColors[i1 * 3 + 2] + vertexColors[i2 * 3 + 2]) / 3 * 255
+                ),
+                1
+              ];
+            } else if (componentsPerColor === 4) {
+              triangleColor = [
+                Math.round(
+                  (vertexColors[i0 * 4] + vertexColors[i1 * 4] + vertexColors[i2 * 4]) / 3 * 255
+                ),
+                Math.round(
+                  (vertexColors[i0 * 4 + 1] + vertexColors[i1 * 4 + 1] + vertexColors[i2 * 4 + 1]) / 3 * 255
+                ),
+                Math.round(
+                  (vertexColors[i0 * 4 + 2] + vertexColors[i1 * 4 + 2] + vertexColors[i2 * 4 + 2]) / 3 * 255
+                ),
+                (vertexColors[i0 * 4 + 3] + vertexColors[i1 * 4 + 3] + vertexColors[i2 * 4 + 3]) / 3
+              ];
+            }
+          } else {
+            triangleColor = materialColor;
+          }
+          triangles.push({
+            vertices: [v0, v1, v2],
+            normal,
+            color: triangleColor
+          });
         }
       } else {
         for (let i = 0; i < vertexCount; i += 3) {
@@ -648,7 +756,44 @@ function extractTrianglesFromGLTF(gltf, binaryBuffer) {
           } else {
             normal = computeNormal(v0, v1, v2);
           }
-          triangles.push({ vertices: [v0, v1, v2], normal });
+          let triangleColor;
+          if (vertexColors) {
+            const componentsPerColor = vertexColors.length / vertexCount;
+            if (componentsPerColor === 3) {
+              triangleColor = [
+                Math.round(
+                  (vertexColors[i * 3] + vertexColors[(i + 1) * 3] + vertexColors[(i + 2) * 3]) / 3 * 255
+                ),
+                Math.round(
+                  (vertexColors[i * 3 + 1] + vertexColors[(i + 1) * 3 + 1] + vertexColors[(i + 2) * 3 + 1]) / 3 * 255
+                ),
+                Math.round(
+                  (vertexColors[i * 3 + 2] + vertexColors[(i + 1) * 3 + 2] + vertexColors[(i + 2) * 3 + 2]) / 3 * 255
+                ),
+                1
+              ];
+            } else if (componentsPerColor === 4) {
+              triangleColor = [
+                Math.round(
+                  (vertexColors[i * 4] + vertexColors[(i + 1) * 4] + vertexColors[(i + 2) * 4]) / 3 * 255
+                ),
+                Math.round(
+                  (vertexColors[i * 4 + 1] + vertexColors[(i + 1) * 4 + 1] + vertexColors[(i + 2) * 4 + 1]) / 3 * 255
+                ),
+                Math.round(
+                  (vertexColors[i * 4 + 2] + vertexColors[(i + 1) * 4 + 2] + vertexColors[(i + 2) * 4 + 2]) / 3 * 255
+                ),
+                (vertexColors[i * 4 + 3] + vertexColors[(i + 1) * 4 + 3] + vertexColors[(i + 2) * 4 + 3]) / 3
+              ];
+            }
+          } else {
+            triangleColor = materialColor;
+          }
+          triangles.push({
+            vertices: [v0, v1, v2],
+            normal,
+            color: triangleColor
+          });
         }
       }
     }
@@ -1018,7 +1163,17 @@ async function convertCircuitJsonTo3D(circuitJson, options = {}) {
       meshType
     };
     if (cad.rotation) {
-      box.rotation = convertRotationFromCadRotation(cad.rotation);
+      if (model_glb_url || model_gltf_url) {
+        box.rotation = convertRotationFromCadRotation({
+          x: cad.rotation.x,
+          y: cad.rotation.z,
+          // Circuit Z rotation becomes model Y rotation
+          z: cad.rotation.y
+          // Circuit Y rotation becomes model Z rotation
+        });
+      } else {
+        box.rotation = convertRotationFromCadRotation(cad.rotation);
+      }
     }
     const defaultTransform = coordinateTransform ?? (model_glb_url || model_gltf_url ? void 0 : COORDINATE_TRANSFORMS.Z_UP_TO_Y_UP_USB_FIX);
     if (model_stl_url) {
@@ -1710,18 +1865,19 @@ var GLTFBuilder = class {
     const meshDataArray = createMeshFromOBJ(objMesh);
     const objMaterialIndices = /* @__PURE__ */ new Map();
     for (const [name, objMaterial] of objMesh.materials) {
-      const dissolve = objMaterial.dissolve ?? 1;
-      const alpha = 1 - dissolve;
-      let baseColor = [0.3, 0.3, 0.3, alpha];
+      let baseColor = [0.3, 0.3, 0.3, 1];
       if (objMaterial.color) {
         const color = typeof objMaterial.color === "string" ? this.parseColorString(objMaterial.color) : [
           objMaterial.color[0] / 255,
           objMaterial.color[1] / 255,
           objMaterial.color[2] / 255,
-          alpha
+          objMaterial.color[3]
+          // Use the alpha from the color
         ];
-        baseColor = [color[0], color[1], color[2], alpha];
+        baseColor = [color[0], color[1], color[2], color[3]];
       }
+      const alpha = objMaterial.dissolve !== void 0 ? 1 - objMaterial.dissolve : baseColor[3];
+      baseColor[3] = alpha;
       const gltfMaterialIndex = this.addMaterial({
         name: `OBJ_${name}`,
         pbrMetallicRoughness: {

package/package.json

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