@woosh/meep-engine 3.42.0 → 3.44.0

package/src/shade/renderer/texture/encode/chunk_bc7_encode_block_mode6.js

@@ -1,327 +1,291 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { chunk_bc7_pack_mode6 } from "./chunk_bc7_pack_mode6.js";
-
-/**
- * Encode sixteen RGBA texels as one BC7 block in mode 6.
- *
- * **Mode 6 is BC1's line with everything turned up**: one subset, so one line through colour
- * space, but in four dimensions with alpha, sixteen points on it instead of four, and the ends
- * stored at seven bits plus a parity bit each — an eight-bit value whose low bit is shared by the
- * endpoint's four channels. It is the mode `bc7enc`'s "mode 6 only" setting, DirectXTex's
- * `BC7_QUICK`, and the mode the UASTC transcoder carries single-subset blocks into, and on its own
- * it beats BC1 by a wide margin on everything but sharply partitioned blocks. The partitioned modes
- * are a later quality step and a separate chunk, not a change to this one.
- *
- * The fit is {@link chunk_bc1_encode_block}'s in four dimensions:
- *
- * 1. The principal axis by power iteration on the 4x4 covariance, seeded with the box diagonal;
- *    the extreme projections as the ends.
- * 2. Two rounds of least squares with the sixteen decode weights shared across channels, each
- *    texel assigned by its projection and the neighbouring weight checked by distance.
- * 3. **Quantisation with every parity.** Each end's low bit is one of two values, so the pair has
- *    four parity combinations; each is rounded to and scored against the decoder's own palette,
- *    and the best is kept. Then one round of coordinate descent over the eight stored components,
- *    stepping by two so the parity holds, keeping any step that lowers the block's error.
- * 4. **The anchor.** Texel 0's index is stored a bit short, so its top bit must be zero: when it
- *    is not, the ends are swapped and every index inverted, which is the same block the other way
- *    up.
- *
- * Every score is against the palette the decoder builds — `(a (64 - w) + b w + 32) >> 6` on the
- * eight-bit ends, with BC7's own four-bit weights, which are not evenly spaced — and alpha counts
- * like any other channel: an opaque source's alpha is a constant the fit may land a level off
- * where that buys colour, as the reference transcoder does (plan §9.12), because this encoder does
- * not know what its consumer will do with alpha and is not the place to decide it.
- *
- * @type {CodeChunk}
- */
-export const chunk_bc7_encode_block_mode6 = CodeChunk.from(
-    //language=WGSL
-    `
-// BC7's four-bit interpolation weights, out of 64 — nearly but not exactly four and a quarter apart
-fn bc7_weight4(index: u32) -> u32 {
-    var weights = array<u32, 16>(0u, 4u, 9u, 13u, 17u, 21u, 26u, 30u, 34u, 38u, 43u, 47u, 51u, 55u, 60u, 64u);
-
-    return weights[index];
-}
-
-// a palette entry as the decoder computes it, from eight-bit ends
-fn bc7_interpolate(e0: vec4<f32>, e1: vec4<f32>, index: u32) -> vec4<f32> {
-    let w = f32(bc7_weight4(index));
-
-    return floor((e0 * (64.0 - w) + e1 * w + 32.0) / 64.0);
-}
-
-// the index whose palette entry is nearest a texel, and the squared distance: the projection's
-// index, checked against its two neighbours because the weights are not evenly spaced and the
-// entries are rounded
-fn bc7_nearest(e0: vec4<f32>, e1: vec4<f32>, texel: vec4<f32>) -> vec2<f32> {
-    let direction = e1 - e0;
-    let span = dot(direction, direction);
-
-    var estimate = 0.0;
-
-    if (span > 0.0) {
-        estimate = clamp(round(dot(texel - e0, direction) / span * 15.0), 0.0, 15.0);
-    }
-
-    var best = estimate;
-    var best_distance = 1e30;
-
-    for (var offset = -1.0; offset <= 1.0; offset += 1.0) {
-        let candidate = clamp(estimate + offset, 0.0, 15.0);
-
-        let delta = bc7_interpolate(e0, e1, u32(candidate)) - texel;
-        let distance = dot(delta, delta);
-
-        if (distance < best_distance) {
-            best_distance = distance;
-            best = candidate;
-        }
-    }
-
-    return vec2<f32>(best, best_distance);
-}
-
-fn bc7_score(texels: array<vec4<f32>, 16>, e0: vec4<f32>, e1: vec4<f32>) -> f32 {
-    var error = 0.0;
-
-    for (var i = 0u; i < 16u; i++) {
-        error += bc7_nearest(e0, e1, texels[i]).y;
-    }
-
-    return error;
-}
-
-// the ends that best reproduce the texels at the weights they are nearest to on a real line: the
-// two-by-two normal equations, shared across the four channels
-fn bc7_refine(texels: array<vec4<f32>, 16>, e0: vec4<f32>, e1: vec4<f32>) -> array<vec4<f32>, 2> {
-    let direction = e1 - e0;
-    let span = dot(direction, direction);
-
-    var aa = 0.0;
-    var ab = 0.0;
-    var bb = 0.0;
-    var ap = vec4<f32>(0.0);
-    var bp = vec4<f32>(0.0);
-
-    for (var i = 0u; i < 16u; i++) {
-        var estimate = 0.0;
-
-        if (span > 0.0) {
-            estimate = clamp(round(dot(texels[i] - e0, direction) / span * 15.0), 0.0, 15.0);
-        }
-
-        // the nearest of the three real points around the projection
-        var best_weight = 0.0;
-        var best_distance = 1e30;
-
-        for (var offset = -1.0; offset <= 1.0; offset += 1.0) {
-            let candidate = clamp(estimate + offset, 0.0, 15.0);
-            let weight = f32(bc7_weight4(u32(candidate))) / 64.0;
-
-            let delta = mix(e0, e1, weight) - texels[i];
-            let distance = dot(delta, delta);
-
-            if (distance < best_distance) {
-                best_distance = distance;
-                best_weight = weight;
-            }
-        }
-
-        let b = best_weight;
-        let a = 1.0 - b;
-
-        aa += a * a;
-        ab += a * b;
-        bb += b * b;
-        ap += a * texels[i];
-        bp += b * texels[i];
-    }
-
-    let determinant = aa * bb - ab * ab;
-
-    var out: array<vec4<f32>, 2>;
-
-    if (abs(determinant) < 1e-6) {
-        out[0] = e0;
-        out[1] = e1;
-
-        return out;
-    }
-
-    out[0] = (bb * ap - ab * bp) / determinant;
-    out[1] = (aa * bp - ab * ap) / determinant;
-
-    return out;
-}
-
-// an end rounded to eight bits with every channel's low bit set to the parity
-fn bc7_quantise(e: vec4<f32>, parity: f32) -> vec4<f32> {
-    let even = round((clamp(e, vec4<f32>(0.0), vec4<f32>(255.0)) - parity) * 0.5) * 2.0 + parity;
-
-    return clamp(even, vec4<f32>(parity), vec4<f32>(254.0 + parity));
-}
-
-// a vector with one component replaced, built rather than assigned into a copy — the same code
-// means the same thing on a device, where a copy is a value, and in the emulator, where it is not
-fn bc7_with_component(v: vec4<f32>, channel: u32, value: f32) -> vec4<f32> {
-    return vec4<f32>(
-        select(v.x, value, channel == 0u),
-        select(v.y, value, channel == 1u),
-        select(v.z, value, channel == 2u),
-        select(v.w, value, channel == 3u)
-    );
-}
-
-fn bc7_encode_block_mode6(texels: array<vec4<f32>, 16>) -> vec4<u32> {
-    var scaled: array<vec4<f32>, 16>;
-
-    var low = vec4<f32>(255.0);
-    var high = vec4<f32>(0.0);
-    var mean = vec4<f32>(0.0);
-
-    for (var i = 0u; i < 16u; i++) {
-        let v = clamp(texels[i], vec4<f32>(0.0), vec4<f32>(1.0)) * 255.0;
-
-        scaled[i] = v;
-        low = min(low, v);
-        high = max(high, v);
-        mean += v;
-    }
-
-    mean = mean / 16.0;
-
-    let extent = high - low;
-
-    var e0 = mean;
-    var e1 = mean;
-
-    if (max(max(extent.x, extent.y), max(extent.z, extent.w)) >= 0.5) {
-        // the ten distinct terms of the 4x4 covariance
-        var cov = array<f32, 10>(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
-
-        for (var i = 0u; i < 16u; i++) {
-            let d = scaled[i] - mean;
-
-            cov[0] += d.x * d.x;
-            cov[1] += d.x * d.y;
-            cov[2] += d.x * d.z;
-            cov[3] += d.x * d.w;
-            cov[4] += d.y * d.y;
-            cov[5] += d.y * d.z;
-            cov[6] += d.y * d.w;
-            cov[7] += d.z * d.z;
-            cov[8] += d.z * d.w;
-            cov[9] += d.w * d.w;
-        }
-
-        var axis = extent;
-
-        for (var iteration = 0u; iteration < 4u; iteration++) {
-            let next = vec4<f32>(
-                cov[0] * axis.x + cov[1] * axis.y + cov[2] * axis.z + cov[3] * axis.w,
-                cov[1] * axis.x + cov[4] * axis.y + cov[5] * axis.z + cov[6] * axis.w,
-                cov[2] * axis.x + cov[5] * axis.y + cov[7] * axis.z + cov[8] * axis.w,
-                cov[3] * axis.x + cov[6] * axis.y + cov[8] * axis.z + cov[9] * axis.w
-            );
-
-            let magnitude = length(next);
-
-            if (magnitude < 1e-3) {
-                break;
-            }
-
-            axis = next / magnitude;
-        }
-
-        axis = normalize(axis);
-
-        var t_min = 1e30;
-        var t_max = -1e30;
-
-        for (var i = 0u; i < 16u; i++) {
-            let t = dot(scaled[i] - mean, axis);
-
-            t_min = min(t_min, t);
-            t_max = max(t_max, t);
-        }
-
-        e0 = mean + axis * t_min;
-        e1 = mean + axis * t_max;
-
-        for (var round = 0u; round < 2u; round++) {
-            let refined = bc7_refine(scaled, e0, e1);
-
-            e0 = clamp(refined[0], vec4<f32>(0.0), vec4<f32>(255.0));
-            e1 = clamp(refined[1], vec4<f32>(0.0), vec4<f32>(255.0));
-        }
-    }
-
-    // every parity combination, rounded to and scored
-    var best = 1e30;
-    var q0 = bc7_quantise(e0, 0.0);
-    var q1 = bc7_quantise(e1, 0.0);
-
-    for (var combination = 0u; combination < 4u; combination++) {
-        let c0 = bc7_quantise(e0, f32(combination & 1u));
-        let c1 = bc7_quantise(e1, f32(combination >> 1u));
-
-        let error = bc7_score(scaled, c0, c1);
-
-        if (error < best) {
-            best = error;
-            q0 = c0;
-            q1 = c1;
-        }
-    }
-
-    // coordinate descent over the eight stored components, stepping by two so the parity holds.
-    // One round: a second was measured on every fixture and moved nothing, to two decimals of a
-    // decibel — the eight-bit ends leave the least-squares answer little to correct
-    for (var component = 0u; component < 8u; component++) {
-        let channel = component % 4u;
-
-        for (var direction = -2.0; direction <= 2.0; direction += 4.0) {
-            var c0 = q0;
-            var c1 = q1;
-
-            if (component < 4u) {
-                c0 = bc7_with_component(q0, channel, clamp(q0[channel] + direction, q0[channel] % 2.0, 254.0 + q0[channel] % 2.0));
-            } else {
-                c1 = bc7_with_component(q1, channel, clamp(q1[channel] + direction, q1[channel] % 2.0, 254.0 + q1[channel] % 2.0));
-            }
-
-            let error = bc7_score(scaled, c0, c1);
-
-            if (error < best) {
-                best = error;
-                q0 = c0;
-                q1 = c1;
-            }
-        }
-    }
-
-    var indices: array<u32, 16>;
-
-    for (var i = 0u; i < 16u; i++) {
-        indices[i] = u32(bc7_nearest(q0, q1, scaled[i]).x);
-    }
-
-    // the anchor: texel 0's top bit is implied zero, so a block with it set is written the other
-    // way up, which decodes identically
-    if (indices[0] >= 8u) {
-        let swap = q0;
-
-        q0 = q1;
-        q1 = swap;
-
-        for (var i = 0u; i < 16u; i++) {
-            indices[i] = 15u - indices[i];
-        }
-    }
-
-    return bc7_pack_mode6(vec4<u32>(q0), vec4<u32>(q1), indices);
-}
-`, [
-        chunk_bc7_pack_mode6,
-    ]);
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_bc7_pack_mode6 } from "./chunk_bc7_pack_mode6.js";
+
+/**
+ * Encode sixteen RGBA texels as one BC7 block in mode 6.
+ *
+ * **Mode 6 is BC1's line with everything turned up**: one subset, so one line through colour
+ * space, but in four dimensions with alpha, sixteen points on it instead of four, and the ends
+ * stored at seven bits plus a parity bit each — an eight-bit value whose low bit is shared by the
+ * endpoint's four channels. It is the mode `bc7enc`'s "mode 6 only" setting, DirectXTex's
+ * `BC7_QUICK`, and the mode the UASTC transcoder carries single-subset blocks into, and on its own
+ * it beats BC1 by a wide margin on everything but sharply partitioned blocks. Those are mode 1's, in
+ * `chunk_bc7_encode_block`, which the kernel calls and which chooses between the two; this chunk is
+ * mode 6 on its own.
+ *
+ * The fit is {@link chunk_bc1_encode_block}'s in four dimensions:
+ *
+ * 1. The principal axis by power iteration on the 4x4 covariance, seeded with the box diagonal;
+ *    the extreme projections as the ends.
+ * 2. One round of least squares with the sixteen decode weights shared across channels, each
+ *    texel at the weight it projects to.
+ * 3. **Quantisation with every parity.** Each end's low bit is one of two values, so the pair has
+ *    four parity combinations; each is rounded to and scored against the decoder's own palette,
+ *    each texel at the entry its projection names, and the best is kept.
+ * 4. **The indices**, each texel's nearest entry of that palette: the projection's index and the
+ *    two beside it, by distance, because the weights are not evenly spaced and the entries are
+ *    rounded.
+ * 5. **The anchor.** Texel 0's index is stored a bit short, so its top bit must be zero: when it
+ *    is not, the ends are swapped and every index inverted, which is the same block the other way
+ *    up.
+ *
+ * **The search is the leanest that holds the line**, by measurement (plan §9.20). The one it
+ * replaced scored each texel at its nearest entry rather than its projection's, ran a second round
+ * of least squares and a round of coordinate descent over the stored ends, and held the block as
+ * floats: 0.17 dB better over twenty photographs, at six times the time. Sixteen points on the line
+ * leave the projection little to miss; the quality BC7 still lacks is in the partitioned modes, and
+ * that is where the budget goes.
+ *
+ * Every score is against the palette the decoder builds — `(a (64 - w) + b w + 32) >> 6` on the
+ * eight-bit ends, with BC7's own four-bit weights, which are not evenly spaced — and alpha counts
+ * like any other channel: an opaque source's alpha is a constant the fit may land a level off
+ * where that buys colour, as the reference transcoder does (plan §9.12), because this encoder does
+ * not know what its consumer will do with alpha and is not the place to decide it.
+ *
+ * The block is held as sixteen packed eight-bit words and unpacked where it is read, which is
+ * sixteen registers instead of sixty-four. A source with more than eight bits a channel is rounded
+ * to eight first: what the format's ends and palette hold.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bc7_encode_block_mode6 = CodeChunk.from(
+    //language=WGSL
+    `
+// BC7's four-bit interpolation weights, out of 64 — nearly but not exactly four and a quarter apart:
+// 0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64, every one of which this computes.
+// Computed rather than looked up: a function-local table indexed at run time lives in local memory
+// rather than registers, and a 4096² encode on a 4090 spent 15% of its time on that lookup
+fn bc7_weight4(index: u32) -> u32 {
+    return (index * 64u + 7u) / 15u;
+}
+
+// a palette entry as the decoder computes it, from eight-bit ends
+fn bc7_interpolate(e0: vec4<f32>, e1: vec4<f32>, index: u32) -> vec4<f32> {
+    let w = f32(bc7_weight4(index));
+
+    return floor((e0 * (64.0 - w) + e1 * w + 32.0) / 64.0);
+}
+
+// a texel of the block, held packed, in the [0, 255] the fit works in
+fn bc7_texel(packed: u32) -> vec4<f32> {
+    return unpack4x8unorm(packed) * 255.0;
+}
+
+// the index a texel projects to on the line between the ends: the nearest of sixteen evenly spaced
+// points, which the decoder's palette — rounded, and not evenly spaced — can move by one
+fn bc7_project(e0: vec4<f32>, e1: vec4<f32>, texel: vec4<f32>) -> f32 {
+    let direction = e1 - e0;
+    let span = dot(direction, direction);
+
+    if (span > 0.0) {
+        return clamp(round(dot(texel - e0, direction) / span * 15.0), 0.0, 15.0);
+    }
+
+    return 0.0;
+}
+
+// the index whose palette entry is nearest a texel: the projection's, or one beside it
+fn bc7_nearest(e0: vec4<f32>, e1: vec4<f32>, texel: vec4<f32>) -> u32 {
+    let estimate = bc7_project(e0, e1, texel);
+
+    var best = estimate;
+    var best_distance = 1e30;
+
+    for (var offset = -1.0; offset <= 1.0; offset += 1.0) {
+        let candidate = clamp(estimate + offset, 0.0, 15.0);
+
+        let delta = bc7_interpolate(e0, e1, u32(candidate)) - texel;
+        let distance = dot(delta, delta);
+
+        if (distance < best_distance) {
+            best_distance = distance;
+            best = candidate;
+        }
+    }
+
+    return u32(best);
+}
+
+// the block's squared error against a pair of ends, each texel at the palette entry its projection
+// names — its nearest, or one beside the nearest, which is close enough to rank pairs by
+fn bc7_score(texels: array<u32, 16>, e0: vec4<f32>, e1: vec4<f32>) -> f32 {
+    var error = 0.0;
+
+    for (var i = 0u; i < 16u; i++) {
+        let texel = bc7_texel(texels[i]);
+        let delta = bc7_interpolate(e0, e1, u32(bc7_project(e0, e1, texel))) - texel;
+
+        error += dot(delta, delta);
+    }
+
+    return error;
+}
+
+// the ends that best reproduce the texels at the weights they project to: the two-by-two normal
+// equations, shared across the four channels
+fn bc7_refine(texels: array<u32, 16>, e0: vec4<f32>, e1: vec4<f32>) -> array<vec4<f32>, 2> {
+    var aa = 0.0;
+    var ab = 0.0;
+    var bb = 0.0;
+    var ap = vec4<f32>(0.0);
+    var bp = vec4<f32>(0.0);
+
+    for (var i = 0u; i < 16u; i++) {
+        let texel = bc7_texel(texels[i]);
+
+        let b = f32(bc7_weight4(u32(bc7_project(e0, e1, texel)))) / 64.0;
+        let a = 1.0 - b;
+
+        aa += a * a;
+        ab += a * b;
+        bb += b * b;
+        ap += a * texel;
+        bp += b * texel;
+    }
+
+    let determinant = aa * bb - ab * ab;
+
+    var out: array<vec4<f32>, 2>;
+
+    if (abs(determinant) < 1e-6) {
+        out[0] = e0;
+        out[1] = e1;
+
+        return out;
+    }
+
+    out[0] = (bb * ap - ab * bp) / determinant;
+    out[1] = (aa * bp - ab * ap) / determinant;
+
+    return out;
+}
+
+// an end rounded to eight bits with every channel's low bit set to the parity
+fn bc7_quantise(e: vec4<f32>, parity: f32) -> vec4<f32> {
+    let even = round((clamp(e, vec4<f32>(0.0), vec4<f32>(255.0)) - parity) * 0.5) * 2.0 + parity;
+
+    return clamp(even, vec4<f32>(parity), vec4<f32>(254.0 + parity));
+}
+
+fn bc7_encode_block_mode6(texels: array<vec4<f32>, 16>) -> vec4<u32> {
+    var packed: array<u32, 16>;
+
+    var low = vec4<f32>(255.0);
+    var high = vec4<f32>(0.0);
+    var mean = vec4<f32>(0.0);
+
+    for (var i = 0u; i < 16u; i++) {
+        packed[i] = pack4x8unorm(texels[i]);
+
+        let v = bc7_texel(packed[i]);
+
+        low = min(low, v);
+        high = max(high, v);
+        mean += v;
+    }
+
+    mean = mean / 16.0;
+
+    let extent = high - low;
+
+    var e0 = mean;
+    var e1 = mean;
+
+    if (max(max(extent.x, extent.y), max(extent.z, extent.w)) >= 0.5) {
+        // the ten distinct terms of the 4x4 covariance
+        var cov = array<f32, 10>(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+
+        for (var i = 0u; i < 16u; i++) {
+            let d = bc7_texel(packed[i]) - mean;
+
+            cov[0] += d.x * d.x;
+            cov[1] += d.x * d.y;
+            cov[2] += d.x * d.z;
+            cov[3] += d.x * d.w;
+            cov[4] += d.y * d.y;
+            cov[5] += d.y * d.z;
+            cov[6] += d.y * d.w;
+            cov[7] += d.z * d.z;
+            cov[8] += d.z * d.w;
+            cov[9] += d.w * d.w;
+        }
+
+        var axis = extent;
+
+        for (var iteration = 0u; iteration < 4u; iteration++) {
+            let next = vec4<f32>(
+                cov[0] * axis.x + cov[1] * axis.y + cov[2] * axis.z + cov[3] * axis.w,
+                cov[1] * axis.x + cov[4] * axis.y + cov[5] * axis.z + cov[6] * axis.w,
+                cov[2] * axis.x + cov[5] * axis.y + cov[7] * axis.z + cov[8] * axis.w,
+                cov[3] * axis.x + cov[6] * axis.y + cov[8] * axis.z + cov[9] * axis.w
+            );
+
+            let magnitude = length(next);
+
+            if (magnitude < 1e-3) {
+                break;
+            }
+
+            axis = next / magnitude;
+        }
+
+        axis = normalize(axis);
+
+        var t_min = 1e30;
+        var t_max = -1e30;
+
+        for (var i = 0u; i < 16u; i++) {
+            let t = dot(bc7_texel(packed[i]) - mean, axis);
+
+            t_min = min(t_min, t);
+            t_max = max(t_max, t);
+        }
+
+        let refined = bc7_refine(packed, mean + axis * t_min, mean + axis * t_max);
+
+        e0 = clamp(refined[0], vec4<f32>(0.0), vec4<f32>(255.0));
+        e1 = clamp(refined[1], vec4<f32>(0.0), vec4<f32>(255.0));
+    }
+
+    // every parity combination, rounded to and scored
+    var best = 1e30;
+    var q0 = bc7_quantise(e0, 0.0);
+    var q1 = bc7_quantise(e1, 0.0);
+
+    for (var combination = 0u; combination < 4u; combination++) {
+        let c0 = bc7_quantise(e0, f32(combination & 1u));
+        let c1 = bc7_quantise(e1, f32(combination >> 1u));
+
+        let error = bc7_score(packed, c0, c1);
+
+        if (error < best) {
+            best = error;
+            q0 = c0;
+            q1 = c1;
+        }
+    }
+
+    var indices: array<u32, 16>;
+
+    for (var i = 0u; i < 16u; i++) {
+        indices[i] = bc7_nearest(q0, q1, bc7_texel(packed[i]));
+    }
+
+    // the anchor: texel 0's top bit is implied zero, so a block with it set is written the other
+    // way up, which decodes identically
+    if (indices[0] >= 8u) {
+        let swap = q0;
+
+        q0 = q1;
+        q1 = swap;
+
+        for (var i = 0u; i < 16u; i++) {
+            indices[i] = 15u - indices[i];
+        }
+    }
+
+    return bc7_pack_mode6(vec4<u32>(q0), vec4<u32>(q1), indices);
+}
+`, [
+        chunk_bc7_pack_mode6,
+    ]);