@polarfront-lab/ionian 1.1.0 → 1.3.0

package/dist/ionian.js

@@ -2,7 +2,7 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import * as THREE from "three";
-import { Mesh, OrthographicCamera, BufferGeometry, Float32BufferAttribute, NearestFilter, ShaderMaterial, WebGLRenderTarget, FloatType, RGBAFormat, DataTexture, ClampToEdgeWrapping } from "three";
+import { Triangle, Vector3, Vector2, Mesh, OrthographicCamera, BufferGeometry, Float32BufferAttribute, NearestFilter, ShaderMaterial, WebGLRenderTarget, FloatType, RGBAFormat, DataTexture, ClampToEdgeWrapping } from "three";
 import { GLTFLoader, DRACOLoader } from "three-stdlib";
 const linear = (n) => n;
 function mitt(n) {
@@ -44,2046 +44,291 @@ class DefaultEventEmitter {
     this.emitter.all.clear();
   }
 }
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-const proxyMarker = Symbol("Comlink.proxy");
-const createEndpoint = Symbol("Comlink.endpoint");
-const releaseProxy = Symbol("Comlink.releaseProxy");
-const finalizer = Symbol("Comlink.finalizer");
-const throwMarker = Symbol("Comlink.thrown");
-const isObject = (val) => typeof val === "object" && val !== null || typeof val === "function";
-const proxyTransferHandler = {
-  canHandle: (val) => isObject(val) && val[proxyMarker],
-  serialize(obj) {
-    const { port1, port2 } = new MessageChannel();
-    expose(obj, port1);
-    return [port2, [port2]];
-  },
-  deserialize(port) {
-    port.start();
-    return wrap(port);
-  }
-};
-const throwTransferHandler = {
-  canHandle: (value) => isObject(value) && throwMarker in value,
-  serialize({ value }) {
-    let serialized;
-    if (value instanceof Error) {
-      serialized = {
-        isError: true,
-        value: {
-          message: value.message,
-          name: value.name,
-          stack: value.stack
-        }
-      };
-    } else {
-      serialized = { isError: false, value };
-    }
-    return [serialized, []];
-  },
-  deserialize(serialized) {
-    if (serialized.isError) {
-      throw Object.assign(new Error(serialized.value.message), serialized.value);
-    }
-    throw serialized.value;
-  }
-};
-const transferHandlers = /* @__PURE__ */ new Map([
-  ["proxy", proxyTransferHandler],
-  ["throw", throwTransferHandler]
-]);
-function isAllowedOrigin(allowedOrigins, origin) {
-  for (const allowedOrigin of allowedOrigins) {
-    if (origin === allowedOrigin || allowedOrigin === "*") {
-      return true;
-    }
-    if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
-      return true;
-    }
-  }
-  return false;
-}
-function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
-  ep.addEventListener("message", function callback(ev) {
-    if (!ev || !ev.data) {
-      return;
-    }
-    if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
-      console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
-      return;
-    }
-    const { id, type, path } = Object.assign({ path: [] }, ev.data);
-    const argumentList = (ev.data.argumentList || []).map(fromWireValue);
-    let returnValue;
-    try {
-      const parent = path.slice(0, -1).reduce((obj2, prop) => obj2[prop], obj);
-      const rawValue = path.reduce((obj2, prop) => obj2[prop], obj);
-      switch (type) {
-        case "GET":
-          {
-            returnValue = rawValue;
-          }
-          break;
-        case "SET":
-          {
-            parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
-            returnValue = true;
-          }
-          break;
-        case "APPLY":
-          {
-            returnValue = rawValue.apply(parent, argumentList);
-          }
-          break;
-        case "CONSTRUCT":
-          {
-            const value = new rawValue(...argumentList);
-            returnValue = proxy(value);
-          }
-          break;
-        case "ENDPOINT":
-          {
-            const { port1, port2 } = new MessageChannel();
-            expose(obj, port2);
-            returnValue = transfer(port1, [port1]);
-          }
-          break;
-        case "RELEASE":
-          {
-            returnValue = void 0;
-          }
-          break;
-        default:
-          return;
-      }
-    } catch (value) {
-      returnValue = { value, [throwMarker]: 0 };
-    }
-    Promise.resolve(returnValue).catch((value) => {
-      return { value, [throwMarker]: 0 };
-    }).then((returnValue2) => {
-      const [wireValue, transferables] = toWireValue(returnValue2);
-      ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
-      if (type === "RELEASE") {
-        ep.removeEventListener("message", callback);
-        closeEndPoint(ep);
-        if (finalizer in obj && typeof obj[finalizer] === "function") {
-          obj[finalizer]();
-        }
-      }
-    }).catch((error) => {
-      const [wireValue, transferables] = toWireValue({
-        value: new TypeError("Unserializable return value"),
-        [throwMarker]: 0
-      });
-      ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
-    });
-  });
-  if (ep.start) {
-    ep.start();
-  }
-}
-function isMessagePort(endpoint) {
-  return endpoint.constructor.name === "MessagePort";
-}
-function closeEndPoint(endpoint) {
-  if (isMessagePort(endpoint))
-    endpoint.close();
-}
-function wrap(ep, target) {
-  const pendingListeners = /* @__PURE__ */ new Map();
-  ep.addEventListener("message", function handleMessage(ev) {
-    const { data } = ev;
-    if (!data || !data.id) {
-      return;
-    }
-    const resolver = pendingListeners.get(data.id);
-    if (!resolver) {
-      return;
-    }
-    try {
-      resolver(data);
-    } finally {
-      pendingListeners.delete(data.id);
-    }
-  });
-  return createProxy(ep, pendingListeners, [], target);
-}
-function throwIfProxyReleased(isReleased) {
-  if (isReleased) {
-    throw new Error("Proxy has been released and is not useable");
-  }
-}
-function releaseEndpoint(ep) {
-  return requestResponseMessage(ep, /* @__PURE__ */ new Map(), {
-    type: "RELEASE"
-  }).then(() => {
-    closeEndPoint(ep);
-  });
-}
-const proxyCounter = /* @__PURE__ */ new WeakMap();
-const proxyFinalizers = "FinalizationRegistry" in globalThis && new FinalizationRegistry((ep) => {
-  const newCount = (proxyCounter.get(ep) || 0) - 1;
-  proxyCounter.set(ep, newCount);
-  if (newCount === 0) {
-    releaseEndpoint(ep);
-  }
-});
-function registerProxy(proxy2, ep) {
-  const newCount = (proxyCounter.get(ep) || 0) + 1;
-  proxyCounter.set(ep, newCount);
-  if (proxyFinalizers) {
-    proxyFinalizers.register(proxy2, ep, proxy2);
-  }
-}
-function unregisterProxy(proxy2) {
-  if (proxyFinalizers) {
-    proxyFinalizers.unregister(proxy2);
-  }
-}
-function createProxy(ep, pendingListeners, path = [], target = function() {
-}) {
-  let isProxyReleased = false;
-  const proxy2 = new Proxy(target, {
-    get(_target, prop) {
-      throwIfProxyReleased(isProxyReleased);
-      if (prop === releaseProxy) {
-        return () => {
-          unregisterProxy(proxy2);
-          releaseEndpoint(ep);
-          pendingListeners.clear();
-          isProxyReleased = true;
-        };
-      }
-      if (prop === "then") {
-        if (path.length === 0) {
-          return { then: () => proxy2 };
-        }
-        const r = requestResponseMessage(ep, pendingListeners, {
-          type: "GET",
-          path: path.map((p) => p.toString())
-        }).then(fromWireValue);
-        return r.then.bind(r);
-      }
-      return createProxy(ep, pendingListeners, [...path, prop]);
-    },
-    set(_target, prop, rawValue) {
-      throwIfProxyReleased(isProxyReleased);
-      const [value, transferables] = toWireValue(rawValue);
-      return requestResponseMessage(ep, pendingListeners, {
-        type: "SET",
-        path: [...path, prop].map((p) => p.toString()),
-        value
-      }, transferables).then(fromWireValue);
-    },
-    apply(_target, _thisArg, rawArgumentList) {
-      throwIfProxyReleased(isProxyReleased);
-      const last = path[path.length - 1];
-      if (last === createEndpoint) {
-        return requestResponseMessage(ep, pendingListeners, {
-          type: "ENDPOINT"
-        }).then(fromWireValue);
-      }
-      if (last === "bind") {
-        return createProxy(ep, pendingListeners, path.slice(0, -1));
-      }
-      const [argumentList, transferables] = processArguments(rawArgumentList);
-      return requestResponseMessage(ep, pendingListeners, {
-        type: "APPLY",
-        path: path.map((p) => p.toString()),
-        argumentList
-      }, transferables).then(fromWireValue);
-    },
-    construct(_target, rawArgumentList) {
-      throwIfProxyReleased(isProxyReleased);
-      const [argumentList, transferables] = processArguments(rawArgumentList);
-      return requestResponseMessage(ep, pendingListeners, {
-        type: "CONSTRUCT",
-        path: path.map((p) => p.toString()),
-        argumentList
-      }, transferables).then(fromWireValue);
-    }
-  });
-  registerProxy(proxy2, ep);
-  return proxy2;
-}
-function myFlat(arr) {
-  return Array.prototype.concat.apply([], arr);
-}
-function processArguments(argumentList) {
-  const processed = argumentList.map(toWireValue);
-  return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
-}
-const transferCache = /* @__PURE__ */ new WeakMap();
-function transfer(obj, transfers) {
-  transferCache.set(obj, transfers);
-  return obj;
+function createDataTexture(data, size) {
+  const texture = new THREE.DataTexture(data, size, size, THREE.RGBAFormat, THREE.FloatType);
+  texture.needsUpdate = true;
+  return texture;
 }
-function proxy(obj) {
-  return Object.assign(obj, { [proxyMarker]: true });
+function createBlankDataTexture(size) {
+  return createDataTexture(new Float32Array(4 * size * size), size);
 }
-function toWireValue(value) {
-  for (const [name, handler] of transferHandlers) {
-    if (handler.canHandle(value)) {
-      const [serializedValue, transferables] = handler.serialize(value);
-      return [
-        {
-          type: "HANDLER",
-          name,
-          value: serializedValue
-        },
-        transferables
-      ];
+function createSpherePoints(size) {
+  const data = new Float32Array(size * size * 4);
+  for (let i = 0; i < size; i++) {
+    for (let j = 0; j < size; j++) {
+      const index = i * size + j;
+      let theta = Math.random() * Math.PI * 2;
+      let phi = Math.acos(Math.random() * 2 - 1);
+      let x = Math.sin(phi) * Math.cos(theta);
+      let y = Math.sin(phi) * Math.sin(theta);
+      let z = Math.cos(phi);
+      data[4 * index] = x;
+      data[4 * index + 1] = y;
+      data[4 * index + 2] = z;
+      data[4 * index + 3] = (Math.random() - 0.5) * 0.01;
     }
   }
-  return [
-    {
-      type: "RAW",
-      value
-    },
-    transferCache.get(value) || []
-  ];
-}
-function fromWireValue(value) {
-  switch (value.type) {
-    case "HANDLER":
-      return transferHandlers.get(value.name).deserialize(value.value);
-    case "RAW":
-      return value.value;
-  }
-}
-function requestResponseMessage(ep, pendingListeners, msg, transfers) {
-  return new Promise((resolve) => {
-    const id = generateUUID();
-    pendingListeners.set(id, resolve);
-    if (ep.start) {
-      ep.start();
-    }
-    ep.postMessage(Object.assign({ id }, msg), transfers);
-  });
-}
-function generateUUID() {
-  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
-}
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+  return createDataTexture(data, size);
 }
-var events = { exports: {} };
-var hasRequiredEvents;
-function requireEvents() {
-  if (hasRequiredEvents) return events.exports;
-  hasRequiredEvents = 1;
-  var R = typeof Reflect === "object" ? Reflect : null;
-  var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
-    return Function.prototype.apply.call(target, receiver, args);
-  };
-  var ReflectOwnKeys;
-  if (R && typeof R.ownKeys === "function") {
-    ReflectOwnKeys = R.ownKeys;
-  } else if (Object.getOwnPropertySymbols) {
-    ReflectOwnKeys = function ReflectOwnKeys2(target) {
-      return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
-    };
+function disposeMesh(mesh) {
+  mesh.geometry.dispose();
+  if (mesh.material instanceof THREE.Material) {
+    mesh.material.dispose();
   } else {
-    ReflectOwnKeys = function ReflectOwnKeys2(target) {
-      return Object.getOwnPropertyNames(target);
-    };
-  }
-  function ProcessEmitWarning(warning) {
-    if (console && console.warn) console.warn(warning);
-  }
-  var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
-    return value !== value;
-  };
-  function EventEmitter() {
-    EventEmitter.init.call(this);
-  }
-  events.exports = EventEmitter;
-  events.exports.once = once;
-  EventEmitter.EventEmitter = EventEmitter;
-  EventEmitter.prototype._events = void 0;
-  EventEmitter.prototype._eventsCount = 0;
-  EventEmitter.prototype._maxListeners = void 0;
-  var defaultMaxListeners = 10;
-  function checkListener(listener) {
-    if (typeof listener !== "function") {
-      throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
-    }
-  }
-  Object.defineProperty(EventEmitter, "defaultMaxListeners", {
-    enumerable: true,
-    get: function() {
-      return defaultMaxListeners;
-    },
-    set: function(arg) {
-      if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
-        throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
-      }
-      defaultMaxListeners = arg;
-    }
-  });
-  EventEmitter.init = function() {
-    if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
-      this._events = /* @__PURE__ */ Object.create(null);
-      this._eventsCount = 0;
-    }
-    this._maxListeners = this._maxListeners || void 0;
-  };
-  EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
-    if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
-      throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
-    }
-    this._maxListeners = n;
-    return this;
-  };
-  function _getMaxListeners(that) {
-    if (that._maxListeners === void 0)
-      return EventEmitter.defaultMaxListeners;
-    return that._maxListeners;
-  }
-  EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
-    return _getMaxListeners(this);
-  };
-  EventEmitter.prototype.emit = function emit(type) {
-    var args = [];
-    for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
-    var doError = type === "error";
-    var events2 = this._events;
-    if (events2 !== void 0)
-      doError = doError && events2.error === void 0;
-    else if (!doError)
-      return false;
-    if (doError) {
-      var er;
-      if (args.length > 0)
-        er = args[0];
-      if (er instanceof Error) {
-        throw er;
-      }
-      var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
-      err.context = er;
-      throw err;
-    }
-    var handler = events2[type];
-    if (handler === void 0)
-      return false;
-    if (typeof handler === "function") {
-      ReflectApply(handler, this, args);
-    } else {
-      var len = handler.length;
-      var listeners = arrayClone(handler, len);
-      for (var i = 0; i < len; ++i)
-        ReflectApply(listeners[i], this, args);
-    }
-    return true;
-  };
-  function _addListener(target, type, listener, prepend) {
-    var m;
-    var events2;
-    var existing;
-    checkListener(listener);
-    events2 = target._events;
-    if (events2 === void 0) {
-      events2 = target._events = /* @__PURE__ */ Object.create(null);
-      target._eventsCount = 0;
-    } else {
-      if (events2.newListener !== void 0) {
-        target.emit(
-          "newListener",
-          type,
-          listener.listener ? listener.listener : listener
-        );
-        events2 = target._events;
-      }
-      existing = events2[type];
-    }
-    if (existing === void 0) {
-      existing = events2[type] = listener;
-      ++target._eventsCount;
-    } else {
-      if (typeof existing === "function") {
-        existing = events2[type] = prepend ? [listener, existing] : [existing, listener];
-      } else if (prepend) {
-        existing.unshift(listener);
-      } else {
-        existing.push(listener);
-      }
-      m = _getMaxListeners(target);
-      if (m > 0 && existing.length > m && !existing.warned) {
-        existing.warned = true;
-        var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
-        w.name = "MaxListenersExceededWarning";
-        w.emitter = target;
-        w.type = type;
-        w.count = existing.length;
-        ProcessEmitWarning(w);
-      }
-    }
-    return target;
-  }
-  EventEmitter.prototype.addListener = function addListener(type, listener) {
-    return _addListener(this, type, listener, false);
-  };
-  EventEmitter.prototype.on = EventEmitter.prototype.addListener;
-  EventEmitter.prototype.prependListener = function prependListener(type, listener) {
-    return _addListener(this, type, listener, true);
-  };
-  function onceWrapper() {
-    if (!this.fired) {
-      this.target.removeListener(this.type, this.wrapFn);
-      this.fired = true;
-      if (arguments.length === 0)
-        return this.listener.call(this.target);
-      return this.listener.apply(this.target, arguments);
-    }
-  }
-  function _onceWrap(target, type, listener) {
-    var state = { fired: false, wrapFn: void 0, target, type, listener };
-    var wrapped = onceWrapper.bind(state);
-    wrapped.listener = listener;
-    state.wrapFn = wrapped;
-    return wrapped;
-  }
-  EventEmitter.prototype.once = function once2(type, listener) {
-    checkListener(listener);
-    this.on(type, _onceWrap(this, type, listener));
-    return this;
-  };
-  EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
-    checkListener(listener);
-    this.prependListener(type, _onceWrap(this, type, listener));
-    return this;
-  };
-  EventEmitter.prototype.removeListener = function removeListener(type, listener) {
-    var list, events2, position, i, originalListener;
-    checkListener(listener);
-    events2 = this._events;
-    if (events2 === void 0)
-      return this;
-    list = events2[type];
-    if (list === void 0)
-      return this;
-    if (list === listener || list.listener === listener) {
-      if (--this._eventsCount === 0)
-        this._events = /* @__PURE__ */ Object.create(null);
-      else {
-        delete events2[type];
-        if (events2.removeListener)
-          this.emit("removeListener", type, list.listener || listener);
-      }
-    } else if (typeof list !== "function") {
-      position = -1;
-      for (i = list.length - 1; i >= 0; i--) {
-        if (list[i] === listener || list[i].listener === listener) {
-          originalListener = list[i].listener;
-          position = i;
-          break;
-        }
-      }
-      if (position < 0)
-        return this;
-      if (position === 0)
-        list.shift();
-      else {
-        spliceOne(list, position);
-      }
-      if (list.length === 1)
-        events2[type] = list[0];
-      if (events2.removeListener !== void 0)
-        this.emit("removeListener", type, originalListener || listener);
-    }
-    return this;
-  };
-  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-  EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
-    var listeners, events2, i;
-    events2 = this._events;
-    if (events2 === void 0)
-      return this;
-    if (events2.removeListener === void 0) {
-      if (arguments.length === 0) {
-        this._events = /* @__PURE__ */ Object.create(null);
-        this._eventsCount = 0;
-      } else if (events2[type] !== void 0) {
-        if (--this._eventsCount === 0)
-          this._events = /* @__PURE__ */ Object.create(null);
-        else
-          delete events2[type];
-      }
-      return this;
-    }
-    if (arguments.length === 0) {
-      var keys = Object.keys(events2);
-      var key;
-      for (i = 0; i < keys.length; ++i) {
-        key = keys[i];
-        if (key === "removeListener") continue;
-        this.removeAllListeners(key);
-      }
-      this.removeAllListeners("removeListener");
-      this._events = /* @__PURE__ */ Object.create(null);
-      this._eventsCount = 0;
-      return this;
-    }
-    listeners = events2[type];
-    if (typeof listeners === "function") {
-      this.removeListener(type, listeners);
-    } else if (listeners !== void 0) {
-      for (i = listeners.length - 1; i >= 0; i--) {
-        this.removeListener(type, listeners[i]);
-      }
-    }
-    return this;
-  };
-  function _listeners(target, type, unwrap) {
-    var events2 = target._events;
-    if (events2 === void 0)
-      return [];
-    var evlistener = events2[type];
-    if (evlistener === void 0)
-      return [];
-    if (typeof evlistener === "function")
-      return unwrap ? [evlistener.listener || evlistener] : [evlistener];
-    return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
-  }
-  EventEmitter.prototype.listeners = function listeners(type) {
-    return _listeners(this, type, true);
-  };
-  EventEmitter.prototype.rawListeners = function rawListeners(type) {
-    return _listeners(this, type, false);
-  };
-  EventEmitter.listenerCount = function(emitter, type) {
-    if (typeof emitter.listenerCount === "function") {
-      return emitter.listenerCount(type);
-    } else {
-      return listenerCount.call(emitter, type);
-    }
-  };
-  EventEmitter.prototype.listenerCount = listenerCount;
-  function listenerCount(type) {
-    var events2 = this._events;
-    if (events2 !== void 0) {
-      var evlistener = events2[type];
-      if (typeof evlistener === "function") {
-        return 1;
-      } else if (evlistener !== void 0) {
-        return evlistener.length;
-      }
-    }
-    return 0;
-  }
-  EventEmitter.prototype.eventNames = function eventNames() {
-    return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
-  };
-  function arrayClone(arr, n) {
-    var copy = new Array(n);
-    for (var i = 0; i < n; ++i)
-      copy[i] = arr[i];
-    return copy;
-  }
-  function spliceOne(list, index) {
-    for (; index + 1 < list.length; index++)
-      list[index] = list[index + 1];
-    list.pop();
-  }
-  function unwrapListeners(arr) {
-    var ret = new Array(arr.length);
-    for (var i = 0; i < ret.length; ++i) {
-      ret[i] = arr[i].listener || arr[i];
-    }
-    return ret;
-  }
-  function once(emitter, name) {
-    return new Promise(function(resolve, reject) {
-      function errorListener(err) {
-        emitter.removeListener(name, resolver);
-        reject(err);
-      }
-      function resolver() {
-        if (typeof emitter.removeListener === "function") {
-          emitter.removeListener("error", errorListener);
-        }
-        resolve([].slice.call(arguments));
-      }
-      eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
-      if (name !== "error") {
-        addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
-      }
-    });
-  }
-  function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
-    if (typeof emitter.on === "function") {
-      eventTargetAgnosticAddListener(emitter, "error", handler, flags);
-    }
-  }
-  function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
-    if (typeof emitter.on === "function") {
-      if (flags.once) {
-        emitter.once(name, listener);
-      } else {
-        emitter.on(name, listener);
-      }
-    } else if (typeof emitter.addEventListener === "function") {
-      emitter.addEventListener(name, function wrapListener(arg) {
-        if (flags.once) {
-          emitter.removeEventListener(name, wrapListener);
-        }
-        listener(arg);
-      });
-    } else {
-      throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
-    }
-  }
-  return events.exports;
-}
-var factoryValidator;
-var hasRequiredFactoryValidator;
-function requireFactoryValidator() {
-  if (hasRequiredFactoryValidator) return factoryValidator;
-  hasRequiredFactoryValidator = 1;
-  factoryValidator = function(factory) {
-    if (typeof factory.create !== "function") {
-      throw new TypeError("factory.create must be a function");
-    }
-    if (typeof factory.destroy !== "function") {
-      throw new TypeError("factory.destroy must be a function");
-    }
-    if (typeof factory.validate !== "undefined" && typeof factory.validate !== "function") {
-      throw new TypeError("factory.validate must be a function");
-    }
-  };
-  return factoryValidator;
-}
-var PoolDefaults_1;
-var hasRequiredPoolDefaults;
-function requirePoolDefaults() {
-  if (hasRequiredPoolDefaults) return PoolDefaults_1;
-  hasRequiredPoolDefaults = 1;
-  class PoolDefaults {
-    constructor() {
-      this.fifo = true;
-      this.priorityRange = 1;
-      this.testOnBorrow = false;
-      this.testOnReturn = false;
-      this.autostart = true;
-      this.evictionRunIntervalMillis = 0;
-      this.numTestsPerEvictionRun = 3;
-      this.softIdleTimeoutMillis = -1;
-      this.idleTimeoutMillis = 3e4;
-      this.acquireTimeoutMillis = null;
-      this.destroyTimeoutMillis = null;
-      this.maxWaitingClients = null;
-      this.min = null;
-      this.max = null;
-      this.Promise = Promise;
-    }
-  }
-  PoolDefaults_1 = PoolDefaults;
-  return PoolDefaults_1;
-}
-var PoolOptions_1;
-var hasRequiredPoolOptions;
-function requirePoolOptions() {
-  if (hasRequiredPoolOptions) return PoolOptions_1;
-  hasRequiredPoolOptions = 1;
-  const PoolDefaults = requirePoolDefaults();
-  class PoolOptions {
-    /**
-     * @param {Object} opts
-     *   configuration for the pool
-     * @param {Number} [opts.max=null]
-     *   Maximum number of items that can exist at the same time.  Default: 1.
-     *   Any further acquire requests will be pushed to the waiting list.
-     * @param {Number} [opts.min=null]
-     *   Minimum number of items in pool (including in-use). Default: 0.
-     *   When the pool is created, or a resource destroyed, this minimum will
-     *   be checked. If the pool resource count is below the minimum, a new
-     *   resource will be created and added to the pool.
-     * @param {Number} [opts.maxWaitingClients=null]
-     *   maximum number of queued requests allowed after which acquire calls will be rejected
-     * @param {Boolean} [opts.testOnBorrow=false]
-     *   should the pool validate resources before giving them to clients. Requires that
-     *   `factory.validate` is specified.
-     * @param {Boolean} [opts.testOnReturn=false]
-     *   should the pool validate resources before returning them to the pool.
-     * @param {Number} [opts.acquireTimeoutMillis=null]
-     *   Delay in milliseconds after which the an `acquire` call will fail. optional.
-     *   Default: undefined. Should be positive and non-zero
-     * @param {Number} [opts.destroyTimeoutMillis=null]
-     *   Delay in milliseconds after which the an `destroy` call will fail, causing it to emit a factoryDestroyError event. optional.
-     *   Default: undefined. Should be positive and non-zero
-     * @param {Number} [opts.priorityRange=1]
-     *   The range from 1 to be treated as a valid priority
-     * @param {Boolean} [opts.fifo=true]
-     *   Sets whether the pool has LIFO (last in, first out) behaviour with respect to idle objects.
-     *   if false then pool has FIFO behaviour
-     * @param {Boolean} [opts.autostart=true]
-     *   Should the pool start creating resources etc once the constructor is called
-     * @param {Number} [opts.evictionRunIntervalMillis=0]
-     *   How often to run eviction checks.  Default: 0 (does not run).
-     * @param {Number} [opts.numTestsPerEvictionRun=3]
-     *   Number of resources to check each eviction run.  Default: 3.
-     * @param {Number} [opts.softIdleTimeoutMillis=-1]
-     *   amount of time an object may sit idle in the pool before it is eligible
-     *   for eviction by the idle object evictor (if any), with the extra condition
-     *   that at least "min idle" object instances remain in the pool. Default -1 (nothing can get evicted)
-     * @param {Number} [opts.idleTimeoutMillis=30000]
-     *   the minimum amount of time that an object may sit idle in the pool before it is eligible for eviction
-     *   due to idle time. Supercedes "softIdleTimeoutMillis" Default: 30000
-     * @param {typeof Promise} [opts.Promise=Promise]
-     *   What promise implementation should the pool use, defaults to native promises.
-     */
-    constructor(opts) {
-      const poolDefaults = new PoolDefaults();
-      opts = opts || {};
-      this.fifo = typeof opts.fifo === "boolean" ? opts.fifo : poolDefaults.fifo;
-      this.priorityRange = opts.priorityRange || poolDefaults.priorityRange;
-      this.testOnBorrow = typeof opts.testOnBorrow === "boolean" ? opts.testOnBorrow : poolDefaults.testOnBorrow;
-      this.testOnReturn = typeof opts.testOnReturn === "boolean" ? opts.testOnReturn : poolDefaults.testOnReturn;
-      this.autostart = typeof opts.autostart === "boolean" ? opts.autostart : poolDefaults.autostart;
-      if (opts.acquireTimeoutMillis) {
-        this.acquireTimeoutMillis = parseInt(opts.acquireTimeoutMillis, 10);
-      }
-      if (opts.destroyTimeoutMillis) {
-        this.destroyTimeoutMillis = parseInt(opts.destroyTimeoutMillis, 10);
-      }
-      if (opts.maxWaitingClients !== void 0) {
-        this.maxWaitingClients = parseInt(opts.maxWaitingClients, 10);
-      }
-      this.max = parseInt(opts.max, 10);
-      this.min = parseInt(opts.min, 10);
-      this.max = Math.max(isNaN(this.max) ? 1 : this.max, 1);
-      this.min = Math.min(isNaN(this.min) ? 0 : this.min, this.max);
-      this.evictionRunIntervalMillis = opts.evictionRunIntervalMillis || poolDefaults.evictionRunIntervalMillis;
-      this.numTestsPerEvictionRun = opts.numTestsPerEvictionRun || poolDefaults.numTestsPerEvictionRun;
-      this.softIdleTimeoutMillis = opts.softIdleTimeoutMillis || poolDefaults.softIdleTimeoutMillis;
-      this.idleTimeoutMillis = opts.idleTimeoutMillis || poolDefaults.idleTimeoutMillis;
-      this.Promise = opts.Promise != null ? opts.Promise : poolDefaults.Promise;
-    }
-  }
-  PoolOptions_1 = PoolOptions;
-  return PoolOptions_1;
-}
-var Deferred_1;
-var hasRequiredDeferred;
-function requireDeferred() {
-  if (hasRequiredDeferred) return Deferred_1;
-  hasRequiredDeferred = 1;
-  class Deferred {
-    constructor(Promise2) {
-      this._state = Deferred.PENDING;
-      this._resolve = void 0;
-      this._reject = void 0;
-      this._promise = new Promise2((resolve, reject) => {
-        this._resolve = resolve;
-        this._reject = reject;
-      });
-    }
-    get state() {
-      return this._state;
-    }
-    get promise() {
-      return this._promise;
-    }
-    reject(reason) {
-      if (this._state !== Deferred.PENDING) {
-        return;
-      }
-      this._state = Deferred.REJECTED;
-      this._reject(reason);
-    }
-    resolve(value) {
-      if (this._state !== Deferred.PENDING) {
-        return;
-      }
-      this._state = Deferred.FULFILLED;
-      this._resolve(value);
-    }
+    mesh.material.forEach((material) => material.dispose());
   }
-  Deferred.PENDING = "PENDING";
-  Deferred.FULFILLED = "FULFILLED";
-  Deferred.REJECTED = "REJECTED";
-  Deferred_1 = Deferred;
-  return Deferred_1;
 }
