@agrotools1/at-components 0.2.5 → 0.2.8-5

package/dist/gltfexport-45261c80.js

@@ -0,0 +1,705 @@
+import { W as j, iN as ae, R as oe, fg as C, bn as W, bd as ce, bf as he, b9 as O, g6 as J, gf as fe, bl as z, gF as se, fw as le, hu as ue, bF as de, a3 as me, s as pe, d0 as _e, a$ as K, iR as ge } from "./index-a450f76b.js";
+import { o as we, e as Te } from "./mat4f64-cce69db4.js";
+import { N as Ae, T as be } from "./quat-48b188ff.js";
+import { o as ye, r as Ee, e as Re } from "./quatf64-bec1af25.js";
+import { i as xe } from "./MeshLocalVertexSpace-a0c9365a.js";
+import { a as Ne } from "./Mesh-17dfbf3e.js";
+import { O as Ie, C as Se } from "./georeference-72e12165.js";
+import { C as g, D as A } from "./enums-2c166c09.js";
+import { r as k } from "./resourceUtils-49ebeb9f.js";
+import "vue";
+import "./mat3f64-03233387.js";
+import "./vec42-1641eab7.js";
+import "./axisAngleDegrees-abd6e971.js";
+import "./vec4f64-043e974c.js";
+import "./imageUtils-c550215a.js";
+import "./meshVertexSpaceUtils-3647b869.js";
+import "./vec3-0abe1464.js";
+import "./earcut-1a1bdd2c.js";
+import "./DoubleArray-61325dbc.js";
+import "./Indices-d59209a8.js";
+import "./deduplicate-be0453c1.js";
+import "./plane-ee1849b4.js";
+import "./triangle-cac8dd7a.js";
+import "./Util-b8d78341.js";
+import "./ObjectStack-5e8cdae7.js";
+import "./lineSegment-53f5f3d5.js";
+import "./basicInterfaces-fa4f5fa7.js";
+import "./VertexAttribute-faad30bf.js";
+import "./projectPointToVector-5800baf2.js";
+import "./External-a5c4899d.js";
+import "./infoFor3D-bf4e6c95.js";
+import "./computeTranslationToOriginAndRotation-466bc2c5.js";
+import "./BufferView-c2f86567.js";
+function Me(i) {
+  const e = ie(i);
+  return e != null ? e.toDataURL() : "";
+}
+async function X(i) {
+  const e = ie(i);
+  if (e == null)
+    throw new j("imageToArrayBuffer", "Unsupported image type");
+  const t = await Oe(i), s = await new Promise((r) => e.toBlob(r, t));
+  if (!s)
+    throw new j("imageToArrayBuffer", "Failed to encode image");
+  return { data: await s.arrayBuffer(), type: t };
+}
+async function Oe(i) {
+  if (!(i instanceof HTMLImageElement))
+    return "image/png";
+  const e = i.src;
+  if (ae(e)) {
+    const t = oe(e);
+    return (t == null ? void 0 : t.mediaType) === "image/jpeg" ? t.mediaType : "image/png";
+  }
+  return /\.png$/i.test(e) ? "image/png" : /\.(jpg|jpeg)$/i.test(e) ? "image/jpeg" : "image/png";
+}
+function ie(i) {
+  if (i instanceof HTMLCanvasElement)
+    return i;
+  if (i instanceof HTMLVideoElement)
+    return null;
+  const e = document.createElement("canvas");
+  e.width = i.width, e.height = i.height;
+  const t = e.getContext("2d");
+  return i instanceof HTMLImageElement ? t.drawImage(i, 0, 0, i.width, i.height) : i instanceof ImageData && t.putImageData(i, 0, 0), e;
+}
+function Be(i) {
+  const e = [], t = new Uint8Array(i);
+  for (let s = 0; s < t.length; s++)
+    e.push(String.fromCharCode(t[s]));
+  return "data:application/octet-stream;base64," + btoa(e.join(""));
+}
+function Le(i) {
+  if (i.byteLength < 8)
+    return !1;
+  const e = new Uint8Array(i);
+  return e[0] === 137 && e[1] === 80 && e[2] === 78 && e[3] === 71 && e[4] === 13 && e[5] === 10 && e[6] === 26 && e[7] === 10;
+}
+var F;
+(function(i) {
+  i[i.JSON = 1313821514] = "JSON", i[i.BIN = 5130562] = "BIN";
+})(F || (F = {}));
+let M = class N {
+  constructor(e, t) {
+    if (!e)
+      throw new Error("GLB requires a JSON gltf chunk");
+    this._length = N.HEADER_SIZE, this._length += N.CHUNK_HEADER_SIZE;
+    const s = this._textToArrayBuffer(e);
+    if (this._length += this._alignTo(s.byteLength, 4), t && (this._length += N.CHUNK_HEADER_SIZE, this._length += t.byteLength, t.byteLength % 4))
+      throw new Error("Expected BIN chunk length to be divisible by 4 at this point");
+    this.buffer = new ArrayBuffer(this._length), this._outView = new DataView(this.buffer), this._writeHeader();
+    const r = this._writeChunk(s, 12, F.JSON, 32);
+    t && this._writeChunk(t, r, F.BIN);
+  }
+  _writeHeader() {
+    this._outView.setUint32(0, N.MAGIC, !0), this._outView.setUint32(4, N.VERSION, !0), this._outView.setUint32(8, this._length, !0);
+  }
+  _writeChunk(e, t, s, r = 0) {
+    const n = this._alignTo(e.byteLength, 4);
+    for (this._outView.setUint32(t, n, !0), this._outView.setUint32(t += 4, s, !0), this._writeArrayBuffer(this._outView.buffer, e, t += 4, 0, e.byteLength), t += e.byteLength; t % 4; )
+      r && this._outView.setUint8(t, r), t++;
+    return t;
+  }
+  _writeArrayBuffer(e, t, s, r, n) {
+    new Uint8Array(e, s, n).set(new Uint8Array(t, r, n), 0);
+  }
+  _textToArrayBuffer(e) {
+    return new TextEncoder().encode(e).buffer;
+  }
+  _alignTo(e, t) {
+    return t * Math.ceil(e / t);
+  }
+};
+M.HEADER_SIZE = 12, M.CHUNK_HEADER_SIZE = 8, M.MAGIC = 1179937895, M.VERSION = 2;
+var E, b, y, T, Q, V, q;
+(function(i) {
+  i[i.External = 0] = "External", i[i.DataURI = 1] = "DataURI", i[i.GLB = 2] = "GLB";
+})(E || (E = {})), function(i) {
+  i[i.External = 0] = "External", i[i.DataURI = 1] = "DataURI", i[i.GLB = 2] = "GLB";
+}(b || (b = {})), function(i) {
+  i[i.ARRAY_BUFFER = 34962] = "ARRAY_BUFFER", i[i.ELEMENT_ARRAY_BUFFER = 34963] = "ELEMENT_ARRAY_BUFFER";
+}(y || (y = {})), function(i) {
+  i.SCALAR = "SCALAR", i.VEC2 = "VEC2", i.VEC3 = "VEC3", i.VEC4 = "VEC4", i.MAT2 = "MAT2", i.MAT3 = "MAT3", i.MAT4 = "MAT4";
+}(T || (T = {})), function(i) {
+  i[i.POINTS = 0] = "POINTS", i[i.LINES = 1] = "LINES", i[i.LINE_LOOP = 2] = "LINE_LOOP", i[i.LINE_STRIP = 3] = "LINE_STRIP", i[i.TRIANGLES = 4] = "TRIANGLES", i[i.TRIANGLE_STRIP = 5] = "TRIANGLE_STRIP", i[i.TRIANGLE_FAN = 6] = "TRIANGLE_FAN";
+}(Q || (Q = {})), function(i) {
+  i.OPAQUE = "OPAQUE", i.MASK = "MASK", i.BLEND = "BLEND";
+}(V || (V = {})), function(i) {
+  i[i.NoColor = 0] = "NoColor", i[i.FaceColor = 1] = "FaceColor", i[i.VertexColor = 2] = "VertexColor";
+}(q || (q = {}));
+let Ce = class {
+  constructor(e, t, s, r, n) {
+    this._buffer = e, this._componentType = s, this._dataType = r, this._data = [], this._isFinalized = !1, this._accessorIndex = -1, this._accessorAttribute = null, this._accessorMin = null, this._accessorMax = null, t.bufferViews || (t.bufferViews = []), this.index = t.bufferViews.length, this._bufferView = { buffer: e.index, byteLength: -1, target: n };
+    const a = this._getElementSize();
+    a >= 4 && n !== y.ELEMENT_ARRAY_BUFFER && (this._bufferView.byteStride = a), t.bufferViews.push(this._bufferView), this._numComponentsForDataType = this._calculateNumComponentsForDataType();
+  }
+  push(e) {
+    const t = this._data.length;
+    if (this._data.push(e), this._accessorIndex >= 0) {
+      const s = t % this._numComponentsForDataType, r = this._accessorMin[s];
+      this._accessorMin[s] = typeof r != "number" ? e : Math.min(r, e);
+      const n = this._accessorMax[s];
+      this._accessorMax[s] = typeof n != "number" ? e : Math.max(n, e);
+    }
+  }
+  get dataSize() {
+    return this._data.length * this._sizeComponentType();
+  }
+  get byteSize() {
+    function e(t, s) {
+      return s * Math.ceil(t / s);
+    }
+    return e(this.dataSize, 4);
+  }
+  getByteOffset() {
+    if (!this._isFinalized)
+      throw new Error("Cannot get BufferView offset until it is finalized");
+    return this._buffer.getByteOffset(this);
+  }
+  get byteOffset() {
+    if (!this._isFinalized)
+      throw new Error("Cannot get BufferView offset until it is finalized");
+    return this._buffer.getByteOffset(this);
+  }
+  _createTypedArray(e, t) {
+    switch (this._componentType) {
+      case g.BYTE:
+        return new Int8Array(e, t);
+      case g.FLOAT:
+        return new Float32Array(e, t);
+      case g.SHORT:
+        return new Int16Array(e, t);
+      case g.UNSIGNED_BYTE:
+        return new Uint8Array(e, t);
+      case g.UNSIGNED_INT:
+        return new Uint32Array(e, t);
+      case g.UNSIGNED_SHORT:
+        return new Uint16Array(e, t);
+    }
+  }
+  writeOutToBuffer(e, t) {
+    this._createTypedArray(e, t).set(this._data);
+  }
+  writeAsync(e) {
+    if (this._asyncWritePromise)
+      throw new Error("Can't write multiple bufferView values asynchronously");
+    return this._asyncWritePromise = e.then((t) => {
+      const s = new Uint8Array(t);
+      for (let r = 0; r < s.length; ++r)
+        this._data.push(s[r]);
+      delete this._asyncWritePromise;
+    }), this._asyncWritePromise;
+  }
+  startAccessor(e) {
+    if (this._accessorIndex >= 0)
+      throw new Error("Accessor was started without ending the previous one");
+    this._accessorIndex = this._data.length, this._accessorAttribute = e;
+    const t = this._numComponentsForDataType;
+    this._accessorMin = new Array(t), this._accessorMax = new Array(t);
+  }
+  endAccessor() {
+    if (this._accessorIndex < 0)
+      throw new Error("An accessor was not started, but was attempted to be ended");
+    const e = this._getElementSize(), t = this._numComponentsForDataType, s = (this._data.length - this._accessorIndex) / t;
+    if (s % 1)
+      throw new Error("An accessor was ended with missing component values");
+    for (let n = 0; n < this._accessorMin.length; ++n)
+      typeof this._accessorMin[n] != "number" && (this._accessorMin[n] = 0), typeof this._accessorMax[n] != "number" && (this._accessorMax[n] = 0);
+    const r = { byteOffset: e * (this._accessorIndex / t), componentType: this._componentType, count: s, type: this._dataType, min: this._accessorMin, max: this._accessorMax, name: this._accessorAttribute };
+    switch (this._accessorAttribute) {
+      case "TEXCOORD_0":
+      case "TEXCOORD_1":
+      case "COLOR_0":
+      case "WEIGHTS_0":
+        switch (this._componentType) {
+          case g.UNSIGNED_BYTE:
+          case g.UNSIGNED_SHORT:
+            r.normalized = !0;
+        }
+    }
+    return this._accessorIndex = -1, this._accessorAttribute = null, this._accessorMin = null, this._accessorMax = null, r;
+  }
+  get finalized() {
+    return this._finalizedPromise ? this._finalizedPromise : this._isFinalized ? this._finalizedPromise = Promise.resolve() : this._finalizedPromise = new Promise((e) => this._finalizedPromiseResolve = e);
+  }
+  async finalize() {
+    const e = this._bufferView, t = this._buffer.getViewFinalizePromises(this);
+    this._asyncWritePromise && t.push(this._asyncWritePromise), await Promise.allSettled(t), this._isFinalized = !0, e.byteOffset = this.getByteOffset(), e.byteLength = this.dataSize, this._finalizedPromiseResolve && this._finalizedPromiseResolve();
+  }
+  _getElementSize() {
+    return this._sizeComponentType() * this._numComponentsForDataType;
+  }
+  _sizeComponentType() {
+    switch (this._componentType) {
+      case g.BYTE:
+      case g.UNSIGNED_BYTE:
+        return 1;
+      case g.SHORT:
+      case g.UNSIGNED_SHORT:
+        return 2;
+      case g.UNSIGNED_INT:
+      case g.FLOAT:
+        return 4;
+    }
+  }
+  _calculateNumComponentsForDataType() {
+    switch (this._dataType) {
+      case T.SCALAR:
+        return 1;
+      case T.VEC2:
+        return 2;
+      case T.VEC3:
+        return 3;
+      case T.VEC4:
+      case T.MAT2:
+        return 4;
+      case T.MAT3:
+        return 9;
+      case T.MAT4:
+        return 16;
+    }
+  }
+}, ee = class {
+  constructor(e) {
+    this._gltf = e, this._bufferViews = [], this._isFinalized = !1, e.buffers || (e.buffers = []), this.index = e.buffers.length;
+    const t = { byteLength: -1 };
+    e.buffers.push(t), this._buffer = t;
+  }
+  addBufferView(e, t, s) {
+    if (this._finalizePromise)
+      throw new Error("Cannot add buffer view after fiinalizing buffer");
+    const r = new Ce(this, this._gltf, e, t, s);
+    return this._bufferViews.push(r), r;
+  }
+  getByteOffset(e) {
+    let t = 0;
+    for (const s of this._bufferViews) {
+      if (s === e)
+        return t;
+      t += s.byteSize;
+    }
+    throw new Error("Given bufferView was not present in this buffer");
+  }
+  getViewFinalizePromises(e) {
+    const t = [];
+    for (const s of this._bufferViews) {
+      if (e && s === e)
+        return t;
+      t.push(s.finalized);
+    }
+    return t;
+  }
+  getArrayBuffer() {
+    if (!this._isFinalized)
+      throw new Error("Cannot get ArrayBuffer from Buffer before it is finalized");
+    const e = this._getTotalSize(), t = new ArrayBuffer(e);
+    let s = 0;
+    for (const r of this._bufferViews)
+      r.writeOutToBuffer(t, s), s += r.byteSize;
+    return t;
+  }
+  finalize() {
+    var e;
+    if (this._finalizePromise)
+      throw new Error(`Buffer ${this.index} was already finalized`);
+    return this._finalizePromise = Promise.allSettled(this.getViewFinalizePromises()).then(() => {
+      this._isFinalized = !0;
+      const t = this.getArrayBuffer();
+      this._buffer.byteLength = t.byteLength, this._buffer.uri = t;
+    }), (e = this._gltf.extras) == null || e.promises.push(this._finalizePromise), this._finalizePromise;
+  }
+  _getTotalSize() {
+    let e = 0;
+    for (const t of this._bufferViews)
+      e += t.byteSize;
+    return e;
+  }
+};
+function ze(i, e) {
+  if (i.components)
+    for (const t of i.components)
+      t.faces && t.shading === "smooth" && Fe(t, e);
+}
+function Fe(i, e) {
+  e.normal == null && (e.normal = new Float32Array(e.position.length));
+  const t = i.faces, { position: s, normal: r } = e, n = t.length / 3;
+  for (let a = 0; a < n; ++a) {
+    const o = 3 * t[3 * a], h = 3 * t[3 * a + 1], l = 3 * t[3 * a + 2], c = C(Ve, s[o], s[o + 1], s[o + 2]), u = C(De, s[h], s[h + 1], s[h + 2]), w = C(Pe, s[l], s[l + 1], s[l + 2]), p = W(u, u, c), m = W(w, w, c), d = ce(p, p, m);
+    r[o] += d[0], r[o + 1] += d[1], r[o + 2] += d[2], r[h] += d[0], r[h + 1] += d[1], r[h + 2] += d[2], r[l] += d[0], r[l + 1] += d[1], r[l + 2] += d[2];
+  }
+  for (let a = 0; a < r.length; a += 3)
+    C(x, r[a], r[a + 1], r[a + 2]), he(x, x), r[a] = x[0], r[a + 1] = x[1], r[a + 2] = x[2];
+}
+const Ve = O(), De = O(), Pe = O(), x = O(), H = () => pe.getLogger("gltf");
+class Ue {
+  constructor(e, t, s) {
+    this.params = {}, this._materialMap = new Array(), this._imageMap = /* @__PURE__ */ new Map(), this._textureMap = /* @__PURE__ */ new Map(), this.gltf = { asset: { version: "2.0", copyright: e.copyright, generator: e.generator }, extras: { options: t, binChunkBuffer: null, promises: [] } }, s && (this.params = s), this._addScenes(e);
+  }
+  _addScenes(e) {
+    this.gltf.scene = e.defaultScene;
+    const t = this.gltf.extras, s = t.options.bufferOutputType === E.GLB || t.options.imageOutputType === b.GLB;
+    s && (t.binChunkBuffer = new ee(this.gltf)), e.forEachScene((r) => {
+      this._addScene(r);
+    }), s && t.binChunkBuffer.finalize();
+  }
+  _addScene(e) {
+    this.gltf.scenes || (this.gltf.scenes = []);
+    const t = {};
+    e.name && (t.name = e.name), e.forEachNode((s) => {
+      t.nodes || (t.nodes = []), t.nodes.push(...this._addNodes(s));
+    }), this.gltf.scenes.push(t);
+  }
+  _addNodes(e) {
+    this.gltf.nodes || (this.gltf.nodes = []);
+    const t = {};
+    e.name && (t.name = e.name);
+    const s = e.translation;
+    J(s, fe) || (t.translation = z(s));
+    const r = e.rotation;
+    Ae(r, ye) || (t.rotation = Ee(r));
+    const n = e.scale;
+    J(n, se) || (t.scale = z(n));
+    const a = this.gltf.nodes.length;
+    if (this.gltf.nodes.push(t), e.mesh && e.mesh.vertexAttributes.position) {
+      const o = this._createMeshes(e.mesh), h = [a];
+      if (o.length === 1)
+        this._addMesh(t, o[0]);
+      else
+        for (const l of o) {
+          const c = {};
+          this._addMesh(c, l), h.push(this.gltf.nodes.length), this.gltf.nodes.push(c);
+        }
+      return h;
+    }
+    return e.forEachNode((o) => {
+      t.children || (t.children = []), t.children.push(...this._addNodes(o));
+    }), [a];
+  }
+  _addMesh(e, t) {
+    var r;
+    (r = this.gltf).meshes ?? (r.meshes = []);
+    const s = this.gltf.meshes.length;
+    this.gltf.meshes.push(t), e.mesh = s;
+  }
+  _createMeshes(e) {
+    const t = this.gltf.extras, s = t.options.bufferOutputType === E.GLB;
+    let r;
+    r = s ? t.binChunkBuffer : new ee(this.gltf), this.params.origin || (this.params.origin = e.anchor);
+    const { ignoreLocalTransform: n } = this.params, a = n ? null : e.transform, { vertexSpace: o, spatialReference: h } = e, l = o.origin, c = e.vertexAttributes;
+    let u = null;
+    if (o.type === "local") {
+      const f = le(h);
+      ue(te, (a == null ? void 0 : a.localMatrix) ?? we, [f, f, f]), u = Ie(c, te);
+    } else {
+      const f = n ? new xe({ origin: l ? z(l) : null }) : o;
+      u = Se(c, f, a, this.params.origin, { geographic: this.params.geographic, unit: "meters" });
+    }
+    if (u == null)
+      throw new j("Error during gltf export.");
+    c.position && u.position === c.position && (u.position = c.position.slice()), c.normal && u.normal === c.normal && (u.normal = c.normal.slice()), c.tangent && u.tangent === c.tangent && (u.tangent = c.tangent.slice()), ze(e, u), this._flipYZAxis(u);
+    const w = r.addBufferView(g.FLOAT, T.VEC3, y.ARRAY_BUFFER);
+    let p, m, d, _;
+    u.normal && (p = r.addBufferView(g.FLOAT, T.VEC3, y.ARRAY_BUFFER)), c.uv && (m = r.addBufferView(g.FLOAT, T.VEC2, y.ARRAY_BUFFER)), u.tangent && (d = r.addBufferView(g.FLOAT, T.VEC4, y.ARRAY_BUFFER)), c.color && (_ = r.addBufferView(g.UNSIGNED_BYTE, T.VEC4, y.ARRAY_BUFFER)), w.startAccessor("POSITION"), p && p.startAccessor("NORMAL"), m && m.startAccessor("TEXCOORD_0"), d && d.startAccessor("TANGENT"), _ && _.startAccessor("COLOR_0");
+    const R = u.position.length / 3, { position: D, normal: B, tangent: I } = u, { color: S, uv: P } = c;
+    for (let f = 0; f < R; ++f)
+      w.push(D[3 * f]), w.push(D[3 * f + 1]), w.push(D[3 * f + 2]), p && B != null && (p.push(B[3 * f]), p.push(B[3 * f + 1]), p.push(B[3 * f + 2])), m && P != null && (m.push(P[2 * f]), m.push(P[2 * f + 1])), d && I != null && (d.push(I[4 * f]), d.push(I[4 * f + 1]), d.push(I[4 * f + 2]), d.push(I[4 * f + 3])), _ && S != null && (_.push(S[4 * f]), _.push(S[4 * f + 1]), _.push(S[4 * f + 2]), _.push(S[4 * f + 3]));
+    const ne = w.endAccessor(), Z = this._addAccessor(w.index, ne);
+    let U, $, G, v, L;
+    if (p) {
+      const f = p.endAccessor();
+      U = this._addAccessor(p.index, f);
+    }
+    if (m) {
+      const f = m.endAccessor();
+      $ = this._addAccessor(m.index, f);
+    }
+    if (d) {
+      const f = d.endAccessor();
+      G = this._addAccessor(d.index, f);
+    }
+    if (_) {
+      const f = _.endAccessor();
+      v = this._addAccessor(_.index, f);
+    }
+    const Y = [];
+    return e.components && e.components.length > 0 && e.components[0].faces ? (L = r.addBufferView(g.UNSIGNED_INT, T.SCALAR, y.ELEMENT_ARRAY_BUFFER), this._addMeshVertexIndexed(L, e.components, Y, Z, U, $, G, v)) : this._addMeshVertexNonIndexed(e.components, Y, Z, U, $, G, v), w.finalize(), p && p.finalize(), m && m.finalize(), d && d.finalize(), L && L.finalize(), _ && _.finalize(), s || r.finalize(), Y;
+  }
+  _flipYZAxis({ position: e, normal: t, tangent: s }) {
+    this._flipYZBuffer(e, 3), this._flipYZBuffer(t, 3), this._flipYZBuffer(s, 4);
+  }
+  _flipYZBuffer(e, t) {
+    if (e != null)
+      for (let s = 1, r = 2; s < e.length; s += t, r += t) {
+        const n = e[s], a = e[r];
+        e[s] = a, e[r] = -n;
+      }
+  }
+  _addMaterial(e) {
+    if (e === null)
+      return;
+    const t = this._materialMap.indexOf(e);
+    if (t !== -1)
+      return t;
+    this.gltf.materials || (this.gltf.materials = []);
+    const s = {};
+    switch (e.alphaMode) {
+      case "mask":
+        s.alphaMode = V.MASK;
+        break;
+      case "auto":
+      case "blend":
+        s.alphaMode = V.BLEND;
+    }
+    e.alphaCutoff !== 0.5 && (s.alphaCutoff = e.alphaCutoff), e.doubleSided && (s.doubleSided = e.doubleSided), s.pbrMetallicRoughness = {};
+    const r = (o) => o ** 2.1, n = (o) => {
+      const h = o.toRgba();
+      return h[0] = r(h[0] / 255), h[1] = r(h[1] / 255), h[2] = r(h[2] / 255), h;
+    };
+    if (e.color != null && (s.pbrMetallicRoughness.baseColorFactor = n(e.color)), e.colorTexture != null && (s.pbrMetallicRoughness.baseColorTexture = this._createTextureInfo(e.colorTexture, e.colorTextureTransform)), e.normalTexture != null && (s.normalTexture = this._createTextureInfo(e.normalTexture, e.normalTextureTransform)), e instanceof Ne) {
+      if (e.emissiveTexture != null && (s.emissiveTexture = this._createTextureInfo(e.emissiveTexture, e.emissiveTextureTransform)), e.emissiveColor != null) {
+        const o = n(e.emissiveColor);
+        s.emissiveFactor = [o[0], o[1], o[2]];
+      }
+      e.occlusionTexture != null && (s.occlusionTexture = this._createTextureInfo(e.occlusionTexture, e.occlusionTextureTransform)), e.metallicRoughnessTexture != null && (s.pbrMetallicRoughness.metallicRoughnessTexture = this._createTextureInfo(e.metallicRoughnessTexture, e.metallicRoughnessTextureTransform)), s.pbrMetallicRoughness.metallicFactor = e.metallic, s.pbrMetallicRoughness.roughnessFactor = e.roughness;
+    } else
+      s.pbrMetallicRoughness.metallicFactor = 1, s.pbrMetallicRoughness.roughnessFactor = 1, H().warnOnce("Meshes exported to GLTF without MeshMaterialMetallicRoughness material will appear different when imported back.");
+    const a = this.gltf.materials.length;
+    return this.gltf.materials.push(s), this._materialMap.push(e), a;
+  }
+  _createTextureInfo(e, t) {
+    const s = { index: this._addTexture(e) };
+    return t && (s.extensions || (s.extensions = {}), s.extensions.KHR_texture_transform = { scale: t.scale, offset: t.offset, rotation: de(t.rotation) }), s;
+  }
+  _addTexture(e) {
+    const t = this.gltf.textures ?? [];
+    return this.gltf.textures = t, me(this._textureMap, e, () => {
+      const s = { sampler: this._addSampler(e), source: this._addImage(e) }, r = t.length;
+      return t.push(s), r;
+    });
+  }
+  _addImage(e) {
+    const t = this._imageMap.get(e);
+    if (t != null)
+      return t;
+    this.gltf.images || (this.gltf.images = []);
+    const s = {};
+    if (e.url)
+      s.uri = e.url;
+    else {
+      const n = e.data;
+      s.extras = n;
+      for (let o = 0; o < this.gltf.images.length; ++o)
+        if (n === this.gltf.images[o].extras)
+          return o;
+      const a = this.gltf.extras;
+      switch (a.options.imageOutputType) {
+        case b.GLB: {
+          const o = a.binChunkBuffer.addBufferView(g.UNSIGNED_BYTE, T.SCALAR);
+          if (k(n))
+            n.data != null && o.writeOutToBuffer(n.data, 0);
+          else {
+            const h = X(n).then(({ data: l, type: c }) => (s.mimeType = c, l));
+            o.writeAsync(h).then(() => {
+              o.finalize();
+            });
+          }
+          s.bufferView = o.index;
+          break;
+        }
+        case b.DataURI:
+          if (k(n)) {
+            H().warnOnce("Image export for basis compressed textures not available.");
+            break;
+          }
+          s.uri = Me(n);
+          break;
+        default:
+          if (k(n)) {
+            H().warnOnce("Image export for basis compressed textures not available.");
+            break;
+          }
+          a.promises.push(X(n).then(({ data: o, type: h }) => {
+            s.uri = o, s.mimeType = h;
+          }));
+      }
+    }
+    const r = this.gltf.images.length;
+    return this.gltf.images.push(s), this._imageMap.set(e, r), r;
+  }
+  _addSampler(e) {
+    this.gltf.samplers || (this.gltf.samplers = []);
+    let t = A.REPEAT, s = A.REPEAT;
+    if (typeof e.wrap == "string")
+      switch (e.wrap) {
+        case "clamp":
+          t = A.CLAMP_TO_EDGE, s = A.CLAMP_TO_EDGE;
+          break;
+        case "mirror":
+          t = A.MIRRORED_REPEAT, s = A.MIRRORED_REPEAT;
+      }
+    else {
+      switch (e.wrap.vertical) {
+        case "clamp":
+          s = A.CLAMP_TO_EDGE;
+          break;
+        case "mirror":
+          s = A.MIRRORED_REPEAT;
+      }
+      switch (e.wrap.horizontal) {
+        case "clamp":
+          t = A.CLAMP_TO_EDGE;
+          break;
+        case "mirror":
+          t = A.MIRRORED_REPEAT;
+      }
+    }
+    const r = { wrapS: t, wrapT: s };
+    for (let a = 0; a < this.gltf.samplers.length; ++a)
+      if (JSON.stringify(r) === JSON.stringify(this.gltf.samplers[a]))
+        return a;
+    const n = this.gltf.samplers.length;
+    return this.gltf.samplers.push(r), n;
+  }
+  _addAccessor(e, t) {
+    this.gltf.accessors || (this.gltf.accessors = []);
+    const s = { bufferView: e, byteOffset: t.byteOffset, componentType: t.componentType, count: t.count, type: t.type, min: t.min, max: t.max, name: t.name };
+    t.normalized && (s.normalized = !0);
+    const r = this.gltf.accessors.length;
+    return this.gltf.accessors.push(s), r;
+  }
+  _addMeshVertexIndexed(e, t, s, r, n, a, o, h) {
+    const l = /* @__PURE__ */ new Map();
+    for (const c of t) {
+      e.startAccessor("INDICES");
+      for (let m = 0; m < c.faces.length; ++m)
+        e.push(c.faces[m]);
+      const u = e.endAccessor(), w = { attributes: { POSITION: r }, indices: this._addAccessor(e.index, u), material: this._addMaterial(c.material) };
+      n && c.shading !== "flat" && (w.attributes.NORMAL = n), a && (w.attributes.TEXCOORD_0 = a), o && c.shading !== "flat" && (w.attributes.TANGENT = o), h && (w.attributes.COLOR_0 = h);
+      const p = l.get(c.name);
+      if (p)
+        p.primitives.push(w);
+      else {
+        const m = { name: c.name, primitives: [w] };
+        l.set(c.name, m), s.push(m);
+      }
+    }
+  }
+  _addMeshVertexNonIndexed(e, t, s, r, n, a, o) {
+    const h = { primitives: [] };
+    t.push(h);
+    const l = { attributes: { POSITION: s } };
+    r && (l.attributes.NORMAL = r), n && (l.attributes.TEXCOORD_0 = n), a && (l.attributes.TANGENT = a), o && (l.attributes.COLOR_0 = o), e && (l.material = this._addMaterial(e[0].material)), h.primitives.push(l);
+  }
+}
+const te = Te();
+let $e = class {
+  constructor() {
+    this.copyright = "", this.defaultScene = 0, this.generator = "", this._scenes = [];
+  }
+  addScene(e) {
+    if (this._scenes.includes(e))
+      throw new Error("Scene already added");
+    this._scenes.push(e);
+  }
+  removeScene(e) {
+    _e(this._scenes, e);
+  }
+  forEachScene(e) {
+    this._scenes.forEach(e);
+  }
+};
+class Ge {
+  constructor() {
+    this.name = "", this._nodes = [];
+  }
+  addNode(e) {
+    if (this._nodes.includes(e))
+      throw new Error("Node already added");
+    this._nodes.push(e);
+  }
+  forEachNode(e) {
+    this._nodes.forEach(e);
+  }
+}
+class ve {
+  constructor(e) {
+    this.mesh = e, this.name = "", this.translation = O(), this.rotation = Re(), this.scale = z(se), this._nodes = [];
+  }
+  addNode(e) {
+    if (this._nodes.includes(e))
+      throw new Error("Node already added");
+    this._nodes.push(e);
+  }
+  forEachNode(e) {
+    this._nodes.forEach(e);
+  }
+  set rotationAngles(e) {
+    be(this.rotation, e[0], e[1], e[2]);
+  }
+}
+const Ye = "model.gltf", re = "model.glb";
+async function ke(i, e, t) {
+  var m;
+  const s = new Ue(i, e = e || {}, t);
+  let r = s.params;
+  r ? r.origin || (r.origin = new K({ x: -1, y: -1, z: -1 })) : r = { origin: new K({ x: -1, y: -1, z: -1 }) };
+  const n = r.origin, a = s.gltf, o = ((m = a.extras) == null ? void 0 : m.promises) ?? [];
+  let h = 1, l = 1, c = null;
+  await Promise.allSettled(o);
+  const u = { origin: n };
+  delete a.extras;
+  const w = typeof e.jsonSpacing == "number" ? e.jsonSpacing : 4, p = JSON.stringify(a, (d, _) => {
+    if (d !== "extras") {
+      if (_ instanceof ArrayBuffer) {
+        if (Le(_))
+          switch (e.imageOutputType) {
+            case b.DataURI:
+            case b.GLB:
+              break;
+            case b.External:
+            default: {
+              const R = `img${l}.png`;
+              return l++, u[R] = _, R;
+            }
+          }
+        switch (e.bufferOutputType) {
+          case E.DataURI:
+            return Be(_);
+          case E.GLB:
+            if (c)
+              throw new Error("Already encountered an ArrayBuffer, there should only be one in the GLB format.");
+            return void (c = _);
+          case E.External:
+          default: {
+            const R = `data${h}.bin`;
+            return h++, u[R] = _, R;
+          }
+        }
+      }
+      return _;
+    }
+  }, w);
+  return e.bufferOutputType === E.GLB || e.imageOutputType === b.GLB ? u[re] = new M(p, c).buffer : u[Ye] = p, u;
+}
+function He(i, e) {
+  return ke(i, { bufferOutputType: E.GLB, imageOutputType: b.GLB, jsonSpacing: 0 }, e);
+}
+class je {
+  constructor(e, t) {
+    this._file = { type: "model/gltf-binary", data: e }, this.origin = t;
+  }
+  buffer() {
+    return Promise.resolve(this._file);
+  }
+  download(e) {
+    ge(new Blob([this._file.data], { type: this._file.type }), e);
+  }
+}
+function Mt(i, e) {
+  const t = new $e(), s = new Ge();
+  return t.addScene(s), s.addNode(new ve(i)), He(t, e).then((r) => new je(r[re], r.origin));
+}
+export {
+  Mt as toBinaryGLTF
+};