gputex 0.6.0 → 0.8.0

package/dist/testing.d.ts

@@ -110,8 +110,10 @@ type ASTC4x4Block = Uint8Array;
  * grayscale + opaque → luminance, opaque → RGB, otherwise RGBA.
  *
  * Algorithm per class:
- *   1. Quantise input to 8-bit; classify.
- *   2. Farthest-pair over the class's channels → initial (e0, e1).
+ *   1. Quantise input to 8-bit; classify (opaque colour tries both CEM 8
+ *      bit budgets and keeps the lower-error one).
+ *   2. Farthest-pair over the class's channels → initial (e0, e1),
+ *      quantised to the class's endpoint range.
  *   3. Assign per-texel indices by nearest palette entry.
  *   4. One LSQ refit pass; accept only if total error strictly decreases.
  *   5. CEM 8/12: flip endpoints (and reflect weights) if
@@ -121,13 +123,14 @@ type ASTC4x4Block = Uint8Array;
 declare function encodeASTC4x4Block(pixels: ASTC4x4Pixels): ASTC4x4Block;
 /**
  * Decode an ASTC 4×4 block produced by this encoder (or by any other
- * encoder that respects our narrow subset: block modes 0x042/0x053/0x253,
- * single partition, CEM 0/8/12 with 8-bit endpoints). Handles the
+ * encoder that respects our narrow subset: block modes 0x042/0x053/0x242/
+ * 0x253, single partition, CEM 0/8/12 — QUANT_192 endpoints with 0x242,
+ * 8-bit endpoints otherwise). Handles the
  * blue-contraction branch even though our encoder doesn't produce it, so
  * externally-supplied blocks round-trip predictably.
  *
  * The CEM is validated against the block mode's expected pairing (we only
- * ever emit the three fixed combinations above).
+ * ever emit the four fixed combinations above).
  *
  * Output: 16 RGBA pixels as 64 floats in [0, 1].
  */

package/dist/testing.js

