modelstage 0.0.0-stage → 0.5.28

package/plugins/unity-spine-bundle/lib/etc2.js

@@ -0,0 +1,371 @@
+// ============================================================================
+// plugins/unity-live2d-bundle/lib/etc2.js —— ETC1 / ETC2 / EAC Alpha 解码
+//
+// 本文件是 GL 系压缩纹理解码的**逐位实现**，覆盖：
+//   · ETC1（个体 individual / 差分 differential）
+//   · ETC2（在 ETC1 差分基础上，按"差分溢出"选 T / H / 平面 planar 三模式）
+//   · ETC2A8（ETC2 RGB + 8 位 EAC Alpha）—— Unity 的 TextureFormat 47 = ETC2_RGBA8 走这条
+//
+// 两块数据的字节顺序（关键，弄反就整张图错位）：
+//   ETC2A8 每个 4x4 块 16 字节 = **前 8 字节是 Alpha，后 8 字节才是 RGB**。
+//   判据：本插件与参考实现（UnityPy 导出 oracle 时用的 texture2ddecoder）逐像素比对一致；
+//   若把顺序反过来，同一份数据会解出完全不同的图。
+//
+// 位序约定：块内索引按"最低位对应第一个像素"逐 3/2 位右移取用，
+//   像素落位用 WriteOrderTable（RGB）与 WriteOrderTableRev（Alpha）两张表，
+//   表值即 4x4 块内的行优先下标（y*4+x）。这两张表来自参考实现，避免自行推导出错。
+//
+// 挂载：globalThis.__ULB__.etc2
+// ============================================================================
+
+'use strict';
+
+{
+  const root = globalThis;   // 原 IIFE 的 root 引用（脚本级裸块内保持同名）
+  const NS = (root.__ULB__ = root.__ULB__ || {});
+
+  const WriteOrderTable = [0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15];
+  const WriteOrderTableRev = [15, 11, 7, 3, 14, 10, 6, 2, 13, 9, 5, 1, 12, 8, 4, 0];
+  const Etc1ModifierTable = [[2, 8], [5, 17], [9, 29], [13, 42], [18, 60], [24, 80], [33, 106], [47, 183]];
+  const Etc1SubblockTable = [
+    [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1],
+    [0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1],
+  ];
+  const Etc2DistanceTable = [3, 6, 11, 16, 23, 32, 41, 64];
+  const Etc2AlphaModTable = [
+    [-3, -6, -9, -15, 2, 5, 8, 14], [-3, -7, -10, -13, 2, 6, 9, 12], [-2, -5, -8, -13, 1, 4, 7, 12],
+    [-2, -4, -6, -13, 1, 3, 5, 12], [-3, -6, -8, -12, 2, 5, 7, 11], [-3, -7, -9, -11, 2, 6, 8, 10],
+    [-4, -7, -8, -11, 3, 6, 7, 10], [-3, -5, -8, -11, 2, 4, 7, 10], [-2, -6, -8, -10, 1, 5, 7, 9],
+    [-2, -5, -8, -10, 1, 4, 7, 9], [-2, -4, -8, -10, 1, 3, 7, 9], [-2, -5, -7, -10, 1, 4, 6, 9],
+    [-3, -4, -7, -10, 2, 3, 6, 9], [-1, -2, -3, -10, 0, 1, 2, 9], [-4, -6, -8, -9, 3, 5, 7, 8],
+    [-3, -5, -7, -9, 2, 4, 6, 8],
+  ];
+
+  const clamp = (n) => (n < 0 ? 0 : n > 255 ? 255 : n);
+
+  /** 把 4x4 块的 RGBA 写进整图（block 内下标记为行优先 y*4+x） */
+  function writeBlock(rgba, blockRGBA, out, outX, outY, width, height) {
+    for (let y = 0; y < 4; y++) {
+      const py = outY + y;
+      if (py >= height) continue;
+      for (let x = 0; x < 4; x++) {
+        const px = outX + x;
+        if (px >= width) continue;
+        const src = (y * 4 + x) * 4;
+        const dst = (py * width + px) * 4;
+        rgba[dst] = blockRGBA[src];
+        rgba[dst + 1] = blockRGBA[src + 1];
+        rgba[dst + 2] = blockRGBA[src + 2];
+        rgba[dst + 3] = blockRGBA[src + 3];
+      }
+    }
+    void out;
+  }
+
+  /** 写块内第 idx 个像素（按 WriteOrderTable 的扫描顺序） */
+  function putPixel(out, idx, r, g, bl) {
+    const p = WriteOrderTable[idx] * 4;
+    out[p] = clamp(r);
+    out[p + 1] = clamp(g);
+    out[p + 2] = clamp(bl);
+    out[p + 3] = 255;
+  }
+
+  /** 差分位（低 3 位）的符号扩展，范围 -8..+7。三个通道共用同一个表达式 */
+  const deltaOf = (x) => ((x << 3) & 0x18) - ((x << 3) & 0x20);
+
+  /**
+   * 选择 RGB 块的子模式。
+   *
+   * **判定顺序即规范，不可调整**：
+   *   individual → T(R 差分溢出) → H(G 差分溢出) → Planar(B 差分溢出) → differential。
+   *   顺序一变，同一个 block 会落进不同模式、解码结果就变了 ——
+   *   不要为了"看起来整齐"把这些 if 重排或合并。
+   * ETC1（etc2 === false）没有 T/H/Planar 三种模式：individual 之后直接进 differential。
+   * @returns {'individual'|'t'|'h'|'planar'|'differential'}
+   */
+  function selectRgbMode(b, o, etc2) {
+    if ((b[o + 3] & 2) === 0) return 'individual';
+    if (!etc2) return 'differential';
+    const r0 = b[o] & 0xf8;
+    const g0 = b[o + 1] & 0xf8;
+    const bl0 = b[o + 2] & 0xf8;
+    if (r0 + deltaOf(b[o]) < 0 || r0 + deltaOf(b[o]) > 255) return 't';
+    if (g0 + deltaOf(b[o + 1]) < 0 || g0 + deltaOf(b[o + 1]) > 255) return 'h';
+    if (bl0 + deltaOf(b[o + 2]) < 0 || bl0 + deltaOf(b[o + 2]) > 255) return 'planar';
+    return 'differential';
+  }
+
+  /** ① 个体模式：两半各自 4 位颜色（不做通道差分） */
+  function decodeIndividualBlock(b, o, j, k, out) {
+    const flip = b[o + 3] & 1;
+    const code = [b[o + 3] >> 5, (b[o + 3] >> 2) & 7];
+    const subblock = Etc1SubblockTable[flip];
+    const c = [[0, 0, 0], [0, 0, 0]];
+    c[0][0] = ((b[o] & 0xf0) | (b[o] >> 4)) & 0xff;
+    c[1][0] = ((b[o] & 0x0f) | (b[o] << 4)) & 0xff;
+    c[0][1] = ((b[o + 1] & 0xf0) | (b[o + 1] >> 4)) & 0xff;
+    c[1][1] = ((b[o + 1] & 0x0f) | (b[o + 1] << 4)) & 0xff;
+    c[0][2] = ((b[o + 2] & 0xf0) | (b[o + 2] >> 4)) & 0xff;
+    c[1][2] = ((b[o + 2] & 0x0f) | (b[o + 2] << 4)) & 0xff;
+    for (let i = 0; i < 16; i++, j >>= 1, k >>= 1) {
+      const s = subblock[i];
+      const m = Etc1ModifierTable[code[s]][j & 1];
+      putPixel(out, i, c[s][0] + (k & 1 ? -m : m), c[s][1] + (k & 1 ? -m : m), c[s][2] + (k & 1 ? -m : m));
+    }
+    return out;
+  }
+
+  /** ② T 模式（ETC2）：两个端点色 + 一组距离偏移，索引为 3 bit */
+  function decodeTBlock(b, o, j, k, out) {
+    const c0 = [
+      ((b[o] << 3) & 0xc0) | ((b[o] << 4) & 0x30) | ((b[o] >> 1) & 0xc) | (b[o] & 3),
+      ((b[o + 1] & 0xf0) | (b[o + 1] >> 4)) & 0xff,
+      ((b[o + 1] & 0x0f) | (b[o + 1] << 4)) & 0xff,
+    ];
+    const c1 = [
+      ((b[o + 2] & 0xf0) | (b[o + 2] >> 4)) & 0xff,
+      ((b[o + 2] & 0x0f) | (b[o + 2] << 4)) & 0xff,
+      ((b[o + 3] & 0xf0) | (b[o + 3] >> 4)) & 0xff,
+    ];
+    const d = Etc2DistanceTable[((b[o + 3] >> 1) & 6) | (b[o + 3] & 1)];
+    const set = [
+      [c0[0], c0[1], c0[2]],
+      [c1[0] + d, c1[1] + d, c1[2] + d],
+      [c1[0], c1[1], c1[2]],
+      [c1[0] - d, c1[1] - d, c1[2] - d],
+    ];
+    k = (k << 1) >>> 0;
+    for (let i = 0; i < 16; i++, j >>= 1, k >>= 1) {
+      const sel = ((k & 2) | (j & 1));
+      putPixel(out, i, set[sel][0], set[sel][1], set[sel][2]);
+    }
+    return out;
+  }
+
+  /** ③ H 模式（ETC2）：两色 + 距离偏移；d 的档位由两色大小关系决定 */
+  function decodeHBlock(b, o, j, k, out) {
+    const c0 = [0, 0, 0];
+    const c1 = [0, 0, 0];
+    c0[0] = ((b[o] << 1) & 0xf0) | ((b[o] >> 3) & 0x0f);
+    c0[1] = ((b[o] << 5) & 0xe0) | (b[o + 1] & 0x10);
+    c0[1] |= c0[1] >> 4;
+    c0[2] = ((b[o + 1] & 8) | ((b[o + 1] << 1) & 6) | (b[o + 2] >> 7)) & 0xff;
+    c0[2] |= (c0[2] << 4) & 0xff;
+    c1[0] = ((b[o + 2] << 1) & 0xf0) | ((b[o + 2] >> 3) & 0x0f);
+    c1[1] = ((b[o + 2] << 5) & 0xe0) | ((b[o + 3] >> 3) & 0x10);
+    c1[1] |= c1[1] >> 4;
+    c1[2] = ((b[o + 3] << 1) & 0xf0) | ((b[o + 3] >> 3) & 0x0f);
+    let d = (b[o + 3] & 4) | ((b[o + 3] << 1) & 2);
+    if (c0[0] > c1[0]
+      || (c0[0] === c1[0] && (c0[1] > c1[1] || (c0[1] === c1[1] && c0[2] >= c1[2])))) d++;
+    d = Etc2DistanceTable[d];
+    const set = [
+      [c0[0] + d, c0[1] + d, c0[2] + d],
+      [c0[0] - d, c0[1] - d, c0[2] - d],
+      [c1[0] + d, c1[1] + d, c1[2] + d],
+      [c1[0] - d, c1[1] - d, c1[2] - d],
+    ];
+    k = (k << 1) >>> 0;
+    for (let i = 0; i < 16; i++, j >>= 1, k >>= 1) {
+      const sel = ((k & 2) | (j & 1));
+      putPixel(out, i, set[sel][0], set[sel][1], set[sel][2]);
+    }
+    return out;
+  }
+
+  /** ④ 平面模式（ETC2）：三顶点色做平面插值；**不用索引位**，按 i*4 顺序直接写 */
+  function decodePlanarBlock(b, o, j, k, out) {
+    void j; void k;   // 平面模式不使用索引位（参数保留只为统一签名）
+    const c = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
+    c[0][0] = ((b[o] << 1) & 0xfc) | ((b[o] >> 5) & 3);
+    c[0][1] = ((b[o] << 7) & 0x80) | (b[o + 1] & 0x7e) | (b[o] & 1);
+    c[0][2] = ((b[o + 1] << 7) & 0x80) | ((b[o + 2] << 2) & 0x60) | ((b[o + 2] << 3) & 0x18) | ((b[o + 3] >> 5) & 4);
+    c[0][2] |= c[0][2] >> 6;
+    c[1][0] = ((b[o + 3] << 1) & 0xf8) | ((b[o + 3] << 2) & 4) | ((b[o + 3] >> 5) & 3);
+    c[1][1] = (b[o + 4] & 0xfe) | (b[o + 4] >> 7);
+    c[1][2] = ((b[o + 4] << 7) & 0x80) | ((b[o + 5] >> 1) & 0x7c);
+    c[1][2] |= c[1][2] >> 6;
+    c[2][0] = ((b[o + 5] << 5) & 0xe0) | ((b[o + 6] >> 3) & 0x1c) | ((b[o + 5] >> 1) & 3);
+    c[2][1] = ((b[o + 6] << 3) & 0xf8) | ((b[o + 7] >> 5) & 0x6) | ((b[o + 6] >> 4) & 1);
+    c[2][2] = ((b[o + 7] << 2) | ((b[o + 7] >> 4) & 3)) & 0xff;
+    for (let y = 0, i = 0; y < 4; y++) {
+      for (let x = 0; x < 4; x++, i++) {
+        const rr = clamp((x * (c[1][0] - c[0][0]) + y * (c[2][0] - c[0][0]) + 4 * c[0][0] + 2) >> 2);
+        const gg = clamp((x * (c[1][1] - c[0][1]) + y * (c[2][1] - c[0][1]) + 4 * c[0][1] + 2) >> 2);
+        const bb = clamp((x * (c[1][2] - c[0][2]) + y * (c[2][2] - c[0][2]) + 4 * c[0][2] + 2) >> 2);
+        const p = i * 4;
+        out[p] = rr; out[p + 1] = gg; out[p + 2] = bb; out[p + 3] = 255;
+      }
+    }
+    return out;
+  }
+
+  /** ⑤ 差分模式（ETC1 本体；ETC2 下三通道都不溢出时也走这里） */
+  function decodeDifferentialBlock(b, o, j, k, out) {
+    const r0 = b[o] & 0xf8;
+    const g0 = b[o + 1] & 0xf8;
+    const bl0 = b[o + 2] & 0xf8;
+    const dr = deltaOf(b[o]);
+    const dg = deltaOf(b[o + 1]);
+    const db = deltaOf(b[o + 2]);
+    const flip = b[o + 3] & 1;
+    const code = [b[o + 3] >> 5, (b[o + 3] >> 2) & 7];
+    const subblock = Etc1SubblockTable[flip];
+    const c = [[0, 0, 0], [0, 0, 0]];
+    c[0][0] = r0 | (r0 >> 5);
+    c[0][1] = g0 | (g0 >> 5);
+    c[0][2] = bl0 | (bl0 >> 5);
+    c[1][0] = (r0 + dr) | ((r0 + dr) >> 5);
+    c[1][1] = (g0 + dg) | ((g0 + dg) >> 5);
+    c[1][2] = (bl0 + db) | ((bl0 + db) >> 5);
+    for (let i = 0; i < 16; i++, j >>= 1, k >>= 1) {
+      const s = subblock[i];
+      const m = Etc1ModifierTable[code[s]][j & 1];
+      putPixel(out, i, c[s][0] + (k & 1 ? -m : m), c[s][1] + (k & 1 ? -m : m), c[s][2] + (k & 1 ? -m : m));
+    }
+    return out;
+  }
+
+  /** 模式名 → 解码函数（签名统一 `(b, o, j, k, out) → out`，out 是 16 像素 × RGBA 的块缓冲） */
+  const RGB_BLOCK_MODES = {
+    individual: decodeIndividualBlock,
+    t: decodeTBlock,
+    h: decodeHBlock,
+    planar: decodePlanarBlock,
+    differential: decodeDifferentialBlock,
+  };
+
+  /** ETC1/ETC2 的 RGB 块（8 字节）→ 4x4 RGBA（alpha 先填 255） */
+  function decodeRgbBlock(data, off, etc2) {
+    const out = new Uint8Array(16 * 4);
+    // 公共头：索引低半（j）与高半（k）各 16 bit
+    const j = (data[off + 6] << 8) | data[off + 7];
+    const k = (data[off + 4] << 8) | data[off + 5];
+    // 先选子模式（顺序即规范，见 selectRgbMode 的注释），再交给对应的模式函数
+    const mode = selectRgbMode(data, off, etc2);
+    return RGB_BLOCK_MODES[mode](data, off, j, k, out);
+  }
+
+  /** ETC2A8 的 Alpha 块（前 8 字节）→ 写进块缓冲的第 4 通道 */
+  function decodeAlphaBlock(data, off, blockRGBA) {
+    const base = data[off];
+    const mullow = data[off + 1];
+    if ((mullow & 0xf0) === 0) {
+      for (let i = 0; i < 16; i++) blockRGBA[i * 4 + 3] = base;
+      return;
+    }
+    const multiplier = mullow >> 4;
+    const table = Etc2AlphaModTable[mullow & 0x0f];
+    // 前 8 字节按大端读取成 64 位，从最低 3 位起每 3 位对应一个像素（落位见 WriteOrderTableRev）
+    let l = 0n;
+    for (let i = 0; i < 8; i++) l = (l << 8n) | BigInt(data[off + i]);
+    for (let i = 0; i < 16; i++, l >>= 3n) {
+      const v = base + multiplier * table[Number(l & 7n)];
+      blockRGBA[WriteOrderTableRev[i] * 4 + 3] = clamp(v);
+    }
+  }
+
+  /**
+   * 解 ETC2_RGBA8（Unity TextureFormat 47）。
+   * @param {Uint8Array} data 压缩数据
+   * @param {number} width 宽
+   * @param {number} height 高
+   * @returns {Uint8Array} RGBA
+   */
+  function decodeEtc2Rgba8(data, width, height) {
+    const bw = Math.ceil(width / 4);
+    const bh = Math.ceil(height / 4);
+    const need = bw * bh * 16;
+    if (data.length < need) throw NS.errors.fail('ULB_ERR_TEX_DATA_SHORT', `ETC2_RGBA8 数据不足：需要 ${need} 字节，实际 ${data.length}`);
+    const rgba = new Uint8Array(width * height * 4);
+    for (let by = 0; by < bh; by++) {
+      for (let bx = 0; bx < bw; bx++) {
+        const off = (by * bw + bx) * 16;
+        // 前 8 字节 Alpha，后 8 字节 RGB（顺序来自参考实现的调用：decode_etc2_block(data+8) + decode_etc2a8_block(data)）
+        const block = decodeRgbBlock(data, off + 8, true);
+        decodeAlphaBlock(data, off, block);
+        writeBlock(rgba, block, null, bx * 4, by * 4, width, height);
+      }
+    }
+    return rgba;
+  }
+
+  /**
+   * 解 ETC2_RGBA1（Unity TextureFormat 48）—— **ETC2 RGB 块 + 1bit alpha 平面**。
+   *
+   * 块布局（每 4×4 像素固定 16 字节）：
+   *   [0..7]    8 字节 ETC2 RGB 块（与 TextureFormat 45 ETC2_RGB 的块同构，可直接复用 decodeRgbBlock）
+   *   [8..15]   8 字节 1bit alpha 平面 = 64 bit = 4×4 每像素 1 bit
+   *
+   * alpha 位序（ETC2 规范）：**位 0 对应块内第一个像素 (x=0,y=0)，按行推进、LSB first** ——
+   *   即 bitIndex = py*4 + px，字节 = 8 + (bitIndex >> 3)，位 = bitIndex & 7；
+   *   置位 = 完全不透明(255)，清零 = 全透明(0)。（与 RGBA8 的 8 字节 EAC 4bit alpha 完全不同，
+   *   不能复用 decodeAlphaBlock。）
+   *
+   * @param {Uint8Array} data 压缩数据
+   * @param {number} width 宽
+   * @param {number} height 高
+   * @returns {Uint8Array} RGBA
+   */
+  function decodeEtc2Rgba1(data, width, height) {
+    const bw = Math.ceil(width / 4);
+    const bh = Math.ceil(height / 4);
+    const need = bw * bh * 16;
+    if (data.length < need) throw NS.errors.fail('ULB_ERR_TEX_DATA_SHORT', `ETC2_RGBA1 数据不足：需要 ${need} 字节，实际 ${data.length}`);
+    const rgba = new Uint8Array(width * height * 4);
+    for (let by = 0; by < bh; by++) {
+      for (let bx = 0; bx < bw; bx++) {
+        const off = (by * bw + bx) * 16;
+        // 前 8 字节 RGB：复用 ETC2 RGB 解出的 4×4 块（其 alpha 由 punch-through 决定，下面会被覆盖）
+        const block = decodeRgbBlock(data, off, true);
+        // 后 8 字节 1bit alpha：逐行、LSB first
+        for (let py = 0; py < 4; py++) {
+          for (let px = 0; px < 4; px++) {
+            const bit = py * 4 + px;
+            const on = (data[off + 8 + (bit >> 3)] >> (bit & 7)) & 1;
+            block[(py * 4 + px) * 4 + 3] = on ? 255 : 0;
+          }
+        }
+        writeBlock(rgba, block, null, bx * 4, by * 4, width, height);
+      }
+    }
+    return rgba;
+  }
+
+  /** 解 ETC1（无 alpha，统一 255）—— 供其他 TextureFormat 复用 */
+  function decodeEtc1Rgb(data, width, height) {
+    const bw = Math.ceil(width / 4);
+    const bh = Math.ceil(height / 4);
+    if (data.length < bw * bh * 8) throw NS.errors.fail('ULB_ERR_TEX_DATA_SHORT', `ETC1 数据不足：需要 ${bw * bh * 8} 字节，实际 ${data.length}`);
+    const rgba = new Uint8Array(width * height * 4);
+    for (let by = 0; by < bh; by++) {
+      for (let bx = 0; bx < bw; bx++) {
+        const block = decodeRgbBlock(data, (by * bw + bx) * 8, false);
+        writeBlock(rgba, block, null, bx * 4, by * 4, width, height);
+      }
+    }
+    return rgba;
+  }
+
+  /** 解 ETC2 RGB（无 alpha，统一 255） */
+  function decodeEtc2Rgb(data, width, height) {
+    const bw = Math.ceil(width / 4);
+    const bh = Math.ceil(height / 4);
+    if (data.length < bw * bh * 8) throw NS.errors.fail('ULB_ERR_TEX_DATA_SHORT', `ETC2 数据不足：需要 ${bw * bh * 8} 字节，实际 ${data.length}`);
+    const rgba = new Uint8Array(width * height * 4);
+    for (let by = 0; by < bh; by++) {
+      for (let bx = 0; bx < bw; bx++) {
+        const block = decodeRgbBlock(data, (by * bw + bx) * 8, true);
+        writeBlock(rgba, block, null, bx * 4, by * 4, width, height);
+      }
+    }
+    return rgba;
+  }
+
+  NS.etc2 = {
+    decodeEtc2Rgba8, decodeEtc2Rgba1, decodeEtc1Rgb, decodeEtc2Rgb, decodeRgbBlock, decodeAlphaBlock,
+    WriteOrderTable, WriteOrderTableRev, Etc1ModifierTable, Etc1SubblockTable,
+    Etc2DistanceTable, Etc2AlphaModTable, clamp,
+  };
+}

