three-stdlib 2.24.2 → 2.25.1

package/loaders/3DMLoader.cjs

@@ -1,803 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const THREE = require("three");
-const _taskCache = /* @__PURE__ */ new WeakMap();
-class Rhino3dmLoader extends THREE.Loader {
-  constructor(manager) {
-    super(manager);
-    this.libraryPath = "";
-    this.libraryPending = null;
-    this.libraryBinary = null;
-    this.libraryConfig = {};
-    this.url = "";
-    this.workerLimit = 4;
-    this.workerPool = [];
-    this.workerNextTaskID = 1;
-    this.workerSourceURL = "";
-    this.workerConfig = {};
-    this.materials = [];
-  }
-  setLibraryPath(path) {
-    this.libraryPath = path;
-    return this;
-  }
-  setWorkerLimit(workerLimit) {
-    this.workerLimit = workerLimit;
-    return this;
-  }
-  load(url, onLoad, onProgress, onError) {
-    const loader = new THREE.FileLoader(this.manager);
-    loader.setPath(this.path);
-    loader.setResponseType("arraybuffer");
-    loader.setRequestHeader(this.requestHeader);
-    this.url = url;
-    loader.load(
-      url,
-      (buffer) => {
-        if (_taskCache.has(buffer)) {
-          const cachedTask = _taskCache.get(buffer);
-          return cachedTask.promise.then(onLoad).catch(onError);
-        }
-        this.decodeObjects(buffer, url).then(onLoad).catch(onError);
-      },
-      onProgress,
-      onError
-    );
-  }
-  debug() {
-    console.log(
-      "Task load: ",
-      this.workerPool.map((worker) => worker._taskLoad)
-    );
-  }
-  decodeObjects(buffer, url) {
-    let worker;
-    let taskID;
-    const taskCost = buffer.byteLength;
-    const objectPending = this._getWorker(taskCost).then((_worker) => {
-      worker = _worker;
-      taskID = this.workerNextTaskID++;
-      return new Promise((resolve, reject) => {
-        worker._callbacks[taskID] = { resolve, reject };
-        worker.postMessage({ type: "decode", id: taskID, buffer }, [buffer]);
-      });
-    }).then((message) => this._createGeometry(message.data));
-    objectPending.catch(() => true).then(() => {
-      if (worker && taskID) {
-        this._releaseTask(worker, taskID);
-      }
-    });
-    _taskCache.set(buffer, {
-      url,
-      promise: objectPending
-    });
-    return objectPending;
-  }
-  parse(data, onLoad, onError) {
-    this.decodeObjects(data, "").then(onLoad).catch(onError);
-  }
-  _compareMaterials(material) {
-    const mat = {};
-    mat.name = material.name;
-    mat.color = {};
-    mat.color.r = material.color.r;
-    mat.color.g = material.color.g;
-    mat.color.b = material.color.b;
-    mat.type = material.type;
-    for (let i = 0; i < this.materials.length; i++) {
-      const m = this.materials[i];
-      const _mat = {};
-      _mat.name = m.name;
-      _mat.color = {};
-      _mat.color.r = m.color.r;
-      _mat.color.g = m.color.g;
-      _mat.color.b = m.color.b;
-      _mat.type = m.type;
-      if (JSON.stringify(mat) === JSON.stringify(_mat)) {
-        return m;
-      }
-    }
-    this.materials.push(material);
-    return material;
-  }
-  _createMaterial(material) {
-    if (material === void 0) {
-      return new THREE.MeshStandardMaterial({
-        color: new THREE.Color(1, 1, 1),
-        metalness: 0.8,
-        name: "default",
-        side: 2
-      });
-    }
-    const _diffuseColor = material.diffuseColor;
-    const diffusecolor = new THREE.Color(_diffuseColor.r / 255, _diffuseColor.g / 255, _diffuseColor.b / 255);
-    if (_diffuseColor.r === 0 && _diffuseColor.g === 0 && _diffuseColor.b === 0) {
-      diffusecolor.r = 1;
-      diffusecolor.g = 1;
-      diffusecolor.b = 1;
-    }
-    const mat = new THREE.MeshStandardMaterial({
-      color: diffusecolor,
-      name: material.name,
-      side: 2,
-      transparent: material.transparency > 0 ? true : false,
-      opacity: 1 - material.transparency
-    });
-    const textureLoader = new THREE.TextureLoader();
-    for (let i = 0; i < material.textures.length; i++) {
-      const texture = material.textures[i];
-      if (texture.image !== null) {
-        const map = textureLoader.load(texture.image);
-        switch (texture.type) {
-          case "Diffuse":
-            mat.map = map;
-            break;
-          case "Bump":
-            mat.bumpMap = map;
-            break;
-          case "Transparency":
-            mat.alphaMap = map;
-            mat.transparent = true;
-            break;
-          case "Emap":
-            mat.envMap = map;
-            break;
-        }
-      }
-    }
-    return mat;
-  }
-  _createGeometry(data) {
-    const object = new THREE.Object3D();
-    const instanceDefinitionObjects = [];
-    const instanceDefinitions = [];
-    const instanceReferences = [];
-    object.userData["layers"] = data.layers;
-    object.userData["groups"] = data.groups;
-    object.userData["settings"] = data.settings;
-    object.userData["objectType"] = "File3dm";
-    object.userData["materials"] = null;
-    object.name = this.url;
-    let objects = data.objects;
-    const materials = data.materials;
-    for (let i = 0; i < objects.length; i++) {
-      const obj = objects[i];
-      const attributes = obj.attributes;
-      switch (obj.objectType) {
-        case "InstanceDefinition":
-          instanceDefinitions.push(obj);
-          break;
-        case "InstanceReference":
-          instanceReferences.push(obj);
-          break;
-        default:
-          let _object;
-          if (attributes.materialIndex >= 0) {
-            const rMaterial = materials[attributes.materialIndex];
-            let material = this._createMaterial(rMaterial);
-            material = this._compareMaterials(material);
-            _object = this._createObject(obj, material);
-          } else {
-            const material = this._createMaterial();
-            _object = this._createObject(obj, material);
-          }
-          if (_object === void 0) {
-            continue;
-          }
-          const layer = data.layers[attributes.layerIndex];
-          _object.visible = layer ? data.layers[attributes.layerIndex].visible : true;
-          if (attributes.isInstanceDefinitionObject) {
-            instanceDefinitionObjects.push(_object);
-          } else {
-            object.add(_object);
-          }
-          break;
-      }
-    }
-    for (let i = 0; i < instanceDefinitions.length; i++) {
-      const iDef = instanceDefinitions[i];
-      objects = [];
-      for (let j = 0; j < iDef.attributes.objectIds.length; j++) {
-        const objId = iDef.attributes.objectIds[j];
-        for (let p = 0; p < instanceDefinitionObjects.length; p++) {
-          const idoId = instanceDefinitionObjects[p].userData.attributes.id;
-          if (objId === idoId) {
-            objects.push(instanceDefinitionObjects[p]);
-          }
-        }
-      }
-      for (let j = 0; j < instanceReferences.length; j++) {
-        const iRef = instanceReferences[j];
-        if (iRef.geometry.parentIdefId === iDef.attributes.id) {
-          const iRefObject = new THREE.Object3D();
-          const xf = iRef.geometry.xform.array;
-          const matrix = new THREE.Matrix4();
-          matrix.set(
-            xf[0],
-            xf[1],
-            xf[2],
-            xf[3],
-            xf[4],
-            xf[5],
-            xf[6],
-            xf[7],
-            xf[8],
-            xf[9],
-            xf[10],
-            xf[11],
-            xf[12],
-            xf[13],
-            xf[14],
-            xf[15]
-          );
-          iRefObject.applyMatrix4(matrix);
-          for (let p = 0; p < objects.length; p++) {
-            iRefObject.add(objects[p].clone(true));
-          }
-          object.add(iRefObject);
-        }
-      }
-    }
-    object.userData["materials"] = this.materials;
-    return object;
-  }
-  _createObject(obj, mat) {
-    const loader = new THREE.BufferGeometryLoader();
-    const attributes = obj.attributes;
-    let geometry, material, _color, color;
-    switch (obj.objectType) {
-      case "Point":
-      case "PointSet":
-        geometry = loader.parse(obj.geometry);
-        if (geometry.attributes.hasOwnProperty("color")) {
-          material = new THREE.PointsMaterial({ vertexColors: true, sizeAttenuation: false, size: 2 });
-        } else {
-          _color = attributes.drawColor;
-          color = new THREE.Color(_color.r / 255, _color.g / 255, _color.b / 255);
-          material = new THREE.PointsMaterial({ color, sizeAttenuation: false, size: 2 });
-        }
-        material = this._compareMaterials(material);
-        const points = new THREE.Points(geometry, material);
-        points.userData["attributes"] = attributes;
-        points.userData["objectType"] = obj.objectType;
-        if (attributes.name) {
-          points.name = attributes.name;
-        }
-        return points;
-      case "Mesh":
-      case "Extrusion":
-      case "SubD":
-      case "Brep":
-        if (obj.geometry === null)
-          return;
-        geometry = loader.parse(obj.geometry);
-        if (geometry.attributes.hasOwnProperty("color")) {
-          mat.vertexColors = true;
-        }
-        if (mat === null) {
-          mat = this._createMaterial();
-          mat = this._compareMaterials(mat);
-        }
-        const mesh = new THREE.Mesh(geometry, mat);
-        mesh.castShadow = attributes.castsShadows;
-        mesh.receiveShadow = attributes.receivesShadows;
-        mesh.userData["attributes"] = attributes;
-        mesh.userData["objectType"] = obj.objectType;
-        if (attributes.name) {
-          mesh.name = attributes.name;
-        }
-        return mesh;
-      case "Curve":
-        geometry = loader.parse(obj.geometry);
-        _color = attributes.drawColor;
-        color = new THREE.Color(_color.r / 255, _color.g / 255, _color.b / 255);
-        material = new THREE.LineBasicMaterial({ color });
-        material = this._compareMaterials(material);
-        const lines = new THREE.Line(geometry, material);
-        lines.userData["attributes"] = attributes;
-        lines.userData["objectType"] = obj.objectType;
-        if (attributes.name) {
-          lines.name = attributes.name;
-        }
-        return lines;
-      case "TextDot":
-        geometry = obj.geometry;
-        const ctx = document.createElement("canvas").getContext("2d");
-        const font = `${geometry.fontHeight}px ${geometry.fontFace}`;
-        ctx.font = font;
-        const width = ctx.measureText(geometry.text).width + 10;
-        const height = geometry.fontHeight + 10;
-        const r = window.devicePixelRatio;
-        ctx.canvas.width = width * r;
-        ctx.canvas.height = height * r;
-        ctx.canvas.style.width = width + "px";
-        ctx.canvas.style.height = height + "px";
-        ctx.setTransform(r, 0, 0, r, 0, 0);
-        ctx.font = font;
-        ctx.textBaseline = "middle";
-        ctx.textAlign = "center";
-        color = attributes.drawColor;
-        ctx.fillStyle = `rgba(${color.r},${color.g},${color.b},${color.a})`;
-        ctx.fillRect(0, 0, width, height);
-        ctx.fillStyle = "white";
-        ctx.fillText(geometry.text, width / 2, height / 2);
-        const texture = new THREE.CanvasTexture(ctx.canvas);
-        texture.minFilter = THREE.LinearFilter;
-        texture.wrapS = THREE.ClampToEdgeWrapping;
-        texture.wrapT = THREE.ClampToEdgeWrapping;
-        material = new THREE.SpriteMaterial({ map: texture, depthTest: false });
-        const sprite = new THREE.Sprite(material);
-        sprite.position.set(geometry.point[0], geometry.point[1], geometry.point[2]);
-        sprite.scale.set(width / 10, height / 10, 1);
-        sprite.userData["attributes"] = attributes;
-        sprite.userData["objectType"] = obj.objectType;
-        if (attributes.name) {
-          sprite.name = attributes.name;
-        }
-        return sprite;
-      case "Light":
-        geometry = obj.geometry;
-        let light;
-        if (geometry.isDirectionalLight) {
-          light = new THREE.DirectionalLight();
-          light.castShadow = attributes.castsShadows;
-          light.position.set(geometry.location[0], geometry.location[1], geometry.location[2]);
-          light.target.position.set(geometry.direction[0], geometry.direction[1], geometry.direction[2]);
-          light.shadow.normalBias = 0.1;
-        } else if (geometry.isPointLight) {
-          light = new THREE.PointLight();
-          light.castShadow = attributes.castsShadows;
-          light.position.set(geometry.location[0], geometry.location[1], geometry.location[2]);
-          light.shadow.normalBias = 0.1;
-        } else if (geometry.isRectangularLight) {
-          light = new THREE.RectAreaLight();
-          const width2 = Math.abs(geometry.width[2]);
-          const height2 = Math.abs(geometry.length[0]);
-          light.position.set(geometry.location[0] - height2 / 2, geometry.location[1], geometry.location[2] - width2 / 2);
-          light.height = height2;
-          light.width = width2;
-          light.lookAt(new THREE.Vector3(geometry.direction[0], geometry.direction[1], geometry.direction[2]));
-        } else if (geometry.isSpotLight) {
-          light = new THREE.SpotLight();
-          light.castShadow = attributes.castsShadows;
-          light.position.set(geometry.location[0], geometry.location[1], geometry.location[2]);
-          light.target.position.set(geometry.direction[0], geometry.direction[1], geometry.direction[2]);
-          light.angle = geometry.spotAngleRadians;
-          light.shadow.normalBias = 0.1;
-        } else if (geometry.isLinearLight) {
-          console.warn("THREE.3DMLoader:  No conversion exists for linear lights.");
-          return;
-        }
-        if (light) {
-          light.intensity = geometry.intensity;
-          _color = geometry.diffuse;
-          color = new THREE.Color(_color.r / 255, _color.g / 255, _color.b / 255);
-          light.color = color;
-          light.userData["attributes"] = attributes;
-          light.userData["objectType"] = obj.objectType;
-        }
-        return light;
-    }
-  }
-  _initLibrary() {
-    if (!this.libraryPending) {
-      const jsLoader = new THREE.FileLoader(this.manager);
-      jsLoader.setPath(this.libraryPath);
-      const jsContent = new Promise((resolve, reject) => {
-        jsLoader.load("rhino3dm.js", resolve, void 0, reject);
-      });
-      const binaryLoader = new THREE.FileLoader(this.manager);
-      binaryLoader.setPath(this.libraryPath);
-      binaryLoader.setResponseType("arraybuffer");
-      const binaryContent = new Promise((resolve, reject) => {
-        binaryLoader.load("rhino3dm.wasm", resolve, void 0, reject);
-      });
-      this.libraryPending = Promise.all([jsContent, binaryContent]).then(([jsContent2, binaryContent2]) => {
-        this.libraryConfig.wasmBinary = binaryContent2;
-        const fn = Rhino3dmWorker.toString();
-        const body = [
-          "/* rhino3dm.js */",
-          jsContent2,
-          "/* worker */",
-          fn.substring(fn.indexOf("{") + 1, fn.lastIndexOf("}"))
-        ].join("\n");
-        this.workerSourceURL = URL.createObjectURL(new Blob([body]));
-      });
-    }
-    return this.libraryPending;
-  }
-  _getWorker(taskCost) {
-    return this._initLibrary().then(() => {
-      if (this.workerPool.length < this.workerLimit) {
-        const worker2 = new Worker(this.workerSourceURL);
-        worker2._callbacks = {};
-        worker2._taskCosts = {};
-        worker2._taskLoad = 0;
-        worker2.postMessage({
-          type: "init",
-          libraryConfig: this.libraryConfig
-        });
-        worker2.onmessage = function(e) {
-          const message = e.data;
-          switch (message.type) {
-            case "decode":
-              worker2._callbacks[message.id].resolve(message);
-              break;
-            case "error":
-              worker2._callbacks[message.id].reject(message);
-              break;
-            default:
-              console.error('THREE.Rhino3dmLoader: Unexpected message, "' + message.type + '"');
-          }
-        };
-        this.workerPool.push(worker2);
-      } else {
-        this.workerPool.sort(function(a, b) {
-          return a._taskLoad > b._taskLoad ? -1 : 1;
-        });
-      }
-      const worker = this.workerPool[this.workerPool.length - 1];
-      worker._taskLoad += taskCost;
-      return worker;
-    });
-  }
-  _releaseTask(worker, taskID) {
-    worker._taskLoad -= worker._taskCosts[taskID];
-    delete worker._callbacks[taskID];
-    delete worker._taskCosts[taskID];
-  }
-  dispose() {
-    for (let i = 0; i < this.workerPool.length; ++i) {
-      this.workerPool[i].terminate();
-    }
-    this.workerPool.length = 0;
-    return this;
-  }
-}
-function Rhino3dmWorker() {
-  let libraryPending;
-  let libraryConfig;
-  let rhino;
-  onmessage = function(e) {
-    const message = e.data;
-    switch (message.type) {
-      case "init":
-        libraryConfig = message.libraryConfig;
-        const wasmBinary = libraryConfig.wasmBinary;
-        let RhinoModule;
-        libraryPending = new Promise(function(resolve) {
-          RhinoModule = { wasmBinary, onRuntimeInitialized: resolve };
-          rhino3dm(RhinoModule);
-        }).then(() => {
-          rhino = RhinoModule;
-        });
-        break;
-      case "decode":
-        const buffer = message.buffer;
-        libraryPending.then(() => {
-          const data = decodeObjects(rhino, buffer);
-          self.postMessage({ type: "decode", id: message.id, data });
-        });
-        break;
-    }
-  };
-  function decodeObjects(rhino2, buffer) {
-    const arr = new Uint8Array(buffer);
-    const doc = rhino2.File3dm.fromByteArray(arr);
-    const objects = [];
-    const materials = [];
-    const layers = [];
-    const views = [];
-    const namedViews = [];
-    const groups = [];
-    const objs = doc.objects();
-    const cnt = objs.count;
-    for (let i = 0; i < cnt; i++) {
-      const _object = objs.get(i);
-      const object = extractObjectData(_object, doc);
-      _object.delete();
-      if (object) {
-        objects.push(object);
-      }
-    }
-    for (let i = 0; i < doc.instanceDefinitions().count(); i++) {
-      const idef = doc.instanceDefinitions().get(i);
-      const idefAttributes = extractProperties(idef);
-      idefAttributes.objectIds = idef.getObjectIds();
-      objects.push({ geometry: null, attributes: idefAttributes, objectType: "InstanceDefinition" });
-    }
-    const textureTypes = [
-      // rhino.TextureType.Bitmap,
-      rhino2.TextureType.Diffuse,
-      rhino2.TextureType.Bump,
-      rhino2.TextureType.Transparency,
-      rhino2.TextureType.Opacity,
-      rhino2.TextureType.Emap
-    ];
-    const pbrTextureTypes = [
-      rhino2.TextureType.PBR_BaseColor,
-      rhino2.TextureType.PBR_Subsurface,
-      rhino2.TextureType.PBR_SubsurfaceScattering,
-      rhino2.TextureType.PBR_SubsurfaceScatteringRadius,
-      rhino2.TextureType.PBR_Metallic,
-      rhino2.TextureType.PBR_Specular,
-      rhino2.TextureType.PBR_SpecularTint,
-      rhino2.TextureType.PBR_Roughness,
-      rhino2.TextureType.PBR_Anisotropic,
-      rhino2.TextureType.PBR_Anisotropic_Rotation,
-      rhino2.TextureType.PBR_Sheen,
-      rhino2.TextureType.PBR_SheenTint,
-      rhino2.TextureType.PBR_Clearcoat,
-      rhino2.TextureType.PBR_ClearcoatBump,
-      rhino2.TextureType.PBR_ClearcoatRoughness,
-      rhino2.TextureType.PBR_OpacityIor,
-      rhino2.TextureType.PBR_OpacityRoughness,
-      rhino2.TextureType.PBR_Emission,
-      rhino2.TextureType.PBR_AmbientOcclusion,
-      rhino2.TextureType.PBR_Displacement
-    ];
-    for (let i = 0; i < doc.materials().count(); i++) {
-      const _material = doc.materials().get(i);
-      const _pbrMaterial = _material.physicallyBased();
-      let material = extractProperties(_material);
-      const textures = [];
-      for (let j = 0; j < textureTypes.length; j++) {
-        const _texture = _material.getTexture(textureTypes[j]);
-        if (_texture) {
-          let textureType = textureTypes[j].constructor.name;
-          textureType = textureType.substring(12, textureType.length);
-          const texture = { type: textureType };
-          const image = doc.getEmbeddedFileAsBase64(_texture.fileName);
-          if (image) {
-            texture.image = "data:image/png;base64," + image;
-          } else {
-            console.warn(`THREE.3DMLoader: Image for ${textureType} texture not embedded in file.`);
-            texture.image = null;
-          }
-          textures.push(texture);
-          _texture.delete();
-        }
-      }
-      material.textures = textures;
-      if (_pbrMaterial.supported) {
-        console.log("pbr true");
-        for (let j = 0; j < pbrTextureTypes.length; j++) {
-          const _texture = _material.getTexture(textureTypes[j]);
-          if (_texture) {
-            const image = doc.getEmbeddedFileAsBase64(_texture.fileName);
-            let textureType = textureTypes[j].constructor.name;
-            textureType = textureType.substring(12, textureType.length);
-            const texture = { type: textureType, image: "data:image/png;base64," + image };
-            textures.push(texture);
-            _texture.delete();
-          }
-        }
-        const pbMaterialProperties = extractProperties(_material.physicallyBased());
-        material = Object.assign(pbMaterialProperties, material);
-      }
-      materials.push(material);
-      _material.delete();
-      _pbrMaterial.delete();
-    }
-    for (let i = 0; i < doc.layers().count(); i++) {
-      const _layer = doc.layers().get(i);
-      const layer = extractProperties(_layer);
-      layers.push(layer);
-      _layer.delete();
-    }
-    for (let i = 0; i < doc.views().count(); i++) {
-      const _view = doc.views().get(i);
-      const view = extractProperties(_view);
-      views.push(view);
-      _view.delete();
-    }
-    for (let i = 0; i < doc.namedViews().count(); i++) {
-      const _namedView = doc.namedViews().get(i);
-      const namedView = extractProperties(_namedView);
-      namedViews.push(namedView);
-      _namedView.delete();
-    }
-    for (let i = 0; i < doc.groups().count(); i++) {
-      const _group = doc.groups().get(i);
-      const group = extractProperties(_group);
-      groups.push(group);
-      _group.delete();
-    }
-    const settings = extractProperties(doc.settings());
-    doc.delete();
-    return { objects, materials, layers, views, namedViews, groups, settings };
-  }
-  function extractObjectData(object, doc) {
-    const _geometry = object.geometry();
-    const _attributes = object.attributes();
-    let objectType = _geometry.objectType;
-    let geometry, attributes, position, data, mesh;
-    switch (objectType) {
-      case rhino.ObjectType.Curve:
-        const pts = curveToPoints(_geometry, 100);
-        position = {};
-        attributes = {};
-        data = {};
-        position.itemSize = 3;
-        position.type = "Float32Array";
-        position.array = [];
-        for (let j = 0; j < pts.length; j++) {
-          position.array.push(pts[j][0]);
-          position.array.push(pts[j][1]);
-          position.array.push(pts[j][2]);
-        }
-        attributes.position = position;
-        data.attributes = attributes;
-        geometry = { data };
-        break;
-      case rhino.ObjectType.Point:
-        const pt = _geometry.location;
-        position = {};
-        const color = {};
-        attributes = {};
-        data = {};
-        position.itemSize = 3;
-        position.type = "Float32Array";
-        position.array = [pt[0], pt[1], pt[2]];
-        const _color = _attributes.drawColor(doc);
-        color.itemSize = 3;
-        color.type = "Float32Array";
-        color.array = [_color.r / 255, _color.g / 255, _color.b / 255];
-        attributes.position = position;
-        attributes.color = color;
-        data.attributes = attributes;
-        geometry = { data };
-        break;
-      case rhino.ObjectType.PointSet:
-      case rhino.ObjectType.Mesh:
-        geometry = _geometry.toThreejsJSON();
-        break;
-      case rhino.ObjectType.Brep:
-        const faces = _geometry.faces();
-        mesh = new rhino.Mesh();
-        for (let faceIndex = 0; faceIndex < faces.count; faceIndex++) {
-          const face = faces.get(faceIndex);
-          const _mesh = face.getMesh(rhino.MeshType.Any);
-          if (_mesh) {
-            mesh.append(_mesh);
-            _mesh.delete();
-          }
-          face.delete();
-        }
-        if (mesh.faces().count > 0) {
-          mesh.compact();
-          geometry = mesh.toThreejsJSON();
-          faces.delete();
-        }
-        mesh.delete();
-        break;
-      case rhino.ObjectType.Extrusion:
-        mesh = _geometry.getMesh(rhino.MeshType.Any);
-        if (mesh) {
-          geometry = mesh.toThreejsJSON();
-          mesh.delete();
-        }
-        break;
-      case rhino.ObjectType.TextDot:
-        geometry = extractProperties(_geometry);
-        break;
-      case rhino.ObjectType.Light:
-        geometry = extractProperties(_geometry);
-        break;
-      case rhino.ObjectType.InstanceReference:
-        geometry = extractProperties(_geometry);
-        geometry.xform = extractProperties(_geometry.xform);
-        geometry.xform.array = _geometry.xform.toFloatArray(true);
-        break;
-      case rhino.ObjectType.SubD:
-        _geometry.subdivide(3);
-        mesh = rhino.Mesh.createFromSubDControlNet(_geometry);
-        if (mesh) {
-          geometry = mesh.toThreejsJSON();
-          mesh.delete();
-        }
-        break;
-      default:
-        console.warn(`THREE.3DMLoader: TODO: Implement ${objectType.constructor.name}`);
-        break;
-    }
-    if (geometry) {
-      attributes = extractProperties(_attributes);
-      attributes.geometry = extractProperties(_geometry);
-      if (_attributes.groupCount > 0) {
-        attributes.groupIds = _attributes.getGroupList();
-      }
-      if (_attributes.userStringCount > 0) {
-        attributes.userStrings = _attributes.getUserStrings();
-      }
-      if (_geometry.userStringCount > 0) {
-        attributes.geometry.userStrings = _geometry.getUserStrings();
-      }
-      attributes.drawColor = _attributes.drawColor(doc);
-      objectType = objectType.constructor.name;
-      objectType = objectType.substring(11, objectType.length);
-      return { geometry, attributes, objectType };
-    } else {
-      console.warn(`THREE.3DMLoader: ${objectType.constructor.name} has no associated mesh geometry.`);
-    }
-  }
-  function extractProperties(object) {
-    const result = {};
-    for (const property in object) {
-      const value = object[property];
-      if (typeof value !== "function") {
-        if (typeof value === "object" && value !== null && value.hasOwnProperty("constructor")) {
-          result[property] = { name: value.constructor.name, value: value.value };
-        } else {
-          result[property] = value;
-        }
-      } else {
-      }
-    }
-    return result;
-  }
-  function curveToPoints(curve, pointLimit) {
-    let pointCount = pointLimit;
-    let rc = [];
-    const ts = [];
-    if (curve instanceof rhino.LineCurve) {
-      return [curve.pointAtStart, curve.pointAtEnd];
-    }
-    if (curve instanceof rhino.PolylineCurve) {
-      pointCount = curve.pointCount;
-      for (let i = 0; i < pointCount; i++) {
-        rc.push(curve.point(i));
-      }
-      return rc;
-    }
-    if (curve instanceof rhino.PolyCurve) {
-      const segmentCount = curve.segmentCount;
-      for (let i = 0; i < segmentCount; i++) {
-        const segment = curve.segmentCurve(i);
-        const segmentArray = curveToPoints(segment, pointCount);
-        rc = rc.concat(segmentArray);
-        segment.delete();
-      }
-      return rc;
-    }
-    if (curve instanceof rhino.ArcCurve) {
-      pointCount = Math.floor(curve.angleDegrees / 5);
-      pointCount = pointCount < 2 ? 2 : pointCount;
-    }
-    if (curve instanceof rhino.NurbsCurve && curve.degree === 1) {
-      const pLine = curve.tryGetPolyline();
-      for (let i = 0; i < pLine.count; i++) {
-        rc.push(pLine.get(i));
-      }
-      pLine.delete();
-      return rc;
-    }
-    const domain = curve.domain;
-    const divisions = pointCount - 1;
-    for (let j = 0; j < pointCount; j++) {
-      const t = domain[0] + j / divisions * (domain[1] - domain[0]);
-      if (t === domain[0] || t === domain[1]) {
-        ts.push(t);
-        continue;
-      }
-      const tan = curve.tangentAt(t);
-      const prevTan = curve.tangentAt(ts.slice(-1)[0]);
-      const tS = tan[0] * tan[0] + tan[1] * tan[1] + tan[2] * tan[2];
-      const ptS = prevTan[0] * prevTan[0] + prevTan[1] * prevTan[1] + prevTan[2] * prevTan[2];
-      const denominator = Math.sqrt(tS * ptS);
-      let angle;
-      if (denominator === 0) {
-        angle = Math.PI / 2;
-      } else {
-        const theta = (tan.x * prevTan.x + tan.y * prevTan.y + tan.z * prevTan.z) / denominator;
-        angle = Math.acos(Math.max(-1, Math.min(1, theta)));
-      }
-      if (angle < 0.1)
-        continue;
-      ts.push(t);
-    }
-    rc = ts.map((t) => curve.pointAt(t));
-    return rc;
-  }
-}
-exports.Rhino3dmLoader = Rhino3dmLoader;