@@ -922,33 +922,49 @@ function decodeBC7Block(block) {
 // src/astc4x4_ref.ts
 var BLOCK_MODE_4x4_2BIT = 66;
 var BLOCK_MODE_4x4_3BIT = 83;
+var BLOCK_MODE_4x4_4BIT = 578;
 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_16 = Array.from({ length: 16 }, (_, w) => {
+  const u = w << 2 | w >> 2;
+  return u > 32 ? u + 1 : u;
+});
 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
+  unq: WEIGHT_UNQ_32,
+  endpointRange: 256
 };
 var CLASS_RGB = {
   cem: CEM_RGB_DIRECT,
   blockMode: BLOCK_MODE_4x4_3BIT,
   channels: [0, 1, 2],
   weightBits: 3,
-  unq: WEIGHT_UNQ_8
+  unq: WEIGHT_UNQ_8,
+  endpointRange: 256
+};
+var CLASS_RGB_Q192 = {
+  cem: CEM_RGB_DIRECT,
+  blockMode: BLOCK_MODE_4x4_4BIT,
+  channels: [0, 1, 2],
+  weightBits: 4,
+  unq: WEIGHT_UNQ_16,
+  endpointRange: 192
 };
 var CLASS_RGBA = {
   cem: CEM_RGBA_DIRECT,
   blockMode: BLOCK_MODE_4x4_2BIT,
   channels: [0, 1, 2, 3],
   weightBits: 2,
-  unq: WEIGHT_UNQ_4
+  unq: WEIGHT_UNQ_4,
+  endpointRange: 256
 };
 function clamp2(v, lo, hi) {
   return v < lo ? lo : v > hi ? hi : v;
@@ -959,6 +975,84 @@ function to82(v) {
 function interp16(e0, e1, w) {
   return (64 - w) * e0 * 257 + w * e1 * 257 + 32 >> 6;
 }
+function unq192(value) {
+  const trit = value >> 6;
+  const bits = value & 63;
+  const A = bits & 1 ? 511 : 0;
+  const f = bits >> 5 & 1;
+  const B = (bits >> 1 & 31) << 4 | f;
+  const T = (trit * 5 + B ^ A) & 511;
+  return (A & 128 | T >> 2) & 255;
+}
+var Q192_VALUE_OF = (() => {
+  const t = new Int16Array(256).fill(-1);
+  for (let v = 0; v < 192; v++) t[unq192(v)] = v;
+  return t;
+})();
+function nearest192(x) {
+  const v = clamp2(Math.round(x), 0, 255);
+  if (Q192_VALUE_OF[v] >= 0) return v;
+  const lo = v - 1;
+  const hi = v + 1;
+  const loOk = lo >= 0 && Q192_VALUE_OF[lo] >= 0;
+  const hiOk = hi <= 255 && Q192_VALUE_OF[hi] >= 0;
+  if (loOk && hiOk) return x - lo <= hi - x ? lo : hi;
+  if (loOk) return x - lo <= 2 ? lo : v + 2;
+  return hiOk ? hi : v - 2;
+}
+function decodeTrits(T) {
+  const bit = (x, i) => x >> i & 1;
+  let C;
+  let t3;
+  let t4;
+  if ((T >> 2 & 7) === 7) {
+    C = (T >> 5 & 7) << 2 | T & 3;
+    t4 = 2;
+    t3 = 2;
+  } else {
+    C = T & 31;
+    if ((T >> 5 & 3) === 3) {
+      t4 = 2;
+      t3 = bit(T, 7);
+    } else {
+      t4 = bit(T, 7);
+      t3 = T >> 5 & 3;
+    }
+  }
+  let t0;
+  let t1;
+  let t2;
+  if ((C & 3) === 3) {
+    t2 = 2;
+    t1 = bit(C, 4);
+    t0 = bit(C, 3) << 1 | bit(C, 2) & ~bit(C, 3) & 1;
+  } else if ((C >> 2 & 3) === 3) {
+    t2 = 2;
+    t1 = 2;
+    t0 = C & 3;
+  } else {
+    t2 = bit(C, 4);
+    t1 = C >> 2 & 3;
+    t0 = bit(C, 1) << 1 | bit(C, 0) & ~bit(C, 1) & 1;
+  }
+  return [t0, t1, t2, t3, t4];
+}
+function encodeTrits(t0, t1, t2, t3, t4) {
+  let C;
+  if (t2 === 2 && t1 === 2) C = 12 | t0;
+  else if (t2 === 2) C = t1 << 4 | t0 << 2 | 3;
+  else C = t2 << 4 | t1 << 2 | t0;
+  if (t3 === 2 && t4 === 2) return C >> 2 << 5 | 7 << 2 | C & 3;
+  if (t4 === 2) return t3 << 7 | 3 << 5 | C;
+  return t4 << 7 | t3 << 5 | C;
+}
+var TRIT_SLICES = [
+  [0, 2],
+  [2, 2],
+  [4, 1],
+  [5, 2],
+  [7, 1]
+];
 var BitWriter1282 = class {
   bits = 0n;
   write(pos, nBits, value) {
@@ -1070,39 +1164,61 @@ function refitEndpoints2(vals, C, indices, unq) {
   }
   return { e0, e1 };
 }
-function encodeASTC4x4Block(pixels) {
-  if (pixels.length !== 64) {
-    throw new Error(`encodeASTC4x4Block: expected 64 values (16 RGBA), got ${pixels.length}`);
-  }
-  const pixels8 = new Uint8Array(64);
-  for (let k = 0; k < 64; k++) pixels8[k] = to82(pixels[k]);
-  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;
+function quantEndpoint(cls, e) {
+  return cls.endpointRange === 192 ? e.map(nearest192) : e.map((v) => clamp2(Math.round(v), 0, 255));
+}
+function fitClass(cls, pixels8) {
   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 e0 = quantEndpoint(
+    cls,
+    Array.from({ length: C }, (_, c) => vals[fp.i0 * C + c])
+  );
+  let e1 = quantEndpoint(
+    cls,
+    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 second = totalSqError(vals, C, refit.e0, refit.e1, cls.unq);
+    const r0 = quantEndpoint(cls, refit.e0);
+    const r1 = quantEndpoint(cls, refit.e1);
+    const second = totalSqError(vals, C, r0, r1, cls.unq);
     if (second.err < err) {
-      e0 = refit.e0;
-      e1 = refit.e1;
+      e0 = r0;
+      e1 = r1;
       indices = second.indices;
       err = second.err;
     }
   }
+  return { e0, e1, indices, err };
+}
+function encodeASTC4x4Block(pixels) {
+  if (pixels.length !== 64) {
+    throw new Error(`encodeASTC4x4Block: expected 64 values (16 RGBA), got ${pixels.length}`);
+  }
+  const pixels8 = new Uint8Array(64);
+  for (let k = 0; k < 64; k++) pixels8[k] = to82(pixels[k]);
+  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 classes = opaque ? gray ? [CLASS_LUM] : [CLASS_RGB, CLASS_RGB_Q192] : [CLASS_RGBA];
+  let best = null;
+  for (const cls2 of classes) {
+    const fit = fitClass(cls2, pixels8);
+    if (!best || fit.err < best.err) best = { cls: cls2, ...fit };
+  }
+  const { cls } = best;
+  let { e0, e1, indices } = best;
+  const C = cls.channels.length;
   {
     const nSum = Math.min(C, 3);
     let s0 = 0;
@@ -1128,9 +1244,29 @@ function packBlock3(cls, e0, e1, indices) {
   bw.write(0, 11, cls.blockMode);
   bw.write(11, 2, 0);
   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]);
+  const values = [];
+  for (let c = 0; c < e0.length; c++) values.push(e0[c], e1[c]);
+  if (cls.endpointRange === 192) {
+    let pos = 17;
+    for (let g = 0; g < values.length; g += 5) {
+      const grp = values.slice(g, g + 5).map((v) => {
+        const q = Q192_VALUE_OF[v];
+        if (q < 0) throw new Error(`packBlock: ${v} is not a QUANT_192 level`);
+        return q;
+      });
+      const t = [0, 0, 0, 0, 0];
+      grp.forEach((q, i) => t[i] = q >> 6);
+      const T = encodeTrits(t[0], t[1], t[2], t[3], t[4]);
+      grp.forEach((q, i) => {
+        bw.write(pos, 6, q & 63);
+        pos += 6;
+        const [start, count] = TRIT_SLICES[i];
+        bw.write(pos, count, T >> start & (1 << count) - 1);
+        pos += count;
+      });
+    }
+  } else {
+    values.forEach((v, i) => bw.write(17 + i * 8, 8, v));
   }
   for (let k = 0; k < 16; k++) {
     const w = indices[k];
@@ -1140,19 +1276,20 @@ function packBlock3(cls, e0, e1, indices) {
   }
   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
+var CLASS_BY_MODE_CEM = {
+  [`${BLOCK_MODE_4x4_2BIT}:${CEM_RGBA_DIRECT}`]: CLASS_RGBA,
+  [`${BLOCK_MODE_4x4_3BIT}:${CEM_RGB_DIRECT}`]: CLASS_RGB,
+  [`${BLOCK_MODE_4x4_4BIT}:${CEM_RGB_DIRECT}`]: CLASS_RGB_Q192,
+  [`${BLOCK_MODE_4x4_5BIT}:${CEM_LUM_DIRECT}`]: CLASS_LUM
 };
+var SUPPORTED_MODES = /* @__PURE__ */ new Set([BLOCK_MODE_4x4_2BIT, BLOCK_MODE_4x4_3BIT, BLOCK_MODE_4x4_4BIT, BLOCK_MODE_4x4_5BIT]);
 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);
-  const cls = CLASS_BY_MODE[mode];
-  if (!cls) {
+  if (!SUPPORTED_MODES.has(mode)) {
     throw new Error(`decodeASTC4x4Block: unsupported block mode 0x${mode.toString(16)}`);
   }
   const partCount = br.read(11, 2);
@@ -1160,12 +1297,31 @@ function decodeASTC4x4Block(block) {
     throw new Error(`decodeASTC4x4Block: multi-partition blocks not supported (count=${partCount + 1})`);
   }
   const cem = br.read(13, 4);
-  if (cem !== cls.cem) {
-    throw new Error(`decodeASTC4x4Block: expected CEM ${cls.cem} with block mode 0x${mode.toString(16)}, got ${cem}`);
+  const cls = CLASS_BY_MODE_CEM[`${mode}:${cem}`];
+  if (!cls) {
+    throw new Error(`decodeASTC4x4Block: unsupported CEM ${cem} with block mode 0x${mode.toString(16)}`);
   }
   const nVals = cls.channels.length * 2;
   const v = [];
-  for (let i = 0; i < nVals; i++) v.push(br.read(17 + i * 8, 8));
+  if (cls.endpointRange === 192) {
+    let pos = 17;
+    for (let g = 0; g < nVals; g += 5) {
+      const n = Math.min(5, nVals - g);
+      const bits = [];
+      let T = 0;
+      for (let i = 0; i < n; i++) {
+        bits.push(br.read(pos, 6));
+        pos += 6;
+        const [start, count] = TRIT_SLICES[i];
+        T |= br.read(pos, count) << start;
+        pos += count;
+      }
+      const t = decodeTrits(T);
+      for (let i = 0; i < n; i++) v.push(unq192(t[i] << 6 | bits[i]));
+    }
+  } else {
+    for (let i = 0; i < nVals; i++) v.push(br.read(17 + i * 8, 8));
+  }
   let e0;
   let e1;
   if (cls.cem === CEM_LUM_DIRECT) {
@@ -1454,6 +1610,7 @@ 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;
+var KAPPA = 0.9;
 function fastTableScore(D, t) {
   let acc = 0;
   for (let i = 0; i < D.length; i++) {
@@ -1543,13 +1700,14 @@ function encodeFastBlock(px) {
   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;
+    return s.sq - dotSum / 8 - KAPPA * (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));
+  const gray = qsum.every((q) => q[0] === q[1] && q[1] === q[2]);
   let flip;
   let cur;
-  if (Math.abs(resA - resB) < 1) {
+  if (gray) {
     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;