lecodes-cli 0.1.3 → 0.1.6

package/runtime/worker/creator.js

@@ -1,930 +0,0 @@
-import {
-  ARScene,
-  Camera,
-  Component,
-  Entity,
-  FormData,
-  LitMaterial,
-  Material,
-  Mesh,
-  MeshGeometry,
-  Ray,
-  Scene,
-  ShadowMaterial,
-  Texture,
-  UnlitMaterial,
-  VideoMaterial,
-  createCubeGeometry,
-  createCubeMesh,
-  createCylinderGeometry,
-  createCylinderMesh,
-  createPlaneGeometry,
-  createPlaneMesh,
-  createSphereGeometry,
-  createSphereMesh,
-  entityMap,
-  getEntityById,
-  getPosition,
-  getScale,
-  normalizeInPlace,
-  registerTouchEndEvent,
-  registerTouchStartEvent,
-  vec3Cross
-} from "./chunk-MI3UXE5H.js";
-
-// ../worker/src/components/Animation.ts
-var animatorRegistered = false;
-var onAnimationComplete = (entityId, clipIndex) => {
-  const entity = entityMap.get(entityId);
-  const controller = entity.animation;
-  if (clipIndex !== controller["_clip"]) return true;
-  if (!controller["_loop"]) {
-    controller["_playing"] = false;
-    Entity.dispatch(entity, "completed", clipIndex);
-  } else {
-    Entity.dispatch(entity, "loopReached", clipIndex);
-  }
-  return controller["_playing"];
-};
-var Animation = class extends Component {
-  name = "animation";
-  _playing = false;
-  _clip = 0;
-  _speed = 1;
-  _loop = false;
-  constructor() {
-    super();
-  }
-  get clips() {
-    return _creator.getGlbAnimations(this.entity._id);
-  }
-  get playing() {
-    return this._playing;
-  }
-  set playing(value) {
-    this._playing = value;
-    _creator.setAnimation(this.entity._id, this._playing, this._clip, this._speed);
-  }
-  play(clip) {
-    if (typeof clip === "number") {
-      this._clip = clip;
-    }
-    this.playing = true;
-    if (!animatorRegistered) {
-      _creator.setOnAnimationComplete(onAnimationComplete);
-      animatorRegistered = true;
-    }
-  }
-  pause() {
-    this.playing = false;
-  }
-  get speed() {
-    return this._speed;
-  }
-  set speed(value) {
-    this._speed = value;
-    _creator.setAnimation(this.entity._id, this._playing, this._clip, this._speed);
-  }
-  get time() {
-    return _creator.getAnimationTime(this.entity._id);
-  }
-  set time(value) {
-    _creator.setAnimationTime(this.entity._id, this._clip, value);
-  }
-  get loop() {
-    return this._loop;
-  }
-  set loop(value) {
-    this._loop = value;
-  }
-};
-
-// ../worker/src/components/Collider.ts
-var primitives = ["box", "sphere"];
-var Collider = class extends Component {
-  name = "collider";
-  _form;
-  created = false;
-  constructor(form = "box") {
-    super();
-    this._form = form;
-  }
-  get form() {
-    return this._form;
-  }
-  set form(form) {
-    this._form = form;
-    if (this.entity) {
-      _creator.setColliderFromMesh(this.entity._id, this.entity._id, primitives.indexOf(form));
-    }
-  }
-  setFromMesh(mesh) {
-    _creator.setColliderFromMesh(this.entity._id, mesh.entity._id, primitives.indexOf(this._form));
-  }
-  set(form, center, arg) {
-    this.created = true;
-    if (!this.entity) return;
-    if (form === "box") {
-      this._form = "box";
-      _creator.setColliderBox(this.entity._id, center[0], center[1], center[2], arg[0], arg[1], arg[2]);
-    } else if (form === "sphere") {
-      this._form = "sphere";
-      _creator.setColliderSphere(this.entity._id, center[0], center[1], center[2], arg);
-    }
-  }
-  onAssign(entityId) {
-    if (this.entity.hasComponent(Mesh)) {
-      _creator.setColliderFromMesh(entityId, entityId, primitives.indexOf(this._form));
-    }
-    if (!this.entity._onListenerAdded) {
-      this.entity._onListenerAdded = {
-        "click": registerTouchEndEvent,
-        "touchstart": registerTouchStartEvent
-      };
-    } else {
-      this.entity._onListenerAdded["click"] = registerTouchEndEvent, this.entity._onListenerAdded["touchstart"] = registerTouchStartEvent;
-    }
-  }
-};
-
-// ../worker/src/components/Particles.ts
-var Particles = class extends Component {
-  name = "particles";
-  custom = new Proxy([], {
-    set(target, property, value) {
-      if (property === "entityId") {
-        target.entityId = value;
-        return true;
-      }
-      const i = parseInt(property);
-      target[i] = value;
-      if (target.entityId) {
-        if (typeof value === "number") {
-          _creator.setParticleSystemParamValue(target.entityId, i, value);
-        } else if ("min" in value) {
-          _creator.setParticleSystemParamRange(target.entityId, i, value.min, value.max);
-        } else {
-          if (typeof value.value === "number") {
-            _creator.setParticleSystemParamValue(target.entityId, i, value.value);
-          } else if (value.value) {
-            _creator.setParticleSystemParamRange(target.entityId, i, value.value.min, value.value.max);
-          }
-          if (value.inc) {
-            _creator.setParticleSystemParamCurveA(target.entityId, i, value.inc, 1);
-          }
-          if (value.inc_b) {
-            _creator.setParticleSystemParamCurveB(target.entityId, i, value.inc_b);
-          }
-          if (value.mul) {
-            _creator.setParticleSystemParamCurveA(target.entityId, i, value.mul, 0);
-          }
-          if (value.mul_b) {
-            _creator.setParticleSystemParamCurveB(target.entityId, i, value.mul_b);
-          }
-        }
-      }
-      return true;
-    }
-  });
-  _material;
-  constructor(material) {
-    super();
-    this._material = material;
-  }
-  spawnParticles(count) {
-    _creator.spawnParticles(this.entity._id, count);
-  }
-  _rate;
-  get rate() {
-    return this._rate ?? 5;
-  }
-  set rate(val) {
-    this._rate = val;
-    if (this.entity) {
-      if (typeof val === "number") {
-        _creator.setParticleSystemRateValue(this.entity._id, val);
-      } else {
-      }
-    }
-  }
-  _shape;
-  get shape() {
-    return this._shape ?? { type: "point", v: [0, 0, 0] };
-  }
-  set shape(shape) {
-    this._shape = shape;
-    if (this.entity) {
-      switch (shape.type) {
-        case "point":
-          _creator.setParticleSystemShapePoint(this.entity._id, shape.v[0], shape.v[1], shape.v[2]);
-          break;
-        case "box":
-          _creator.setParticleSystemShapeBox(this.entity._id, shape.min[0], shape.min[1], shape.min[2], shape.max[0], shape.max[1], shape.max[2]);
-          break;
-      }
-    }
-  }
-  _startVelocity;
-  get startVelocity() {
-    return this._startVelocity ?? [0, 0, 0];
-  }
-  set startVelocity(val) {
-    this._startVelocity = val;
-    if (this.entity) {
-      if (Array.isArray(val) || val instanceof Float32Array) {
-        _creator.setParticleSystemVelocityValue(this.entity._id, 1, val[0], val[1], val[2]);
-      } else {
-        if ("from" in val) {
-          _creator.setParticleSystemVelocityValue(this.entity._id, 2, val.from[0], val.from[1], val.from[2]);
-        } else if ("to" in val) {
-          _creator.setParticleSystemVelocityValue(this.entity._id, 3, val.to[0], val.to[1], val.to[2]);
-        } else if ("dir" in val) {
-          _creator.setParticleSystemVelocityValue(this.entity._id, 1, val.dir[0], val.dir[1], val.dir[2]);
-        } else {
-          _creator.setParticleSystemVelocityValue(this.entity._id, 0, 0, 0, 0);
-        }
-        if ("speed" in val) {
-          if (typeof val.speed === "number") {
-            _creator.setParticleSystemVelocitySpeedValue(this.entity._id, val.speed);
-          } else if (val.speed) {
-            _creator.setParticleSystemVelocitySpeedRange(this.entity._id, val.speed.min, val.speed.max);
-          }
-        }
-        if ("randomizeAngle" in val && val.randomizeAngle) {
-          _creator.setParticleSystemVelocityRndAngle(
-            this.entity._id,
-            val.randomizeAngle.min[0],
-            val.randomizeAngle.min[1],
-            val.randomizeAngle.min[2],
-            val.randomizeAngle.max[0],
-            val.randomizeAngle.max[1],
-            val.randomizeAngle.max[2]
-          );
-        }
-      }
-    }
-  }
-  _gravity;
-  get gravity() {
-    return this._drag ?? 0;
-  }
-  set gravity(val) {
-    this._gravity = val;
-    if (this.entity) {
-      _creator.setParticleSystemGravityValue(this.entity._id, val);
-    }
-  }
-  _drag;
-  get drag() {
-    return this._drag ?? 0;
-  }
-  set drag(val) {
-    this._drag = val;
-    if (this.entity) {
-      _creator.setParticleSystemDragValue(this.entity._id, val);
-    }
-  }
-  get size() {
-    return this.custom[0];
-  }
-  set size(val) {
-    this.custom[0] = val;
-  }
-  get rotation() {
-    return this.custom[1];
-  }
-  set rotation(val) {
-    this.custom[1] = val;
-  }
-  _lifetime;
-  get lifetime() {
-    return this._lifetime ?? 5;
-  }
-  set lifetime(val) {
-    this._lifetime = val;
-    if (this.entity) {
-      if (typeof val === "number") {
-        _creator.setParticleSystemLifetimeValue(this.entity._id, val);
-      } else {
-        _creator.setParticleSystemLifetimeRange(this.entity._id, val.min, val.max);
-      }
-    }
-  }
-  _color;
-  get color() {
-    return this._color ?? "#FFFFFF";
-  }
-  set color(value) {
-    this._color = value;
-    if (typeof value === "string") {
-      _creator.setParticleSystemColorValue(this.entity._id, value);
-    } else if ("min" in value) {
-      _creator.setParticleSystemColorRange(this.entity._id, value.min, value.max);
-    } else {
-      if (typeof value.value === "string") {
-        _creator.setParticleSystemColorValue(this.entity._id, value.value);
-      } else if (value.value) {
-        _creator.setParticleSystemColorRange(this.entity._id, value.value.min, value.value.max);
-      }
-      if (value.mul) {
-        _creator.setParticleSystemColorCurveA(this.entity._id, value.mul, value.t);
-      }
-      if (value.mul_b) {
-        _creator.setParticleSystemColorCurveB(this.entity._id, value.mul_b, value.t);
-      }
-    }
-  }
-  get material() {
-    return this._material;
-  }
-  set material(material) {
-    this._material = material;
-    if (this.entity) {
-      _creator.setMaterial(this.entity._id, Material.getInternalId(this._material), 0);
-    }
-  }
-  _noise = null;
-  get noise() {
-    return this._noise;
-  }
-  set noise(noise) {
-    this._noise = noise;
-    if (this.entity) {
-      if (noise) {
-        _creator.setParticleSystemNoise(this.entity._id, noise.strength ?? 1, noise.frequency ?? 1, noise.speed ?? 1);
-      } else {
-        _creator.disableParticleSystemNoise(this.entity._id);
-      }
-    }
-  }
-  onAssign(entityId) {
-    _creator.createParticleSystem(entityId, Material.getInternalId(this._material));
-    this.custom.entityId = entityId;
-    if (this._rate !== void 0) {
-      this.rate = this._rate;
-    }
-    if (this._shape !== void 0) {
-      this.shape = this._shape;
-    }
-    if (this._startVelocity !== void 0) {
-      this.startVelocity = this._startVelocity;
-    }
-    if (this._gravity !== void 0) {
-      this.gravity = this._gravity;
-    }
-    if (this._drag !== void 0) {
-      this.drag = this._drag;
-    }
-    if (this._lifetime !== void 0) {
-      this.lifetime = this._lifetime;
-    }
-    if (this._color !== void 0) {
-      this.color = this._color;
-    }
-    if (this._noise !== null) {
-      this.noise = this._noise;
-    }
-    for (let i = 0; i < 4; i++) {
-      if (this.custom[i] !== void 0) {
-        this.custom[i] = this.custom[i];
-      }
-    }
-  }
-};
-var dynamicColor = (baseValue, ...args) => {
-  const t = new Float32Array(args.length / 2);
-  const mul = [];
-  let mul_b = void 0;
-  for (let i = 0; i < args.length / 2; i++) {
-    if (typeof args[i * 2] !== "number") {
-      throw new Error(`Wrong particle system curve value ${i * 2}. Expected number, received ${typeof args[i * 2]}`);
-    }
-    t[i] = args[i * 2];
-    const val = args[i * 2 + 1];
-    if (typeof val === "string") {
-      mul[i] = val;
-      if (mul_b) {
-        mul_b[i] = val;
-      }
-    } else if (typeof val === "number") {
-      throw new Error(`Wrong particle system curve value ${i * 2 + 1}. Expected string, received ${typeof val}`);
-    } else {
-      mul[i] = val.min;
-      if (!mul_b) {
-        mul_b = [...mul];
-      }
-      mul_b[i] = val.max;
-    }
-  }
-  return {
-    value: baseValue,
-    mul: mul.join("\0"),
-    mul_b: mul_b?.join("\0"),
-    t
-  };
-};
-var dynamic = (baseValue, type, ...args) => {
-  const inc = new Float32Array(args.length);
-  let inc_b = void 0;
-  for (let i = 0; i < args.length; i += 2) {
-    if (typeof args[i] !== "number") {
-      throw new Error(`Wrong particle system curve value ${i}. Expected number, received ${typeof args[i]}`);
-    }
-    inc[i] = args[i];
-    if (inc_b) {
-      inc_b[i] = args[i];
-    }
-    const val = args[i + 1];
-    if (typeof val === "number") {
-      inc[i + 1] = val;
-      if (inc_b) {
-        inc_b[i + 1] = val;
-      }
-    } else {
-      inc[i + 1] = val.min;
-      if (!inc_b) {
-        inc_b = new Float32Array(inc);
-      }
-      inc_b[i + 1] = val.max;
-    }
-  }
-  if (type === "inc") {
-    return {
-      value: baseValue,
-      inc,
-      inc_b
-    };
-  } else {
-    return {
-      value: baseValue,
-      mul: inc,
-      mul_b: inc_b
-    };
-  }
-};
-
-// ../worker/src/glb.ts
-var loadGlb = (urlOrResponse, options = {}) => {
-  if (typeof urlOrResponse === "string") {
-    return fetch(urlOrResponse, { useOnce: true, onProgress: options.onProgress }).then((resp) => {
-      if (resp.status >= 400) {
-        return Promise.reject(new Error(`Failed to load GLB from ${urlOrResponse}. HTTP code: ${resp.status}`));
-      } else {
-        return loadGlb(resp, options);
-      }
-    });
-  } else {
-    return new Promise((res, rej) => {
-      _creator.createGlb(urlOrResponse._id, (entityId) => {
-        if (entityId === 0) {
-          rej(new Error("Failed to load GLB from Data"));
-          return;
-        }
-        const entity = new Entity(entityId);
-        entity.addComponent(new Animation());
-        if (options?.culling !== true) {
-          _creator.setGlbCulling(entityId, false);
-        }
-        res(entity);
-      }, rej);
-    });
-  }
-};
-
-// ../worker/src/utils/Plane.ts
-import * as vec3Op from "gl-matrix/vec3";
-import * as mat4Op from "gl-matrix/mat4";
-var Plane = class _Plane {
-  /** Outward-facing unit normal of the plane. */
-  normal;
-  /** Scalar offset: dot(normal, point) */
-  d;
-  /**
-   * @param normal - A vector perpendicular to the plane (need not be normalised).
-   * @param point  - Any point that lies on the plane.
-   */
-  constructor(normal, point) {
-    const n = vec3Op.create();
-    vec3Op.normalize(n, normal);
-    this.normal = n;
-    this.d = vec3Op.dot(n, point);
-  }
-  // ---------------------------------------------------------------------------
-  // Factory helpers
-  // ---------------------------------------------------------------------------
-  /**
-   * Construct a plane from three non-collinear points.
-   * The normal follows the right-hand rule: (b-a) × (c-a).
-   */
-  static fromPoints(a, b, c) {
-    const ab = vec3Op.subtract(vec3Op.create(), b, a);
-    const ac = vec3Op.subtract(vec3Op.create(), c, a);
-    const normal = vec3Op.cross(vec3Op.create(), ab, ac);
-    return new _Plane(normal, a);
-  }
-  /**
-   * Construct a plane from the four coefficients of the equation ax+by+cz=d.
-   */
-  static fromCoefficients(a, b, c, d) {
-    const rawNormal = vec3Op.fromValues(a, b, c);
-    const len = vec3Op.length(rawNormal);
-    const point = vec3Op.fromValues(
-      a * d / (len * len),
-      b * d / (len * len),
-      c * d / (len * len)
-    );
-    return new _Plane(rawNormal, point);
-  }
-  // ---------------------------------------------------------------------------
-  // Ray intersection
-  // ---------------------------------------------------------------------------
-  /**
-   * Test whether `ray` intersects the plane.
-   *
-   * @param ray - The ray to test.
-   * @returns The parameter `t` such that `ray.getPoint(t)` is the intersection
-   *          point, or `null` when the ray misses (parallel or behind origin).
-   *
-   * Derivation:
-   *   Substituting the ray into the plane equation:
-   *     dot(n, origin + t*dir) = d
-   *     dot(n, origin) + t * dot(n, dir) = d
-   *     t = (d - dot(n, origin)) / dot(n, dir)
-   */
-  intersectRay(ray) {
-    const denom = vec3Op.dot(this.normal, ray.dir);
-    if (Math.abs(denom) < 1e-8) return null;
-    const t = (this.d - vec3Op.dot(this.normal, ray.origin)) / denom;
-    if (t < 0) return null;
-    return t;
-  }
-  /**
-   * Like `intersectRay` but also accepts hits *behind* the origin (t < 0).
-   * Useful for line-plane intersection rather than ray-plane intersection.
-   */
-  intersectLine(ray) {
-    const denom = vec3Op.dot(this.normal, ray.dir);
-    if (Math.abs(denom) < 1e-8) return null;
-    return (this.d - vec3Op.dot(this.normal, ray.origin)) / denom;
-  }
-  // ---------------------------------------------------------------------------
-  // Utility
-  // ---------------------------------------------------------------------------
-  /**
-   * Signed distance from `point` to the plane.
-   * Positive values are on the side the normal points toward.
-   */
-  signedDistance(point) {
-    return vec3Op.dot(this.normal, point) - this.d;
-  }
-  /**
-   * Project `point` onto the plane.
-   */
-  projectPoint(point) {
-    const dist = this.signedDistance(point);
-    return vec3Op.scaleAndAdd(vec3Op.create(), point, this.normal, -dist);
-  }
-  /**
-   * Transform the plane by a 4×4 matrix.
-   * The normal is transformed by the inverse-transpose of `m`.
-   */
-  transform(m) {
-    const pointOnPlane = vec3Op.scale(vec3Op.create(), this.normal, this.d);
-    const newPoint = vec3Op.transformMat4(vec3Op.create(), pointOnPlane, m);
-    const inv = mat4Op.invert(mat4Op.create(), m);
-    if (!inv) throw new Error("Matrix is not invertible.");
-    mat4Op.transpose(inv, inv);
-    const newNormal = vec3Op.transformMat4(vec3Op.create(), this.normal, inv);
-    return new _Plane(newNormal, newPoint);
-  }
-  toString() {
-    const [nx, ny, nz] = this.normal;
-    return `Plane(normal=[${nx.toFixed(4)}, ${ny.toFixed(4)}, ${nz.toFixed(4)}], d=${this.d.toFixed(4)})`;
-  }
-};
-
-// ../worker/src/utils/addControls.ts
-import { quat, vec2, vec3 } from "gl-matrix";
-var addControls = (scene, target, minScale = 0.08, maxScale = 2) => {
-  let tempQuat = quat.create();
-  const activeTouches = [];
-  scene.addEventListener("touchstart", (e) => {
-    const touch = { pointerId: e.pointerId, pos: vec2.fromValues(e.clientX, e.clientY) };
-    activeTouches.push(touch);
-    e.track({
-      onMove(e2) {
-        if (activeTouches.length === 2) {
-          const altTouch = activeTouches.find((item) => item != touch);
-          const dir = vec2.subtract(vec2.create(), altTouch.pos, touch.pos);
-          const dist = vec2.length(dir);
-          dir[0] /= dist;
-          dir[1] /= dist;
-          const dir2 = vec2.fromValues(-dir[1], dir[0]);
-          const delta = vec2.fromValues(e2.deltaX, e2.deltaY);
-          const dot2 = -vec2.dot(dir, delta);
-          const tangent = vec2.dot(dir2, delta);
-          const newScale = Math.max(Math.min(target.scale[0] * (dist + dot2) / dist, maxScale * 1.5), minScale * 0.4);
-          target.scale = vec3.fromValues(newScale, newScale, newScale);
-          target.quaternion = quat.rotateY(target.quaternion, target.quaternion, Math.atan2(tangent, dist));
-        } else {
-          const dir = scene.camera.forward;
-          const parent = target.parent;
-          if (parent) {
-            const inverted = quat.invert(tempQuat, parent.quaternion);
-            vec3.transformQuat(dir, dir, inverted);
-          }
-          dir[1] = 0;
-          const dist = vec3.dist(target.worldPosition, scene.camera.worldPosition);
-          const k = Math.hypot(dir[0], dir[2]);
-          const dir2 = vec3.fromValues(-dir[2], 0, dir[0]);
-          const screenSize = Math.max(...scene.camera.camera.displaySize);
-          vec3.scale(dir2, dir2, e2.deltaX / k / screenSize * dist);
-          vec3.scale(dir, dir, -e2.deltaY / k / screenSize * dist);
-          const pos = target.position;
-          target.position = [pos[0] + dir[0] + dir2[0], pos[1], pos[2] + dir[2] + dir2[2]];
-        }
-        touch.pos[0] = e2.clientX;
-        touch.pos[1] = e2.clientY;
-      },
-      onEnd() {
-        const index = activeTouches.indexOf(touch);
-        if (index >= 0) {
-          activeTouches.splice(index, 1);
-        }
-      }
-    });
-  });
-};
-
-// ../worker/src/utils/EntityUtils.ts
-function lookAt(entity, point, mode = "-z", ortho = [0, 1, 0]) {
-  const worldMatrix = entity.worldMatrix;
-  const pos = getPosition(worldMatrix);
-  const dir = new Float32Array(3);
-  dir[0] = point[0] - pos[0];
-  dir[1] = point[1] - pos[1];
-  dir[2] = point[2] - pos[2];
-  const l = 1 / Math.hypot(dir[0], dir[1], dir[2]);
-  if (l === Infinity) {
-    return;
-  }
-  let _mode = mode;
-  if (mode.startsWith("-")) {
-    dir[0] = dir[0] * -l;
-    dir[1] = dir[1] * -l;
-    dir[2] = dir[2] * -l;
-    _mode = mode.slice(1);
-  } else {
-    dir[0] = dir[0] * l;
-    dir[1] = dir[1] * l;
-    dir[2] = dir[2] * l;
-  }
-  let forward, right, up;
-  switch (_mode) {
-    case "x":
-      right = dir;
-      up = vec3Cross(new Float32Array(3), ortho, right);
-      normalizeInPlace(up);
-      forward = vec3Cross(new Float32Array(3), up, right);
-      normalizeInPlace(forward);
-      break;
-    case "y":
-      up = dir;
-      right = vec3Cross(new Float32Array(3), ortho, up);
-      normalizeInPlace(right);
-      forward = vec3Cross(new Float32Array(3), up, right);
-      normalizeInPlace(forward);
-      break;
-    case "z":
-      forward = dir;
-      right = vec3Cross(new Float32Array(3), ortho, dir);
-      normalizeInPlace(right);
-      up = vec3Cross(new Float32Array(3), dir, right);
-      break;
-    default:
-      return;
-  }
-  const s = getScale(worldMatrix);
-  entity.worldMatrix = Float32Array.of(
-    // write X axis (right)
-    right[0] * s[0],
-    right[1] * s[0],
-    right[2] * s[0],
-    0,
-    // write Y axis (up)
-    up[0] * s[1],
-    up[1] * s[1],
-    up[2] * s[1],
-    0,
-    // write Z axis (forward)
-    forward[0] * s[2],
-    forward[1] * s[2],
-    forward[2] * s[2],
-    0,
-    worldMatrix[12],
-    worldMatrix[13],
-    worldMatrix[14],
-    worldMatrix[15]
-  );
-}
-
-// ../worker/src/utils/smoothDamp.ts
-import * as vec2Op from "gl-matrix/vec3";
-import * as vec3Op2 from "gl-matrix/vec3";
-import * as quatOp from "gl-matrix/quat";
-function lerp3(a, b, t) {
-  return typeof a === "number" ? a + (b - a) * t : a.length === 2 ? vec2Op.lerp(vec2Op.create(), a, b, t) : a.length === 3 ? vec3Op2.lerp(vec3Op2.create(), a, b, t) : a.length === 4 ? quatOp.slerp(quatOp.create(), a, b, t) : a;
-}
-function clamp(value, min, max) {
-  return value < min ? min : value > max ? max : value;
-}
-function smoothDamp(initialValue, smoothTime, maxSpeed = Infinity) {
-  let current = typeof initialValue === "number" ? initialValue : initialValue.length === 2 ? vec2Op.clone(initialValue) : initialValue.length === 3 ? vec3Op2.clone(initialValue) : initialValue.length === 4 ? quatOp.clone(initialValue) : 0;
-  let velocity = typeof initialValue === "number" ? 0 : initialValue.length === 2 ? vec2Op.create() : initialValue.length === 3 ? vec3Op2.create() : initialValue.length === 4 ? 0 : 0;
-  const damp = function damp2(target, deltaTime) {
-    smoothTime = Math.max(1e-4, smoothTime);
-    const omega = 2 / smoothTime;
-    const x = omega * deltaTime;
-    const exp = 1 / (1 + x + 0.48 * x * x + 0.235 * x * x * x);
-    const maxDelta = maxSpeed * smoothTime;
-    if (typeof current === "number") {
-      let delta = current - target;
-      if (delta > maxDelta) {
-        delta = maxDelta;
-      } else if (delta < -maxDelta) {
-        delta = -maxDelta;
-      }
-      const newTarget = current - delta;
-      const temp = (velocity + omega * delta) * deltaTime;
-      velocity = (velocity - omega * temp) * exp;
-      current = newTarget + (delta + temp) * exp;
-      return current;
-    }
-    if (current.length === 2) {
-      let delta = vec2Op.sub(vec2Op.create(), current, target);
-      let l = Math.hypot(delta[0], delta[1]);
-      if (l > maxDelta) {
-        vec2Op.scale(delta, delta, maxDelta / l);
-      }
-      vec2Op.sub(current, current, delta);
-      const temp = vec2Op.scaleAndAdd(vec2Op.create(), velocity, delta, omega);
-      vec2Op.scale(temp, temp, deltaTime);
-      vec2Op.scaleAndAdd(velocity, velocity, temp, -omega);
-      vec2Op.scale(velocity, velocity, exp);
-      vec2Op.add(temp, temp, delta);
-      vec2Op.scaleAndAdd(current, current, temp, exp);
-      return current;
-    }
-    if (current.length === 3) {
-      let delta = vec3Op2.sub(vec3Op2.create(), current, target);
-      let l = Math.hypot(delta[0], delta[1]);
-      if (l > maxDelta) {
-        vec3Op2.scale(delta, delta, maxDelta / l);
-      }
-      vec3Op2.sub(current, current, delta);
-      const temp = vec3Op2.scaleAndAdd(vec3Op2.create(), velocity, delta, omega);
-      vec3Op2.scale(temp, temp, deltaTime);
-      vec3Op2.scaleAndAdd(velocity, velocity, temp, -omega);
-      vec3Op2.scale(velocity, velocity, exp);
-      vec3Op2.add(temp, temp, delta);
-      vec3Op2.scaleAndAdd(current, current, temp, exp);
-      return current;
-    }
-    if (current.length === 4) {
-      let angle = quatOp.getAngle(current, target);
-      if (angle < 1e-6) {
-        quatOp.copy(current, target);
-        velocity = 0;
-        return current;
-      }
-      const maxDeltaAngle = maxSpeed * smoothTime;
-      let c = angle;
-      let delta = c;
-      if (delta > maxDeltaAngle) delta = maxDeltaAngle;
-      else if (delta < -maxDeltaAngle) delta = -maxDeltaAngle;
-      const targetAngle = c - delta;
-      const temp = (velocity + omega * delta) * deltaTime;
-      velocity = (velocity - omega * temp) * exp;
-      let newAngle = targetAngle + (delta + temp) * exp;
-      if (!Number.isFinite(newAngle) || newAngle < 0) {
-        newAngle = 0;
-        velocity = 0;
-      }
-      let t = 1 - newAngle / c;
-      if (t < 0) t = 0;
-      else if (t > 1) t = 1;
-      quatOp.slerp(current, current, target, t);
-      return current;
-    }
-    return current;
-  };
-  damp.setValue = (value) => {
-    current = typeof value === "number" ? value : value.length === 2 ? vec2Op.clone(value) : value.length === 3 ? vec3Op2.clone(value) : 0;
-  };
-  return damp;
-}
-
-// ../worker/src/utils/PerlinNoise.ts
-var PerlinNoise = class {
-  _id;
-  constructor() {
-    this._id = _creator.createNoise();
-  }
-  get(x, y) {
-    return _creator.getNoise2D(this._id, x, y);
-  }
-  get3d(x, y, z) {
-    return _creator.getNoise3D(this._id, x, y, z);
-  }
-  _frequency = 0.01;
-  get frequency() {
-    return this._frequency;
-  }
-  set frequency(value) {
-    this._frequency = value;
-    _creator.setNoiseFrequency(this._id, value);
-  }
-  _fractalLunacrity = 0.01;
-  get fractalLunacrity() {
-    return this._fractalLunacrity;
-  }
-  set fractalLunacrity(value) {
-    this._fractalLunacrity = value;
-    _creator.setNoiseFractalLunacrity(this._id, value);
-  }
-  _fractalGain = 0.01;
-  get fractalGain() {
-    return this._fractalGain;
-  }
-  set fractalGain(value) {
-    this._fractalGain = value;
-    _creator.setNoiseFractalGain(this._id, value);
-  }
-  _octaves = 0.01;
-  get octaves() {
-    return this._octaves;
-  }
-  set octaves(value) {
-    this._octaves = value;
-    _creator.setNoiseOctaves(this._id, value);
-  }
-};
-
-// ../worker/src/utils/SceneCapture.ts
-var SceneCapture = {
-  captureImage(scene) {
-    return new Promise((res, rej) => {
-      _creator.captureImage(scene._id, (bufferId, name, size) => {
-        res(new File(bufferId, name, size));
-      }, rej);
-    });
-  }
-  // startCapture(scene: Scene): void {
-  //   _creator.startCapture((scene as any)._id)
-  // },
-  // stopCapture(): Promise<FetchResponse> {
-  //   return new Promise<FetchResponse>((res, rej) => {
-  //     _creator.stopCapture((bufferId) => res({ _id: bufferId } as any), rej)
-  //   })
-  // }
-};
-export {
-  ARScene,
-  Animation,
-  Camera,
-  Collider,
-  Component,
-  Entity,
-  FormData,
-  LitMaterial,
-  Material,
-  Mesh,
-  MeshGeometry,
-  Particles,
-  PerlinNoise,
-  Plane,
-  Ray,
-  Scene,
-  SceneCapture,
-  ShadowMaterial,
-  Texture,
-  UnlitMaterial,
-  VideoMaterial,
-  addControls,
-  clamp,
-  createCubeGeometry,
-  createCubeMesh,
-  createCylinderGeometry,
-  createCylinderMesh,
-  createPlaneGeometry,
-  createPlaneMesh,
-  createSphereGeometry,
-  createSphereMesh,
-  dynamic,
-  dynamicColor,
-  getEntityById,
-  lerp3 as lerp,
-  loadGlb,
-  lookAt,
-  smoothDamp
-};