@buerli.io/headless 0.5.0-beta.2 → 0.5.0-beta.4

package/build/esm/solid.js

@@ -1,7 +1,14 @@
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 /* eslint-disable max-lines */
 import { ccAPI } from '@buerli.io/classcad';
 import { api, getDrawing } from '@buerli.io/core';
-import { Mesh, MeshStandardMaterial, Scene, Shape } from 'three';
+import { Group, Mesh, MeshStandardMaterial, Scene, Shape } from 'three';
 import * as BufferGeometryUtils_ from 'three/examples/jsm/utils/BufferGeometryUtils';
 const solidAPI = ccAPI.solid;
 let BufferGeometryUtils = BufferGeometryUtils_;
@@ -231,25 +238,73 @@ export default class CAD {
                         return BufferGeometryUtils.mergeBufferGeometries(entity.meshes.map(m => m.geometry));
                     }
                 },
-                createScene: async (solid) => {
+                createScene: async (solids, options) => {
+                    var e_1, _a;
                     await this.queue;
                     this.queue = Promise.resolve(0);
-                    const rSolid = await solid;
-                    await ccAPI.baseModeler.requestVisualisationOfObject(drawingId, rSolid);
-                    const entity = await getEntity(drawingId, rSolid);
-                    const group = new Scene();
-                    group.userData = { id: rSolid };
-                    group.name = 'Solid';
-                    if (entity != null) {
-                        for (const mesh of entity.meshes) {
-                            group.add(new Mesh(mesh.geometry, new MeshStandardMaterial({
-                                color: mesh.color,
-                                transparent: mesh.opacity < 1,
-                                opacity: mesh.opacity,
-                            })));
+                    const scene = new Scene();
+                    scene.name = 'Scene'; // Default name for the scene
+                    const part = new Group();
+                    part.name = 'Part'; // Default name for the part
+                    const _solids = [];
+                    const meshes = [];
+                    try {
+                        for (var solids_1 = __asyncValues(solids), solids_1_1; solids_1_1 = await solids_1.next(), !solids_1_1.done;) {
+                            const solid = solids_1_1.value;
+                            await ccAPI.baseModeler.requestVisualisationOfObject(drawingId, solid);
+                            const cDrawing = getDrawing(drawingId);
+                            const solidObject = cDrawing.structure.tree[solid];
+                            if (solidObject) {
+                                const _solid = new Group();
+                                _solid.name = solidObject.name;
+                                _solid.userData = { id: solidObject.id }; // add solid id to the userData
+                                const entities = solidObject.geometryIdList;
+                                if (entities && entities.length > 0) {
+                                    const entity = cDrawing.geometry.cache[entities[0]];
+                                    if (entity && entity.meshes.length > 0) {
+                                        if (options === null || options === void 0 ? void 0 : options.meshPerGeometry) {
+                                            // Create a mesh for each geometry element
+                                            entity.meshes.forEach(m => {
+                                                const mesh = new Mesh();
+                                                mesh.userData = { id: m.graphicId }; // add graphic id to the userData
+                                                mesh.geometry = m.geometry;
+                                                mesh.material = new MeshStandardMaterial({
+                                                    color: m.color,
+                                                    transparent: m.opacity < 1,
+                                                    opacity: m.opacity,
+                                                });
+                                                _solid.add(mesh);
+                                                meshes.push(mesh);
+                                            });
+                                        }
+                                        else {
+                                            // Merge all geometries into one mesh
+                                            const mesh = new Mesh();
+                                            mesh.geometry = BufferGeometryUtils.mergeBufferGeometries(entity.meshes.map(m => m.geometry));
+                                            mesh.material = new MeshStandardMaterial({
+                                                color: entity.meshes[0].color,
+                                                transparent: entity.meshes[0].opacity < 1,
+                                                opacity: entity.meshes[0].opacity,
+                                            });
+                                            _solid.add(mesh); // Add mesh to solid of the scene
+                                            meshes.push(mesh); // Collect mesh to return later
+                                        }
+                                        part.add(_solid); // Add solid to part of the scene
+                                        _solids.push(_solid); // Collect solid to return later
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (solids_1_1 && !solids_1_1.done && (_a = solids_1.return)) await _a.call(solids_1);
                         }
+                        finally { if (e_1) throw e_1.error; }
                     }
-                    return group;
+                    scene.add(part); // Add part to the scene
+                    return { scene, part, solids: _solids, meshes };
                 },
                 cylinder: (length, diameter) => {
                     return this.resolve(async () => {