simsite/frontend/node_modules/three-stdlib/loaders/3DMLoader.cjs

"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;
        }
      }
    }
    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;
//# sourceMappingURL=3DMLoader.cjs.map