ranuts 0.4.1-alpha.1 → 0.5.0

package/dist/src/utils/visual/render/utils/batch/index.js

@@ -0,0 +1,88 @@
+import "../../../enums.js";
+var g = (t, s) => {
+  if (s.worldAlpha <= 0 || !s.visible) return;
+  s.buildBatches(t);
+  const r = s.children;
+  for (let e = 0; e < r.length; e++) g(t, r[e]);
+}, b = (t, s) => {
+  if (s.worldAlpha <= 0 || !s.visible) return;
+  s.updateBatches(t);
+  const r = s.children;
+  for (let e = 0; e < r.length; e++) b(t, r[e]);
+}, y = class {
+  vertexCount = 0;
+  indexCount = 0;
+  rgba = 0;
+  vertexStart = 0;
+  indexStart = 0;
+}, E = class {
+  style;
+  vertexStart = 0;
+  indexStart = 0;
+  vertexCount = 0;
+  indexCount = 0;
+  constructor(t) {
+    this.style = t;
+  }
+  start(t, s) {
+    this.vertexStart = t, this.indexStart = s;
+  }
+  end(t, s) {
+    this.vertexCount = t, this.indexCount = s;
+  }
+}, S = class {
+  idx = 0;
+  reset() {
+    this.idx = 0;
+  }
+}, B = class extends S {
+  batches = [];
+  constructor() {
+    super();
+  }
+  getOne() {
+    return this.batches[this.idx] || (this.batches[this.idx] = new C()), this.batches[this.idx++];
+  }
+}, C = class extends y {
+  vertexOffset = 0;
+  indexOffset = 0;
+  graphics;
+  packVertices(t, s) {
+    const e = this.graphics.geometry.vertices.data, c = this.vertexOffset;
+    for (let i = 0; i < this.vertexCount; i++) {
+      const h = e[(c + i) * 2], o = e[(c + i) * 2 + 1], { a: l, b: v, c: a, d: n, tx: d, ty: x } = this.graphics.worldTransform, f = l * h + a * o + d, u = v * h + n * o + x, p = (this.vertexStart + i) * 3;
+      t[p] = f, t[p + 1] = u, s[p + 2] = this.rgba;
+    }
+  }
+  packIndices(t) {
+    const s = this.graphics.geometry.indices.data, r = this.indexOffset;
+    for (let e = 0; e < this.indexCount; e++) t[this.indexStart + e] = s[e + r] + this.vertexStart;
+  }
+  updateVertices(t) {
+    const r = this.graphics.geometry.vertices.data, e = this.vertexOffset, { a: c, b: i, c: h, d: o, tx: l, ty: v } = this.graphics.worldTransform;
+    for (let a = 0; a < this.vertexCount; a++) {
+      const n = r[(e + a) * 2], d = r[(e + a) * 2 + 1], x = (this.vertexStart + a) * 3;
+      t[x] = c * n + h * d + l, t[x + 1] = i * n + o * d + v;
+    }
+  }
+}, O = class {
+  batchesMap = { graphics: new B() };
+  get(t) {
+    return this.batchesMap[t].getOne();
+  }
+  reset() {
+    Object.values(this.batchesMap).forEach((t) => {
+      t.reset();
+    });
+  }
+}, w = new O();
+export {
+  y as Batch,
+  E as BatchPart,
+  S as BatchPool,
+  C as GraphicsBatch,
+  B as GraphicsBatchPool,
+  w as batchPool,
+  g as buildArray,
+  b as updateArray
+};

package/dist/src/utils/visual/render/utils/earcut.js

