lecodes-cli 0.1.1 → 0.1.2

package/runtime/worker/chunk-MI3UXE5H.js

@@ -0,0 +1,1395 @@
+// ../worker/src/components/Component.ts
+var Component = class {
+  onAssign(entityId) {
+  }
+  entity;
+  channels;
+};
+
+// ../worker/src/fetch.ts
+var FetchResponseImpl = class {
+  _id;
+  status;
+  constructor(_id, status) {
+    this.status = status;
+    this._id = _id;
+  }
+  json() {
+    return _creatorUtils.fetchToJson(this._id);
+  }
+  text() {
+    return _creatorUtils.fetchToText(this._id);
+  }
+  dispose() {
+    _creatorUtils.disposeFetch(this._id);
+  }
+};
+var fetch2 = (url, fetchOptions = {}) => {
+  return new Promise((res, rej) => {
+    _creatorUtils.fetch(url, fetchOptions, (systemId, statusCode) => {
+      res(new FetchResponseImpl(systemId, statusCode));
+    }, rej);
+  });
+};
+var fetchLocal = (path) => {
+  return new FetchResponseImpl(_creatorUtils.fetchLocal(path), 200);
+};
+var FormData = class {
+  _entries = [];
+  append(name, value, filename) {
+    this._entries.push([name, value, filename ?? (typeof value === "object" ? value.name : void 0)]);
+  }
+  delete(name) {
+    const index = this._entries.findIndex((i) => i[0] === name);
+    if (index >= 0) {
+      this._entries.splice(index);
+    }
+  }
+};
+var File = class {
+  _id;
+  name;
+  size;
+  constructor(_id, name, size) {
+    this._id = _id;
+    this.name = name;
+    this.size = size;
+  }
+};
+
+// ../worker/src/Texture.ts
+var Texture = class _Texture {
+  _id;
+  /** Defines how the texture is wrapped horizontally and corresponds to U in UV mapping. */
+  wrapS = 1;
+  /** Defines how the texture is wrapped vertically and corresponds to V in UV mapping. */
+  wrapT = 1;
+  width;
+  height;
+  constructor(width, height, externalId) {
+    this.width = width;
+    this.height = height;
+    this._id = externalId;
+  }
+  static load(urlOrResponse) {
+    if (typeof urlOrResponse === "string") {
+      return fetch(urlOrResponse, { useOnce: true }).then((resp) => {
+        if (resp.status >= 400) {
+          return Promise.reject(new Error(`Failed to fetch texture from ${urlOrResponse}. HTTP code: ${resp.status}`));
+        } else {
+          return _Texture.load(resp);
+        }
+      });
+    } else {
+      return new Promise((res, rej) => {
+        _creator.createTexture(urlOrResponse._id, (id, width, height) => {
+          res(new _Texture(width, height, id));
+        }, rej);
+      });
+    }
+  }
+  // static getInternalId(texture: Texture): number {
+  //   return texture._id
+  // }
+};
+
+// ../worker/src/Material.ts
+function set(target, key, newValue) {
+  target[key] = newValue;
+  if (typeof newValue === "string") {
+    if (newValue.length > 7) {
+      _creator.setUniformRgba(this._id, key, parseInt(newValue.slice(1), 16));
+    } else {
+      _creator.setUniformRgb(this._id, key, parseInt(newValue.slice(1), 16));
+    }
+  } else if (typeof newValue === "number") {
+    _creator.setUniformFloat(this._id, key, newValue);
+  } else if (typeof newValue === "boolean") {
+    _creator.setUniformBoolean(this._id, key, newValue);
+  } else if (newValue instanceof Texture) {
+    _creator.setUniformTexture(this._id, key, newValue._id, newValue.wrapS, newValue.wrapT);
+  } else if (newValue instanceof Float32Array) {
+    _creator.setUniformArray(this._id, key, newValue);
+  } else if (Array.isArray(newValue)) {
+    _creator.setUniformArray(this._id, key, Float32Array.of(...newValue));
+  } else if (typeof newValue === null) {
+    _creator.setUniformNull(this._id, key);
+  }
+  return true;
+}
+function get(target, key) {
+  return target[key];
+}
+var Material = class _Material {
+  _id;
+  // private _onlyClone: boolean = false
+  shader;
+  _uniforms = {};
+  uniforms;
+  constructor(shader) {
+    if (typeof shader === "number") {
+      this.shader = "unknown";
+      this._id = shader;
+    } else {
+      this.shader = shader;
+      this._id = _creator.createMaterial(shader._id);
+    }
+    this.uniforms = new Proxy(this._uniforms, {
+      set: set.bind(this),
+      get: get.bind(this)
+    });
+  }
+  clone() {
+    return new _Material(this.shader);
+  }
+  static load(url) {
+    return fetch(url, { useOnce: true }).then((resp) => {
+      if (resp.status >= 400) {
+        return Promise.reject(new Error(`Failed to fetch shader from ${url}. HTTP code: ${resp.status}`));
+      } else {
+        return new _Material(resp);
+      }
+    });
+  }
+  // static setOnlyClone(material: Material, value: boolean): void {
+  //   material._onlyClone = value
+  // }
+  // static isOnlyClone(material: Material): boolean {
+  //   return material._onlyClone
+  // }
+  static getInternalId(material) {
+    return material._id;
+  }
+};
+var LitMaterial = class extends Material {
+  constructor(options) {
+    super({ _id: _creatorUtils.fetchLocal("lit.filamat") });
+    if (options?.map) {
+      this.map = options.map;
+    }
+    if (options?.color) {
+      this.color = this.color;
+    }
+  }
+  set color(value) {
+    this.uniforms.color = value;
+  }
+  get color() {
+    return this.uniforms.color;
+  }
+  set map(value) {
+    if (value === null) {
+      this.uniforms.useBaseColorMap = false;
+    } else {
+      this.uniforms.baseColorMap = value;
+      this.uniforms.useBaseColorMap = true;
+    }
+  }
+  get map() {
+    return this.uniforms.map;
+  }
+};
+var UnlitMaterial = class extends Material {
+  constructor(options) {
+    super({ _id: _creatorUtils.fetchLocal("unlit.filamat") });
+    if (options?.map) {
+      this.map = options.map;
+    }
+    if (options?.color) {
+      this.color = this.color;
+    }
+  }
+  set color(value) {
+    this.uniforms.baseColor = value;
+  }
+  get color() {
+    return this.uniforms.baseColor;
+  }
+  set map(value) {
+    if (value === null) {
+      this.uniforms.useBaseColorMap = false;
+    } else {
+      this.uniforms.baseColorMap = value;
+      this.uniforms.useBaseColorMap = true;
+    }
+  }
+  get map() {
+    return this.uniforms.map;
+  }
+};
+var VideoMaterial = class extends Material {
+  constructor(map) {
+    super({ _id: _creatorUtils.fetchLocal("video.filamat") });
+    if (map) {
+      this.map = map;
+    }
+  }
+  set map(value) {
+    this.uniforms.baseColorMap = value;
+  }
+  get map() {
+    return this.uniforms.baseColorMap;
+  }
+};
+var ShadowMaterial = class extends Material {
+  constructor(color) {
+    super({ _id: _creatorUtils.fetchLocal("shadow.filamat") });
+    if (color) {
+      this.color = color;
+    } else {
+      this.color = "#000000aa";
+    }
+  }
+  set color(value) {
+    this.uniforms.color = value;
+  }
+  get color() {
+    return this.uniforms.color;
+  }
+};
+
+// ../worker/src/primitives/MeshGeometry.ts
+var MeshGeometry = class {
+  vertices;
+  normals;
+  indices;
+  uv;
+  _meshType = 0;
+  constructor(vertices, normals, indices, uv) {
+    this.vertices = vertices;
+    this.normals = normals;
+    this.indices = indices;
+    this.uv = uv;
+  }
+  translate(x, y, z) {
+    for (let i = 0; i < this.vertices.length; i += 3) {
+      this.vertices[i] = x + this.vertices[i];
+      this.vertices[i + 1] = y + this.vertices[i + 1];
+      this.vertices[i + 2] = z + this.vertices[i + 2];
+    }
+    return this;
+  }
+  scale(x, y, z) {
+    for (let i = 0; i < this.vertices.length; i += 3) {
+      this.vertices[i] = x * this.vertices[i];
+      this.vertices[i + 1] = y * this.vertices[i + 1];
+      this.vertices[i + 2] = z * this.vertices[i + 2];
+    }
+    return this;
+  }
+  scaleUV(x, y) {
+    for (let i = 0; i < this.uv.length; i += 2) {
+      this.uv[i] = x * this.uv[i];
+      this.uv[i + 1] = y * this.uv[i + 1];
+    }
+    return this;
+  }
+  set meshType(type) {
+    if (type === "triangles") {
+      this._meshType = 0;
+    } else if (type === "edges") {
+      this._meshType = 1;
+    } else if (type === "vertices") {
+      this._meshType = 2;
+    }
+  }
+};
+
+// ../worker/src/primitives/cube.ts
+var createCubeGeometry = () => {
+  const vertices = new Float32Array(6 * 4 * 3);
+  const normals = new Float32Array(6 * 4 * 3);
+  const uv = new Float32Array(6 * 4 * 3);
+  const indices = new Uint16Array(6 * 6);
+  let cnt = 0;
+  let indicesCnt = 0;
+  const sides = [-0.5, 0.5];
+  for (let i = 0; i < 6; i++) {
+    const s = cnt;
+    const side = i % 2 == 0 ? -0.5 : 0.5;
+    for (let a of sides) {
+      for (let b of sides) {
+        uv.set([a + 0.5, b + 0.5], cnt * 2);
+        if (i == 0 || i == 1) {
+          vertices.set([side, b, -a], cnt * 3);
+          normals.set([side * 2, 0, 0], cnt * 3);
+        }
+        if (i == 2 || i == 3) {
+          vertices.set([a, side, -b], cnt * 3);
+          normals.set([0, side * 2, 0], cnt * 3);
+        }
+        if (i == 4 || i == 5) {
+          vertices.set([a, b, side], cnt * 3);
+          normals.set([0, 0, side * 2], cnt * 3);
+        }
+        cnt++;
+      }
+    }
+    let s1 = s + 1;
+    let s2 = s + 2;
+    let s3 = s + 3;
+    if (i % 2 == 0) {
+      indices.set([s, s1, s2, s3, s2, s1], indicesCnt);
+    } else {
+      indices.set([s2, s1, s, s1, s2, s3], indicesCnt);
+    }
+    indicesCnt += 6;
+  }
+  return new MeshGeometry(vertices, normals, indices, uv);
+};
+
+// ../worker/src/primitives/cylinder.ts
+var createCylinderGeometry = (options = {}) => {
+  const { edges = 32, smooth = true, radius = 0.5, radiusTop = radius, radiusBottom = radius } = options;
+  const verticesCount = edges * 4 + (edges + 1) * 2;
+  const vertices = new Float32Array(verticesCount * 3);
+  const normals = new Float32Array(verticesCount * 3);
+  const uv = new Float32Array(verticesCount * 2);
+  const indices = new Uint16Array(edges * 6 + edges * 6);
+  const sides = [-0.5, 0.5];
+  let cnt = 0;
+  let indicesCnt = 0;
+  for (let i = 0; i < edges; i++) {
+    const s = cnt;
+    const normalX = Math.cos((i + 0.5) / edges * Math.PI * 2);
+    const normalY = Math.sin((i + 0.5) / edges * Math.PI * 2);
+    for (let j = 0; j < 2; j++) {
+      const x = Math.cos((i + j) / edges * Math.PI * 2);
+      const y = Math.sin((i + j) / edges * Math.PI * 2);
+      for (let side of sides) {
+        if (side > 0) {
+          vertices.set([x * radiusTop, side, y * radiusTop], cnt * 3);
+        } else {
+          vertices.set([x * radiusBottom, side, y * radiusBottom], cnt * 3);
+        }
+        if (smooth) {
+          normals.set([x, 0, y], cnt * 3);
+        } else {
+          normals.set([normalX, 0, normalY], cnt * 3);
+        }
+        uv.set([(i + j) / edges, side + 0.5], cnt * 2);
+        cnt++;
+      }
+    }
+    let s1 = s + 1;
+    let s2 = (s + 2) % (edges * 4);
+    let s3 = (s + 3) % (edges * 4);
+    indices.set([s, s1, s2, s3, s2, s1], indicesCnt);
+    indicesCnt += 6;
+  }
+  for (let side of sides) {
+    let center = cnt;
+    vertices.set([0, side, 0], cnt * 3);
+    normals.set([0, side * 2, 0], cnt * 3);
+    cnt++;
+    for (let i = 0; i < edges; i++) {
+      const x = Math.cos(i / edges * Math.PI * 2);
+      const y = Math.sin(i / edges * Math.PI * 2);
+      if (side > 0) {
+        vertices.set([x * radiusTop, side, y * radiusTop], cnt * 3);
+      } else {
+        vertices.set([x * radiusBottom, side, y * radiusBottom], cnt * 3);
+      }
+      normals.set([0, side * 2, 0], cnt * 3);
+      if (side < 0) {
+        indices.set([center, center + i + 1, center + 1 + (i + 1) % edges], indicesCnt);
+      } else {
+        indices.set([center + 1 + (i + 1) % edges, center + i + 1, center], indicesCnt);
+      }
+      indicesCnt += 3;
+      cnt++;
+    }
+  }
+  return new MeshGeometry(vertices, normals, indices, uv);
+};
+
+// ../worker/src/primitives/plane.ts
+import * as vec3Op from "gl-matrix/vec3";
+var createPlaneGeometry = (options = {}) => {
+  const { normal = Float32Array.of(0, 0, 1) } = options;
+  const vertices = new Float32Array(4 * 3);
+  const normals = new Float32Array(4 * 3);
+  const uvs = new Float32Array(4 * 2);
+  const sides = [-0.5, 0.5];
+  let cnt = 0;
+  let upVector;
+  let rightVec;
+  if (normal[1] === 0 && normal[2] === 0) {
+    upVector = Float32Array.of(0, 1, 0);
+    rightVec = Float32Array.of(0, 0, normal[0]);
+  } else if (normal[0] === 0 && normal[2] === 0) {
+    upVector = Float32Array.of(0, 0, 1);
+    rightVec = Float32Array.of(normal[1], 0, 0);
+  } else if (normal[0] === 0 && normal[1] === 0) {
+    upVector = Float32Array.of(0, 1, 0);
+    rightVec = Float32Array.of(normal[2], 0, 0);
+  } else {
+    const tempVec = Math.abs(normal[0]) < 0.5 ? Float32Array.of(1, 0, 0) : Float32Array.of(0, 0, 1);
+    upVector = vec3Op.cross(tempVec, tempVec, normal);
+    rightVec = vec3Op.cross(new Float32Array(3), upVector, normal);
+  }
+  for (let a of sides) {
+    for (let b of sides) {
+      normals.set(normal, cnt * 3);
+      uvs.set([a + 0.5, b + 0.5], cnt * 2);
+      vertices.set([
+        rightVec[0] * a + upVector[0] * b,
+        rightVec[1] * a + upVector[1] * b,
+        rightVec[2] * a + upVector[2] * b
+      ], cnt * 3);
+      cnt++;
+    }
+  }
+  const indices = new Uint16Array([2, 1, 0, 1, 2, 3]);
+  return new MeshGeometry(vertices, normals, indices, uvs);
+};
+
+// ../worker/src/primitives/sphere.ts
+var createSphereGeometry = (options = {}) => {
+  const { radius = 0.5, widthSegments = 32, heightSegments = 32 } = options;
+  const verticesCount = (widthSegments + 1) * (heightSegments - 1) + widthSegments * 2;
+  const vertices = new Float32Array(verticesCount * 3);
+  const normals = new Float32Array(verticesCount * 3);
+  const uvs = new Float32Array(verticesCount * 2);
+  const indices = new Uint16Array(widthSegments * (heightSegments - 2) * 6 + widthSegments * 3 * 2);
+  const phiStart = 0;
+  const phiLength = Math.PI * 2;
+  const thetaStart = 0;
+  const thetaLength = Math.PI;
+  let uOffset = 0;
+  let vertexCnt = 0;
+  let indicesCnt = 0;
+  for (let iy = 1; iy < heightSegments; iy++) {
+    const v = iy / heightSegments;
+    for (let ix = 0; ix <= widthSegments; ix++) {
+      const u = ix / widthSegments;
+      const point = [
+        -Math.cos(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength),
+        Math.cos(thetaStart + v * thetaLength),
+        Math.sin(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength)
+      ];
+      vertices.set([point[0] * radius, point[1] * radius, point[2] * radius], vertexCnt * 3);
+      normals.set(point, vertexCnt * 3);
+      uvs.set([u + uOffset, 1 - v], vertexCnt * 2);
+      if (iy > 1 && ix > 0) {
+        const s = vertexCnt - 1;
+        const s1 = vertexCnt - (widthSegments + 1) - 1;
+        const s2 = s + 1;
+        const s3 = s1 + 1;
+        indices.set([s2, s1, s, s1, s2, s3], indicesCnt);
+        indicesCnt += 6;
+      }
+      vertexCnt++;
+    }
+  }
+  const sides = [-radius, radius];
+  const circleStart2 = vertexCnt - (widthSegments + 1);
+  for (let side of sides) {
+    const circleStart = side > 0 ? 0 : circleStart2;
+    for (let ix = 0; ix < widthSegments; ix++) {
+      const u = (ix + 0.5) / widthSegments;
+      vertices.set([0, side, 0], vertexCnt * 3);
+      normals.set([0, side < 0 ? -1 : 1, 0], vertexCnt * 3);
+      uvs.set([u + uOffset, side < 0 ? 0 : 1], vertexCnt * 2);
+      const s = circleStart + ix;
+      const s1 = s + 1;
+      if (side > 0) {
+        indices.set([s, s1, vertexCnt], indicesCnt);
+      } else {
+        indices.set([vertexCnt, s1, s], indicesCnt);
+      }
+      indicesCnt += 3;
+      vertexCnt++;
+    }
+  }
+  return new MeshGeometry(vertices, normals, indices, uvs);
+};
+
+// ../worker/src/components/Mesh.ts
+var assignMaterial = (mesh, material, index) => {
+  if (!mesh["_materials"]) {
+    if (index === 0) {
+      mesh["_materials"] = [material];
+    } else {
+      mesh["_materials"] = [];
+      mesh["_materials"][index] = material;
+    }
+  } else {
+    mesh["_materials"][index] = material;
+  }
+};
+var Mesh = class _Mesh extends Component {
+  name = "mesh";
+  _materials;
+  _geometry;
+  _culling = true;
+  constructor(geometry, material) {
+    super();
+    this._geometry = geometry;
+    if (material) {
+      this._materials = [material];
+    }
+  }
+  getMaterial(index) {
+    const existsMaterial = this._materials?.[index];
+    if (existsMaterial) {
+      return existsMaterial;
+    }
+    const materialId = _creator.getMaterial(this.entity._id, index);
+    if (materialId === 0) return null;
+    const mat = new Material(materialId);
+    assignMaterial(this, mat, index);
+    return mat;
+  }
+  setMaterial(material, index) {
+    assignMaterial(this, material, index);
+    if (this.entity) {
+      _creator.setMaterial(this.entity._id, Material.getInternalId(material), index);
+    }
+  }
+  clone() {
+    const mesh = new _Mesh(this._geometry);
+    mesh._materials = this._materials ? [...this._materials] : void 0;
+    return mesh;
+  }
+  get material() {
+    return this.getMaterial(0);
+  }
+  set material(material) {
+    this.setMaterial(material, 0);
+  }
+  // static createCube(): Mesh
+  // static createCylinder(radius = 0.5, edges = 32, smooth: boolean = true): Mesh {
+  //   return new Mesh(createCylinder(radius, edges, smooth))
+  // }
+  // static createSphere(radius = 0.5, widthSegments = 32, heightSegments = 16): Mesh {
+  //   return new Mesh(createSphere(radius, widthSegments, heightSegments))
+  // }
+  // static createPlane(normal?: ReadonlyVec3): Mesh {
+  //   return new Mesh(createPlane(normal))
+  // }
+  // static createEmpty(): Mesh {
+  //   const mesh = new Mesh()
+  //   return mesh
+  // }
+  onAssign(entityId) {
+    if (this._geometry) {
+      if (!this._materials) {
+        this._materials = [new UnlitMaterial()];
+      }
+      _creator.setMesh(
+        entityId,
+        Material.getInternalId(this._materials[0]),
+        this._geometry.vertices,
+        this._geometry.normals,
+        this._geometry.indices,
+        this._geometry.uv,
+        this._geometry._meshType
+      );
+      if (this._culling !== true) {
+        _creator.setCulling(entityId, this._culling);
+      }
+    }
+  }
+  get culling() {
+    return this._culling;
+  }
+  get geometry() {
+    return this._geometry;
+  }
+  set culling(culling) {
+    this._culling = culling;
+    if (this.entity) {
+      _creator.setCulling(this.entity._id, this._culling);
+    }
+  }
+  set castShadows(value) {
+    _creator.setCastShadows(this.entity._id, value);
+  }
+  set receiveShadows(value) {
+    _creator.setReceiveShadows(this.entity._id, value);
+  }
+  // setMeshType(meshType: "triangles" | "vertices" | "edges"): this {
+  //   if (this._geometry) {
+  //     this._geometry.meshType = meshType
+  //   }
+  //   return this
+  // }
+};
+var createCubeMesh = (mat) => new Mesh(createCubeGeometry(), mat);
+var createCylinderMesh = (options = {}) => {
+  return new Mesh(createCylinderGeometry(options), options.material);
+};
+var createPlaneMesh = (options = {}) => {
+  return new Mesh(createPlaneGeometry(options), options.material);
+};
+var createSphereMesh = (options = {}) => {
+  return new Mesh(createSphereGeometry(options), options.material);
+};
+
+// ../worker/src/utils/transform.ts
+import * as mat4Op from "gl-matrix/mat4";
+var getPosition = (mat) => {
+  return Float32Array.of(mat[12], mat[13], mat[14]);
+};
+var getScale = (mat) => {
+  const m11 = mat[0];
+  const m12 = mat[1];
+  const m13 = mat[2];
+  const m21 = mat[4];
+  const m22 = mat[5];
+  const m23 = mat[6];
+  const m31 = mat[8];
+  const m32 = mat[9];
+  const m33 = mat[10];
+  return Float32Array.of(Math.hypot(m11, m12, m13), Math.hypot(m21, m22, m23), Math.hypot(m31, m32, m33));
+};
+var getQuaternion = (mat, scale) => {
+  const is1 = 1 / scale[0];
+  const is2 = 1 / scale[1];
+  const is3 = 1 / scale[2];
+  const sm11 = mat[0] * is1;
+  const sm12 = mat[1] * is2;
+  const sm13 = mat[2] * is3;
+  const sm21 = mat[4] * is1;
+  const sm22 = mat[5] * is2;
+  const sm23 = mat[6] * is3;
+  const sm31 = mat[8] * is1;
+  const sm32 = mat[9] * is2;
+  const sm33 = mat[10] * is3;
+  const trace = sm11 + sm22 + sm33;
+  let S = 0;
+  if (trace > 0) {
+    S = Math.sqrt(trace + 1) * 2;
+    return Float32Array.of(
+      (sm23 - sm32) / S,
+      (sm31 - sm13) / S,
+      (sm12 - sm21) / S,
+      0.25 * S
+    );
+  } else if (sm11 > sm22 && sm11 > sm33) {
+    S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2;
+    return Float32Array.of(
+      0.25 * S,
+      (sm12 + sm21) / S,
+      (sm31 + sm13) / S,
+      (sm23 - sm32) / S
+    );
+  } else if (sm22 > sm33) {
+    S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2;
+    return Float32Array.of(
+      (sm12 + sm21) / S,
+      0.25 * S,
+      (sm23 + sm32) / S,
+      (sm31 - sm13) / S
+    );
+  } else {
+    S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2;
+    return Float32Array.of(
+      (sm31 + sm13) / S,
+      (sm23 + sm32) / S,
+      0.25 * S,
+      (sm12 - sm21) / S
+    );
+  }
+};
+var getEulerAngles = (mat, order = "YXZ") => {
+  let x = 0, y = 0, z = 0;
+  const m11 = mat[0], m12 = mat[1], m13 = mat[2];
+  const m21 = mat[4], m22 = mat[5], m23 = mat[6];
+  const m31 = mat[8], m32 = mat[9], m33 = mat[10];
+  switch (order) {
+    case "XYZ":
+      y = Math.asin(Math.min(Math.max(m13, -1), 1));
+      if (Math.abs(m13) < 0.9999999) {
+        x = Math.atan2(-m23, m33);
+        z = Math.atan2(-m12, m11);
+      } else {
+        x = Math.atan2(m32, m22);
+        z = 0;
+      }
+      break;
+    case "YXZ":
+      x = Math.asin(-Math.min(Math.max(m23, -1), 1));
+      if (Math.abs(m23) < 0.9999999) {
+        y = Math.atan2(m13, m33);
+        z = Math.atan2(m21, m22);
+      } else {
+        y = Math.atan2(-m31, m11);
+        z = 0;
+      }
+      break;
+    case "ZXY":
+      x = Math.asin(Math.min(Math.max(m32, -1), 1));
+      if (Math.abs(m32) < 0.9999999) {
+        y = Math.atan2(-m31, m33);
+        z = Math.atan2(-m12, m22);
+      } else {
+        y = 0;
+        z = Math.atan2(m21, m11);
+      }
+      break;
+    case "ZYX":
+      y = Math.asin(-Math.min(Math.max(m31, -1), 1));
+      if (Math.abs(m31) < 0.9999999) {
+        x = Math.atan2(m32, m33);
+        z = Math.atan2(m21, m11);
+      } else {
+        x = 0;
+        z = Math.atan2(-m12, m22);
+      }
+      break;
+    case "YZX":
+      z = Math.asin(Math.min(Math.max(m21, -1), 1));
+      if (Math.abs(m21) < 0.9999999) {
+        x = Math.atan2(-m23, m22);
+        y = Math.atan2(-m31, m11);
+      } else {
+        x = 0;
+        y = Math.atan2(m13, m33);
+      }
+      break;
+    case "XZY":
+      z = Math.asin(-Math.min(Math.max(m12, -1), 1));
+      if (Math.abs(m12) < 0.9999999) {
+        x = Math.atan2(m32, m22);
+        y = Math.atan2(m13, m11);
+      } else {
+        x = Math.atan2(-m23, m33);
+        y = 0;
+      }
+      break;
+    default:
+      throw new Error(`Unknown rotation order: ${order}`);
+  }
+  return Float32Array.of(x * RAD2DEG, y * RAD2DEG, z * RAD2DEG);
+};
+function vec3Cross(out, a, b) {
+  var ax = a[0], ay = a[1], az = a[2];
+  var bx = b[0], by = b[1], bz = b[2];
+  out[0] = ay * bz - az * by;
+  out[1] = az * bx - ax * bz;
+  out[2] = ax * by - ay * bx;
+  return out;
+}
+function normalizeInPlace(a) {
+  let len = Math.hypot(a[0], a[1], a[2]);
+  if (len > 0) {
+    len = 1 / len;
+  }
+  a[0] *= len;
+  a[1] *= len;
+  a[2] *= len;
+  return a;
+}
+
+// ../worker/src/utils/clone.ts
+var cloneDeep = (obj) => {
+  if (typeof obj !== "object" || obj === null) return obj;
+  if (Array.isArray(obj)) {
+    return [...obj.map(cloneDeep)];
+  }
+  return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, cloneDeep(value)]));
+};
+
+// ../worker/src/Entity.ts
+var entityMap = /* @__PURE__ */ new Map();
+var getEntityById = (entityId) => {
+  return entityMap.get(entityId) ?? new Entity(entityId);
+};
+var Entity = class Entity2 {
+  _id;
+  _matrix;
+  _lastSync = 0;
+  _worldMatrix;
+  _scale;
+  // private _components?: ComponentConstructor<Component>[]
+  constructor(...components) {
+    if (typeof components[0] === "number") {
+      this._id = components.shift();
+      if (_creator.hasMesh(this._id)) {
+        this.addComponent(new Mesh());
+      }
+    } else {
+      this._id = _creator.createEntity();
+    }
+    entityMap.set(this._id, this);
+    for (let component of components) {
+      this.addComponent(component);
+    }
+  }
+  // Name methods
+  get name() {
+    return _creator.getName(this._id);
+  }
+  set name(value) {
+    _creator.setName(this._id, value);
+  }
+  // Visible methods
+  get visible() {
+    return _creator.isVisible(this._id);
+  }
+  set visible(value) {
+    _creator.setVisible(this._id, value);
+  }
+  // Component methods
+  addComponent(component) {
+    component.entity = this;
+    this[component.name] = component;
+    const proto = Object.getPrototypeOf(component);
+    if (!proto.name) {
+      proto.name = component.name;
+    }
+    component["onAssign"](this._id);
+    return this;
+  }
+  setData(data) {
+    return Object.assign(this, data);
+  }
+  hasComponent(component) {
+    const name = component.prototype.name;
+    if (!name) return false;
+    return name in this;
+  }
+  _listeners = {};
+  _onListenerAdded;
+  addEventListener(channel, callback) {
+    if (!this._listeners[channel]) {
+      this._onListenerAdded?.[channel]?.();
+      this._listeners[channel] = [callback];
+    } else {
+      this._listeners[channel].push(callback);
+    }
+  }
+  removeEventListener(channel, callback) {
+    if (!this._listeners[channel]) return;
+    const index = this._listeners[channel].indexOf(callback);
+    if (index >= 0) {
+      this._listeners[channel].splice(index, 1);
+    }
+  }
+  // Transform methods
+  get children() {
+    return _creator.getChildren(this._id).map((entityId) => getEntityById(entityId));
+  }
+  get childCount() {
+    return _creator.getChildCount(this._id);
+  }
+  getChild(index) {
+    const entity = _creator.getChild(this._id, index);
+    if (entity === 0) return null;
+    return getEntityById(entity);
+  }
+  get parent() {
+    const entityId = _creator.getParent(this._id);
+    if (entityId === 0) return null;
+    return getEntityById(entityId);
+  }
+  get matrix() {
+    if (!this._matrix) {
+      this._matrix = new Float32Array(16);
+    }
+    if (this._lastSync === 0 || Date.now() - this._lastSync > 10) {
+      _creator.getMatrix(this._id, this._matrix);
+      delete this._scale;
+      this._lastSync = Date.now();
+    }
+    return this._matrix;
+  }
+  set matrix(matrix) {
+    this._matrix = matrix;
+    _creator.setMatrix(this._id, matrix);
+  }
+  get worldMatrix() {
+    if (this.parent === null) {
+      return this.matrix;
+    }
+    if (!this._worldMatrix) {
+      this._worldMatrix = new Float32Array(16);
+    }
+    _creator.getWorldMatrix(this._id, this._worldMatrix);
+    return this._worldMatrix;
+  }
+  set worldMatrix(matrix) {
+    if (this.parent === null) {
+      this.matrix = matrix;
+    } else {
+      this._lastSync = 0;
+      _creator.setWorldMatrix(this._id, matrix);
+    }
+  }
+  get worldMatrixInverse() {
+    const mat = new Float32Array(16);
+    _creator.getWorldMatrix(this._id, mat);
+    return mat;
+  }
+  get position() {
+    return getPosition(this.matrix);
+  }
+  get quaternion() {
+    return getQuaternion(this.matrix, this.scale);
+  }
+  get eulerAngles() {
+    return getEulerAngles(this.matrix);
+  }
+  get scale() {
+    if (this._lastSync === 0 || !this._scale) {
+      this._scale = getScale(this.matrix);
+    }
+    return this._scale;
+  }
+  /** Get forward direction in global space */
+  get forward() {
+    const vec = new Float32Array(3);
+    _creator.getWorldDirection(this._id, 2, vec);
+    vec[0] = -vec[0];
+    vec[1] = -vec[1];
+    vec[2] = -vec[2];
+    return vec;
+  }
+  /** Get position in global space */
+  get worldPosition() {
+    const vec = new Float32Array(3);
+    _creator.getWorldPosition(this._id, vec);
+    return vec;
+  }
+  get worldQuaternion() {
+    return getQuaternion(this.worldMatrix, this.worldScale);
+  }
+  get worldScale() {
+    return getScale(this.worldMatrix);
+  }
+  get worldEulerAngles() {
+    return getEulerAngles(this.worldMatrix);
+  }
+  set position(val) {
+    this._lastSync = 0;
+    _creator.setPosition(this._id, val[0], val[1], val[2]);
+  }
+  set quaternion(val) {
+    this._lastSync = 0;
+    _creator.setQuaternion(this._id, val[0], val[1], val[2], val[3]);
+  }
+  set eulerAngles(val) {
+    this._lastSync = 0;
+    _creator.setEulerAngles(this._id, val[0], val[1], val[2], 0);
+  }
+  set scale(val) {
+    this._lastSync = 0;
+    _creator.setScale(this._id, val[0], val[1], val[2]);
+  }
+  addChildren(...entities) {
+    for (let child of entities) {
+      _creator.setParent(child._id, this._id, false);
+    }
+  }
+  setParent(parent, worldPositionStays = false) {
+    if (parent === null) {
+      _creator.setParentNull(this._id, worldPositionStays);
+    } else {
+      _creator.setParent(this._id, parent._id, worldPositionStays);
+    }
+    if (worldPositionStays) {
+      this._lastSync = 0;
+    }
+  }
+  traverse(callback) {
+    callback(this);
+    _creator.traverse(this._id, (entityId) => {
+      callback(getEntityById(entityId));
+    });
+  }
+  static dispatchEvent(entity, event) {
+    if (!entity._listeners) return;
+    const _listener = entity._listeners[event.type];
+    if (!_listener) return;
+    for (let listener of _listener) {
+      listener(event);
+      if (event.defaultPrevented) return;
+    }
+  }
+  static dispatch(entity, channel, ...args) {
+    if (!entity._listeners) return;
+    const _listener = entity._listeners[channel];
+    if (!_listener) return;
+    for (let listener of _listener) {
+      listener(...args);
+    }
+  }
+  clone() {
+    const newEntity = new Entity2(_creator.cloneEntity(this._id));
+    for (let key in this) {
+      if (key in newEntity) continue;
+      const data = this[key];
+      if (data instanceof Component) {
+        const clone2 = "clone" in data ? data.clone() : new data.constructor();
+        newEntity.addComponent(clone2);
+      } else {
+        newEntity[key] = cloneDeep(data);
+      }
+    }
+    return newEntity;
+  }
+};
+
+// ../worker/src/Ray.ts
+import * as vec3Op2 from "gl-matrix/vec3";
+var Ray = class {
+  origin;
+  dir;
+  /**
+   * @param origin - The start point of the ray.
+   * @param dir    - The direction of the ray (need not be normalised).
+   */
+  constructor(origin, dir) {
+    this.origin = vec3Op2.clone(origin);
+    this.dir = vec3Op2.clone(dir);
+  }
+  /**
+   * Evaluate the ray at parameter `t`.
+   * @returns The world-space point `origin + t * dir`.
+   */
+  getPoint(t) {
+    return vec3Op2.scaleAndAdd(vec3Op2.create(), this.origin, this.dir, t);
+  }
+  toString() {
+    const [ox, oy, oz] = this.origin;
+    const [dx, dy, dz] = this.dir;
+    return `Ray(origin=[${ox.toFixed(4)}, ${oy.toFixed(4)}, ${oz.toFixed(4)}], dir=[${dx.toFixed(4)}, ${dy.toFixed(4)}, ${dz.toFixed(4)}])`;
+  }
+};
+
+// ../worker/src/components/Camera.ts
+var Camera = class extends Component {
+  name = "camera";
+  sceneId = -1;
+  _fov = 60;
+  projectionMatrix = new Float32Array(16);
+  get fov() {
+    return _creator.getCameraFov(this.sceneId, 0);
+  }
+  get horizontalFov() {
+    return _creator.getCameraFov(this.sceneId, 1);
+  }
+  get displaySize() {
+    return _creator.getDisplaySize();
+  }
+  onProjectionChange(mat, fov) {
+    this._fov = fov;
+    for (let i = 0; i < 16; i++) {
+      this.projectionMatrix[i] = mat[i];
+    }
+  }
+  static attachToScene(camera, scene) {
+    _creator.attachCameraToAR(scene._id, camera._id, camera.camera.onProjectionChange);
+    camera.camera.sceneId = scene._id;
+  }
+  getViewDirection(screenX, screenY) {
+    if (this.sceneId < 0) throw new Error("Camera not attached to scene");
+    const vec = new Float32Array(3);
+    _creator.getCameraViewDirection(this.sceneId, screenX, screenY, vec);
+    return vec;
+  }
+  getRay(clientX, clientY) {
+    return new Ray(this.entity.worldPosition, this.getViewDirection(clientX, clientY));
+  }
+};
+
+// ../worker/src/Scene.ts
+var Scene = class _Scene {
+  /** Main scene camera */
+  camera;
+  /** Internal scene ID */
+  _id;
+  /** Entities added to this scene */
+  // protected _entities: Entity[] = []
+  /**
+   * Create a new scene
+   * @param options Scene configuration (IBL, sun light, shadows, etc.)
+   */
+  constructor(options = {}) {
+    if (options._parent) {
+      this.camera = options._parent.camera;
+      this._id = _creator.createOverlayScene(options._parent._id);
+    } else {
+      this.camera = new Entity(new Camera());
+      this._id = _creator.createScene();
+    }
+    Camera.attachToScene(this.camera, this);
+    if (options.ibl !== false) {
+      _creator.setDefaultIbl(this._id, options.iblIntensity ?? 2e4);
+    }
+    if (options.sunLight !== false) {
+      const lightEntity = new Entity();
+      _creator.createSunLight(lightEntity._id, 0.548267, -0.473983, -0.689016, 1e5, 16777215, options.castShadows ?? true);
+      _creator.addEntityToScene(this._id, lightEntity._id);
+    }
+    if (options.bloom) {
+      _creator.setBloomOptions(this._id, true, options.bloomIntensity ?? 0.2, 1);
+    }
+  }
+  static _activeScene = null;
+  /** Currently active scene (if any) */
+  static get activeScene() {
+    return this._activeScene;
+  }
+  /** Open this scene and set it as active */
+  open() {
+    _creator.openScene(this._id);
+    _Scene._activeScene = this;
+  }
+  close() {
+    _creator.closeScene();
+    _Scene._activeScene = null;
+  }
+  // /** Get entities in this scene (readonly) */
+  // get entities() {
+  //   return this._entities as Readonly<Entity[]>
+  // }
+  _material;
+  /** Get scene occlusion material */
+  get occlusionMaterial() {
+    if (!this._material) {
+      this._material = new Material(_creator.getSceneMaterial(this._id));
+    }
+    return this._material;
+  }
+  setMaterialGlobalParameter(i, x, y, z, w) {
+    _creator.setMaterialGlobalParameter(this._id, i, x, y, z, w);
+  }
+  /**
+   * Set skybox background color
+   * @param color RGB hex value
+   */
+  setSkyboxColor(color) {
+    _creator.setSkybox(this._id, color);
+  }
+  setMultiSampleAntiAliasing(enabled, scale = 4) {
+    _creator.setSceneMultiSampleAntiAliasing(this._id, enabled, scale);
+  }
+  createOverlayScene(options) {
+    return new _Scene({ ...options, _parent: this });
+  }
+  /**
+   * Add entities to this scene
+   * @param entities Entities to add
+   */
+  add(...entities) {
+    for (let entity of entities) {
+      _creator.addEntityToScene(this._id, entity._id);
+    }
+  }
+  /**
+  * Remove entities from this scene
+  * @param entities Entities to remove
+  */
+  remove(...entities) {
+    for (let entity of entities) {
+      _creator.removeEntityFromScene(this._id, entity._id);
+    }
+  }
+  warmRender() {
+    return new Promise((res, _rej) => _creator.warmRender(this._id, res));
+  }
+  _clickListeners = [];
+  _touchStartListeners = [];
+  addEventListener(channel, callback) {
+    if (channel === "click") {
+      if (this._clickListeners.includes(callback)) return;
+      this._clickListeners.push(callback);
+      registerTouchEndEvent();
+    } else if (channel === "touchstart") {
+      if (this._touchStartListeners.includes(callback)) return;
+      this._touchStartListeners.push(callback);
+      registerTouchStartEvent();
+    }
+  }
+  removeEventListener(channel, callback) {
+    if (channel === "click") {
+      const itemIndex = this._clickListeners.indexOf(callback);
+      if (itemIndex >= 0) {
+        this._clickListeners.splice(itemIndex);
+      }
+    } else if (channel === "touchstart") {
+      const itemIndex = this._touchStartListeners.indexOf(callback);
+      if (itemIndex >= 0) {
+        this._touchStartListeners.splice(itemIndex);
+      }
+    }
+  }
+};
+var onTrackStateChange = (entityId, track) => {
+  const entity = entityMap.get(entityId);
+  if (!entity) return;
+  entity.isTracked = track;
+  if (track) {
+    Entity.dispatch(entity, "track");
+  } else {
+    Entity.dispatch(entity, "untrack");
+  }
+};
+var ARScene = class extends Scene {
+  /** Current AR mode */
+  mode;
+  _root;
+  useWarmRender = true;
+  /**
+   * Create a new AR scene
+   * @param options AR scene configuration (mode, lights, IBL, etc.)
+   */
+  constructor(options = {}) {
+    super(options);
+    this.mode = options.mode ?? "default";
+    _creator.createARController(this._id, this.camera._id, this.mode, onTrackStateChange);
+  }
+  /** Root anchor entity (not available in marker mode) */
+  get root() {
+    if (this._root) return this._root;
+    const entityId = _creator.createRootAnchor(this._id);
+    this._root = new Entity(entityId);
+    return this._root;
+  }
+  /** Current AR mode */
+  // get mode(): T {
+  //   return modes[this._mode] as T
+  // }
+  /**
+   * Create an anchor from a given source (e.g. image target)
+   * @param source Tracking source (image, object, etc.)
+   * @param physicalWidth Real-world width in meters (default 0.2)
+   * @returns Anchor entity
+   */
+  createAnchor(source, physicalWidth = 0.2) {
+    const entityId = _creator.createAnchor(this._id, physicalWidth, source._id);
+    return new Entity(entityId);
+  }
+  /** Open AR session and activate this scene */
+  async open() {
+    await new Promise((res, rej) => {
+      _creator.requestCamera(res, rej);
+    });
+    if (this.useWarmRender) {
+      _creator.createGLView();
+      await this.warmRender();
+    }
+    await new Promise((res, rej) => {
+      _creator.launchAR(this._id, res, rej);
+    });
+    super.open();
+  }
+  close() {
+    _creator.stopAR();
+    super.close();
+  }
+};
+
+// ../worker/src/TouchEventSystem.ts
+var onTouchEnd = (pointerId, clientX, clientY, entityId) => {
+  if (!Scene.activeScene) return null;
+  const touchEvent = new ClickEvent(clientX, clientY, pointerId);
+  if (entityId > 0) {
+    touchEvent.target = entityMap.get(entityId);
+    Entity.dispatchEvent(touchEvent.target, touchEvent);
+  } else {
+    touchEvent.target = null;
+  }
+  for (let listener of Scene.activeScene._clickListeners) {
+    listener(touchEvent);
+  }
+  return null;
+};
+var onTouchStart = (pointerId, clientX, clientY, entityId) => {
+  if (!Scene.activeScene) return null;
+  const touchEvent = new TouchStartEvent(clientX, clientY, pointerId);
+  if (entityId > 0) {
+    touchEvent.target = entityMap.get(entityId);
+    Entity.dispatchEvent(touchEvent.target, touchEvent);
+    if (touchEvent._trackHandler) {
+      return touchEvent._trackHandler;
+    }
+  } else {
+    touchEvent.target = null;
+  }
+  for (let listener of Scene.activeScene._touchStartListeners) {
+    listener(touchEvent);
+    if (touchEvent._trackHandler) {
+      return touchEvent._trackHandler;
+    }
+  }
+  return null;
+};
+var onResizeEvents = [];
+var onResizeEvent = (width, height) => {
+  for (let listener of onResizeEvents) {
+    listener(width, height);
+  }
+};
+function addEventListener(channel, callback) {
+  if (channel === "resize") {
+    onResizeEvents.push(callback);
+    if (onResizeEvents.length === 1) {
+      _creatorUI.registerResizeEvent(onResizeEvent);
+    }
+  }
+}
+function removeEventListener(channel, callback) {
+  if (channel === "resize") {
+    const index = onResizeEvents.indexOf(callback);
+    if (index >= 0) {
+      onResizeEvents.splice(index, 1);
+    }
+  }
+}
+var touchStartRegistered = false;
+var registerTouchStartEvent = () => {
+  if (!touchStartRegistered) {
+    _creatorUI.registerTouchStartEvent(onTouchStart);
+    touchStartRegistered = true;
+  }
+};
+var touchEndRegistered = false;
+var registerTouchEndEvent = () => {
+  if (!touchEndRegistered) {
+    _creatorUI.registerTouchEndEvent(onTouchEnd);
+    touchEndRegistered = true;
+  }
+};
+
+export {
+  getPosition,
+  getScale,
+  vec3Cross,
+  normalizeInPlace,
+  Component,
+  fetch2 as fetch,
+  fetchLocal,
+  FormData,
+  File,
+  Texture,
+  Material,
+  LitMaterial,
+  UnlitMaterial,
+  VideoMaterial,
+  ShadowMaterial,
+  MeshGeometry,
+  createCubeGeometry,
+  createCylinderGeometry,
+  createPlaneGeometry,
+  createSphereGeometry,
+  Mesh,
+  createCubeMesh,
+  createCylinderMesh,
+  createPlaneMesh,
+  createSphereMesh,
+  entityMap,
+  getEntityById,
+  Entity,
+  Ray,
+  Camera,
+  addEventListener,
+  removeEventListener,
+  registerTouchStartEvent,
+  registerTouchEndEvent,
+  Scene,
+  ARScene
+};