gputex 0.3.4 → 0.5.0

package/dist/testing.js

@@ -679,12 +679,239 @@ function decodeBC7Mode6Block(block) {
   }
   return out;
 }
+var BC7_PARTITION2 = [
+  52428,
+  34952,
+  61166,
+  60616,
+  51328,
+  65260,
+  65224,
+  60544,
+  51200,
+  65516,
+  65152,
+  59392,
+  65512,
+  65280,
+  65520,
+  61440,
+  63248,
+  142,
+  28928,
+  2254,
+  140,
+  29456,
+  12544,
+  36046,
+  2188,
+  12560,
+  26214,
+  13932,
+  6120,
+  4080,
+  29070,
+  14748,
+  43690,
+  61680,
+  23130,
+  13260,
+  15420,
+  21930,
+  38550,
+  42330,
+  29646,
+  5064,
+  12876,
+  15324,
+  27030,
+  49980,
+  39270,
+  1632,
+  626,
+  1252,
+  20032,
+  10016,
+  51510,
+  37740,
+  14790,
+  25500,
+  37686,
+  40134,
+  33150,
+  59160,
+  52464,
+  4044,
+  30532,
+  60962
+];
+var BC7_ANCHOR2 = [
+  15,
+  15,
+  15,
+  15,
+  15,
+  15,
+  15,
+  15,
+  15,
+  15,
+  15,
+  15,
+  15,
+  15,
+  15,
+  15,
+  15,
+  2,
+  8,
+  2,
+  2,
+  8,
+  8,
+  15,
+  2,
+  8,
+  2,
+  2,
+  8,
+  8,
+  2,
+  2,
+  15,
+  15,
+  6,
+  8,
+  2,
+  8,
+  15,
+  15,
+  2,
+  8,
+  2,
+  2,
+  2,
+  15,
+  15,
+  6,
+  6,
+  2,
+  6,
+  8,
+  15,
+  15,
+  2,
+  2,
+  15,
+  15,
+  15,
+  15,
+  15,
+  2,
+  2,
+  15
+];
+var W3 = [0, 9, 18, 27, 37, 46, 55, 64];
+function decodeBC7Mode1Block(block) {
+  if (block.length !== 16) {
+    throw new Error(`decodeBC7Mode1Block: expected 16 bytes, got ${block.length}`);
+  }
+  const mode = readBC7Mode(block);
+  if (mode !== 1) {
+    throw new Error(`decodeBC7Mode1Block: expected mode 1, got mode ${mode}`);
+  }
+  const br = new BitReader128(block);
+  br.read(2);
+  const part = br.read(6);
+  const ep = [[], [], [], []];
+  for (let c = 0; c < 3; c++) {
+    for (let e = 0; e < 4; e++) ep[e].push(br.read(6));
+  }
+  const p0 = br.read(1);
+  const p1 = br.read(1);
+  const pbits = [p0, p0, p1, p1];
+  const e8 = ep.map(
+    (rgb, e) => rgb.map((v6) => {
+      const v7 = v6 << 1 | pbits[e];
+      return v7 << 1 | v7 >> 6;
+    })
+  );
+  const pal = [0, 1].map((s) => {
+    const lo = e8[s * 2];
+    const hi = e8[s * 2 + 1];
+    return W3.map((w) => [0, 1, 2].map((c) => ((64 - w) * lo[c] + w * hi[c] + 32 >> 6) / 255));
+  });
+  const anchor2 = BC7_ANCHOR2[part];
+  const mask = BC7_PARTITION2[part];
+  const out = new Float32Array(64);
+  for (let k = 0; k < 16; k++) {
+    const w = br.read(k === 0 || k === anchor2 ? 2 : 3);
+    const subset = mask >> k & 1;
+    const rgb = pal[subset][w];
+    out[k * 4] = rgb[0];
+    out[k * 4 + 1] = rgb[1];
+    out[k * 4 + 2] = rgb[2];
+    out[k * 4 + 3] = 1;
+  }
+  return out;
+}
+var W2 = [0, 21, 43, 64];
+function decodeBC7Mode4Block(block) {
+  if (block.length !== 16) {
+    throw new Error(`decodeBC7Mode4Block: expected 16 bytes, got ${block.length}`);
+  }
+  const mode = readBC7Mode(block);
+  if (mode !== 4) {
+    throw new Error(`decodeBC7Mode4Block: expected mode 4, got mode ${mode}`);
+  }
+  const br = new BitReader128(block);
+  br.read(5);
+  const rotation = br.read(2);
+  const idxMode = br.read(1);
+  const c5 = [];
+  for (let i = 0; i < 6; i++) c5.push(br.read(5));
+  const a6 = [br.read(6), br.read(6)];
+  const c8 = c5.map((v) => v << 3 | v >> 2);
+  const a8 = a6.map((v) => v << 2 | v >> 4);
+  const e0 = [c8[0], c8[2], c8[4]];
+  const e1 = [c8[1], c8[3], c8[5]];
+  const w2idx = new Uint8Array(16);
+  for (let k = 0; k < 16; k++) w2idx[k] = br.read(k === 0 ? 1 : 2);
+  const w3idx = new Uint8Array(16);
+  for (let k = 0; k < 16; k++) w3idx[k] = br.read(k === 0 ? 2 : 3);
+  const out = new Float32Array(64);
+  for (let k = 0; k < 16; k++) {
+    const cw = idxMode === 0 ? W2[w2idx[k]] : W3[w3idx[k]];
+    const aw = idxMode === 0 ? W3[w3idx[k]] : W2[w2idx[k]];
+    const px = [
+      interp8(e0[0], e1[0], cw),
+      interp8(e0[1], e1[1], cw),
+      interp8(e0[2], e1[2], cw),
+      interp8(a8[0], a8[1], aw)
+    ];
+    if (rotation > 0) {
+      const c = rotation - 1;
+      const t = px[3];
+      px[3] = px[c];
+      px[c] = t;
+    }
+    out[k * 4] = px[0] / 255;
+    out[k * 4 + 1] = px[1] / 255;
+    out[k * 4 + 2] = px[2] / 255;
+    out[k * 4 + 3] = px[3] / 255;
+  }
+  return out;
+}
 function encodeBC7Block(pixels) {
   return encodeBC7Mode6Block(pixels);
 }
 function decodeBC7Block(block) {
   const mode = readBC7Mode(block);
   switch (mode) {
+    case 1:
+      return decodeBC7Mode1Block(block);
+    case 4:
+      return decodeBC7Mode4Block(block);
     case 6:
       return decodeBC7Mode6Block(block);
     default:
@@ -694,16 +921,43 @@ function decodeBC7Block(block) {
 
 // src/astc4x4_ref.ts
 var BLOCK_MODE_4x4_2BIT = 66;
+var BLOCK_MODE_4x4_3BIT = 83;
+var BLOCK_MODE_4x4_5BIT = 595;
+var CEM_LUM_DIRECT = 0;
+var CEM_RGB_DIRECT = 8;
 var CEM_RGBA_DIRECT = 12;
 var WEIGHT_UNQ_4 = [0, 21, 43, 64];
+var WEIGHT_UNQ_8 = [0, 9, 18, 27, 37, 46, 55, 64];
+var WEIGHT_UNQ_32 = Array.from({ length: 32 }, (_, w) => w <= 15 ? 2 * w : 2 * w + 2);
+var CLASS_LUM = {
+  cem: CEM_LUM_DIRECT,
+  blockMode: BLOCK_MODE_4x4_5BIT,
+  channels: [0],
+  weightBits: 5,
+  unq: WEIGHT_UNQ_32
+};
+var CLASS_RGB = {
+  cem: CEM_RGB_DIRECT,
+  blockMode: BLOCK_MODE_4x4_3BIT,
+  channels: [0, 1, 2],
+  weightBits: 3,
+  unq: WEIGHT_UNQ_8
+};
+var CLASS_RGBA = {
+  cem: CEM_RGBA_DIRECT,
+  blockMode: BLOCK_MODE_4x4_2BIT,
+  channels: [0, 1, 2, 3],
+  weightBits: 2,
+  unq: WEIGHT_UNQ_4
+};
 function clamp2(v, lo, hi) {
   return v < lo ? lo : v > hi ? hi : v;
 }
 function to82(v) {
   return clamp2(Math.round(v * 255), 0, 255);
 }
-function interp82(e0, e1, w) {
-  return (64 - w) * e0 + w * e1 + 32 >> 6;
+function interp16(e0, e1, w) {
+  return (64 - w) * e0 * 257 + w * e1 * 257 + 32 >> 6;
 }
 var BitWriter1282 = class {
   bits = 0n;
@@ -737,18 +991,16 @@ var BitReader1282 = class {
     return Number(this.bits >> BigInt(pos) & mask);
   }
 };
-function farthestPair2(pixels8) {
+function farthestPair2(vals, C) {
   let best = -1;
   let bi0 = 0, bi1 = 1;
   for (let i = 0; i < 16; i++) {
-    const bi = i * 4;
     for (let j = i + 1; j < 16; j++) {
-      const bj = j * 4;
-      const dr = pixels8[bi] - pixels8[bj];
-      const dg = pixels8[bi + 1] - pixels8[bj + 1];
-      const db = pixels8[bi + 2] - pixels8[bj + 2];
-      const da = pixels8[bi + 3] - pixels8[bj + 3];
-      const d = dr * dr + dg * dg + db * db + da * da;
+      let d = 0;
+      for (let c = 0; c < C; c++) {
+        const t = vals[i * C + c] - vals[j * C + c];
+        d += t * t;
+      }
       if (d > best) {
         best = d;
         bi0 = i;
@@ -758,68 +1010,61 @@ function farthestPair2(pixels8) {
   }
   return { i0: bi0, i1: bi1 };
 }
-function buildPalette(e0, e1) {
-  const pal = new Uint8Array(4 * 4);
-  for (let i = 0; i < 4; i++) {
-    const w = WEIGHT_UNQ_4[i];
-    const base = i * 4;
-    for (let c = 0; c < 4; c++) {
-      pal[base + c] = interp82(e0[c], e1[c], w);
+function buildPalette(e0, e1, unq) {
+  const C = e0.length;
+  const pal = new Float64Array(unq.length * C);
+  for (let i = 0; i < unq.length; i++) {
+    for (let c = 0; c < C; c++) {
+      pal[i * C + c] = interp16(e0[c], e1[c], unq[i]) / 257;
     }
   }
   return pal;
 }
-function assignIndex2(pixel, palette) {
-  let bestIdx = 0;
-  let bestD = Infinity;
-  for (let i = 0; i < 4; i++) {
-    const base = i * 4;
-    const dr = palette[base] - pixel[0];
-    const dg = palette[base + 1] - pixel[1];
-    const db = palette[base + 2] - pixel[2];
-    const da = palette[base + 3] - pixel[3];
-    const d = dr * dr + dg * dg + db * db + da * da;
-    if (d < bestD) {
-      bestD = d;
-      bestIdx = i;
-    }
-  }
-  return { idx: bestIdx, err: bestD };
-}
-function totalSqError(pixels8, e0, e1) {
-  const pal = buildPalette(e0, e1);
+function totalSqError(vals, C, e0, e1, unq) {
+  const pal = buildPalette(e0, e1, unq);
+  const levels = unq.length;
   const indices = new Uint8Array(16);
   let err = 0;
   for (let k = 0; k < 16; k++) {
-    const base = k * 4;
-    const sel = assignIndex2([pixels8[base], pixels8[base + 1], pixels8[base + 2], pixels8[base + 3]], pal);
-    indices[k] = sel.idx;
-    err += sel.err;
+    let bestIdx = 0;
+    let bestD = Infinity;
+    for (let i = 0; i < levels; i++) {
+      let d = 0;
+      for (let c = 0; c < C; c++) {
+        const t = pal[i * C + c] - vals[k * C + c];
+        d += t * t;
+      }
+      if (d < bestD) {
+        bestD = d;
+        bestIdx = i;
+      }
+    }
+    indices[k] = bestIdx;
+    err += bestD;
   }
   return { indices, err };
 }
-function refitEndpoints2(pixels8, indices) {
+function refitEndpoints2(vals, C, indices, unq) {
   let sAA = 0, sBB = 0, sAB = 0;
-  const sAV = [0, 0, 0, 0];
-  const sBV = [0, 0, 0, 0];
+  const sAV = new Float64Array(C);
+  const sBV = new Float64Array(C);
   for (let k = 0; k < 16; k++) {
-    const unq = WEIGHT_UNQ_4[indices[k]];
-    const a = (64 - unq) / 64;
-    const b = unq / 64;
+    const u = unq[indices[k]];
+    const a = (64 - u) / 64;
+    const b = u / 64;
     sAA += a * a;
     sBB += b * b;
     sAB += a * b;
-    const base = k * 4;
-    for (let c = 0; c < 4; c++) {
-      sAV[c] += a * pixels8[base + c];
-      sBV[c] += b * pixels8[base + c];
+    for (let c = 0; c < C; c++) {
+      sAV[c] += a * vals[k * C + c];
+      sBV[c] += b * vals[k * C + c];
     }
   }
   const det = sAA * sBB - sAB * sAB;
   if (Math.abs(det) < 1e-9) return null;
-  const e0 = [0, 0, 0, 0];
-  const e1 = [0, 0, 0, 0];
-  for (let c = 0; c < 4; c++) {
+  const e0 = Array.from({ length: C }, () => 0);
+  const e1 = Array.from({ length: C }, () => 0);
+  for (let c = 0; c < C; c++) {
     e0[c] = clamp2(Math.round((sBB * sAV[c] - sAB * sBV[c]) / det), 0, 255);
     e1[c] = clamp2(Math.round((sAA * sBV[c] - sAB * sAV[c]) / det), 0, 255);
   }
@@ -831,101 +1076,677 @@ function encodeASTC4x4Block(pixels) {
   }
   const pixels8 = new Uint8Array(64);
   for (let k = 0; k < 64; k++) pixels8[k] = to82(pixels[k]);
-  const fp = farthestPair2(pixels8);
-  let e0 = [
-    pixels8[fp.i0 * 4],
-    pixels8[fp.i0 * 4 + 1],
-    pixels8[fp.i0 * 4 + 2],
-    pixels8[fp.i0 * 4 + 3]
-  ];
-  let e1 = [
-    pixels8[fp.i1 * 4],
-    pixels8[fp.i1 * 4 + 1],
-    pixels8[fp.i1 * 4 + 2],
-    pixels8[fp.i1 * 4 + 3]
-  ];
-  let { indices, err } = totalSqError(pixels8, e0, e1);
-  const refit = refitEndpoints2(pixels8, indices);
+  let gray = true;
+  let opaque = true;
+  for (let k = 0; k < 16; k++) {
+    const r = pixels8[k * 4];
+    if (pixels8[k * 4 + 1] !== r || pixels8[k * 4 + 2] !== r) gray = false;
+    if (pixels8[k * 4 + 3] !== 255) opaque = false;
+  }
+  const cls = opaque ? gray ? CLASS_LUM : CLASS_RGB : CLASS_RGBA;
+  const C = cls.channels.length;
+  const vals = new Float64Array(16 * C);
+  for (let k = 0; k < 16; k++) {
+    for (let c = 0; c < C; c++) vals[k * C + c] = pixels8[k * 4 + cls.channels[c]];
+  }
+  const fp = farthestPair2(vals, C);
+  let e0 = Array.from({ length: C }, (_, c) => vals[fp.i0 * C + c]);
+  let e1 = Array.from({ length: C }, (_, c) => vals[fp.i1 * C + c]);
+  let { indices, err } = totalSqError(vals, C, e0, e1, cls.unq);
+  const refit = refitEndpoints2(vals, C, indices, cls.unq);
   if (refit) {
-    const { indices: idx2, err: err2 } = totalSqError(pixels8, refit.e0, refit.e1);
-    if (err2 < err) {
+    const second = totalSqError(vals, C, refit.e0, refit.e1, cls.unq);
+    if (second.err < err) {
       e0 = refit.e0;
       e1 = refit.e1;
-      indices = idx2;
-      err = err2;
+      indices = second.indices;
+      err = second.err;
     }
   }
-  const s0 = e0[0] + e0[1] + e0[2];
-  const s1 = e1[0] + e1[1] + e1[2];
-  if (s0 > s1) {
-    const tmp = e0;
-    e0 = e1;
-    e1 = tmp;
-    const inv = new Uint8Array(16);
-    for (let k = 0; k < 16; k++) inv[k] = 3 - indices[k];
-    indices = inv;
+  {
+    const nSum = Math.min(C, 3);
+    let s0 = 0;
+    let s1 = 0;
+    for (let c = 0; c < nSum; c++) {
+      s0 += e0[c];
+      s1 += e1[c];
+    }
+    if (s0 > s1) {
+      const tmp = e0;
+      e0 = e1;
+      e1 = tmp;
+      const wmax = cls.unq.length - 1;
+      const inv = new Uint8Array(16);
+      for (let k = 0; k < 16; k++) inv[k] = wmax - indices[k];
+      indices = inv;
+    }
   }
-  return packBlock3(e0, e1, indices);
+  return packBlock3(cls, e0, e1, indices);
 }
-function packBlock3(e0, e1, indices) {
+function packBlock3(cls, e0, e1, indices) {
   const bw = new BitWriter1282();
-  bw.write(0, 11, BLOCK_MODE_4x4_2BIT);
+  bw.write(0, 11, cls.blockMode);
   bw.write(11, 2, 0);
-  bw.write(13, 4, CEM_RGBA_DIRECT);
-  const ep = [e0[0], e1[0], e0[1], e1[1], e0[2], e1[2], e0[3], e1[3]];
-  for (let i = 0; i < 8; i++) bw.write(17 + i * 8, 8, ep[i]);
+  bw.write(13, 4, cls.cem);
+  for (let c = 0; c < e0.length; c++) {
+    bw.write(17 + c * 16, 8, e0[c]);
+    bw.write(25 + c * 16, 8, e1[c]);
+  }
   for (let k = 0; k < 16; k++) {
-    const w = indices[k] & 3;
-    bw.write(127 - 2 * k, 1, w & 1);
-    bw.write(126 - 2 * k, 1, w >> 1 & 1);
+    const w = indices[k];
+    for (let j = 0; j < cls.weightBits; j++) {
+      bw.write(127 - cls.weightBits * k - j, 1, w >> j & 1);
+    }
   }
   return bw.toBytes();
 }
+var CLASS_BY_MODE = {
+  [BLOCK_MODE_4x4_2BIT]: CLASS_RGBA,
+  [BLOCK_MODE_4x4_3BIT]: CLASS_RGB,
+  [BLOCK_MODE_4x4_5BIT]: CLASS_LUM
+};
 function decodeASTC4x4Block(block) {
   if (block.length !== 16) {
     throw new Error(`decodeASTC4x4Block: expected 16 bytes, got ${block.length}`);
   }
   const br = new BitReader1282(block);
   const mode = br.read(0, 11);
-  if (mode !== BLOCK_MODE_4x4_2BIT) {
-    throw new Error(
-      `decodeASTC4x4Block: expected block mode 0x${BLOCK_MODE_4x4_2BIT.toString(16)}, got 0x${mode.toString(16)}`
-    );
+  const cls = CLASS_BY_MODE[mode];
+  if (!cls) {
+    throw new Error(`decodeASTC4x4Block: unsupported block mode 0x${mode.toString(16)}`);
   }
   const partCount = br.read(11, 2);
   if (partCount !== 0) {
     throw new Error(`decodeASTC4x4Block: multi-partition blocks not supported (count=${partCount + 1})`);
   }
   const cem = br.read(13, 4);
-  if (cem !== CEM_RGBA_DIRECT) {
-    throw new Error(`decodeASTC4x4Block: only CEM 12 supported, got ${cem}`);
+  if (cem !== cls.cem) {
+    throw new Error(`decodeASTC4x4Block: expected CEM ${cls.cem} with block mode 0x${mode.toString(16)}, got ${cem}`);
   }
+  const nVals = cls.channels.length * 2;
   const v = [];
-  for (let i = 0; i < 8; i++) v.push(br.read(17 + i * 8, 8));
-  const [v0, v1, v2, v3, v4, v5, v6, v7] = v;
+  for (let i = 0; i < nVals; i++) v.push(br.read(17 + i * 8, 8));
   let e0;
   let e1;
-  if (v0 + v2 + v4 <= v1 + v3 + v5) {
-    e0 = [v0, v2, v4, v6];
-    e1 = [v1, v3, v5, v7];
+  if (cls.cem === CEM_LUM_DIRECT) {
+    e0 = [v[0], v[0], v[0], 255];
+    e1 = [v[1], v[1], v[1], 255];
   } else {
-    e0 = [v1 + v5 >> 1, v3 + v5 >> 1, v5, v7];
-    e1 = [v0 + v4 >> 1, v2 + v4 >> 1, v4, v6];
+    const a0 = cls.cem === CEM_RGBA_DIRECT ? v[6] : 255;
+    const a1 = cls.cem === CEM_RGBA_DIRECT ? v[7] : 255;
+    if (v[0] + v[2] + v[4] <= v[1] + v[3] + v[5]) {
+      e0 = [v[0], v[2], v[4], a0];
+      e1 = [v[1], v[3], v[5], a1];
+    } else {
+      e0 = [v[1] + v[5] >> 1, v[3] + v[5] >> 1, v[5], a1];
+      e1 = [v[0] + v[4] >> 1, v[2] + v[4] >> 1, v[4], a0];
+    }
   }
   const weights = new Uint8Array(16);
   for (let k = 0; k < 16; k++) {
-    const lsb = br.read(127 - 2 * k, 1);
-    const msb = br.read(126 - 2 * k, 1);
-    weights[k] = lsb | msb << 1;
+    let w = 0;
+    for (let j = 0; j < cls.weightBits; j++) {
+      w |= br.read(127 - cls.weightBits * k - j, 1) << j;
+    }
+    weights[k] = w;
   }
   const out = new Float32Array(64);
   for (let k = 0; k < 16; k++) {
-    const w = WEIGHT_UNQ_4[weights[k]];
+    const u = cls.unq[weights[k]];
     const base = k * 4;
     for (let c = 0; c < 4; c++) {
-      out[base + c] = interp82(e0[c], e1[c], w) / 255;
+      out[base + c] = interp16(e0[c], e1[c], u) / 65535;
+    }
+  }
+  return out;
+}
+
+// src/etc2_ref.ts
+var MODIFIERS = [
+  [2, 8, -2, -8],
+  [5, 17, -5, -17],
+  [9, 29, -9, -29],
+  [13, 42, -13, -42],
+  [18, 60, -18, -60],
+  [24, 80, -24, -80],
+  [33, 106, -33, -106],
+  [47, 183, -47, -183]
+];
+var TH_DISTANCES = [3, 6, 11, 16, 23, 32, 41, 64];
+var clamp255 = (v) => v < 0 ? 0 : v > 255 ? 255 : v;
+var extend4 = (x) => x << 4 | x;
+var extend5 = (x) => x << 3 | x >> 2;
+var extend6 = (x) => x << 2 | x >> 4;
+var extend7 = (x) => x << 1 | x >> 6;
+var quant = (v, maxCode) => {
+  const q = Math.floor(v * maxCode / 255 + 0.5);
+  return q < 0 ? 0 : q > maxCode ? maxCode : q;
+};
+var signed3 = (bits) => bits > 3 ? bits - 8 : bits;
+function subblockTexels(flip, sb) {
+  const out = [];
+  for (let k = 0; k < 16; k++) {
+    const x = k & 3;
+    const y = k >> 2;
+    const inSb1 = flip === 0 ? x >= 2 : y >= 2;
+    if ((inSb1 ? 1 : 0) === sb) out.push(k);
+  }
+  return out;
+}
+var SUBBLOCKS = [
+  [subblockTexels(0, 0), subblockTexels(0, 1)],
+  [subblockTexels(1, 0), subblockTexels(1, 1)]
+];
+function fitSubblock(px, texels, base) {
+  const best = { table: 0, indices: new Uint8Array(8), err: Infinity, modSum: 0 };
+  const idx = new Uint8Array(8);
+  for (let t = 0; t < 8; t++) {
+    const mods = MODIFIERS[t];
+    let err = 0;
+    let modSum = 0;
+    for (let i = 0; i < texels.length; i++) {
+      const k = texels[i];
+      const r = px[k * 3];
+      const g = px[k * 3 + 1];
+      const b = px[k * 3 + 2];
+      let bestJ = 0;
+      let bestD = Infinity;
+      let bestM = 0;
+      for (let j = 0; j < 4; j++) {
+        const m = mods[j];
+        const dr = clamp255(base[0] + m) - r;
+        const dg = clamp255(base[1] + m) - g;
+        const db = clamp255(base[2] + m) - b;
+        const d = dr * dr + dg * dg + db * db;
+        if (d < bestD) {
+          bestD = d;
+          bestJ = j;
+          bestM = m;
+        }
+      }
+      idx[i] = bestJ;
+      err += bestD;
+      modSum += bestM;
+    }
+    if (err < best.err) {
+      best.table = t;
+      best.indices.set(idx);
+      best.err = err;
+      best.modSum = modSum;
+    }
+  }
+  return best;
+}
+function quantiseBases(avg0, avg1, diff, clampDelta) {
+  if (!diff) {
+    return { codes0: avg0.map((v) => quant(v, 15)), codes1: avg1.map((v) => quant(v, 15)) };
+  }
+  const codes0 = avg0.map((v) => quant(v, 31));
+  const codes1 = [];
+  for (let c = 0; c < 3; c++) {
+    let d = quant(avg1[c], 31) - codes0[c];
+    if (d < -4 || d > 3) {
+      if (!clampDelta) return null;
+      d = d < -4 ? -4 : 3;
+    }
+    codes1.push(codes0[c] + d);
+  }
+  return { codes0, codes1 };
+}
+var decodeBases = (codes, diff) => codes.map(diff ? extend5 : extend4);
+function fitEtc1(px, flip, diff, clampDelta, avg0, avg1, refits) {
+  const texels0 = SUBBLOCKS[flip][0];
+  const texels1 = SUBBLOCKS[flip][1];
+  const q = quantiseBases(avg0, avg1, diff, clampDelta);
+  if (!q) return null;
+  let { codes0, codes1 } = q;
+  let fit0 = fitSubblock(px, texels0, decodeBases(codes0, diff));
+  let fit1 = fitSubblock(px, texels1, decodeBases(codes1, diff));
+  let err = fit0.err + fit1.err;
+  for (let round = 0; round < refits; round++) {
+    const shift0 = fit0.modSum / texels0.length;
+    const shift1 = fit1.modSum / texels1.length;
+    const nAvg0 = avg0.map((v) => v - shift0);
+    const nAvg1 = avg1.map((v) => v - shift1);
+    const nq = quantiseBases(nAvg0, nAvg1, diff, true);
+    if (!nq) break;
+    if (nq.codes0.every((v, c) => v === codes0[c]) && nq.codes1.every((v, c) => v === codes1[c])) break;
+    const nFit0 = fitSubblock(px, texels0, decodeBases(nq.codes0, diff));
+    const nFit1 = fitSubblock(px, texels1, decodeBases(nq.codes1, diff));
+    if (nFit0.err + nFit1.err >= err) break;
+    codes0 = nq.codes0;
+    codes1 = nq.codes1;
+    fit0 = nFit0;
+    fit1 = nFit1;
+    err = fit0.err + fit1.err;
+  }
+  return { diff, flip, codes0, codes1, fit0, fit1, err };
+}
+var PLANAR_GINV = [
+  [0.2875, -0.0125, -0.0125],
+  [-0.0125, 0.4875, -0.3125],
+  [-0.0125, -0.3125, 0.4875]
+];
+function planarError(px, o, h, v) {
+  const ext = (codes) => [extend6(codes[0]), extend7(codes[1]), extend6(codes[2])];
+  const eo = ext(o);
+  const eh = ext(h);
+  const ev = ext(v);
+  let err = 0;
+  for (let k = 0; k < 16; k++) {
+    const x = k & 3;
+    const y = k >> 2;
+    for (let c = 0; c < 3; c++) {
+      const val = clamp255(x * (eh[c] - eo[c]) + y * (ev[c] - eo[c]) + 4 * eo[c] + 2 >> 2);
+      const d = val - px[k * 3 + c];
+      err += d * d;
+    }
+  }
+  return err;
+}
+function fitPlanar(px, polish) {
+  const o = [];
+  const h = [];
+  const v = [];
+  const maxCode = [63, 127, 63];
+  for (let c = 0; c < 3; c++) {
+    let sA = 0;
+    let sB = 0;
+    let sC = 0;
+    for (let k = 0; k < 16; k++) {
+      const x = (k & 3) / 4;
+      const y = (k >> 2) / 4;
+      const p = px[k * 3 + c];
+      sA += (1 - x - y) * p;
+      sB += x * p;
+      sC += y * p;
+    }
+    const oc = PLANAR_GINV[0][0] * sA + PLANAR_GINV[0][1] * sB + PLANAR_GINV[0][2] * sC;
+    const hc = PLANAR_GINV[1][0] * sA + PLANAR_GINV[1][1] * sB + PLANAR_GINV[1][2] * sC;
+    const vc = PLANAR_GINV[2][0] * sA + PLANAR_GINV[2][1] * sB + PLANAR_GINV[2][2] * sC;
+    o.push(quant(clamp255(oc), maxCode[c]));
+    h.push(quant(clamp255(hc), maxCode[c]));
+    v.push(quant(clamp255(vc), maxCode[c]));
+  }
+  let err = planarError(px, o, h, v);
+  if (polish) {
+    const params = [o, h, v];
+    for (let p = 0; p < 3; p++) {
+      for (let c = 0; c < 3; c++) {
+        const cur = params[p][c];
+        for (const cand of [cur - 1, cur + 1]) {
+          if (cand < 0 || cand > maxCode[c]) continue;
+          params[p][c] = cand;
+          const e = planarError(px, o, h, v);
+          if (e < err) {
+            err = e;
+          } else {
+            params[p][c] = cur;
+          }
+        }
+      }
+    }
+  }
+  return { o, h, v, err };
+}
+function wordsToBlock(hi, lo) {
+  const out = new Uint8Array(8);
+  out[0] = hi >>> 24 & 255;
+  out[1] = hi >>> 16 & 255;
+  out[2] = hi >>> 8 & 255;
+  out[3] = hi & 255;
+  out[4] = lo >>> 24 & 255;
+  out[5] = lo >>> 16 & 255;
+  out[6] = lo >>> 8 & 255;
+  out[7] = lo & 255;
+  return out;
+}
+function packIndices(cand) {
+  let lo = 0;
+  for (let sb = 0; sb < 2; sb++) {
+    const texels = SUBBLOCKS[cand.flip][sb];
+    const fit = sb === 0 ? cand.fit0 : cand.fit1;
+    for (let i = 0; i < texels.length; i++) {
+      const k = texels[i];
+      const wire = (k & 3) * 4 + (k >> 2);
+      const idx = fit.indices[i];
+      lo |= (idx & 1) << wire;
+      lo |= (idx >> 1 & 1) << 16 + wire;
     }
   }
+  return lo >>> 0;
+}
+function packEtc1(cand) {
+  const { codes0: c0, codes1: c1 } = cand;
+  let hi;
+  if (cand.diff) {
+    const d = [c1[0] - c0[0], c1[1] - c0[1], c1[2] - c0[2]];
+    hi = c0[0] << 27 | (d[0] & 7) << 24 | c0[1] << 19 | (d[1] & 7) << 16 | c0[2] << 11 | (d[2] & 7) << 8 | cand.fit0.table << 5 | cand.fit1.table << 2 | 2 | cand.flip;
+  } else {
+    hi = c0[0] << 28 | c1[0] << 24 | c0[1] << 20 | c1[1] << 16 | c0[2] << 12 | c1[2] << 8 | cand.fit0.table << 5 | cand.fit1.table << 2 | 0 | cand.flip;
+  }
+  return wordsToBlock(hi >>> 0, packIndices(cand));
+}
+function packPlanar(cand) {
+  const ro = cand.o[0];
+  const go = cand.o[1];
+  const bo = cand.o[2];
+  const rh = cand.h[0];
+  const gh = cand.h[1];
+  const bh = cand.h[2];
+  const rv = cand.v[0];
+  const gv = cand.v[1];
+  const bv = cand.v[2];
+  const rSum = (ro >> 2) + signed3((ro & 3) << 1 | go >> 6);
+  const rFix = rSum < 0 ? 1 : 0;
+  const gSum = (go >> 2 & 15) + signed3((go & 3) << 1 | bo >> 5);
+  const gFix = gSum < 0 ? 1 : 0;
+  const p = bo >> 3 & 3;
+  const q = bo >> 1 & 3;
+  const bFix3 = p + q >= 4 ? 7 : 0;
+  const bFix1 = p + q >= 4 ? 0 : 1;
+  const hi = rFix << 31 | ro << 25 | go >> 6 << 24 | gFix << 23 | (go & 63) << 17 | bo >> 5 << 16 | bFix3 << 13 | (bo >> 3 & 3) << 11 | bFix1 << 10 | (bo & 7) << 7 | rh >> 1 << 2 | 2 | // diffbit
+  rh & 1;
+  const lo = gh << 25 | bh << 19 | rv << 13 | gv << 6 | bv;
+  return wordsToBlock(hi >>> 0, lo >>> 0);
+}
+var A3 = MODIFIERS.map((m) => 3 * m[0]);
+var B3 = MODIFIERS.map((m) => 3 * m[1]);
+var THR3 = MODIFIERS.map((m) => 1.5 * (m[0] + m[1]));
+var PLANAR_FUDGE = 8;
+function fastTableScore(D, t) {
+  let acc = 0;
+  for (let i = 0; i < D.length; i++) {
+    const ad = Math.abs(D[i]);
+    const m3 = ad > THR3[t] ? B3[t] : A3[t];
+    acc += m3 * (m3 - 2 * ad);
+  }
+  return acc;
+}
+function fastSearch(D) {
+  let mx = 0;
+  for (let i = 0; i < D.length; i++) mx = Math.max(mx, Math.abs(D[i]));
+  let cover = 0;
+  while (cover < 7 && B3[cover] < mx) cover++;
+  const tLo = cover === 0 ? 0 : cover - 1;
+  const accLo = fastTableScore(D, tLo);
+  const accHi = fastTableScore(D, cover);
+  return accLo <= accHi ? { table: tLo, acc: accLo } : { table: cover, acc: accHi };
+}
+function fastIndices(D, t) {
+  const indices = new Uint8Array(D.length);
+  let modSum = 0;
+  for (let i = 0; i < D.length; i++) {
+    const d = D[i];
+    const large = Math.abs(d) > THR3[t];
+    const neg = d < 0;
+    indices[i] = (large ? 1 : 0) | (neg ? 2 : 0);
+    modSum += (neg ? -1 : 1) * (large ? B3[t] : A3[t]) / 3;
+  }
+  return { table: t, indices, err: 0, modSum };
+}
+function encodeFastBlock(px) {
+  const luma = new Float64Array(16);
+  const qsum = [
+    [0, 0, 0],
+    [0, 0, 0],
+    [0, 0, 0],
+    [0, 0, 0]
+  ];
+  const qsq = [0, 0, 0, 0];
+  const qlsq = [0, 0, 0, 0];
+  for (let k = 0; k < 16; k++) {
+    const r = px[k * 3];
+    const g = px[k * 3 + 1];
+    const b = px[k * 3 + 2];
+    const l = r + g + b;
+    luma[k] = l;
+    const q = ((k & 3) >= 2 ? 1 : 0) | (k >> 2 >= 2 ? 2 : 0);
+    qsum[q][0] += r;
+    qsum[q][1] += g;
+    qsum[q][2] += b;
+    qsq[q] += r * r + g * g + b * b;
+    qlsq[q] += l * l;
+  }
+  const pair = (a, b) => ({
+    sum: [qsum[a][0] + qsum[b][0], qsum[a][1] + qsum[b][1], qsum[a][2] + qsum[b][2]],
+    sq: qsq[a] + qsq[b],
+    lsq: qlsq[a] + qlsq[b]
+  });
+  const constErr = (s, b) => s.sq - 2 * (b[0] * s.sum[0] + b[1] * s.sum[1] + b[2] * s.sum[2]) + 8 * (b[0] * b[0] + b[1] * b[1] + b[2] * b[2]);
+  const Dof = (texels, lb) => texels.map((k) => luma[k] - lb);
+  const evalCodes = (flip2, s0, s1, diff2, c) => {
+    const b0 = decodeBases(c.codes0, diff2);
+    const b1 = decodeBases(c.codes1, diff2);
+    const lb0 = b0[0] + b0[1] + b0[2];
+    const lb1 = b1[0] + b1[1] + b1[2];
+    const f0 = fastSearch(Dof(SUBBLOCKS[flip2][0], lb0));
+    const f1 = fastSearch(Dof(SUBBLOCKS[flip2][1], lb1));
+    return {
+      est: constErr(s0, b0) + constErr(s1, b1) + (f0.acc + f1.acc) / 3,
+      diff: diff2,
+      codes: c,
+      t0: f0.table,
+      t1: f1.table,
+      lb0,
+      lb1
+    };
+  };
+  const evalFlip = (flip2, s0, s1) => {
+    const avg0 = s0.sum.map((v2) => v2 / 8);
+    const avg1 = s1.sum.map((v2) => v2 / 8);
+    const tryDiff = quantiseBases(avg0, avg1, true, false);
+    const diff2 = tryDiff !== null;
+    const c = tryDiff ?? quantiseBases(avg0, avg1, false, false);
+    return evalCodes(flip2, s0, s1, diff2, c);
+  };
+  const residual = (s) => {
+    const dotSum = s.sum[0] * s.sum[0] + s.sum[1] * s.sum[1] + s.sum[2] * s.sum[2];
+    const lsum = s.sum[0] + s.sum[1] + s.sum[2];
+    return s.sq - dotSum / 8 - (s.lsq - lsum * lsum / 8) / 3;
+  };
+  const resA = residual(pair(0, 2)) + residual(pair(1, 3));
+  const resB = residual(pair(0, 1)) + residual(pair(2, 3));
+  let flip;
+  let cur;
+  if (Math.abs(resA - resB) < 1) {
+    const fa = evalFlip(0, pair(0, 2), pair(1, 3));
+    const fb = evalFlip(1, pair(0, 1), pair(2, 3));
+    flip = fb.est < fa.est ? 1 : 0;
+    cur = fb.est < fa.est ? fb : fa;
+  } else {
+    flip = resB < resA ? 1 : 0;
+    cur = evalFlip(flip, flip === 0 ? pair(0, 2) : pair(0, 1), flip === 0 ? pair(1, 3) : pair(2, 3));
+  }
+  const texels0 = SUBBLOCKS[flip][0];
+  const texels1 = SUBBLOCKS[flip][1];
+  const diff = cur.diff;
+  const codes = cur.codes;
+  const fit0 = fastIndices(Dof(texels0, cur.lb0), cur.t0);
+  const fit1 = fastIndices(Dof(texels1, cur.lb1), cur.t1);
+  const o = [];
+  const h = [];
+  const v = [];
+  const maxCode = [63, 127, 63];
+  const extendOHV = [extend6, extend7, extend6];
+  let planarEst = PLANAR_FUDGE;
+  for (let c = 0; c < 3; c++) {
+    let sA = 0;
+    let sB = 0;
+    let sC = 0;
+    let sq = 0;
+    for (let k = 0; k < 16; k++) {
+      const x = (k & 3) / 4;
+      const y = (k >> 2) / 4;
+      const p = px[k * 3 + c];
+      sA += (1 - x - y) * p;
+      sB += x * p;
+      sC += y * p;
+      sq += p * p;
+    }
+    const oc = PLANAR_GINV[0][0] * sA + PLANAR_GINV[0][1] * sB + PLANAR_GINV[0][2] * sC;
+    const hc = PLANAR_GINV[1][0] * sA + PLANAR_GINV[1][1] * sB + PLANAR_GINV[1][2] * sC;
+    const vc = PLANAR_GINV[2][0] * sA + PLANAR_GINV[2][1] * sB + PLANAR_GINV[2][2] * sC;
+    const qO = quant(oc, maxCode[c]);
+    const qH = quant(hc, maxCode[c]);
+    const qV = quant(vc, maxCode[c]);
+    o.push(qO);
+    h.push(qH);
+    v.push(qV);
+    const eO = extendOHV[c](qO);
+    const eH = extendOHV[c](qH);
+    const eV = extendOHV[c](qV);
+    planarEst += sq - 2 * (eO * sA + eH * sB + eV * sC) + 3.5 * (eO * eO + eH * eH + eV * eV) + 0.5 * eO * eH + 0.5 * eO * eV + 4.5 * eH * eV;
+  }
+  if (cur.est <= planarEst) {
+    return packEtc1({ diff, flip, codes0: codes.codes0, codes1: codes.codes1, fit0, fit1, err: cur.est });
+  }
+  return packPlanar({ o, h, v, err: planarEst });
+}
+function blockSse(px, block) {
+  const decoded = decodeETC2Block(block);
+  let sse = 0;
+  for (let i = 0; i < 48; i++) {
+    const d = decoded[i] * 255 - px[i];
+    sse += d * d;
+  }
+  return sse;
+}
+function encodeETC2Block(pixels, { quality = "fast" } = {}) {
+  if (pixels.length !== 48) {
+    throw new Error(`encodeETC2Block: expected 48 values (16 RGB), got ${pixels.length}`);
+  }
+  const px = new Int32Array(48);
+  for (let i = 0; i < 48; i++) {
+    const v = Math.round(pixels[i] * 255);
+    px[i] = v < 0 ? 0 : v > 255 ? 255 : v;
+  }
+  const fastBlock = encodeFastBlock(px);
+  if (quality === "fast") return fastBlock;
+  let bestEtc1 = null;
+  for (let flip = 0; flip < 2; flip++) {
+    const avgs = [];
+    for (let sb = 0; sb < 2; sb++) {
+      const texels = SUBBLOCKS[flip][sb];
+      const a = [0, 0, 0];
+      for (const k of texels) {
+        a[0] += px[k * 3];
+        a[1] += px[k * 3 + 1];
+        a[2] += px[k * 3 + 2];
+      }
+      avgs.push(a.map((s) => s / texels.length));
+    }
+    const [avg0, avg1] = avgs;
+    for (const t of [
+      { diff: true, clampDelta: true },
+      { diff: false, clampDelta: false }
+    ]) {
+      const cand = fitEtc1(px, flip, t.diff, t.clampDelta, avg0, avg1, 4);
+      if (cand && (!bestEtc1 || cand.err < bestEtc1.err)) bestEtc1 = cand;
+    }
+  }
+  const planar = fitPlanar(px, true);
+  const highBlock = bestEtc1 && bestEtc1.err <= planar.err ? packEtc1(bestEtc1) : packPlanar(planar);
+  return blockSse(px, highBlock) <= blockSse(px, fastBlock) ? highBlock : fastBlock;
+}
+function readETC2Mode(block) {
+  const hi = (block[0] << 24 | block[1] << 16 | block[2] << 8 | block[3]) >>> 0;
+  if ((hi >> 1 & 1) === 0) return "individual";
+  const r = (hi >> 27 & 31) + signed3(hi >> 24 & 7);
+  if (r < 0 || r > 31) return "T";
+  const g = (hi >> 19 & 31) + signed3(hi >> 16 & 7);
+  if (g < 0 || g > 31) return "H";
+  const b = (hi >> 11 & 31) + signed3(hi >> 8 & 7);
+  if (b < 0 || b > 31) return "planar";
+  return "differential";
+}
+function decodeETC2Block(block) {
+  if (block.length !== 8) {
+    throw new Error(`decodeETC2Block: expected 8 bytes, got ${block.length}`);
+  }
+  const hi = (block[0] << 24 | block[1] << 16 | block[2] << 8 | block[3]) >>> 0;
+  const lo = (block[4] << 24 | block[5] << 16 | block[6] << 8 | block[7]) >>> 0;
+  const mode = readETC2Mode(block);
+  const out = new Float32Array(48);
+  const wireIndex = (k) => {
+    const wire = (k & 3) * 4 + (k >> 2);
+    return (lo >>> 16 + wire & 1) << 1 | lo >>> wire & 1;
+  };
+  const writeTexel = (k, r, g, b) => {
+    out[k * 3] = clamp255(r) / 255;
+    out[k * 3 + 1] = clamp255(g) / 255;
+    out[k * 3 + 2] = clamp255(b) / 255;
+  };
+  if (mode === "planar") {
+    const ro = extend6(hi >> 25 & 63);
+    const go = extend7((hi >> 24 & 1) << 6 | hi >> 17 & 63);
+    const bo = extend6((hi >> 16 & 1) << 5 | (hi >> 11 & 3) << 3 | hi >> 7 & 7);
+    const rh = extend6((hi >> 2 & 31) << 1 | hi & 1);
+    const gh = extend7(lo >>> 25 & 127);
+    const bh = extend6(lo >>> 19 & 63);
+    const rv = extend6(lo >>> 13 & 63);
+    const gv = extend7(lo >>> 6 & 127);
+    const bv = extend6(lo & 63);
+    for (let k = 0; k < 16; k++) {
+      const x = k & 3;
+      const y = k >> 2;
+      writeTexel(
+        k,
+        x * (rh - ro) + y * (rv - ro) + 4 * ro + 2 >> 2,
+        x * (gh - go) + y * (gv - go) + 4 * go + 2 >> 2,
+        x * (bh - bo) + y * (bv - bo) + 4 * bo + 2 >> 2
+      );
+    }
+    return out;
+  }
+  if (mode === "T" || mode === "H") {
+    let base12;
+    let base22;
+    let dIdx;
+    if (mode === "T") {
+      base12 = [(hi >> 27 & 3) << 2 | hi >> 24 & 3, hi >> 20 & 15, hi >> 16 & 15];
+      base22 = [hi >> 12 & 15, hi >> 8 & 15, hi >> 4 & 15];
+      dIdx = (hi >> 2 & 3) << 1 | hi & 1;
+    } else {
+      base12 = [hi >> 27 & 15, (hi >> 24 & 7) << 1 | hi >> 20 & 1, (hi >> 19 & 1) << 3 | hi >> 15 & 7];
+      base22 = [hi >> 11 & 15, hi >> 7 & 15, hi >> 3 & 15];
+      const v1 = base12[0] << 8 | base12[1] << 4 | base12[2];
+      const v2 = base22[0] << 8 | base22[1] << 4 | base22[2];
+      dIdx = (hi >> 2 & 1) << 2 | (hi & 1) << 1 | (v1 >= v2 ? 1 : 0);
+    }
+    const c1 = base12.map(extend4);
+    const c2 = base22.map(extend4);
+    const d = TH_DISTANCES[dIdx];
+    const palette = mode === "T" ? [c1, c2.map((v) => v + d), c2, c2.map((v) => v - d)] : [c1.map((v) => v + d), c1.map((v) => v - d), c2.map((v) => v + d), c2.map((v) => v - d)];
+    for (let k = 0; k < 16; k++) {
+      const pc = palette[wireIndex(k)];
+      writeTexel(k, pc[0], pc[1], pc[2]);
+    }
+    return out;
+  }
+  const diff = mode === "differential";
+  let base1;
+  let base2;
+  if (diff) {
+    const codes1 = [hi >> 27 & 31, hi >> 19 & 31, hi >> 11 & 31];
+    const codes2 = codes1.map((v, c) => v + signed3(hi >> 24 - c * 8 & 7));
+    base1 = codes1.map(extend5);
+    base2 = codes2.map(extend5);
+  } else {
+    base1 = [hi >> 28 & 15, hi >> 20 & 15, hi >> 12 & 15].map(extend4);
+    base2 = [hi >> 24 & 15, hi >> 16 & 15, hi >> 8 & 15].map(extend4);
+  }
+  const table1 = hi >> 5 & 7;
+  const table2 = hi >> 2 & 7;
+  const flip = hi & 1;
+  for (let k = 0; k < 16; k++) {
+    const x = k & 3;
+    const y = k >> 2;
+    const sb1 = flip === 0 ? x >= 2 : y >= 2;
+    const base = sb1 ? base2 : base1;
+    const m = MODIFIERS[sb1 ? table2 : table1][wireIndex(k)];
+    writeTexel(k, base[0] + m, base[1] + m, base[2] + m);
+  }
   return out;
 }
 export {
@@ -934,12 +1755,17 @@ export {
   decodeBC4Block,
   decodeBC5Block,
   decodeBC7Block,
+  decodeBC7Mode1Block,
+  decodeBC7Mode4Block,
   decodeBC7Mode6Block,
+  decodeETC2Block,
   encodeASTC4x4Block,
   encodeBC1Block,
   encodeBC4Block,
   encodeBC5Block,
   encodeBC7Block,
   encodeBC7Mode6Block,
-  readBC7Mode
+  encodeETC2Block,
+  readBC7Mode,
+  readETC2Mode
 };