-var errors;
-var hasRequiredErrors;
-function requireErrors() {
-  if (hasRequiredErrors) return errors;
-  hasRequiredErrors = 1;
-  class ExtendableError extends Error {
-    constructor(message) {
-      super(message);
-      this.name = this.constructor.name;
-      this.message = message;
-      if (typeof Error.captureStackTrace === "function") {
-        Error.captureStackTrace(this, this.constructor);
-      } else {
-        this.stack = new Error(message).stack;
-      }
-    }
-  }
-  class TimeoutError extends ExtendableError {
-    constructor(m) {
-      super(m);
-    }
-  }
-  errors = {
-    TimeoutError
-  };
-  return errors;
+function clamp(value, min, max) {
+  value = Math.min(value, max);
+  value = Math.max(value, min);
+  return value;
 }
-var ResourceRequest_1;
-var hasRequiredResourceRequest;
-function requireResourceRequest() {
-  if (hasRequiredResourceRequest) return ResourceRequest_1;
-  hasRequiredResourceRequest = 1;
-  const Deferred = requireDeferred();
-  const errors2 = requireErrors();
-  function fbind(fn, ctx) {
-    return function bound() {
-      return fn.apply(ctx, arguments);
-    };
-  }
-  class ResourceRequest extends Deferred {
-    /**
-     * [constructor description]
-     * @param  {Number} ttl     timeout
-     */
-    constructor(ttl, Promise2) {
-      super(Promise2);
-      this._creationTimestamp = Date.now();
-      this._timeout = null;
-      if (ttl !== void 0) {
-        this.setTimeout(ttl);
-      }
-    }
-    setTimeout(delay) {
-      if (this._state !== ResourceRequest.PENDING) {
-        return;
-      }
-      const ttl = parseInt(delay, 10);
-      if (isNaN(ttl) || ttl <= 0) {
-        throw new Error("delay must be a positive int");
-      }
-      const age = Date.now() - this._creationTimestamp;
-      if (this._timeout) {
-        this.removeTimeout();
-      }
-      this._timeout = setTimeout(
-        fbind(this._fireTimeout, this),
-        Math.max(ttl - age, 0)
-      );
-    }
-    removeTimeout() {
-      if (this._timeout) {
-        clearTimeout(this._timeout);
-      }
-      this._timeout = null;
-    }
-    _fireTimeout() {
-      this.reject(new errors2.TimeoutError("ResourceRequest timed out"));
-    }
-    reject(reason) {
-      this.removeTimeout();
-      super.reject(reason);
-    }
-    resolve(value) {
-      this.removeTimeout();
-      super.resolve(value);
-    }
+class AssetService {
+  constructor(eventEmitter) {
+    __publicField(this, "serviceState", "created");
+    __publicField(this, "eventEmitter");
+    __publicField(this, "meshes", /* @__PURE__ */ new Map());
+    __publicField(this, "textures", /* @__PURE__ */ new Map());
+    __publicField(this, "gltfLoader", new GLTFLoader());
+    __publicField(this, "textureLoader", new THREE.TextureLoader());
+    __publicField(this, "dracoLoader", new DRACOLoader());
+    __publicField(this, "solidColorTexture", new THREE.DataTexture(new Uint8Array([127, 127, 127, 255]), 1, 1, THREE.RGBAFormat));
+    this.eventEmitter = eventEmitter;
+    this.dracoLoader.setDecoderPath("https://www.gstatic.com/draco/versioned/decoders/1.5.7/");
+    this.gltfLoader.setDRACOLoader(this.dracoLoader);
+    this.updateServiceState("ready");
   }
-  ResourceRequest_1 = ResourceRequest;
-  return ResourceRequest_1;
-}
-var ResourceLoan_1;
-var hasRequiredResourceLoan;
-function requireResourceLoan() {
-  if (hasRequiredResourceLoan) return ResourceLoan_1;
-  hasRequiredResourceLoan = 1;
-  const Deferred = requireDeferred();
-  class ResourceLoan extends Deferred {
-    /**
-     *
-     * @param  {any} pooledResource the PooledResource this loan belongs to
-     * @return {any}                [description]
-     */
-    constructor(pooledResource, Promise2) {
-      super(Promise2);
-      this._creationTimestamp = Date.now();
-      this.pooledResource = pooledResource;
-    }
-    reject() {
+  /**
+   * Registers an asset.
+   * @param id - The ID of the asset.
+   * @param item - The asset to set.
+   */
+  register(id, item) {
+    item.name = id;
+    if (item instanceof THREE.Mesh) {
+      const prev = this.meshes.get(id);
+      if (prev) disposeMesh(prev);
+      this.meshes.set(id, item);
+    } else {
+      const prev = this.textures.get(id);
+      if (prev) prev.dispose();
+      this.textures.set(id, item);
     }
+    this.eventEmitter.emit("assetRegistered", { id });
   }
-  ResourceLoan_1 = ResourceLoan;
-  return ResourceLoan_1;
-}
-var PooledResourceStateEnum_1;
-var hasRequiredPooledResourceStateEnum;
-function requirePooledResourceStateEnum() {
-  if (hasRequiredPooledResourceStateEnum) return PooledResourceStateEnum_1;
-  hasRequiredPooledResourceStateEnum = 1;
-  const PooledResourceStateEnum = {
-    ALLOCATED: "ALLOCATED",
-    // In use
-    IDLE: "IDLE",
-    // In the queue, not in use.
-    INVALID: "INVALID",
-    // Failed validation
-    RETURNING: "RETURNING",
-    // Resource is in process of returning
-    VALIDATION: "VALIDATION"
-    // Currently being tested
-  };
-  PooledResourceStateEnum_1 = PooledResourceStateEnum;
-  return PooledResourceStateEnum_1;
-}
-var PooledResource_1;
-var hasRequiredPooledResource;
-function requirePooledResource() {
-  if (hasRequiredPooledResource) return PooledResource_1;
-  hasRequiredPooledResource = 1;
-  const PooledResourceStateEnum = requirePooledResourceStateEnum();
-  class PooledResource {
-    constructor(resource) {
-      this.creationTime = Date.now();
-      this.lastReturnTime = null;
-      this.lastBorrowTime = null;
-      this.lastIdleTime = null;
-      this.obj = resource;
-      this.state = PooledResourceStateEnum.IDLE;
-    }
-    // mark the resource as "allocated"
-    allocate() {
-      this.lastBorrowTime = Date.now();
-      this.state = PooledResourceStateEnum.ALLOCATED;
-    }
-    // mark the resource as "deallocated"
-    deallocate() {
-      this.lastReturnTime = Date.now();
-      this.state = PooledResourceStateEnum.IDLE;
-    }
-    invalidate() {
-      this.state = PooledResourceStateEnum.INVALID;
-    }
-    test() {
-      this.state = PooledResourceStateEnum.VALIDATION;
-    }
-    idle() {
-      this.lastIdleTime = Date.now();
-      this.state = PooledResourceStateEnum.IDLE;
-    }
-    returning() {
-      this.state = PooledResourceStateEnum.RETURNING;
-    }
+  setSolidColor(color) {
+    this.changeColor(color);
   }
-  PooledResource_1 = PooledResource;
-  return PooledResource_1;
-}
-var DefaultEvictor_1;
-var hasRequiredDefaultEvictor;
-function requireDefaultEvictor() {
-  if (hasRequiredDefaultEvictor) return DefaultEvictor_1;
-  hasRequiredDefaultEvictor = 1;
-  class DefaultEvictor {
-    evict(config, pooledResource, availableObjectsCount) {
-      const idleTime = Date.now() - pooledResource.lastIdleTime;
-      if (config.softIdleTimeoutMillis > 0 && config.softIdleTimeoutMillis < idleTime && config.min < availableObjectsCount) {
-        return true;
-      }
-      if (config.idleTimeoutMillis < idleTime) {
-        return true;
-      }
-      return false;
-    }
+  getSolidColorTexture() {
+    return this.solidColorTexture;
   }
-  DefaultEvictor_1 = DefaultEvictor;
-  return DefaultEvictor_1;
-}
-var DoublyLinkedList_1;
-var hasRequiredDoublyLinkedList;
-function requireDoublyLinkedList() {
-  if (hasRequiredDoublyLinkedList) return DoublyLinkedList_1;
-  hasRequiredDoublyLinkedList = 1;
-  class DoublyLinkedList {
-    constructor() {
-      this.head = null;
-      this.tail = null;
-      this.length = 0;
-    }
-    insertBeginning(node) {
-      if (this.head === null) {
-        this.head = node;
-        this.tail = node;
-        node.prev = null;
-        node.next = null;
-        this.length++;
-      } else {
-        this.insertBefore(this.head, node);
-      }
-    }
-    insertEnd(node) {
-      if (this.tail === null) {
-        this.insertBeginning(node);
-      } else {
-        this.insertAfter(this.tail, node);
-      }
-    }
-    insertAfter(node, newNode) {
-      newNode.prev = node;
-      newNode.next = node.next;
-      if (node.next === null) {
-        this.tail = newNode;
-      } else {
-        node.next.prev = newNode;
-      }
-      node.next = newNode;
-      this.length++;
-    }
-    insertBefore(node, newNode) {
-      newNode.prev = node.prev;
-      newNode.next = node;
-      if (node.prev === null) {
-        this.head = newNode;
-      } else {
-        node.prev.next = newNode;
-      }
-      node.prev = newNode;
-      this.length++;
-    }
-    remove(node) {
-      if (node.prev === null) {
-        this.head = node.next;
-      } else {
-        node.prev.next = node.next;
-      }
-      if (node.next === null) {
-        this.tail = node.prev;
-      } else {
-        node.next.prev = node.prev;
-      }
-      node.prev = null;
-      node.next = null;
-      this.length--;
-    }
-    // FIXME: this should not live here and has become a dumping ground...
-    static createNode(data) {
-      return {
-        prev: null,
-        next: null,
-        data
-      };
-    }
+  getMesh(id) {
+    return this.meshes.get(id) ?? null;
   }
-  DoublyLinkedList_1 = DoublyLinkedList;
-  return DoublyLinkedList_1;
-}
-var DoublyLinkedListIterator_1;
-var hasRequiredDoublyLinkedListIterator;
-function requireDoublyLinkedListIterator() {
-  if (hasRequiredDoublyLinkedListIterator) return DoublyLinkedListIterator_1;
-  hasRequiredDoublyLinkedListIterator = 1;
-  class DoublyLinkedListIterator {
-    /**
-     * @param  {Object} doublyLinkedList     a node that is part of a doublyLinkedList
-     * @param  {Boolean} [reverse=false]     is this a reverse iterator? default: false
-     */
-    constructor(doublyLinkedList, reverse) {
-      this._list = doublyLinkedList;
-      this._direction = reverse === true ? "prev" : "next";
-      this._startPosition = reverse === true ? "tail" : "head";
-      this._started = false;
-      this._cursor = null;
-      this._done = false;
-    }
-    _start() {
-      this._cursor = this._list[this._startPosition];
-      this._started = true;
-    }
-    _advanceCursor() {
-      if (this._started === false) {
-        this._started = true;
-        this._cursor = this._list[this._startPosition];
-        return;
-      }
-      this._cursor = this._cursor[this._direction];
-    }
-    reset() {
-      this._done = false;
-      this._started = false;
-      this._cursor = null;
-    }
-    remove() {
-      if (this._started === false || this._done === true || this._isCursorDetached()) {
-        return false;
-      }
-      this._list.remove(this._cursor);
-    }
-    next() {
-      if (this._done === true) {
-        return { done: true };
-      }
-      this._advanceCursor();
-      if (this._cursor === null || this._isCursorDetached()) {
-        this._done = true;
-        return { done: true };
-      }
-      return {
-        value: this._cursor,
-        done: false
-      };
-    }
-    /**
-     * Is the node detached from a list?
-     * NOTE: you can trick/bypass/confuse this check by removing a node from one DoublyLinkedList
-     * and adding it to another.
-     * TODO: We can make this smarter by checking the direction of travel and only checking
-     * the required next/prev/head/tail rather than all of them
-     * @return {Boolean}      [description]
-     */
-    _isCursorDetached() {
-      return this._cursor.prev === null && this._cursor.next === null && this._list.tail !== this._cursor && this._list.head !== this._cursor;
-    }
+  getMatcap(id) {
+    const texture = this.textures.get(id);
+    if (!texture) this.eventEmitter.emit("invalidRequest", { message: `texture with id "${id}" not found. using solid color texture instead...` });
+    return texture ?? this.solidColorTexture;
   }
-  DoublyLinkedListIterator_1 = DoublyLinkedListIterator;
-  return DoublyLinkedListIterator_1;
-}
-var DequeIterator_1;
-var hasRequiredDequeIterator;
-function requireDequeIterator() {
-  if (hasRequiredDequeIterator) return DequeIterator_1;
-  hasRequiredDequeIterator = 1;
-  const DoublyLinkedListIterator = requireDoublyLinkedListIterator();
-  class DequeIterator extends DoublyLinkedListIterator {
-    next() {
-      const result = super.next();
-      if (result.value) {
-        result.value = result.value.data;
-      }
-      return result;
-    }
+  getMeshIDs() {
+    return Array.from(this.meshes.keys());
   }
-  DequeIterator_1 = DequeIterator;
-  return DequeIterator_1;
-}
-var Deque_1;
-var hasRequiredDeque;
-function requireDeque() {
-  if (hasRequiredDeque) return Deque_1;
-  hasRequiredDeque = 1;
-  const DoublyLinkedList = requireDoublyLinkedList();
-  const DequeIterator = requireDequeIterator();
-  class Deque {
-    constructor() {
-      this._list = new DoublyLinkedList();
-    }
-    /**
-     * removes and returns the first element from the queue
-     * @return {any} [description]
-     */
-    shift() {
-      if (this.length === 0) {
-        return void 0;
-      }
-      const node = this._list.head;
-      this._list.remove(node);
-      return node.data;
-    }
-    /**
-     * adds one elemts to the beginning of the queue
-     * @param  {any} element [description]
-     * @return {any}         [description]
-     */
-    unshift(element) {
-      const node = DoublyLinkedList.createNode(element);
-      this._list.insertBeginning(node);
-    }
-    /**
-     * adds one to the end of the queue
-     * @param  {any} element [description]
-     * @return {any}         [description]
-     */
-    push(element) {
-      const node = DoublyLinkedList.createNode(element);
-      this._list.insertEnd(node);
-    }
-    /**
-     * removes and returns the last element from the queue
-     */
-    pop() {
-      if (this.length === 0) {
-        return void 0;
-      }
-      const node = this._list.tail;
-      this._list.remove(node);
-      return node.data;
-    }
-    [Symbol.iterator]() {
-      return new DequeIterator(this._list);
-    }
-    iterator() {
-      return new DequeIterator(this._list);
-    }
-    reverseIterator() {
-      return new DequeIterator(this._list, true);
-    }
-    /**
-     * get a reference to the item at the head of the queue
-     * @return {any} [description]
-     */
-    get head() {
-      if (this.length === 0) {
-        return void 0;
-      }
-      const node = this._list.head;
-      return node.data;
-    }
-    /**
-     * get a reference to the item at the tail of the queue
-     * @return {any} [description]
-     */
-    get tail() {
-      if (this.length === 0) {
-        return void 0;
-      }
-      const node = this._list.tail;
-      return node.data;
-    }
-    get length() {
-      return this._list.length;
-    }
+  getTextureIDs() {
+    return Array.from(this.textures.keys());
   }
-  Deque_1 = Deque;
-  return Deque_1;
-}
-var Queue_1;
-var hasRequiredQueue;
-function requireQueue() {
-  if (hasRequiredQueue) return Queue_1;
-  hasRequiredQueue = 1;
-  const DoublyLinkedList = requireDoublyLinkedList();
-  const Deque = requireDeque();
-  class Queue extends Deque {
-    /**
-     * Adds the obj to the end of the list for this slot
-     * we completely override the parent method because we need access to the
-     * node for our rejection handler
-     * @param {any} resourceRequest [description]
-     */
-    push(resourceRequest) {
-      const node = DoublyLinkedList.createNode(resourceRequest);
-      resourceRequest.promise.catch(this._createTimeoutRejectionHandler(node));
-      this._list.insertEnd(node);
-    }
-    _createTimeoutRejectionHandler(node) {
-      return (reason) => {
-        if (reason.name === "TimeoutError") {
-          this._list.remove(node);
-        }
-      };
-    }
+  getMeshes() {
+    return Array.from(this.meshes.values());
   }
-  Queue_1 = Queue;
-  return Queue_1;
-}
-var PriorityQueue_1;
-var hasRequiredPriorityQueue;
-function requirePriorityQueue() {
-  if (hasRequiredPriorityQueue) return PriorityQueue_1;
-  hasRequiredPriorityQueue = 1;
-  const Queue = requireQueue();
-  class PriorityQueue {
-    constructor(size) {
-      this._size = Math.max(+size | 0, 1);
-      this._slots = [];
-      for (let i = 0; i < this._size; i++) {
-        this._slots.push(new Queue());
-      }
-    }
-    get length() {
-      let _length = 0;
-      for (let i = 0, slots = this._slots.length; i < slots; i++) {
-        _length += this._slots[i].length;
-      }
-      return _length;
-    }
-    enqueue(obj, priority) {
-      priority = priority && +priority | 0 || 0;
-      if (priority) {
-        if (priority < 0 || priority >= this._size) {
-          priority = this._size - 1;
-        }
-      }
-      this._slots[priority].push(obj);
-    }
-    dequeue() {
-      for (let i = 0, sl = this._slots.length; i < sl; i += 1) {
-        if (this._slots[i].length) {
-          return this._slots[i].shift();
-        }
-      }
-      return;
-    }
-    get head() {
-      for (let i = 0, sl = this._slots.length; i < sl; i += 1) {
-        if (this._slots[i].length > 0) {
-          return this._slots[i].head;
-        }
-      }
-      return;
-    }
-    get tail() {
-      for (let i = this._slots.length - 1; i >= 0; i--) {
-        if (this._slots[i].length > 0) {
-          return this._slots[i].tail;
-        }
-      }
-      return;
-    }
+  getTextures() {
+    return Array.from(this.textures.values());
   }
-  PriorityQueue_1 = PriorityQueue;
-  return PriorityQueue_1;
-}
-var utils = {};
-var hasRequiredUtils;
-function requireUtils() {
-  if (hasRequiredUtils) return utils;
-  hasRequiredUtils = 1;
-  function noop() {
-  }
-  utils.reflector = function(promise) {
-    return promise.then(noop, noop);
-  };
-  return utils;
-}
-var Pool_1;
-var hasRequiredPool;
-function requirePool() {
-  if (hasRequiredPool) return Pool_1;
-  hasRequiredPool = 1;
-  const EventEmitter = requireEvents().EventEmitter;
-  const factoryValidator2 = requireFactoryValidator();
-  const PoolOptions = requirePoolOptions();
-  const ResourceRequest = requireResourceRequest();
-  const ResourceLoan = requireResourceLoan();
-  const PooledResource = requirePooledResource();
-  requireDefaultEvictor();
-  requireDeque();
-  const Deferred = requireDeferred();
-  requirePriorityQueue();
-  requireDequeIterator();
-  const reflector = requireUtils().reflector;
-  const FACTORY_CREATE_ERROR = "factoryCreateError";
-  const FACTORY_DESTROY_ERROR = "factoryDestroyError";
-  class Pool extends EventEmitter {
-    /**
-     * Generate an Object pool with a specified `factory` and `config`.
-     *
-     * @param {typeof DefaultEvictor} Evictor
-     * @param {typeof Deque} Deque
-     * @param {typeof PriorityQueue} PriorityQueue
-     * @param {Object} factory
-     *   Factory to be used for generating and destroying the items.
-     * @param {Function} factory.create
-     *   Should create the item to be acquired,
-     *   and call it's first callback argument with the generated item as it's argument.
-     * @param {Function} factory.destroy
-     *   Should gently close any resources that the item is using.
-     *   Called before the items is destroyed.
-     * @param {Function} factory.validate
-     *   Test if a resource is still valid .Should return a promise that resolves to a boolean, true if resource is still valid and false
-     *   If it should be removed from pool.
-     * @param {Object} options
-     */
-    constructor(Evictor, Deque, PriorityQueue, factory, options) {
-      super();
-      factoryValidator2(factory);
-      this._config = new PoolOptions(options);
-      this._Promise = this._config.Promise;
-      this._factory = factory;
-      this._draining = false;
-      this._started = false;
-      this._waitingClientsQueue = new PriorityQueue(this._config.priorityRange);
-      this._factoryCreateOperations = /* @__PURE__ */ new Set();
-      this._factoryDestroyOperations = /* @__PURE__ */ new Set();
-      this._availableObjects = new Deque();
-      this._testOnBorrowResources = /* @__PURE__ */ new Set();
-      this._testOnReturnResources = /* @__PURE__ */ new Set();
-      this._validationOperations = /* @__PURE__ */ new Set();
-      this._allObjects = /* @__PURE__ */ new Set();
-      this._resourceLoans = /* @__PURE__ */ new Map();
-      this._evictionIterator = this._availableObjects.iterator();
-      this._evictor = new Evictor();
-      this._scheduledEviction = null;
-      if (this._config.autostart === true) {
-        this.start();
-      }
-    }
-    _destroy(pooledResource) {
-      pooledResource.invalidate();
-      this._allObjects.delete(pooledResource);
-      const destroyPromise = this._factory.destroy(pooledResource.obj);
-      const wrappedDestroyPromise = this._config.destroyTimeoutMillis ? this._Promise.resolve(this._applyDestroyTimeout(destroyPromise)) : this._Promise.resolve(destroyPromise);
-      this._trackOperation(
-        wrappedDestroyPromise,
-        this._factoryDestroyOperations
-      ).catch((reason) => {
-        this.emit(FACTORY_DESTROY_ERROR, reason);
-      });
-      this._ensureMinimum();
-    }
-    _applyDestroyTimeout(promise) {
-      const timeoutPromise = new this._Promise((resolve, reject) => {
-        setTimeout(() => {
-          reject(new Error("destroy timed out"));
-        }, this._config.destroyTimeoutMillis).unref();
-      });
-      return this._Promise.race([timeoutPromise, promise]);
-    }
-    /**
-     * Attempt to move an available resource into test and then onto a waiting client
-     * @return {Boolean} could we move an available resource into test
-     */
-    _testOnBorrow() {
-      if (this._availableObjects.length < 1) {
-        return false;
-      }
-      const pooledResource = this._availableObjects.shift();
-      pooledResource.test();
-      this._testOnBorrowResources.add(pooledResource);
-      const validationPromise = this._factory.validate(pooledResource.obj);
-      const wrappedValidationPromise = this._Promise.resolve(validationPromise);
-      this._trackOperation(
-        wrappedValidationPromise,
-        this._validationOperations
-      ).then((isValid) => {
-        this._testOnBorrowResources.delete(pooledResource);
-        if (isValid === false) {
-          pooledResource.invalidate();
-          this._destroy(pooledResource);
-          this._dispense();
-          return;
-        }
-        this._dispatchPooledResourceToNextWaitingClient(pooledResource);
-      });
-      return true;
-    }
-    /**
-     * Attempt to move an available resource to a waiting client
-     * @return {Boolean} [description]
-     */
-    _dispatchResource() {
-      if (this._availableObjects.length < 1) {
-        return false;
-      }
-      const pooledResource = this._availableObjects.shift();
-      this._dispatchPooledResourceToNextWaitingClient(pooledResource);
-      return false;
-    }
-    /**
-     * Attempt to resolve an outstanding resource request using an available resource from
-     * the pool, or creating new ones
-     *
-     * @private
-     */
-    _dispense() {
-      const numWaitingClients = this._waitingClientsQueue.length;
-      if (numWaitingClients < 1) {
-        return;
-      }
-      const resourceShortfall = numWaitingClients - this._potentiallyAllocableResourceCount;
-      const actualNumberOfResourcesToCreate = Math.min(
-        this.spareResourceCapacity,
-        resourceShortfall
-      );
-      for (let i = 0; actualNumberOfResourcesToCreate > i; i++) {
-        this._createResource();
-      }
-      if (this._config.testOnBorrow === true) {
-        const desiredNumberOfResourcesToMoveIntoTest = numWaitingClients - this._testOnBorrowResources.size;
-        const actualNumberOfResourcesToMoveIntoTest = Math.min(
-          this._availableObjects.length,
-          desiredNumberOfResourcesToMoveIntoTest
-        );
-        for (let i = 0; actualNumberOfResourcesToMoveIntoTest > i; i++) {
-          this._testOnBorrow();
-        }
-      }
-      if (this._config.testOnBorrow === false) {
-        const actualNumberOfResourcesToDispatch = Math.min(
-          this._availableObjects.length,
-          numWaitingClients
-        );
-        for (let i = 0; actualNumberOfResourcesToDispatch > i; i++) {
-          this._dispatchResource();
-        }
-      }
-    }
-    /**
-     * Dispatches a pooledResource to the next waiting client (if any) else
-     * puts the PooledResource back on the available list
-     * @param  {PooledResource} pooledResource [description]
-     * @return {Boolean}                [description]
-     */
-    _dispatchPooledResourceToNextWaitingClient(pooledResource) {
-      const clientResourceRequest = this._waitingClientsQueue.dequeue();
-      if (clientResourceRequest === void 0 || clientResourceRequest.state !== Deferred.PENDING) {
-        this._addPooledResourceToAvailableObjects(pooledResource);
-        return false;
-      }
-      const loan = new ResourceLoan(pooledResource, this._Promise);
-      this._resourceLoans.set(pooledResource.obj, loan);
-      pooledResource.allocate();
-      clientResourceRequest.resolve(pooledResource.obj);
-      return true;
-    }
-    /**
-     * tracks on operation using given set
-     * handles adding/removing from the set and resolve/rejects the value/reason
-     * @param  {Promise} operation
-     * @param  {Set} set       Set holding operations
-     * @return {Promise}       Promise that resolves once operation has been removed from set
-     */
-    _trackOperation(operation, set) {
-      set.add(operation);
-      return operation.then(
-        (v) => {
-          set.delete(operation);
-          return this._Promise.resolve(v);
-        },
-        (e) => {
-          set.delete(operation);
-          return this._Promise.reject(e);
-        }
-      );
-    }
-    /**
-     * @private
-     */
-    _createResource() {
-      const factoryPromise = this._factory.create();
-      const wrappedFactoryPromise = this._Promise.resolve(factoryPromise).then((resource) => {
-        const pooledResource = new PooledResource(resource);
-        this._allObjects.add(pooledResource);
-        this._addPooledResourceToAvailableObjects(pooledResource);
-      });
-      this._trackOperation(wrappedFactoryPromise, this._factoryCreateOperations).then(() => {
-        this._dispense();
-        return null;
-      }).catch((reason) => {
-        this.emit(FACTORY_CREATE_ERROR, reason);
-        this._dispense();
-      });
-    }
-    /**
-     * @private
-     */
-    _ensureMinimum() {
-      if (this._draining === true) {
-        return;
-      }
-      const minShortfall = this._config.min - this._count;
-      for (let i = 0; i < minShortfall; i++) {
-        this._createResource();
-      }
-    }
-    _evict() {
-      const testsToRun = Math.min(
-        this._config.numTestsPerEvictionRun,
-        this._availableObjects.length
-      );
-      const evictionConfig = {
-        softIdleTimeoutMillis: this._config.softIdleTimeoutMillis,
-        idleTimeoutMillis: this._config.idleTimeoutMillis,
-        min: this._config.min
-      };
-      for (let testsHaveRun = 0; testsHaveRun < testsToRun; ) {
-        const iterationResult = this._evictionIterator.next();
-        if (iterationResult.done === true && this._availableObjects.length < 1) {
-          this._evictionIterator.reset();
-          return;
-        }
-        if (iterationResult.done === true && this._availableObjects.length > 0) {
-          this._evictionIterator.reset();
-          continue;
-        }
-        const resource = iterationResult.value;
-        const shouldEvict = this._evictor.evict(
-          evictionConfig,
-          resource,
-          this._availableObjects.length
-        );
-        testsHaveRun++;
-        if (shouldEvict === true) {
-          this._evictionIterator.remove();
-          this._destroy(resource);
-        }
-      }
-    }
-    _scheduleEvictorRun() {
-      if (this._config.evictionRunIntervalMillis > 0) {
-        this._scheduledEviction = setTimeout(() => {
-          this._evict();
-          this._scheduleEvictorRun();
-        }, this._config.evictionRunIntervalMillis).unref();
-      }
-    }
-    _descheduleEvictorRun() {
-      if (this._scheduledEviction) {
-        clearTimeout(this._scheduledEviction);
-      }
-      this._scheduledEviction = null;
-    }
-    start() {
-      if (this._draining === true) {
-        return;
-      }
-      if (this._started === true) {
-        return;
-      }
-      this._started = true;
-      this._scheduleEvictorRun();
-      this._ensureMinimum();
-    }
-    /**
-     * Request a new resource. The callback will be called,
-     * when a new resource is available, passing the resource to the callback.
-     * TODO: should we add a seperate "acquireWithPriority" function
-     *
-     * @param {Number} [priority=0]
-     *   Optional.  Integer between 0 and (priorityRange - 1).  Specifies the priority
-     *   of the caller if there are no available resources.  Lower numbers mean higher
-     *   priority.
-     *
-     * @returns {Promise}
-     */
-    acquire(priority) {
-      if (this._started === false && this._config.autostart === false) {
-        this.start();
-      }
-      if (this._draining) {
-        return this._Promise.reject(
-          new Error("pool is draining and cannot accept work")
-        );
-      }
-      if (this.spareResourceCapacity < 1 && this._availableObjects.length < 1 && this._config.maxWaitingClients !== void 0 && this._waitingClientsQueue.length >= this._config.maxWaitingClients) {
-        return this._Promise.reject(
-          new Error("max waitingClients count exceeded")
-        );
-      }
-      const resourceRequest = new ResourceRequest(
-        this._config.acquireTimeoutMillis,
-        this._Promise
-      );
-      this._waitingClientsQueue.enqueue(resourceRequest, priority);
-      this._dispense();
-      return resourceRequest.promise;
-    }
-    /**
-     * [use method, aquires a resource, passes the resource to a user supplied function and releases it]
-     * @param  {Function} fn [a function that accepts a resource and returns a promise that resolves/rejects once it has finished using the resource]
-     * @return {Promise}      [resolves once the resource is released to the pool]
-     */
-    use(fn, priority) {
-      return this.acquire(priority).then((resource) => {
-        return fn(resource).then(
-          (result) => {
-            this.release(resource);
-            return result;
-          },
-          (err) => {
-            this.destroy(resource);
-            throw err;
-          }
-        );
-      });
-    }
-    /**
-     * Check if resource is currently on loan from the pool
-     *
-     * @param {Function} resource
-     *    Resource for checking.
-     *
-     * @returns {Boolean}
-     *  True if resource belongs to this pool and false otherwise
-     */
-    isBorrowedResource(resource) {
-      return this._resourceLoans.has(resource);
-    }
-    /**
-     * Return the resource to the pool when it is no longer required.
-     *
-     * @param {Object} resource
-     *   The acquired object to be put back to the pool.
-     */
-    release(resource) {
-      const loan = this._resourceLoans.get(resource);
-      if (loan === void 0) {
-        return this._Promise.reject(
-          new Error("Resource not currently part of this pool")
-        );
-      }
-      this._resourceLoans.delete(resource);
-      loan.resolve();
-      const pooledResource = loan.pooledResource;
-      pooledResource.deallocate();
-      this._addPooledResourceToAvailableObjects(pooledResource);
-      this._dispense();
-      return this._Promise.resolve();
-    }
-    /**
-     * Request the resource to be destroyed. The factory's destroy handler
-     * will also be called.
-     *
-     * This should be called within an acquire() block as an alternative to release().
-     *
-     * @param {Object} resource
-     *   The acquired resource to be destoyed.
-     */
-    destroy(resource) {
-      const loan = this._resourceLoans.get(resource);
-      if (loan === void 0) {
-        return this._Promise.reject(
-          new Error("Resource not currently part of this pool")
-        );
-      }
-      this._resourceLoans.delete(resource);
-      loan.resolve();
-      const pooledResource = loan.pooledResource;
-      pooledResource.deallocate();
-      this._destroy(pooledResource);
-      this._dispense();
-      return this._Promise.resolve();
-    }
-    _addPooledResourceToAvailableObjects(pooledResource) {
-      pooledResource.idle();
-      if (this._config.fifo === true) {
-        this._availableObjects.push(pooledResource);
-      } else {
-        this._availableObjects.unshift(pooledResource);
-      }
-    }
-    /**
-     * Disallow any new acquire calls and let the request backlog dissapate.
-     * The Pool will no longer attempt to maintain a "min" number of resources
-     * and will only make new resources on demand.
-     * Resolves once all resource requests are fulfilled and all resources are returned to pool and available...
-     * Should probably be called "drain work"
-     * @returns {Promise}
-     */
-    drain() {
-      this._draining = true;
-      return this.__allResourceRequestsSettled().then(() => {
-        return this.__allResourcesReturned();
-      }).then(() => {
-        this._descheduleEvictorRun();
-      });
-    }
-    __allResourceRequestsSettled() {
-      if (this._waitingClientsQueue.length > 0) {
-        return reflector(this._waitingClientsQueue.tail.promise);
+  /**
+   * Loads a mesh asynchronously.
+   * @param id - The ID of the mesh.
+   * @param url - The URL of the mesh.
+   * @param options - Optional parameters.
+   * @returns The loaded mesh or null.
+   */
+  async loadMeshAsync(id, url, options = {}) {
+    const gltf = await this.gltfLoader.loadAsync(url);
+    try {
+      if (options.meshName) {
+        const mesh = gltf.scene.getObjectByName(options.meshName);
+        this.register(id, mesh);
+        return mesh;
+      } else {
+        const mesh = gltf.scene.children[0];
+        this.register(id, mesh);
+        return mesh;
       }
-      return this._Promise.resolve();
-    }
-    // FIXME: this is a horrific mess
-    __allResourcesReturned() {
-      const ps = Array.from(this._resourceLoans.values()).map((loan) => loan.promise).map(reflector);
-      return this._Promise.all(ps);
-    }
-    /**
-     * Forcibly destroys all available resources regardless of timeout.  Intended to be
-     * invoked as part of a drain.  Does not prevent the creation of new
-     * resources as a result of subsequent calls to acquire.
-     *
-     * Note that if factory.min > 0 and the pool isn't "draining", the pool will destroy all idle resources
-     * in the pool, but replace them with newly created resources up to the
-     * specified factory.min value.  If this is not desired, set factory.min
-     * to zero before calling clear()
-     *
-     */
-    clear() {
-      const reflectedCreatePromises = Array.from(
-        this._factoryCreateOperations
-      ).map(reflector);
-      return this._Promise.all(reflectedCreatePromises).then(() => {
-        for (const resource of this._availableObjects) {
-          this._destroy(resource);
-        }
-        const reflectedDestroyPromises = Array.from(
-          this._factoryDestroyOperations
-        ).map(reflector);
-        return reflector(this._Promise.all(reflectedDestroyPromises));
-      });
-    }
-    /**
-     * Waits until the pool is ready.
-     * We define ready by checking if the current resource number is at least
-     * the minimum number defined.
-     * @returns {Promise} that resolves when the minimum number is ready.
-     */
-    ready() {
-      return new this._Promise((resolve) => {
-        const isReady = () => {
-          if (this.available >= this.min) {
-            resolve();
-          } else {
-            setTimeout(isReady, 100);
-          }
-        };
-        isReady();
-      });
-    }
-    /**
-     * How many resources are available to allocated
-     * (includes resources that have not been tested and may faul validation)
-     * NOTE: internal for now as the name is awful and might not be useful to anyone
-     * @return {Number} number of resources the pool has to allocate
-     */
-    get _potentiallyAllocableResourceCount() {
-      return this._availableObjects.length + this._testOnBorrowResources.size + this._testOnReturnResources.size + this._factoryCreateOperations.size;
-    }
-    /**
-     * The combined count of the currently created objects and those in the
-     * process of being created
-     * Does NOT include resources in the process of being destroyed
-     * sort of legacy...
-     * @return {Number}
-     */
-    get _count() {
-      return this._allObjects.size + this._factoryCreateOperations.size;
-    }
-    /**
-     * How many more resources does the pool have room for
-     * @return {Number} number of resources the pool could create before hitting any limits
-     */
-    get spareResourceCapacity() {
-      return this._config.max - (this._allObjects.size + this._factoryCreateOperations.size);
-    }
-    /**
-     * see _count above
-     * @return {Number} [description]
-     */
-    get size() {
-      return this._count;
-    }
-    /**
-     * number of available resources
-     * @return {Number} [description]
-     */
-    get available() {
-      return this._availableObjects.length;
-    }
-    /**
-     * number of resources that are currently acquired
-     * @return {Number} [description]
-     */
-    get borrowed() {
-      return this._resourceLoans.size;
-    }
-    /**
-     * number of waiting acquire calls
-     * @return {Number} [description]
-     */
-    get pending() {
-      return this._waitingClientsQueue.length;
-    }
-    /**
-     * maximum size of the pool
-     * @return {Number} [description]
-     */
-    get max() {
-      return this._config.max;
-    }
-    /**
-     * minimum size of the pool
-     * @return {Number} [description]
-     */
-    get min() {
-      return this._config.min;
+    } catch (error) {
+      this.eventEmitter.emit("invalidRequest", { message: `failed to load mesh: ${id}. ${error}` });
+      return null;
     }
   }
-  Pool_1 = Pool;
-  return Pool_1;
-}
-var genericPool$1;
-var hasRequiredGenericPool;
-function requireGenericPool() {
-  if (hasRequiredGenericPool) return genericPool$1;
-  hasRequiredGenericPool = 1;
-  const Pool = requirePool();
-  const Deque = requireDeque();
-  const PriorityQueue = requirePriorityQueue();
-  const DefaultEvictor = requireDefaultEvictor();
-  genericPool$1 = {
-    Pool,
-    Deque,
-    PriorityQueue,
-    DefaultEvictor,
-    createPool: function(factory, config) {
-      return new Pool(DefaultEvictor, Deque, PriorityQueue, factory, config);
+  /**
+   * Loads a texture asynchronously.
+   * @param id - The ID of the texture.
+   * @param url - The URL of the texture.
+   * @returns The loaded texture or null.
+   */
+  async loadTextureAsync(id, url) {
+    try {
+      const texture = await this.textureLoader.loadAsync(url);
+      this.register(id, texture);
+      return texture;
+    } catch (error) {
+      this.eventEmitter.emit("invalidRequest", { message: `failed to load texture: ${id}. ${error}` });
+      return null;
     }
-  };
-  return genericPool$1;
-}
-var genericPoolExports = requireGenericPool();
-const genericPool = /* @__PURE__ */ getDefaultExportFromCjs(genericPoolExports);
-const workerFactory = {
-  create: async () => {
-    const workerPath = new URL("data:video/mp2t;base64,aW1wb3J0IHsgTWVzaERhdGEgfSBmcm9tICdAL2xpYi90eXBlcyc7CmltcG9ydCAqIGFzIENvbWxpbmsgZnJvbSAnY29tbGluayc7CmltcG9ydCAqIGFzIFRIUkVFIGZyb20gJ3RocmVlJzsKaW1wb3J0IHsgTWVzaFN1cmZhY2VTYW1wbGVyIH0gZnJvbSAndGhyZWUvZXhhbXBsZXMvanNtL21hdGgvTWVzaFN1cmZhY2VTYW1wbGVyLmpzJzsKCmV4cG9ydCBpbnRlcmZhY2UgTWVzaFNhbXBsZXJBUEkgewogIHNhbXBsZU1lc2g6IChtZXNoRGF0YTogTWVzaERhdGEsIHNpemU6IG51bWJlcikgPT4gUHJvbWlzZTxGbG9hdDMyQXJyYXk+Owp9Cgpjb25zdCBhcGkgPSB7CiAgc2FtcGxlTWVzaDogKG1lc2hEYXRhOiBNZXNoRGF0YSwgc2l6ZTogbnVtYmVyKTogRmxvYXQzMkFycmF5ID0+IHsKICAgIGNvbnN0IGdlb21ldHJ5ID0gbmV3IFRIUkVFLkJ1ZmZlckdlb21ldHJ5KCk7CiAgICBnZW9tZXRyeS5zZXRBdHRyaWJ1dGUoJ3Bvc2l0aW9uJywgbmV3IFRIUkVFLkJ1ZmZlckF0dHJpYnV0ZShuZXcgRmxvYXQzMkFycmF5KG1lc2hEYXRhLnBvc2l0aW9uKSwgMykpOwogICAgaWYgKG1lc2hEYXRhLm5vcm1hbCkgewogICAgICBnZW9tZXRyeS5zZXRBdHRyaWJ1dGUoJ25vcm1hbCcsIG5ldyBUSFJFRS5CdWZmZXJBdHRyaWJ1dGUobmV3IEZsb2F0MzJBcnJheShtZXNoRGF0YS5ub3JtYWwpLCAzKSk7CiAgICB9CiAgICBjb25zdCBtYXRlcmlhbCA9IG5ldyBUSFJFRS5NZXNoQmFzaWNNYXRlcmlhbCgpOwogICAgY29uc3QgbWVzaCA9IG5ldyBUSFJFRS5NZXNoKGdlb21ldHJ5LCBtYXRlcmlhbCk7CiAgICBtZXNoLnNjYWxlLnNldChtZXNoRGF0YS5zY2FsZS54LCBtZXNoRGF0YS5zY2FsZS55LCBtZXNoRGF0YS5zY2FsZS56KTsKCiAgICBjb25zdCBzYW1wbGVyID0gbmV3IE1lc2hTdXJmYWNlU2FtcGxlcihtZXNoKS5idWlsZCgpOwogICAgY29uc3QgZGF0YSA9IG5ldyBGbG9hdDMyQXJyYXkoc2l6ZSAqIHNpemUgKiA0KTsKICAgIGNvbnN0IHBvc2l0aW9uID0gbmV3IFRIUkVFLlZlY3RvcjMoKTsKCiAgICBmb3IgKGxldCBpID0gMDsgaSA8IHNpemU7IGkrKykgewogICAgICBmb3IgKGxldCBqID0gMDsgaiA8IHNpemU7IGorKykgewogICAgICAgIGNvbnN0IGluZGV4ID0gaSAqIHNpemUgKyBqOwogICAgICAgIHNhbXBsZXIuc2FtcGxlKHBvc2l0aW9uKTsKICAgICAgICBkYXRhWzQgKiBpbmRleF0gPSBwb3NpdGlvbi54ICogbWVzaERhdGEuc2NhbGUueDsKICAgICAgICBkYXRhWzQgKiBpbmRleCArIDFdID0gcG9zaXRpb24ueSAqIG1lc2hEYXRhLnNjYWxlLnk7CiAgICAgICAgZGF0YVs0ICogaW5kZXggKyAyXSA9IHBvc2l0aW9uLnogKiBtZXNoRGF0YS5zY2FsZS56OwogICAgICAgIGRhdGFbNCAqIGluZGV4ICsgM10gPSAoTWF0aC5yYW5kb20oKSAtIDAuNSkgKiAwLjAxOwogICAgICB9CiAgICB9CgogICAgcmV0dXJuIGRhdGE7CiAgfSwKfTsKCkNvbWxpbmsuZXhwb3NlKGFwaSk7Cg==", import.meta.url);
-    const worker = new Worker(workerPath, { type: "module" });
-    return wrap(worker);
-  },
-  destroy: async (worker) => {
-    return worker[releaseProxy]();
   }
-};
-const pool = genericPool.createPool(workerFactory, {
-  max: navigator.hardwareConcurrency || 4,
-  min: 2
-});
-function createDataTexture(data, size) {
-  const texture = new THREE.DataTexture(data, size, size, THREE.RGBAFormat, THREE.FloatType);
-  texture.needsUpdate = true;
-  return texture;
-}
-function createBlankDataTexture(size) {
-  return createDataTexture(new Float32Array(4 * size * size), size);
-}
-function createSpherePoints(size) {
-  const data = new Float32Array(size * size * 4);
-  for (let i = 0; i < size; i++) {
-    for (let j = 0; j < size; j++) {
-      const index = i * size + j;
-      let theta = Math.random() * Math.PI * 2;
-      let phi = Math.acos(Math.random() * 2 - 1);
-      let x = Math.sin(phi) * Math.cos(theta);
-      let y = Math.sin(phi) * Math.sin(theta);
-      let z = Math.cos(phi);
-      data[4 * index] = x;
-      data[4 * index + 1] = y;
-      data[4 * index + 2] = z;
-      data[4 * index + 3] = (Math.random() - 0.5) * 0.01;
-    }
+  dispose() {
+    this.updateServiceState("disposed");
+    this.meshes.forEach((mesh) => disposeMesh(mesh));
+    this.meshes.clear();
+    this.textures.forEach((texture) => texture.dispose());
+    this.textures.clear();
   }
-  return createDataTexture(data, size);
-}
-function disposeMesh(mesh) {
-  mesh.geometry.dispose();
-  if (mesh.material instanceof THREE.Material) {
-    mesh.material.dispose();
-  } else {
-    mesh.material.forEach((material) => material.dispose());
+  changeColor(color) {
+    const actual = new THREE.Color(color);
+    this.solidColorTexture = new THREE.DataTexture(new Uint8Array([actual.r, actual.g, actual.b, 255]), 1, 1, THREE.RGBAFormat);
+    this.solidColorTexture.needsUpdate = true;
+  }
+  updateServiceState(serviceState) {
+    this.serviceState = serviceState;
+    this.eventEmitter.emit("serviceStateUpdated", { type: "asset", state: serviceState });
   }
 }
-function clamp(value, min, max) {
-  value = Math.min(value, max);
-  value = Math.max(value, min);
-  return value;
+const _face = new Triangle();
+const _color = new Vector3();
+const _uva = new Vector2(), _uvb = new Vector2(), _uvc = new Vector2();
+class MeshSurfaceSampler {
+  constructor(mesh) {
+    this.geometry = mesh.geometry;
+    this.randomFunction = Math.random;
+    this.indexAttribute = this.geometry.index;
+    this.positionAttribute = this.geometry.getAttribute("position");
+    this.normalAttribute = this.geometry.getAttribute("normal");
+    this.colorAttribute = this.geometry.getAttribute("color");
+    this.uvAttribute = this.geometry.getAttribute("uv");
+    this.weightAttribute = null;
+    this.distribution = null;
+  }
+  setWeightAttribute(name) {
+    this.weightAttribute = name ? this.geometry.getAttribute(name) : null;
+    return this;
+  }
+  build() {
+    const indexAttribute = this.indexAttribute;
+    const positionAttribute = this.positionAttribute;
+    const weightAttribute = this.weightAttribute;
+    const totalFaces = indexAttribute ? indexAttribute.count / 3 : positionAttribute.count / 3;
+    const faceWeights = new Float32Array(totalFaces);
+    for (let i = 0; i < totalFaces; i++) {
+      let faceWeight = 1;
+      let i0 = 3 * i;
+      let i1 = 3 * i + 1;
+      let i2 = 3 * i + 2;
+      if (indexAttribute) {
+        i0 = indexAttribute.getX(i0);
+        i1 = indexAttribute.getX(i1);
+        i2 = indexAttribute.getX(i2);
+      }
+      if (weightAttribute) {
+        faceWeight = weightAttribute.getX(i0) + weightAttribute.getX(i1) + weightAttribute.getX(i2);
+      }
+      _face.a.fromBufferAttribute(positionAttribute, i0);
+      _face.b.fromBufferAttribute(positionAttribute, i1);
+      _face.c.fromBufferAttribute(positionAttribute, i2);
+      faceWeight *= _face.getArea();
+      faceWeights[i] = faceWeight;
+    }
+    const distribution = new Float32Array(totalFaces);
+    let cumulativeTotal = 0;
+    for (let i = 0; i < totalFaces; i++) {
+      cumulativeTotal += faceWeights[i];
+      distribution[i] = cumulativeTotal;
+    }
+    this.distribution = distribution;
+    return this;
+  }
+  setRandomGenerator(randomFunction) {
+    this.randomFunction = randomFunction;
+    return this;
+  }
+  sample(targetPosition, targetNormal, targetColor, targetUV) {
+    const faceIndex = this.sampleFaceIndex();
+    return this.sampleFace(faceIndex, targetPosition, targetNormal, targetColor, targetUV);
+  }
+  sampleFaceIndex() {
+    const cumulativeTotal = this.distribution[this.distribution.length - 1];
+    return this.binarySearch(this.randomFunction() * cumulativeTotal);
+  }
+  binarySearch(x) {
+    const dist = this.distribution;
+    let start = 0;
+    let end = dist.length - 1;
+    let index = -1;
+    while (start <= end) {
+      const mid = Math.ceil((start + end) / 2);
+      if (mid === 0 || dist[mid - 1] <= x && dist[mid] > x) {
+        index = mid;
+        break;
+      } else if (x < dist[mid]) {
+        end = mid - 1;
+      } else {
+        start = mid + 1;
+      }
+    }
+    return index;
+  }
+  sampleFace(faceIndex, targetPosition, targetNormal, targetColor, targetUV) {
+    let u = this.randomFunction();
+    let v = this.randomFunction();
+    if (u + v > 1) {
+      u = 1 - u;
+      v = 1 - v;
+    }
+    const indexAttribute = this.indexAttribute;
+    let i0 = faceIndex * 3;
+    let i1 = faceIndex * 3 + 1;
+    let i2 = faceIndex * 3 + 2;
+    if (indexAttribute) {
+      i0 = indexAttribute.getX(i0);
+      i1 = indexAttribute.getX(i1);
+      i2 = indexAttribute.getX(i2);
+    }
+    _face.a.fromBufferAttribute(this.positionAttribute, i0);
+    _face.b.fromBufferAttribute(this.positionAttribute, i1);
+    _face.c.fromBufferAttribute(this.positionAttribute, i2);
+    targetPosition.set(0, 0, 0).addScaledVector(_face.a, u).addScaledVector(_face.b, v).addScaledVector(_face.c, 1 - (u + v));
+    if (targetNormal !== void 0) {
+      if (this.normalAttribute !== void 0) {
+        _face.a.fromBufferAttribute(this.normalAttribute, i0);
+        _face.b.fromBufferAttribute(this.normalAttribute, i1);
+        _face.c.fromBufferAttribute(this.normalAttribute, i2);
+        targetNormal.set(0, 0, 0).addScaledVector(_face.a, u).addScaledVector(_face.b, v).addScaledVector(_face.c, 1 - (u + v)).normalize();
+      } else {
+        _face.getNormal(targetNormal);
+      }
+    }
+    if (targetColor !== void 0 && this.colorAttribute !== void 0) {
+      _face.a.fromBufferAttribute(this.colorAttribute, i0);
+      _face.b.fromBufferAttribute(this.colorAttribute, i1);
+      _face.c.fromBufferAttribute(this.colorAttribute, i2);
+      _color.set(0, 0, 0).addScaledVector(_face.a, u).addScaledVector(_face.b, v).addScaledVector(_face.c, 1 - (u + v));
+      targetColor.r = _color.x;
+      targetColor.g = _color.y;
+      targetColor.b = _color.z;
+    }
+    if (targetUV !== void 0 && this.uvAttribute !== void 0) {
+      _uva.fromBufferAttribute(this.uvAttribute, i0);
+      _uvb.fromBufferAttribute(this.uvAttribute, i1);
+      _uvc.fromBufferAttribute(this.uvAttribute, i2);
+      targetUV.set(0, 0).addScaledVector(_uva, u).addScaledVector(_uvb, v).addScaledVector(_uvc, 1 - (u + v));
+    }
+    return this;
+  }
 }
 class DataTextureService {
   /**
@@ -2117,15 +362,10 @@ class DataTextureService {
       return texture;
     }
     const meshData = parseMeshData(asset);
-    const worker = await pool.acquire();
-    try {
-      const array = await worker.sampleMesh(meshData, this.textureSize);
-      const dataTexture = createDataTexture(array, this.textureSize);
-      dataTexture.name = asset.name;
-      return dataTexture;
-    } finally {
-      await pool.release(worker);
-    }
+    const array = sampleMesh(meshData, this.textureSize);
+    const dataTexture = createDataTexture(array, this.textureSize);
+    dataTexture.name = asset.name;
+    return dataTexture;
   }
   async dispose() {
     this.dataTextures.clear();
@@ -2143,12 +383,36 @@ function parseMeshData(mesh) {
     scale: { x: mesh.scale.x, y: mesh.scale.y, z: mesh.scale.z }
   };
 }
+function sampleMesh(meshData, size) {
+  const geometry = new THREE.BufferGeometry();
+  geometry.setAttribute("position", new THREE.BufferAttribute(new Float32Array(meshData.position), 3));
+  if (meshData.normal) {
+    geometry.setAttribute("normal", new THREE.BufferAttribute(new Float32Array(meshData.normal), 3));
+  }
+  const material = new THREE.MeshBasicMaterial();
+  const mesh = new THREE.Mesh(geometry, material);
+  mesh.scale.set(meshData.scale.x, meshData.scale.y, meshData.scale.z);
+  const sampler = new MeshSurfaceSampler(mesh).build();
+  const data = new Float32Array(size * size * 4);
+  const position = new THREE.Vector3();
+  for (let i = 0; i < size; i++) {
+    for (let j = 0; j < size; j++) {
+      const index = i * size + j;
+      sampler.sample(position);
+      data[4 * index] = position.x * meshData.scale.x;
+      data[4 * index + 1] = position.y * meshData.scale.y;
+      data[4 * index + 2] = position.z * meshData.scale.z;
+      data[4 * index + 3] = (Math.random() - 0.5) * 0.01;
+    }
+  }
+  return data;
+}
 const instanceFragmentShader = `
 varying vec2 vUv;
 uniform sampler2D uTexture;
 
-uniform sampler2D uSourceMatcap;
-uniform sampler2D uTargetMatcap;
+uniform sampler2D uOriginTexture;
+uniform sampler2D uDestinationTexture;
 
 uniform float uProgress;
 varying vec3 vNormal;
@@ -2159,8 +423,8 @@ void main() {
     vec3 y = cross( viewDir, x );
     vec2 uv = vec2( dot( x, vNormal ), dot( y, vNormal ) ) * 0.495 + 0.5; // 0.495 to remove artifacts caused by undersized matcap disks
 
-    vec4 sourceMatcap = texture2D( uSourceMatcap, uv );
-    vec4 targetMatcap = texture2D( uTargetMatcap, uv );
+    vec4 sourceMatcap = texture2D( uOriginTexture, uv );
+    vec4 targetMatcap = texture2D( uDestinationTexture, uv );
 
     vec4 matcap = mix(sourceMatcap, targetMatcap, uProgress);
     gl_FragColor = matcap;
@@ -2220,32 +484,36 @@ class InstancedMeshManager {
     __publicField(this, "size");
     __publicField(this, "mesh");
     __publicField(this, "matcapMaterial");
-    __publicField(this, "fallbackMaterial");
     __publicField(this, "fallbackGeometry");
-    __publicField(this, "materials");
+    __publicField(this, "uniforms");
+    __publicField(this, "originColor");
+    __publicField(this, "destinationColor");
     __publicField(this, "geometries");
     __publicField(this, "uvRefsCache");
     __publicField(this, "previousScale");
     this.size = initialSize;
-    this.materials = /* @__PURE__ */ new Map();
     this.geometries = /* @__PURE__ */ new Map();
     this.uvRefsCache = /* @__PURE__ */ new Map();
     this.previousScale = { x: 1, y: 1, z: 1 };
+    this.originColor = "grey";
+    this.destinationColor = "grey";
+    this.uniforms = {
+      uTime: { value: 0 },
+      uProgress: { value: 0 },
+      uTexture: { value: null },
+      uVelocity: { value: null },
+      uOriginTexture: { value: null },
+      uDestinationTexture: { value: null }
+    };
     this.matcapMaterial = new THREE.ShaderMaterial({
-      uniforms: {
-        uTime: { value: 0 },
-        uProgress: { value: 0 },
-        uTexture: { value: null },
-        uVelocity: { value: null },
-        uSourceMatcap: { value: null },
-        uTargetMatcap: { value: null }
-      },
+      uniforms: this.uniforms,
       vertexShader: instanceVertexShader,
       fragmentShader: instanceFragmentShader
     });
-    this.fallbackMaterial = new THREE.MeshBasicMaterial({ color: 16777215 });
+    this.setOriginColor(this.originColor);
+    this.setDestinationColor(this.destinationColor);
     this.fallbackGeometry = new THREE.BoxGeometry(1e-3, 1e-3, 1e-3);
-    this.mesh = this.createInstancedMesh(initialSize, this.fallbackGeometry, this.fallbackMaterial);
+    this.mesh = this.createInstancedMesh(initialSize, this.fallbackGeometry, this.matcapMaterial);
   }
   /**
    * Gets the instanced mesh.
@@ -2269,10 +537,12 @@ class InstancedMeshManager {
    * @param matcap The matcap texture to set.
    */
   setOriginMatcap(matcap) {
-    this.matcapMaterial.uniforms.uSourceMatcap.value = matcap;
+    this.disposeSolidColorOriginTexture();
+    this.matcapMaterial.uniforms.uOriginTexture.value = matcap;
   }
   setDestinationMatcap(matcap) {
-    this.matcapMaterial.uniforms.uTargetMatcap.value = matcap;
+    this.disposeSolidColorDestinationTexture();
+    this.matcapMaterial.uniforms.uDestinationTexture.value = matcap;
   }
   setProgress(float) {
     float = Math.max(0, float);
@@ -2290,16 +560,6 @@ class InstancedMeshManager {
   useMatcapMaterial() {
     this.mesh.material = this.matcapMaterial;
   }
-  /**
-   * Use the specified material for the instanced mesh.
-   * @param id The ID of the material to use.
-   */
-  useMaterial(id) {
-    const material = this.materials.get(id);
-    if (material) {
-      this.mesh.material = material;
-    }
-  }
   /**
    * Use the specified geometry for the instanced mesh.
    * @param id The ID of the geometry to use.
@@ -2342,10 +602,11 @@ class InstancedMeshManager {
   dispose() {
     this.mesh.dispose();
     this.geometries.forEach((geometry) => geometry.dispose());
-    this.materials.forEach((material) => material.dispose());
+    this.disposeSolidColorOriginTexture();
+    this.disposeSolidColorDestinationTexture();
+    this.matcapMaterial.dispose();
     this.uvRefsCache.clear();
     this.geometries.clear();
-    this.materials.clear();
   }
   /**
    * Registers a geometry.
@@ -2359,7 +620,7 @@ class InstancedMeshManager {
         return;
       }
     }
-    const uvRefs = this.getUVRefs(this.size);
+    const uvRefs = this.createUVRefs(this.size);
     geometry.setAttribute("uvRef", uvRefs);
     this.geometries.set(id, geometry);
     if (this.mesh.geometry === previous) {
@@ -2367,30 +628,22 @@ class InstancedMeshManager {
     }
     previous == null ? void 0 : previous.dispose();
   }
-  /**
-   * Registers a material.
-   * @param id The ID of the material to register.
-   * @param material The material to register.
-   */
-  registerMaterial(id, material) {
-    const previous = this.materials.get(id);
-    if (previous) {
-      if (previous === material) {
-        return;
-      }
-    }
-    if (this.mesh.material === previous) {
-      this.mesh.material = material;
-    }
-    this.materials.set(id, material);
-    previous == null ? void 0 : previous.dispose();
+  setOriginColor(color) {
+    this.disposeSolidColorOriginTexture();
+    this.originColor = color;
+    this.uniforms.uOriginTexture.value = this.createSolidColorDataTexture(color);
+  }
+  setDestinationColor(color) {
+    this.disposeSolidColorDestinationTexture();
+    this.destinationColor = color;
+    this.uniforms.uDestinationTexture.value = this.createSolidColorDataTexture(color);
   }
   /**
    * Gets the UV references for the specified size.
    * @param size The size for which to generate UV references.
    * @returns The UV references.
    */
-  getUVRefs(size) {
+  createUVRefs(size) {
     const cached = this.uvRefsCache.get(size);
     if (cached) {
       return cached;
@@ -2416,10 +669,50 @@ class InstancedMeshManager {
    */
   createInstancedMesh(size, geometry, material) {
     geometry = geometry || this.fallbackGeometry;
-    geometry.setAttribute("uvRef", this.getUVRefs(size));
+    geometry.setAttribute("uvRef", this.createUVRefs(size));
     const count = size * size;
     return new THREE.InstancedMesh(geometry, material, count);
   }
+  createSolidColorDataTexture(color, size = 16) {
+    const col = new THREE.Color(color);
+    const width = size;
+    const height = size;
+    const data = new Uint8Array(width * height * 4);
+    const r = Math.floor(col.r * 255);
+    const g = Math.floor(col.g * 255);
+    const b = Math.floor(col.b * 255);
+    for (let i = 0; i < width * height; i++) {
+      const index = i * 4;
+      data[index] = r;
+      data[index + 1] = g;
+      data[index + 2] = b;
+      data[index + 3] = 255;
+    }
+    const texture = new THREE.DataTexture(data, width, height, THREE.RGBAFormat);
+    texture.type = THREE.UnsignedByteType;
+    texture.wrapS = THREE.RepeatWrapping;
+    texture.wrapT = THREE.RepeatWrapping;
+    texture.minFilter = THREE.NearestFilter;
+    texture.magFilter = THREE.NearestFilter;
+    texture.needsUpdate = true;
+    return texture;
+  }
+  disposeSolidColorOriginTexture() {
+    if (this.originColor) {
+      this.originColor = null;
+      if (this.uniforms.uOriginTexture.value) {
+        this.uniforms.uOriginTexture.value.dispose();
+      }
+    }
+  }
+  disposeSolidColorDestinationTexture() {
+    if (this.destinationColor) {
+      this.destinationColor = null;
+      if (this.uniforms.uDestinationTexture.value) {
+        this.uniforms.uDestinationTexture.value.dispose();
+      }
+    }
+  }
 }
 class IntersectionService {
   /**
@@ -3187,122 +1480,6 @@ class TransitionService {
     this.eventEmitter.emit("transitionFinished", { type });
   }
 }
-class AssetService {
-  constructor(eventEmitter) {
-    __publicField(this, "serviceState", "created");
-    __publicField(this, "eventEmitter");
-    __publicField(this, "meshes", /* @__PURE__ */ new Map());
-    __publicField(this, "textures", /* @__PURE__ */ new Map());
-    __publicField(this, "gltfLoader", new GLTFLoader());
-    __publicField(this, "textureLoader", new THREE.TextureLoader());
-    __publicField(this, "dracoLoader", new DRACOLoader());
-    __publicField(this, "solidColorTexture", new THREE.DataTexture(new Uint8Array([127, 127, 127, 255]), 1, 1, THREE.RGBAFormat));
-    this.eventEmitter = eventEmitter;
-    this.dracoLoader.setDecoderPath("https://www.gstatic.com/draco/versioned/decoders/1.5.7/");
-    this.gltfLoader.setDRACOLoader(this.dracoLoader);
-    this.updateServiceState("ready");
-  }
-  /**
-   * Registers an asset.
-   * @param id - The ID of the asset.
-   * @param item - The asset to set.
-   */
-  register(id, item) {
-    item.name = id;
-    if (item instanceof THREE.Mesh) {
-      const prev = this.meshes.get(id);
-      if (prev) disposeMesh(prev);
-      this.meshes.set(id, item);
-    } else {
-      const prev = this.textures.get(id);
-      if (prev) prev.dispose();
-      this.textures.set(id, item);
-    }
-    this.eventEmitter.emit("assetRegistered", { id });
-  }
-  setSolidColor(color) {
-    this.changeColor(color);
-  }
-  getSolidColorTexture() {
-    return this.solidColorTexture;
-  }
-  getMesh(id) {
-    return this.meshes.get(id) ?? null;
-  }
-  getMatcap(id) {
-    const texture = this.textures.get(id);
-    if (!texture) this.eventEmitter.emit("invalidRequest", { message: `texture with id "${id}" not found. using solid color texture instead...` });
-    return texture ?? this.solidColorTexture;
-  }
-  getMeshIDs() {
-    return Array.from(this.meshes.keys());
-  }
-  getTextureIDs() {
-    return Array.from(this.textures.keys());
-  }
-  getMeshes() {
-    return Array.from(this.meshes.values());
-  }
-  getTextures() {
-    return Array.from(this.textures.values());
-  }
-  /**
-   * Loads a mesh asynchronously.
-   * @param id - The ID of the mesh.
-   * @param url - The URL of the mesh.
-   * @param options - Optional parameters.
-   * @returns The loaded mesh or null.
-   */
-  async loadMeshAsync(id, url, options = {}) {
-    const gltf = await this.gltfLoader.loadAsync(url);
-    try {
-      if (options.meshName) {
-        const mesh = gltf.scene.getObjectByName(options.meshName);
-        this.register(id, mesh);
-        return mesh;
-      } else {
-        const mesh = gltf.scene.children[0];
-        this.register(id, mesh);
-        return mesh;
-      }
-    } catch (error) {
-      this.eventEmitter.emit("invalidRequest", { message: `failed to load mesh: ${id}. ${error}` });
-      return null;
-    }
-  }
-  /**
-   * Loads a texture asynchronously.
-   * @param id - The ID of the texture.
-   * @param url - The URL of the texture.
-   * @returns The loaded texture or null.
-   */
-  async loadTextureAsync(id, url) {
-    try {
-      const texture = await this.textureLoader.loadAsync(url);
-      this.register(id, texture);
-      return texture;
-    } catch (error) {
-      this.eventEmitter.emit("invalidRequest", { message: `failed to load texture: ${id}. ${error}` });
-      return null;
-    }
-  }
-  dispose() {
-    this.updateServiceState("disposed");
-    this.meshes.forEach((mesh) => disposeMesh(mesh));
-    this.meshes.clear();
-    this.textures.forEach((texture) => texture.dispose());
-    this.textures.clear();
-  }
-  changeColor(color) {
-    const actual = new THREE.Color(color);
-    this.solidColorTexture = new THREE.DataTexture(new Uint8Array([actual.r, actual.g, actual.b, 255]), 1, 1, THREE.RGBAFormat);
-    this.solidColorTexture.needsUpdate = true;
-  }
-  updateServiceState(serviceState) {
-    this.serviceState = serviceState;
-    this.eventEmitter.emit("serviceStateUpdated", { type: "asset", state: serviceState });
-  }
-}
 class ParticlesEngine {
   /**
    * Creates a new ParticlesEngine instance.
@@ -3549,6 +1726,12 @@ class ParticlesEngine {
   handleInteractionPositionUpdated({ position }) {
     this.simulationRendererService.setInteractionPosition(position);
   }
+  setOriginColor(color) {
+    this.instancedMeshManager.setOriginColor(color);
+  }
+  setDestinationColor(color) {
+    this.instancedMeshManager.setDestinationColor(color);
+  }
 }
 export {
   ParticlesEngine