@@ -0,0 +1,328 @@
+var L = /* @__PURE__ */ new Set(), C = !1;
+function ge(e, n, t = 2) {
+  const r = n && n.length, o = r ? n[0] * t : e.length;
+  L.size && L.clear();
+  let x = G(e, 0, o, t, !0);
+  const i = [];
+  if (!x || x.next === x.prev) return i;
+  let f = 0, l = 0, c = 0;
+  if (r && (x = ne(e, n, x, t)), e.length > 80 * t) {
+    f = e[0], l = e[1];
+    let y = f, m = l;
+    for (let h = t; h < o; h += t) {
+      const s = e[h], u = e[h + 1];
+      s < f && (f = s), u < l && (l = u), s > y && (y = s), u > m && (m = u);
+    }
+    c = Math.max(y - f, m - l), c = c !== 0 ? 32767 / c : 0;
+  }
+  return F(x, i, f, l, c), i;
+}
+function G(e, n, t, r, o) {
+  let x = null;
+  if (o === pe(e, n, t, r) > 0) for (let i = n; i < t; i += r) x = d(i / r | 0, e[i], e[i + 1], x);
+  else for (let i = t - r; i >= n; i -= r) x = d(i / r | 0, e[i], e[i + 1], x);
+  return x && I(x, x.next) && (Y(x), x = x.next), x;
+}
+function A(e, n = e) {
+  const t = n === e;
+  let r = e, o;
+  do
+    o = !1, r !== r.next && (L.size === 0 || !L.has(r)) && (I(r, r.next) || p(r.prev, r, r.next) === 0) ? ((t || r === n) && (n = r.prev), C = !0, Y(r), r = r.prev, o = !0) : (t || r !== n) && (r = r.next, o = !t);
+  while (o || r !== n);
+  return n;
+}
+function F(e, n, t, r, o) {
+  o && ue(e, t, r, o);
+  let x = e, i = !1;
+  for (; e.prev !== e.next; ) {
+    const f = e.prev, l = e.next;
+    if (p(f, e, l) < 0 && (o ? q(e, t, r, o) : b(e))) {
+      n.push(f.i, e.i, l.i), Y(e), e = l, x = l;
+      continue;
+    }
+    if (e = l, e === x) {
+      if (C = !1, e = A(e), C) {
+        x = e;
+        continue;
+      }
+      if (!i) {
+        e = ee(e, n), x = e, i = !0;
+        continue;
+      }
+      te(e, n, t, r, o);
+      break;
+    }
+  }
+}
+function b(e) {
+  const n = e.prev, t = e, r = e.next, o = n.x, x = t.x, i = r.x, f = n.y, l = t.y, c = r.y, y = Math.min(o, x, i), m = Math.min(f, l, c), h = Math.max(o, x, i), s = Math.max(f, l, c);
+  let u = r.next;
+  for (; u !== n; ) {
+    if (u.x >= y && u.x <= h && u.y >= m && u.y <= s && !(o === u.x && f === u.y) && X(o, f, x, l, i, c, u.x, u.y) && p(u.prev, u, u.next) >= 0) return !1;
+    u = u.next;
+  }
+  return !0;
+}
+function q(e, n, t, r) {
+  const o = e.prev, x = e, i = e.next, f = o.x, l = x.x, c = i.x, y = o.y, m = x.y, h = i.y, s = Math.min(f, l, c), u = Math.min(y, m, h), M = Math.max(f, l, c), j = Math.max(y, m, h), _ = R(s, u, n, t, r), $ = R(M, j, n, t, r);
+  let g = e.prevZ;
+  for (; g && g.z >= _; ) {
+    if (g.x >= s && g.x <= M && g.y >= u && g.y <= j && g !== i && !(f === g.x && y === g.y) && X(f, y, l, m, c, h, g.x, g.y) && p(g.prev, g, g.next) >= 0) return !1;
+    g = g.prevZ;
+  }
+  let w = e.nextZ;
+  for (; w && w.z <= $; ) {
+    if (w.x >= s && w.x <= M && w.y >= u && w.y <= j && w !== i && !(f === w.x && y === w.y) && X(f, y, l, m, c, h, w.x, w.y) && p(w.prev, w, w.next) >= 0) return !1;
+    w = w.nextZ;
+  }
+  return !0;
+}
+function ee(e, n) {
+  let t = e, r = !1;
+  do {
+    const o = t.prev, x = t.next.next;
+    Q(o, t, t.next, x, !1) && U(o, x) && U(x, o) && (n.push(o.i, t.i, x.i), Y(t), Y(t.next), t = e = x, r = !0), t = t.next;
+  } while (t !== e);
+  return r ? A(t) : t;
+}
+function te(e, n, t, r, o) {
+  let x = e;
+  do {
+    let i = x.next.next;
+    for (; i !== x.prev; ) {
+      if (x.i !== i.i && se(x, i)) {
+        let f = W(x, i);
+        x = A(x, x.next), f = A(f, f.next), F(x, n, t, r, o), F(f, n, t, r, o);
+        return;
+      }
+      i = i.next;
+    }
+    x = x.next;
+  } while (x !== e);
+}
+var O = !1;
+function ne(e, n, t, r) {
+  const o = [];
+  for (let x = 0, i = n.length; x < i; x++) {
+    const f = G(e, n[x] * r, x < i - 1 ? n[x + 1] * r : e.length, r, !1);
+    f === f.next && L.add(f), o.push(ye(f));
+  }
+  o.sort(xe), ie(e.length / r, n.length), N(t, t), O = !0;
+  for (let x = 0; x < o.length; x++) t = re(o[x], t);
+  return O = !1, A(t);
+}
+function xe(e, n) {
+  return e.x - n.x || e.y - n.y || (e.next.y - e.y) / (e.next.x - e.x) - (n.next.y - n.y) / (n.next.x - n.x);
+}
+function re(e, n) {
+  const t = fe(e, n);
+  if (!t) return n;
+  const r = W(t, e), o = r.next;
+  return N(t, o.next), A(r, r.next), A(t, t.next);
+}
+var J = 16, v = /* @__PURE__ */ new Float64Array(0), E = 0, D = [], K = [];
+function ie(e, n) {
+  const t = Math.ceil((e + 2 * n) / J) + n + 2;
+  v.length < t * 4 && (v = new Float64Array(t * 4)), E = 0;
+}
+function N(e, n) {
+  let t = e;
+  do {
+    const r = E++;
+    D[r] = t;
+    let o = 1 / 0, x = 1 / 0, i = -1 / 0, f = -1 / 0, l = 0;
+    do {
+      const y = t.next;
+      t.z = r, t.x < o && (o = t.x), t.x > i && (i = t.x), t.y < x && (x = t.y), t.y > f && (f = t.y), y.x < o && (o = y.x), y.x > i && (i = y.x), y.y < x && (x = y.y), y.y > f && (f = y.y), t = y;
+    } while (++l < J && t !== n);
+    K[r] = t;
+    const c = r * 4;
+    v[c] = o, v[c + 1] = x, v[c + 2] = i, v[c + 3] = f;
+  } while (t !== n);
+}
+function oe(e, n) {
+  const t = e.z * 4;
+  n.x < v[t] && (v[t] = n.x), n.y < v[t + 1] && (v[t + 1] = n.y), n.x > v[t + 2] && (v[t + 2] = n.x), n.y > v[t + 3] && (v[t + 3] = n.y);
+}
+function T(e) {
+  let n = K[e];
+  for (; n.prev.next !== n; ) n = n.next;
+  return K[e] = n, n;
+}
+function V(e) {
+  let n = D[e];
+  for (; n.prev.next !== n; ) n = n.next;
+  return D[e] = n, n;
+}
+function fe(e, n) {
+  let t = n;
+  const r = e.x, o = e.y;
+  let x = -1 / 0, i;
+  if (I(e, t)) return t;
+  for (let h = 0, s = 0; h < E; h++, s += 4) {
+    if (o < v[s + 1] || o > v[s + 3] || v[s] > r || v[s + 2] <= x) continue;
+    const u = T(h);
+    t = V(h);
+    do {
+      if (t.prev.next === t) {
+        if (I(e, t.next)) return t.next;
+        if (o <= t.y && o >= t.next.y && t.next.y !== t.y) {
+          const M = t.x + (o - t.y) * (t.next.x - t.x) / (t.next.y - t.y);
+          if (M <= r && M > x && (x = M, i = t.x < t.next.x ? t : t.next, M === r))
+            return i;
+        }
+      }
+      t = t.next;
+    } while (t !== u);
+  }
+  if (!i) return null;
+  const f = i.x, l = i.y, c = Math.min(o, l), y = Math.max(o, l);
+  let m = 1 / 0;
+  for (let h = 0, s = 0; h < E; h++, s += 4) {
+    if (v[s + 2] < f || v[s] > r || v[s + 3] < c || v[s + 1] > y) continue;
+    const u = T(h);
+    t = V(h);
+    do {
+      if (t.prev.next === t && r >= t.x && t.x >= f && r !== t.x && X(o < l ? r : x, o, f, l, o < l ? x : r, o, t.x, t.y)) {
+        const M = Math.abs(o - t.y) / (r - t.x);
+        (U(t, e) || t.y === o && t.next.y === o && t.next.x > r) && (M < m || M === m && (t.x > i.x || t.x === i.x && le(i, t))) && (i = t, m = M);
+      }
+      t = t.next;
+    } while (t !== u);
+  }
+  return i;
+}
+function le(e, n) {
+  return p(e.prev, e, n.prev) < 0 && p(n.next, e, e.next) < 0;
+}
+var Z = [], z = [], k = /* @__PURE__ */ new Uint32Array(0), B = /* @__PURE__ */ new Uint32Array(0), H = /* @__PURE__ */ new Uint32Array(256);
+function ue(e, n, t, r) {
+  let o = e, x = 0;
+  do
+    o.z = R(o.x, o.y, n, t, r), Z[x++] = o, o = o.next;
+  while (o !== e);
+  ce(x);
+  let i = null;
+  for (let f = 0; f < x; f++) {
+    const l = Z[f];
+    l.prevZ = i, i && (i.nextZ = l), i = l;
+  }
+  i.nextZ = null;
+}
+function ce(e) {
+  if (e <= 32) {
+    for (let n = 1; n < e; n++) {
+      const t = Z[n], r = t.z;
+      let o = n - 1;
+      for (; o >= 0 && Z[o].z > r; )
+        Z[o + 1] = Z[o], o--;
+      Z[o + 1] = t;
+    }
+    return;
+  }
+  k.length < e && (k = new Uint32Array(e), B = new Uint32Array(e), z = Array.from({ length: e }));
+  for (let n = 0; n < e; n++) k[n] = Z[n].z;
+  P(e, Z, k, z, B, 0), P(e, z, B, Z, k, 8), P(e, Z, k, z, B, 16), P(e, z, B, Z, k, 24);
+}
+function P(e, n, t, r, o, x) {
+  H.fill(0);
+  for (let f = 0; f < e; f++) H[t[f] >>> x & 255]++;
+  let i = 0;
+  for (let f = 0; f < 256; f++) {
+    const l = H[f];
+    H[f] = i, i += l;
+  }
+  for (let f = 0; f < e; f++) {
+    const l = t[f], c = H[l >>> x & 255]++;
+    r[c] = n[f], o[c] = l;
+  }
+}
+function R(e, n, t, r, o) {
+  let x = (e - t) * o | 0, i = (n - r) * o | 0;
+  return x = (x | x << 8) & 16711935, x = (x | x << 4) & 252645135, x = (x | x << 2) & 858993459, x = (x | x << 1) & 1431655765, i = (i | i << 8) & 16711935, i = (i | i << 4) & 252645135, i = (i | i << 2) & 858993459, i = (i | i << 1) & 1431655765, x | i << 1;
+}
+function ye(e) {
+  let n = e, t = e;
+  do
+    (n.x < t.x || n.x === t.x && n.y < t.y) && (t = n), n = n.next;
+  while (n !== e);
+  return t;
+}
+function X(e, n, t, r, o, x, i, f) {
+  return (o - i) * (n - f) >= (e - i) * (x - f) && (e - i) * (r - f) >= (t - i) * (n - f) && (t - i) * (x - f) >= (o - i) * (r - f);
+}
+function se(e, n) {
+  const t = I(e, n) && p(e.prev, e, e.next) > 0 && p(n.prev, n, n.next) > 0;
+  return e.next.i !== n.i && (t || U(e, n) && U(n, e) && (p(e.prev, e, n.prev) !== 0 || p(e, n.prev, n) !== 0)) && !ve(e, n) && (t || he(e, n));
+}
+function p(e, n, t) {
+  return (n.y - e.y) * (t.x - n.x) - (n.x - e.x) * (t.y - n.y);
+}
+function I(e, n) {
+  return e.x === n.x && e.y === n.y;
+}
+function Q(e, n, t, r, o = !0) {
+  const x = p(e, n, t), i = p(e, n, r), f = p(t, r, e), l = p(t, r, n);
+  return (x > 0 && i < 0 || x < 0 && i > 0) && (f > 0 && l < 0 || f < 0 && l > 0) ? !0 : o ? !!(x === 0 && a(e, t, n) || i === 0 && a(e, r, n) || f === 0 && a(t, e, r) || l === 0 && a(t, n, r)) : !1;
+}
+function a(e, n, t) {
+  return n.x <= Math.max(e.x, t.x) && n.x >= Math.min(e.x, t.x) && n.y <= Math.max(e.y, t.y) && n.y >= Math.min(e.y, t.y);
+}
+function ve(e, n) {
+  const t = Math.min(e.x, n.x), r = Math.max(e.x, n.x), o = Math.min(e.y, n.y), x = Math.max(e.y, n.y);
+  let i = e;
+  do {
+    const f = i.next;
+    if (i.x > r && f.x > r || i.x < t && f.x < t || i.y > x && f.y > x || i.y < o && f.y < o) {
+      i = f;
+      continue;
+    }
+    if (i.i !== e.i && f.i !== e.i && i.i !== n.i && f.i !== n.i && Q(i, f, e, n)) return !0;
+    i = f;
+  } while (i !== e);
+  return !1;
+}
+function U(e, n) {
+  return p(e.prev, e, e.next) < 0 ? p(e, n, e.next) >= 0 && p(e, e.prev, n) >= 0 : p(e, n, e.prev) < 0 || p(e, e.next, n) < 0;
+}
+function he(e, n) {
+  let t = e, r = !1;
+  const o = (e.x + n.x) / 2, x = (e.y + n.y) / 2;
+  do {
+    const i = t.next;
+    t.y > x != i.y > x && o < (i.x - t.x) * (x - t.y) / (i.y - t.y) + t.x && (r = !r), t = i;
+  } while (t !== e);
+  return r;
+}
+function W(e, n) {
+  const t = S(e.i, e.x, e.y), r = S(n.i, n.x, n.y), o = e.next, x = n.prev;
+  return e.next = n, n.prev = e, t.next = o, o.prev = t, r.next = t, t.prev = r, x.next = r, r.prev = x, r;
+}
+function d(e, n, t, r) {
+  const o = S(e, n, t);
+  return r ? (o.next = r.next, o.prev = r, r.next.prev = o, r.next = o) : (o.prev = o, o.next = o), o;
+}
+function Y(e) {
+  e.next.prev = e.prev, e.prev.next = e.next, e.prevZ && (e.prevZ.nextZ = e.nextZ), e.nextZ && (e.nextZ.prevZ = e.prevZ), O && oe(e.prev, e.next);
+}
+function S(e, n, t) {
+  return {
+    i: e,
+    x: n,
+    y: t,
+    prev: null,
+    next: null,
+    z: 0,
+    prevZ: null,
+    nextZ: null
+  };
+}
+function pe(e, n, t, r) {
+  let o = 0;
+  for (let x = n, i = t - r; x < t; x += r)
+    o += (e[i] - e[x]) * (e[x + 1] + e[i + 1]), i = x;
+  return o;
+}
+export {
+  ge as default
+};