package/plugins/unity-spine-bundle/lib/extract.js

@@ -0,0 +1,242 @@
+// ============================================================================
+// plugins/unity-live2d-bundle/lib/extract.js —— 从对象表里抽取资源
+//
+// 这里回答"包里的东西分别在哪、怎么取出来"，与游戏无关（碧蓝只是首个样本）：
+//   · moc3        ：MonoBehaviour 对象里的字节数组（TypelessData）。本实现用
+//                   「MOC3 魔数 + 前置 u32 长度」定位（实测该方法在本样本上精确成立：
+//                   魔数前 4 字节 = 3,225,600，恰好等于该对象内剩余长度）；
+//                   同时保留类型树读数作为对照口径。
+//   · physics3.json：TextAsset 的 m_Script（UTF-8 字符串 → 字节）。
+//   · model3/motion3：**原生 Cubism 包**里直接带的 TextAsset/文件（本样本没有，属另一种包型）。
+//   · 纹理元信息  ：Texture2D 的宽高/格式/完整尺寸 + m_StreamData（数据在 .resS 里的偏移与长度），
+//                   没有流数据时退回对象内的内联 image data。
+//
+// 两种包型都必须支持（同一插件要能读不止一个游戏的包）：
+//   ① 原生 Cubism 文件集：包内直接有 .moc3 / .model3.json / .motion3.json / .physics3.json
+//   ② Unity 集成版：只有 moc3（MonoBehaviour 字节数组）+ physics3.json（TextAsset）+ 纹理 + 动画曲线
+//   本文件负责把两种形态都"找出来"，是否需要重建 model3/motion3 由上层按"有没有"决定。
+//
+// 挂载：globalThis.__ULB__.extract
+// ============================================================================
+
+'use strict';
+
+{
+  const root = globalThis;   // 原 IIFE 的 root 引用（脚本级裸块内保持同名）
+  const NS = (root.__ULB__ = root.__ULB__ || {});
+  const B = NS.bytes;
+
+  const MOC3_MAGIC = [0x4d, 0x4f, 0x43, 0x33];   // "MOC3"
+
+  const utf8 = (str) => new TextEncoder().encode(str);
+  const decodeUtf8 = (u8) => new TextDecoder('utf-8').decode(u8);
+
+  /** 在字节里找第一个匹配 magic 的位置（-1 表示没有） */
+  function indexOfMagic(u8, magic, from) {
+    const start = from || 0;
+    outer:
+    for (let i = start; i <= u8.length - magic.length; i++) {
+      for (let k = 0; k < magic.length; k++) if (u8[i + k] !== magic[k]) continue outer;
+      return i;
+    }
+    return -1;
+  }
+
+  /**
+   * 在 MonoBehaviour 对象里找 moc3。
+   * 判据（两条都满足才算命中，宁缺勿错）：
+   *   ① 对象里出现 "MOC3" 魔数，且前面 4 字节（小端 u32）是长度 L；
+   *   ② L 恰好等于「魔数起点 + L = 对象末尾」（对象里该字段就是最后一段）。
+   * @returns {{object:object, magicOffset:number, bytes:Uint8Array}|null}
+   */
+  function findMoc3(sf) {
+    const monos = NS.serialized.byClass(sf, 114);
+    const candidates = [];
+    for (const obj of monos) {
+      const bytes = sf.bytes.subarray(obj.dataOffset, obj.dataOffset + obj.byteSize);
+      let from = 0;
+      for (;;) {
+        const magicOffset = indexOfMagic(bytes, MOC3_MAGIC, from);
+        if (magicOffset < 0) break;
+        if (magicOffset >= 4) {
+          const r = new B.Reader(bytes, { pos: magicOffset - 4 });
+          const len = r.u32();
+          if (len > 64 && magicOffset + len === bytes.length) {
+            candidates.push({
+              object: obj,
+              magicOffset,
+              length: len,
+              bytes: bytes.subarray(magicOffset, magicOffset + len),
+            });
+            break;
+          }
+        }
+        from = magicOffset + 1;
+      }
+    }
+    if (!candidates.length) return null;
+    // 多个候选时取最大的那个（moc3 是本插件里最大的嵌入式模型数据）
+    candidates.sort((a, b) => b.length - a.length);
+    return candidates[0];
+  }
+
+  /** 取全部 TextAsset（名 + 字节） */
+  function findTextAssets(sf) {
+    if (!NS.typetree) return [];
+    const out = [];
+    for (const obj of NS.serialized.byClass(sf, 49)) {
+      let fields;
+      try { fields = NS.typetree.readObject(sf, obj); }
+      catch (e) { out.push({ object: obj, name: null, bytes: null, error: e.message }); continue; }
+      const name = fields.m_Name || '';
+      const script = fields.m_Script;
+      out.push({
+        object: obj,
+        name,
+        pathName: fields.m_PathName || '',
+        bytes: typeof script === 'string' ? utf8(script) : null,
+      });
+    }
+    return out;
+  }
+
+  /**
+   * 取 Texture2D 元信息（不解码，只给出"数据在哪、什么格式、多大"）。
+   * @returns {Array<{object:object,name:string,width:number,height:number,format:number,
+   *   completeImageSize:number,mipCount:number,stream:{offset:number,size:number,path:string}|null,
+   *   inline:Uint8Array|null, raw:object}>}
+   */
+  function findTextures(sf) {
+    if (!NS.typetree) throw NS.errors.fail('ULB_ERR_EXTRACT', '缺少 lib/typetree.js，无法读取 Texture2D 字段');
+    // 字段名在类型树里可能是带空格的可读名（如 "image data"），也可能是 m_ 前缀名；
+    //   两种都认，避免因类型树命名差异把"内联图像数据"当成不存在（本样本 texture_00 就是 "image data"）。
+    const pick = (obj, names) => {
+      for (const n of names) if (obj[n] !== undefined && obj[n] !== null) return obj[n];
+      return undefined;
+    };
+    const out = [];
+    for (const obj of NS.serialized.byClass(sf, 28)) {
+      const f = NS.typetree.readObject(sf, obj);
+      const sd = pick(f, ['m_StreamData', 'StreamData']) || {};
+      const rawInline = pick(f, ['m_ImageData', 'image data', 'ImageData']);
+      const inline = rawInline && rawInline.byteLength !== undefined && rawInline.byteLength > 0 ? rawInline : null;
+      const stream = sd.path
+        ? { offset: Number(sd.offset || 0), size: Number(sd.size || 0), path: String(sd.path) }
+        : null;
+      out.push({
+        object: obj,
+        name: pick(f, ['m_Name', 'name']) || '',
+        width: pick(f, ['m_Width', 'width']) || 0,
+        height: pick(f, ['m_Height', 'height']) || 0,
+        format: pick(f, ['m_TextureFormat', 'm_Format']),
+        formatName: NS.texdecode ? NS.texdecode.formatName(pick(f, ['m_TextureFormat', 'm_Format'])) : '',
+        completeImageSize: Number(pick(f, ['m_CompleteImageSize']) || 0),
+        mipCount: pick(f, ['m_MipCount', 'm_MipmapCount']) || 0,
+        stream,
+        inline,
+        raw: f,
+      });
+    }
+    // 按名字里的数字排序（texture_00 < texture_01 < …）。
+    //   为什么重要：Cubism 的 model3.json 用 **Textures 数组下标** 给绘制对象分配贴图，
+    //     Unity 资源包里没有 model3，贴图顺序只能从名字恢复；导出件的命名就是 texture_NN，
+    //     顺序即下标。若不排序（按对象表顺序取，实测是 texture_01 在前），
+    //     整个模型会用错贴图 —— 表现就是"碎板/花屏"。
+    out.sort((a, b) => String(a.name).localeCompare(String(b.name), undefined, { numeric: true }));
+    return out;
+  }
+
+  /**
+   * 原生 Cubism 文件集：把包内以 .moc3 / .model3.json / .motion3.json / .physics3.json /
+   * .cdi3.json 结尾的 TextAsset 按"文件"收集起来（另一种包型的直接通路，不需要重建）。
+   */
+  function findNativeCubismFiles(sf) {
+    const wanted = ['.moc3', '.model3.json', '.motion3.json', '.physics3.json', '.cdi3.json', '.exp3.json'];
+    const files = [];
+    for (const ta of findTextAssets(sf)) {
+      const lower = String(ta.name || '').toLowerCase();
+      if (!wanted.some((w) => lower.endsWith(w))) continue;
+      files.push({ name: ta.name, kind: lower.slice(lower.lastIndexOf('.') + 1), bytes: ta.bytes });
+    }
+    return files;
+  }
+
+  /**
+   * 从 moc3 里扫出**可作为参数名/部件名候选的字符串**。
+   *
+   * 为什么要它：Unity 的动画绑定只存 32 位哈希（CRC32），要还原成参数名就得有一份候选名单。
+   *   moc3 里带有模型的参数 ID 表与部件名，是最完整的候选来源；这里用「可打印字符串扫描」
+   *   而不去解析 moc3 二进制布局——布局随 moc3 版本变化，扫描对版本不敏感，
+   *   多余的候选无害（最终按 CRC 精确匹配，撞不上的名字不会被用）。
+   *
+   * @param {Uint8Array} moc3Bytes
+   * @param {number} [minLen] 最短长度（默认 3）
+   * @returns {string[]} 去重后的候选字符串
+   */
+  function moc3NameCandidates(moc3Bytes, minLen) {
+    const min = minLen || 3;
+    const out = new Set();
+    if (!moc3Bytes) return [];
+    let start = -1;
+    for (let i = 0; i <= moc3Bytes.length; i++) {
+      const b = i < moc3Bytes.length ? moc3Bytes[i] : 0;
+      const printable = b >= 0x20 && b <= 0x7e;
+      if (printable) {
+        if (start < 0) start = i;
+      } else {
+        if (start >= 0) {
+          const len = i - start;
+          if (len >= min && len <= 64) {
+            const s = B.latin1(moc3Bytes, start, i);
+            // 只要「像标识符」的字符串：字母或下划线开头，其余为字母数字/下划线
+            if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(s)) out.add(s);
+          }
+          start = -1;
+        }
+      }
+    }
+    return [...out];
+  }
+
+  /**
+   * 一次抽齐（M5/M6 用）。
+   * @param {{cabBytes:Uint8Array, resSBytes:Uint8Array, sf?:object}} input
+   */
+  function extractAll(input) {
+    const sf = input.sf || NS.serialized.parse(input.cabBytes);
+    const moc3Hit = findMoc3(sf);
+    const textAssets = findTextAssets(sf);
+    const physTa = textAssets.find((t) => /\.physics3$/i.test(t.name || ''));
+    const textures = findTextures(sf);
+    return {
+      sf,
+      moc3: moc3Hit ? moc3Hit.bytes : null,
+      moc3Object: moc3Hit ? moc3Hit.object : null,
+      moc3MagicOffset: moc3Hit ? moc3Hit.magicOffset : -1,
+      physics3: physTa ? physTa.bytes : null,
+      textAssets,
+      textures,
+      nativeFiles: findNativeCubismFiles(sf),
+      containerPaths: sf.externals.map((e) => e.path),
+    };
+  }
+
+  /** 取某张纹理的压缩数据：优先 m_StreamData 指向的 .resS 切片，其次对象内联数据 */
+  function textureCompressedBytes(texture, resSBytes) {
+    if (texture.stream) {
+      if (!resSBytes) throw NS.errors.fail('ULB_ERR_EXTRACT', `纹理 ${texture.name} 的数据在 .resS 里，但没有提供 .resS 字节`);
+      const { offset, size } = texture.stream;
+      if (offset + size > resSBytes.length) {
+        throw NS.errors.fail('ULB_ERR_EXTRACT', `纹理 ${texture.name} 的流数据越界：offset=${offset} size=${size} .resS=${resSBytes.length}`);
+      }
+      return resSBytes.subarray(offset, offset + size);
+    }
+    if (texture.inline) return texture.inline;
+    throw NS.errors.fail('ULB_ERR_EXTRACT', `纹理 ${texture.name} 既没有流数据也没有内联数据`);
+  }
+
+  NS.extract = {
+    findMoc3, findTextAssets, findTextures, findNativeCubismFiles,
+    extractAll, textureCompressedBytes, indexOfMagic, decodeUtf8, moc3NameCandidates,
+  };
+}

package/plugins/unity-spine-bundle/lib/lzma-d-min.LICENSE.txt

@@ -0,0 +1,21 @@
+// dsh-skip-sensitive: MIT 许可全文中的作者邮箱
+© 2016 Nathan Rugg <nmrugg@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.