@buerli.io/headless 0.0.36-beta.2 → 0.2.0

package/build/history.js

@@ -246,6 +246,16 @@ const createRecursiveBufferGeometry = async (object, drawingId, bufferGeomArray)
         }
     }
 };
+/**
+ * We traverse recursively over structure tree, starting with object and create three objects and meshes
+ * for the scene. Each part or assembly will be turned into groups and subgroups. Solids from parts will be turned
+ * into merged meshes, which are children of the group. Faces of a solid with different color
+ * or transparency will get its own mesh.
+ * @param object root object where we start building the three scene
+ * @param drawingId id of the drawing
+ * @param root the root of the scene
+ * @param options e.g. meshPerFace controls if each face gets a own mesh or if they will be combined/merged
+ */
 const createRecursiveScene = async (object, drawingId, root, options) => {
     let cDrawing = getDrawing(drawingId);
     const tree = cDrawing.structure.tree;
@@ -254,6 +264,7 @@ const createRecursiveScene = async (object, drawingId, root, options) => {
         const solids = object.link ? tree[object.link].solids : object.solids;
         if (solids != undefined) {
             let meshes = [];
+            const cachedSolids = [];
             for (const solid of solids) {
                 let cachedSolid = cDrawing.geometry.cache[solid];
                 if (!cachedSolid) {
@@ -262,30 +273,55 @@ const createRecursiveScene = async (object, drawingId, root, options) => {
                     cDrawing = getDrawing(drawingId); // get current drawing state after request
                     cachedSolid = cDrawing.geometry.cache[solid];
                 }
-                if (cachedSolid)
-                    meshes = [...meshes, ...cachedSolid.meshes.map(m => m)];
+                if (cachedSolid) {
+                    if (options === null || options === void 0 ? void 0 : options.meshPerFace) {
+                        meshes = [...meshes, ...cachedSolid.meshes.map(m => m)];
+                    }
+                    else {
+                        cachedSolids.push(cachedSolid);
+                    }
+                }
             }
-            if (meshes.length > 0) {
-                if (options === null || options === void 0 ? void 0 : options.meshPerFace) {
+            // If meshPerFace = true, we create for each face a separat mesh
+            if (options === null || options === void 0 ? void 0 : options.meshPerFace) {
+                if (meshes.length > 0) {
                     const part = new Group();
                     part.matrix = MathUtils.convertToMatrix4(object.coordinateSystem);
                     part.matrixAutoUpdate = false;
-                    part.userData = { id: object.id };
-                    part.name = object.name;
+                    part.userData = { id: object.id }; // product reference id
+                    part.name = object.name; // product reference name
                     for (const mesh of meshes) {
                         part.add(new Mesh(mesh.geometry, new MeshStandardMaterial({ color: mesh.color, transparent: mesh.opacity < 1, opacity: mesh.opacity })));
                     }
                     root.add(part);
                 }
-                else {
-                    const mesh = new Mesh();
-                    mesh.matrix = MathUtils.convertToMatrix4(object.coordinateSystem);
-                    mesh.matrixAutoUpdate = false;
-                    mesh.userData = { id: object.id };
-                    mesh.name = object.name;
-                    mesh.geometry = BufferGeometryUtils.mergeBufferGeometries(meshes.map(m => m.geometry));
-                    mesh.material = new MeshStandardMaterial();
-                    root.add(mesh);
+            }
+            else {
+                if (cachedSolids.length > 0) {
+                    const part = new Group();
+                    part.matrix = MathUtils.convertToMatrix4(object.coordinateSystem);
+                    part.matrixAutoUpdate = false;
+                    part.userData = { id: object.id }; // product reference id
+                    part.name = object.name; // product reference name
+                    // A cached solid can have different colored faces, e.g. if a brep has been decorated.
+                    // In that case, we group the meshes with the same color/tranparency
+                    for (const cs of cachedSolids) {
+                        const colorMeshesMap = getDifferentColoredMeshesFromSolid(cs);
+                        Object.keys(colorMeshesMap).forEach(key => {
+                            const coloredMeshes = colorMeshesMap[key];
+                            const mesh = new Mesh();
+                            mesh.userData = { id: cs.container.ownerId }; // solid id
+                            mesh.name = tree[cs.container.ownerId].name; // solid name
+                            mesh.geometry = BufferGeometryUtils.mergeBufferGeometries(coloredMeshes.map(m => m.geometry));
+                            mesh.material = new MeshStandardMaterial({
+                                color: coloredMeshes[0].color,
+                                transparent: coloredMeshes[0].opacity < 1,
+                                opacity: coloredMeshes[0].opacity,
+                            });
+                            part.add(mesh);
+                        });
+                    }
+                    root.add(part);
                 }
             }
         }
@@ -295,8 +331,8 @@ const createRecursiveScene = async (object, drawingId, root, options) => {
         const assembly = new Group();
         assembly.matrix = MathUtils.convertToMatrix4(object.coordinateSystem);
         assembly.matrixAutoUpdate = false;
-        assembly.userData = { id: object.id };
-        assembly.name = object.name;
+        assembly.userData = { id: object.id }; // assembly root or product reference id
+        assembly.name = object.name; // assembly root or product reference name
         root.add(assembly);
         for (const child of object.children) {
             if (tree[child].class === CCClasses.CCProductReference || tree[child].class === CCClasses.CCProductReferenceET) {
@@ -305,6 +341,24 @@ const createRecursiveScene = async (object, drawingId, root, options) => {
         }
     }
 };
+/**
+ * Get all meshes in a map, sorted by their color / transparency
+ * @param solid solid to look for the meshes
+ * @returns map (key = color/transparency as string, value = meshes array)
+ */
+const getDifferentColoredMeshesFromSolid = (solid) => {
+    const colorMeshesMap = {};
+    solid.meshes.forEach(mesh => {
+        const key = mesh.color.getHexString() + mesh.opacity.toString();
+        if (colorMeshesMap[key]) {
+            colorMeshesMap[key].push(mesh);
+        }
+        else {
+            colorMeshesMap[key] = [mesh];
+        }
+    });
+    return colorMeshesMap;
+};
 export default class CAD {
     constructor() {
         this.drawingId = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buerli.io/headless",
-  "version": "0.0.36-beta.2",
+  "version": "0.2.0",
   "description": "A non-manifold CAD workflow for the web",
   "author": "AWV Informatik AG <info@awv-informatik.ch>",
   "license": "ISC",
@@ -29,6 +29,6 @@
     "three": ">=0.138"
   },
   "dependencies": {
-    "@buerli.io/classcad": "0.0.36-beta.2"
+    "@buerli.io/classcad": "0.2.0"
   }
 }