package/dist/src/utils/visual/render/utils/float.js

@@ -0,0 +1,65 @@
+var e = 16, i = class {
+  _oldLength = -1;
+  _length = 0;
+  curMaxLen = e;
+  float32 = new Float32Array(e);
+  _data;
+  get length() {
+    return this._length;
+  }
+  concat(t) {
+    const n = this._length + t.length;
+    for (; n > this.curMaxLen; ) this.expandCapacity();
+    for (let h = 0; h < t.length; h++)
+      this.float32[this._length] = t[h], this._length++;
+  }
+  push(t) {
+    this._length >= this.curMaxLen && this.expandCapacity(), this.float32[this._length] = t, this._length++;
+  }
+  expandCapacity() {
+    this.curMaxLen *= 2;
+    const t = new Float32Array(this.curMaxLen);
+    t.set(this.float32), this.float32 = t;
+  }
+  get data() {
+    return this._oldLength !== this._length && (this._data = new Float32Array(this.float32.buffer, 0, this._length), this._oldLength = this._length), this._data;
+  }
+  clear() {
+    this._length = 0;
+  }
+}, a = class {
+  _oldLength = -1;
+  _length = 0;
+  curMaxLen = 8;
+  int32 = /* @__PURE__ */ new Uint32Array(8);
+  _data;
+  get length() {
+    return this._length;
+  }
+  concat(t) {
+    const n = this.length + t.length;
+    for (; n > this.curMaxLen; ) this.expandCapacity();
+    for (let h = 0; h < t.length; h++)
+      this.int32[this._length] = t[h], this._length++;
+  }
+  concatUInt16(t) {
+    const n = this.length + t.length;
+    for (; n > this.curMaxLen; ) this.expandCapacity();
+    this.int32.set(t, this._length), this._length = n;
+  }
+  expandCapacity() {
+    this.curMaxLen *= 2;
+    const t = new Uint32Array(this.curMaxLen);
+    t.set(this.int32), this.int32 = t;
+  }
+  get data() {
+    return this._oldLength !== this._length && (this._data = new Uint32Array(this.int32.buffer, 0, this._length), this._oldLength = this._length), this._data;
+  }
+  clear() {
+    this._length = 0;
+  }
+};
+export {
+  i as CustomFloatArray,
+  a as CustomIntArray
+};

package/dist/src/utils/visual/render/utils/index.js

@@ -0,0 +1,50 @@
+var l = /* @__PURE__ */ new Map(), n, i = (t) => {
+  if (n === void 0 && (n = typeof document < "u" ? document.createElement("canvas").getContext("2d") : null), !n) return [
+    0,
+    0,
+    0
+  ];
+  n.fillStyle = "#000", n.fillStyle = t, n.fillRect(0, 0, 1, 1);
+  const [a, r, e] = n.getImageData(0, 0, 1, 1).data;
+  return [
+    a,
+    r,
+    e
+  ];
+}, c = (t) => {
+  const a = l.get(t);
+  if (a) return a;
+  let r;
+  if (/^#?[0-9a-fA-F]{3}$/.test(t)) {
+    const e = t.replace("#", "");
+    r = [
+      parseInt(e[0] + e[0], 16),
+      parseInt(e[1] + e[1], 16),
+      parseInt(e[2] + e[2], 16)
+    ];
+  } else if (/^#?[0-9a-fA-F]{6}$/.test(t)) {
+    const e = parseInt(t.replace("#", ""), 16);
+    r = [
+      e >> 16 & 255,
+      e >> 8 & 255,
+      e & 255
+    ];
+  } else r = i(t);
+  return l.set(t, r), r;
+}, u = (t, a) => {
+  const [r, e, o] = c(t).map((g) => Math.round(g * a)), f = Math.round(a * 255);
+  let s = 0;
+  return s += f << 24, s += o << 16, s += e << 8, s += r, s;
+}, d = (t) => {
+  const [a, r, e] = c(t);
+  return [
+    a / 255,
+    r / 255,
+    e / 255
+  ];
+};
+export {
+  c as getRgb,
+  d as toRgbArray,
+  u as toRgbaLittleEndian
+};

package/dist/src/utils/visual/render/utils/verticy.d.ts

@@ -1,5 +1,5 @@
-import type { GraphicsData } from '@/utils/visual/graphics/graphicsData';
-import type { GraphicsGeometry } from '@/utils/visual/graphics/graphicsGeometry';
+import type { GraphicsData } from "../../graphics/graphicsData.js";
+import type { GraphicsGeometry } from "../../graphics/graphicsGeometry.js";
 /**
  * Turn a shape into vertices
  * @param data the sub-shape's data