@woosh/meep-engine 3.43.0 → 3.45.0

package/src/shade/renderer/texture/encode/chunk_bc7_encode_block.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Encode sixteen RGBA texels as one BC7 block, in mode 6 or in mode 1 — whichever an estimate says
+ * loses less — fitting and writing only that one.
+ *
+ * **Mode 1 is two lines.** Mode 6 (`chunk_bc7_encode_block_mode6`) puts one line through the
+ * block in four channels; a block holding two colour regions, each varying its own way, is two lines
+ * that point different ways, and no single line holds both. Mode 1 splits the block by one of BC7's
+ * sixty-four two-subset partitions and gives each subset a line of its own: colour only, six bits a
+ * channel and a parity bit shared by the subset's two ends, eight levels on each line. It decodes
+ * opaque.
+ *
+ * **Chosen by estimate, not by search.** Each candidate's squared error is predicted from the block's
+ * statistics without encoding it — the approach of Geldreich's bc7f — and only the winner is fitted:
+ *
+ * 1. A line's distance from its texels is the lesser eigenvalues of their scatter about their mean,
+ *    the trace less the largest. It is read here as the sum of the scatter's principal two-by-two
+ *    minors over its trace: exact as the line thins, half the truth for a ball, and on Spark.js's
+ *    twenty report images within 0.02 dB of solving for the eigenvalue, at well under its cost.
+ * 2. To that, what quantisation adds: the spread along the line over the squared steps between its
+ *    levels, by a share calibrated on those images (0.5; flat within 0.01 dB from 0.35 to 0.5), and
+ *    a term per block for the ends, larger for mode 1's coarser ones (8 and 18; flat from 18 to 25).
+ * 3. Mode 1 is estimated at **every** partition. A partition's second subset is the same texels in
+ *    every invocation, so its sums are taken over exactly those, by a branch that does not diverge,
+ *    and the first subset's are the block's less the second's. Ranking the partitions by how many
+ *    texels they put across the block's principal split, and estimating the best four, measured
+ *    0.8 dB worse.
+ * 4. Mode 1 is charged each texel's distance from opaque in alpha, which keeps it off blocks that
+ *    are not.
+ *
+ * Choosing the mode by the estimate rather than by each one's actual error costs 0.12 dB at the
+ * estimate's partition; fitting mode 1 at all sixty-four and keeping the best by actual error,
+ * sixty-five fits a block, was 0.3 dB better at forty to eighty times the time.
+ *
+ * **One fit for both modes.** The chosen mode reaches the fit as data — which texels are in the
+ * second subset, the levels, the bits an end keeps, whether alpha is held — so a group of
+ * invocations holding both modes runs one fit rather than both. Per subset: the principal axis by
+ * power iteration, the extreme projections as the ends, one round of least squares with each texel
+ * at the weight it projects to; then the parities, rounded to and **scored by the least squares'
+ * own quadratic form**: at its optimum the error grows by `aa |d0|² + 2 ab d0·d1 + bb |d1|²` for
+ * ends moved by `d0` and `d1`, so no combination needs a pass over the texels — 0.1 dB below scoring
+ * each against the decoder's palette, at about two fifths of the fit's time. Then each texel's exact
+ * nearest entry, once, and the anchors: texel 0 and the partition's second anchor are stored a bit
+ * short, and a subset whose anchor lands in the upper half is written the other way up.
+ *
+ * **Modes 3 and 7 are not here, by measurement.** Mode 3, two subsets of four levels on eight-bit
+ * ends, chosen by the same estimate at mode 1's partition, bought 0.05 dB over the twenty images and
+ * nothing on the graphic ones; mode 7 is mode 3 with alpha, and those images are opaque. A block
+ * with alpha that varies is mode 6's.
+ *
+ * Measured on an RTX 4090, 4096² tiled from Spark.js's twenty report images, one level, kernel
+ * minimum: 0.47 ms and 40.86 dB mean PSNR for mode 6 alone, 0.83 ms and 44.07 dB for this — and on
+ * the two graphic images Spark leads on, RMSE 5.15 to 2.89 (`hype`) and 7.30 to 4.00 (`paint2`).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bc7_encode_block: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_bc7_encode_block.d.ts.map

package/src/shade/renderer/texture/encode/chunk_bc7_encode_block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_bc7_encode_block.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/chunk_bc7_encode_block.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,qCAFU,SAAS,CA6dZ;0BAvhBmB,oCAAoC"}

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

@@ -0,0 +1,536 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_bc7_pack_mode1 } from "./chunk_bc7_pack_mode1.js";
+import { chunk_bc7_pack_mode6 } from "./chunk_bc7_pack_mode6.js";
+import { chunk_bc7_partition_2 } from "./chunk_bc7_partition_2.js";
+
+/**
+ * Encode sixteen RGBA texels as one BC7 block, in mode 6 or in mode 1 — whichever an estimate says
+ * loses less — fitting and writing only that one.
+ *
+ * **Mode 1 is two lines.** Mode 6 (`chunk_bc7_encode_block_mode6`) puts one line through the
+ * block in four channels; a block holding two colour regions, each varying its own way, is two lines
+ * that point different ways, and no single line holds both. Mode 1 splits the block by one of BC7's
+ * sixty-four two-subset partitions and gives each subset a line of its own: colour only, six bits a
+ * channel and a parity bit shared by the subset's two ends, eight levels on each line. It decodes
+ * opaque.
+ *
+ * **Chosen by estimate, not by search.** Each candidate's squared error is predicted from the block's
+ * statistics without encoding it — the approach of Geldreich's bc7f — and only the winner is fitted:
+ *
+ * 1. A line's distance from its texels is the lesser eigenvalues of their scatter about their mean,
+ *    the trace less the largest. It is read here as the sum of the scatter's principal two-by-two
+ *    minors over its trace: exact as the line thins, half the truth for a ball, and on Spark.js's
+ *    twenty report images within 0.02 dB of solving for the eigenvalue, at well under its cost.
+ * 2. To that, what quantisation adds: the spread along the line over the squared steps between its
+ *    levels, by a share calibrated on those images (0.5; flat within 0.01 dB from 0.35 to 0.5), and
+ *    a term per block for the ends, larger for mode 1's coarser ones (8 and 18; flat from 18 to 25).
+ * 3. Mode 1 is estimated at **every** partition. A partition's second subset is the same texels in
+ *    every invocation, so its sums are taken over exactly those, by a branch that does not diverge,
+ *    and the first subset's are the block's less the second's. Ranking the partitions by how many
+ *    texels they put across the block's principal split, and estimating the best four, measured
+ *    0.8 dB worse.
+ * 4. Mode 1 is charged each texel's distance from opaque in alpha, which keeps it off blocks that
+ *    are not.
+ *
+ * Choosing the mode by the estimate rather than by each one's actual error costs 0.12 dB at the
+ * estimate's partition; fitting mode 1 at all sixty-four and keeping the best by actual error,
+ * sixty-five fits a block, was 0.3 dB better at forty to eighty times the time.
+ *
+ * **One fit for both modes.** The chosen mode reaches the fit as data — which texels are in the
+ * second subset, the levels, the bits an end keeps, whether alpha is held — so a group of
+ * invocations holding both modes runs one fit rather than both. Per subset: the principal axis by
+ * power iteration, the extreme projections as the ends, one round of least squares with each texel
+ * at the weight it projects to; then the parities, rounded to and **scored by the least squares'
+ * own quadratic form**: at its optimum the error grows by `aa |d0|² + 2 ab d0·d1 + bb |d1|²` for
+ * ends moved by `d0` and `d1`, so no combination needs a pass over the texels — 0.1 dB below scoring
+ * each against the decoder's palette, at about two fifths of the fit's time. Then each texel's exact
+ * nearest entry, once, and the anchors: texel 0 and the partition's second anchor are stored a bit
+ * short, and a subset whose anchor lands in the upper half is written the other way up.
+ *
+ * **Modes 3 and 7 are not here, by measurement.** Mode 3, two subsets of four levels on eight-bit
+ * ends, chosen by the same estimate at mode 1's partition, bought 0.05 dB over the twenty images and
+ * nothing on the graphic ones; mode 7 is mode 3 with alpha, and those images are opaque. A block
+ * with alpha that varies is mode 6's.
+ *
+ * Measured on an RTX 4090, 4096² tiled from Spark.js's twenty report images, one level, kernel
+ * minimum: 0.47 ms and 40.86 dB mean PSNR for mode 6 alone, 0.83 ms and 44.07 dB for this — and on
+ * the two graphic images Spark leads on, RMSE 5.15 to 2.89 (`hype`) and 7.30 to 4.00 (`paint2`).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bc7_encode_block = CodeChunk.from(
+    //language=WGSL
+    `
+// the estimate's quantisation terms: the indices' error as a share of the spread along the line over
+// the squared steps between levels, and the ends' error per block, by mode
+const BC7_ESTIMATE_INDEX: f32 = 0.5;
+const BC7_ESTIMATE_END_6: f32 = 8.0;
+const BC7_ESTIMATE_END_1: f32 = 18.0;
+
+// a partition's second subset, as sums over its texels' offsets from the block's mean, colour only
+struct Bc7Subset {
+    sum: vec3<f32>,
+    c00: f32,
+    c01: f32,
+    c02: f32,
+    c11: f32,
+    c12: f32,
+    c22: f32,
+}
+
+// a texel of the block, held packed, in the [0, 255] the fit works in
+fn bc7_block_texel(packed: u32) -> vec4<f32> {
+    return unpack4x8unorm(packed) * 255.0;
+}
+
+// the ten distinct terms of a four-channel scatter, for one offset
+fn bc7_scatter_terms(d: vec4<f32>) -> array<f32, 10> {
+    return array<f32, 10>(
+        d.x * d.x, d.x * d.y, d.x * d.z, d.x * d.w,
+        d.y * d.y, d.y * d.z, d.y * d.w,
+        d.z * d.z, d.z * d.w,
+        d.w * d.w
+    );
+}
+
+fn bc7_scatter_times(c: array<f32, 10>, v: vec4<f32>) -> vec4<f32> {
+    return vec4<f32>(
+        c[0] * v.x + c[1] * v.y + c[2] * v.z + c[3] * v.w,
+        c[1] * v.x + c[4] * v.y + c[5] * v.z + c[6] * v.w,
+        c[2] * v.x + c[5] * v.y + c[7] * v.z + c[8] * v.w,
+        c[3] * v.x + c[6] * v.y + c[8] * v.z + c[9] * v.w
+    );
+}
+
+// the principal axis of a scatter, by power iteration from its widest channel; that channel's unit
+// vector when the scatter is zero
+fn bc7_principal_axis(c: array<f32, 10>) -> vec4<f32> {
+    let diagonal = vec4<f32>(c[0], c[4], c[7], c[9]);
+    let widest = max(max(diagonal.x, diagonal.y), max(diagonal.z, diagonal.w));
+
+    var axis = select(
+        select(
+            select(vec4<f32>(0.0, 0.0, 0.0, 1.0), vec4<f32>(0.0, 0.0, 1.0, 0.0), diagonal.z == widest),
+            vec4<f32>(0.0, 1.0, 0.0, 0.0),
+            diagonal.y == widest
+        ),
+        vec4<f32>(1.0, 0.0, 0.0, 0.0),
+        diagonal.x == widest
+    );
+
+    for (var iteration = 0u; iteration < 4u; iteration++) {
+        let next = bc7_scatter_times(c, axis);
+        let magnitude = length(next);
+
+        if (magnitude < 1e-3) {
+            break;
+        }
+
+        axis = next / magnitude;
+    }
+
+    return axis;
+}
+
+// the estimated squared error of texels on one line, from the trace of their scatter about their mean
+// and the sum of its principal two-by-two minors: the distance from the line, which is the scatter's
+// lesser eigenvalues and is read as minors over trace — exact as the line thins, half of it for a
+// ball — and the spread along the line over the squared steps between levels
+fn bc7_estimate_line(trace: f32, minors: f32, steps: f32) -> f32 {
+    let off = clamp(minors / max(trace, 1e-6), 0.0, trace);
+
+    return off + (trace - off) * BC7_ESTIMATE_INDEX / (steps * steps);
+}
+
+fn bc7_estimate_line3(xx: f32, xy: f32, xz: f32, yy: f32, yz: f32, zz: f32, steps: f32) -> f32 {
+    return bc7_estimate_line(
+        xx + yy + zz,
+        xx * yy - xy * xy + xx * zz - xz * xz + yy * zz - yz * yz,
+        steps
+    );
+}
+
+fn bc7_estimate_line4(c: array<f32, 10>, steps: f32) -> f32 {
+    return bc7_estimate_line(
+        c[0] + c[4] + c[7] + c[9],
+        c[0] * c[4] - c[1] * c[1] + c[0] * c[7] - c[2] * c[2] + c[0] * c[9] - c[3] * c[3]
+            + c[4] * c[7] - c[5] * c[5] + c[4] * c[9] - c[6] * c[6] + c[7] * c[9] - c[8] * c[8],
+        steps
+    );
+}
+
+// a palette entry as the decoder computes it from eight-bit ends: an index's weight out of 64 is
+// round(64 i / steps), which is BC7's own table for two-, three- and four-bit indices
+fn bc7_palette_entry(e0: vec4<f32>, e1: vec4<f32>, index: f32, steps: f32) -> vec4<f32> {
+    let w = round(index * 64.0 / steps);
+
+    return floor((e0 * (64.0 - w) + e1 * w + 32.0) / 64.0);
+}
+
+// the index a texel projects to on the line between the ends, of steps + 1 evenly spaced
+fn bc7_projected_index(e0: vec4<f32>, e1: vec4<f32>, texel: vec4<f32>, steps: f32) -> f32 {
+    let direction = e1 - e0;
+    let span = dot(direction, direction);
+
+    if (span > 0.0) {
+        return clamp(round(dot(texel - e0, direction) / span * steps), 0.0, steps);
+    }
+
+    return 0.0;
+}
+
+// the index whose palette entry is nearest a texel: the projection's, or one beside it
+fn bc7_nearest_index(e0: vec4<f32>, e1: vec4<f32>, texel: vec4<f32>, steps: f32) -> u32 {
+    let estimate = bc7_projected_index(e0, e1, texel, steps);
+
+    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, steps);
+
+        let delta = bc7_palette_entry(e0, e1, candidate, steps) - texel;
+        let distance = dot(delta, delta);
+
+        if (distance < best_distance) {
+            best_distance = distance;
+            best = candidate;
+        }
+    }
+
+    return u32(best);
+}
+
+// an end rounded to what a mode stores, \`bits\` a channel with the parity as the lowest, and widened
+// back to the eight bits the decoder interpolates, by its bit replication
+fn bc7_quantise_end(e: vec4<f32>, bits: u32, parity: u32) -> vec4<f32> {
+    let top = f32((1u << bits) - 1u);
+    let p = f32(parity);
+
+    let code = clamp(
+        round((clamp(e, vec4<f32>(0.0), vec4<f32>(255.0)) * (top / 255.0) - p) * 0.5) * 2.0 + p,
+        vec4<f32>(p),
+        vec4<f32>(top - 1.0 + p)
+    );
+
+    let q = vec4<u32>(code);
+
+    return vec4<f32>((q << vec4<u32>(8u - bits)) | (q >> vec4<u32>(2u * bits - 8u)));
+}
+
+fn bc7_encode_block(texels: array<vec4<f32>, 16>) -> vec4<u32> {
+    var packed: array<u32, 16>;
+
+    var mean = vec4<f32>(0.0);
+
+    // what mode 1, which decodes opaque, costs in alpha
+    var alpha_error = 0.0;
+
+    for (var i = 0u; i < 16u; i++) {
+        packed[i] = pack4x8unorm(texels[i]);
+
+        let v = bc7_block_texel(packed[i]);
+
+        mean += v;
+        alpha_error += (255.0 - v.w) * (255.0 - v.w);
+    }
+
+    mean = mean / 16.0;
+
+    var block = array<f32, 10>(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+
+    // the texels' colour about the block's mean, held for the sixty-four partitions
+    var offsets: array<vec3<f32>, 16>;
+
+    for (var i = 0u; i < 16u; i++) {
+        let d = bc7_block_texel(packed[i]) - mean;
+
+        offsets[i] = d.xyz;
+
+        let t = bc7_scatter_terms(d);
+
+        for (var k = 0u; k < 10u; k++) {
+            block[k] += t[k];
+        }
+    }
+
+    // mode 6: one line through all four channels, sixteen levels on it
+    let estimate6 = bc7_estimate_line4(block, 15.0) + BC7_ESTIMATE_END_6;
+
+    // mode 1: two lines through the colour, eight levels on each, over every partition. The second
+    // subset's sums are taken over its texels — the same texels in every invocation, so the branch
+    // does not diverge — and the first's are the block's less the second's
+    var estimate1 = 1e30;
+    var pattern = 0u;
+    var second = Bc7Subset(vec3<f32>(0.0), 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+
+    for (var p = 0u; p < 64u; p++) {
+        let mask = bc7_partition_2_mask(p);
+
+        var s = Bc7Subset(vec3<f32>(0.0), 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+
+        for (var i = 0u; i < 16u; i++) {
+            if (((mask >> i) & 1u) != 0u) {
+                let d = offsets[i];
+
+                s.sum += d;
+                s.c00 += d.x * d.x;
+                s.c01 += d.x * d.y;
+                s.c02 += d.x * d.z;
+                s.c11 += d.y * d.y;
+                s.c12 += d.y * d.z;
+                s.c22 += d.z * d.z;
+            }
+        }
+
+        let n1 = f32(countOneBits(mask));
+
+        // each subset's scatter about its own mean: the second's sum, negated, is the first's
+        let m1 = s.sum / n1;
+        let m0 = s.sum / (16.0 - n1);
+
+        let estimate = BC7_ESTIMATE_END_1
+            + bc7_estimate_line3(
+                s.c00 - s.sum.x * m1.x, s.c01 - s.sum.x * m1.y, s.c02 - s.sum.x * m1.z,
+                s.c11 - s.sum.y * m1.y, s.c12 - s.sum.y * m1.z,
+                s.c22 - s.sum.z * m1.z,
+                7.0
+            )
+            + bc7_estimate_line3(
+                block[0] - s.c00 - s.sum.x * m0.x,
+                block[1] - s.c01 - s.sum.x * m0.y,
+                block[2] - s.c02 - s.sum.x * m0.z,
+                block[4] - s.c11 - s.sum.y * m0.y,
+                block[5] - s.c12 - s.sum.y * m0.z,
+                block[7] - s.c22 - s.sum.z * m0.z,
+                7.0
+            );
+
+        if (estimate < estimate1) {
+            estimate1 = estimate;
+            pattern = p;
+            second = s;
+        }
+    }
+
+    return bc7_encode_fit(packed, mean, block, estimate1 + alpha_error < estimate6, pattern, second);
+}
+
+// fit and write the chosen mode: one or two lines, each through its subset, by the same steps for
+// both modes so a group of invocations holding both runs one fit
+fn bc7_encode_fit(
+    packed: array<u32, 16>,
+    block_mean: vec4<f32>,
+    block_scatter: array<f32, 10>,
+    two: bool,
+    pattern: u32,
+    second: Bc7Subset
+) -> vec4<u32> {
+    let mask = select(0u, bc7_partition_2_mask(pattern), two);
+    let anchor = select(0u, bc7_partition_2_anchor(pattern), two);
+
+    let steps = select(15.0, 7.0, two);
+    let bits = select(8u, 7u, two);
+
+    // mode 1 decodes opaque: its fit sees every texel as opaque, which leaves alpha out of it
+    let held = select(vec4<f32>(1.0), vec4<f32>(1.0, 1.0, 1.0, 0.0), two);
+    let opaque = select(vec4<f32>(0.0), vec4<f32>(0.0, 0.0, 0.0, 255.0), two);
+
+    // each subset's mean and scatter about it, from the second subset's sums; mode 6 has no second
+    let n1 = f32(countOneBits(mask));
+    let n0 = 16.0 - n1;
+
+    let k = select(0.0, 1.0, two);
+
+    let s = second.sum * k;
+
+    let q = array<f32, 6>(
+        second.c00 * k, second.c01 * k, second.c02 * k,
+        second.c11 * k, second.c12 * k,
+        second.c22 * k
+    );
+
+    let m1 = s / max(n1, 1.0);
+    let m0 = s / n0;
+
+    let mean0 = block_mean * held + opaque - vec4<f32>(m0, 0.0);
+    let mean1 = block_mean * held + opaque + vec4<f32>(m1, 0.0);
+
+    let c0 = array<f32, 10>(
+        block_scatter[0] - q[0] - s.x * m0.x,
+        block_scatter[1] - q[1] - s.x * m0.y,
+        block_scatter[2] - q[2] - s.x * m0.z,
+        block_scatter[3] * held.w,
+        block_scatter[4] - q[3] - s.y * m0.y,
+        block_scatter[5] - q[4] - s.y * m0.z,
+        block_scatter[6] * held.w,
+        block_scatter[7] - q[5] - s.z * m0.z,
+        block_scatter[8] * held.w,
+        block_scatter[9] * held.w
+    );
+
+    let c1 = array<f32, 10>(
+        q[0] - s.x * m1.x, q[1] - s.x * m1.y, q[2] - s.x * m1.z, 0.0,
+        q[3] - s.y * m1.y, q[4] - s.y * m1.z, 0.0,
+        q[5] - s.z * m1.z, 0.0,
+        0.0
+    );
+
+    let axis0 = bc7_principal_axis(c0);
+    let axis1 = bc7_principal_axis(c1);
+
+    // each subset's extreme projections onto its axis
+    var low = vec2<f32>(1e30);
+    var high = vec2<f32>(-1e30);
+
+    for (var i = 0u; i < 16u; i++) {
+        let in_second = ((mask >> i) & 1u) != 0u;
+        let texel = bc7_block_texel(packed[i]) * held + opaque;
+
+        let t = dot(texel - select(mean0, mean1, in_second), select(axis0, axis1, in_second));
+
+        low = select(vec2<f32>(min(low.x, t), low.y), vec2<f32>(low.x, min(low.y, t)), in_second);
+        high = select(vec2<f32>(max(high.x, t), high.y), vec2<f32>(high.x, max(high.y, t)), in_second);
+    }
+
+    // a subset with no texels — mode 6's second — gets a point, not an infinite line
+    let empty = high < low;
+
+    low = select(low, vec2<f32>(0.0), empty);
+    high = select(high, vec2<f32>(0.0), empty);
+
+    var a0 = mean0 + axis0 * low.x;
+    var a1 = mean0 + axis0 * high.x;
+    var b0 = mean1 + axis1 * low.y;
+    var b1 = mean1 + axis1 * high.y;
+
+    // one round of least squares per subset, each texel at the weight it projects to
+    var aa = vec2<f32>(0.0);
+    var ab = vec2<f32>(0.0);
+    var bb = vec2<f32>(0.0);
+    var ap0 = vec4<f32>(0.0);
+    var bp0 = vec4<f32>(0.0);
+    var ap1 = vec4<f32>(0.0);
+    var bp1 = vec4<f32>(0.0);
+
+    for (var i = 0u; i < 16u; i++) {
+        let in_second = ((mask >> i) & 1u) != 0u;
+        let texel = bc7_block_texel(packed[i]) * held + opaque;
+
+        let index = bc7_projected_index(select(a0, b0, in_second), select(a1, b1, in_second), texel, steps);
+
+        let wb = round(index * 64.0 / steps) / 64.0;
+        let wa = 1.0 - wb;
+
+        let into = select(vec2<f32>(1.0, 0.0), vec2<f32>(0.0, 1.0), in_second);
+
+        aa += into * (wa * wa);
+        ab += into * (wa * wb);
+        bb += into * (wb * wb);
+
+        ap0 += texel * (wa * into.x);
+        bp0 += texel * (wb * into.x);
+        ap1 += texel * (wa * into.y);
+        bp1 += texel * (wb * into.y);
+    }
+
+    let determinant = aa * bb - ab * ab;
+
+    if (abs(determinant.x) >= 1e-6) {
+        a0 = (bb.x * ap0 - ab.x * bp0) / determinant.x;
+        a1 = (aa.x * bp0 - ab.x * ap0) / determinant.x;
+    }
+
+    if (abs(determinant.y) >= 1e-6) {
+        b0 = (bb.y * ap1 - ab.y * bp1) / determinant.y;
+        b1 = (aa.y * bp1 - ab.y * ap1) / determinant.y;
+    }
+
+    // the parities, by what each combination adds to the least squares' error without a pass over the
+    // texels: at its optimum the error grows by aa |d0|² + 2 ab d0·d1 + bb |d1|² for ends moved by d0
+    // and d1. Mode 1 shares one parity between a subset's two ends
+    var best = vec2<f32>(1e30);
+
+    var qa0 = vec4<f32>(0.0);
+    var qa1 = vec4<f32>(0.0);
+    var qb0 = vec4<f32>(0.0);
+    var qb1 = vec4<f32>(0.0);
+
+    for (var combination = 0u; combination < 4u; combination++) {
+        let p0 = combination & 1u;
+        let p1 = combination >> 1u;
+
+        let ca0 = bc7_quantise_end(a0, bits, p0) * held + opaque;
+        let ca1 = bc7_quantise_end(a1, bits, p1) * held + opaque;
+        let cb0 = bc7_quantise_end(b0, bits, p0) * held + opaque;
+        let cb1 = bc7_quantise_end(b1, bits, p1) * held + opaque;
+
+        let da0 = (ca0 - a0) * held;
+        let da1 = (ca1 - a1) * held;
+        let db0 = (cb0 - b0) * held;
+        let db1 = (cb1 - b1) * held;
+
+        let error = vec2<f32>(
+            aa.x * dot(da0, da0) + 2.0 * ab.x * dot(da0, da1) + bb.x * dot(da1, da1),
+            aa.y * dot(db0, db0) + 2.0 * ab.y * dot(db0, db1) + bb.y * dot(db1, db1)
+        ) + select(vec2<f32>(0.0), vec2<f32>(1e30), two && p0 != p1);
+
+        if (error.x < best.x) {
+            best.x = error.x;
+            qa0 = ca0;
+            qa1 = ca1;
+        }
+
+        if (error.y < best.y) {
+            best.y = error.y;
+            qb0 = cb0;
+            qb1 = cb1;
+        }
+    }
+
+    // each texel's nearest entry of its subset's palette
+    var indices: array<u32, 16>;
+
+    for (var i = 0u; i < 16u; i++) {
+        let in_second = ((mask >> i) & 1u) != 0u;
+        let texel = bc7_block_texel(packed[i]) * held + opaque;
+
+        indices[i] = bc7_nearest_index(select(qa0, qb0, in_second), select(qa1, qb1, in_second), texel, steps);
+    }
+
+    // the anchors, texel 0 and the second subset's, are stored a bit short: a subset whose anchor
+    // lands in the upper half is written the other way up, which decodes identically
+    let top = u32(steps);
+    let upper = (top + 1u) / 2u;
+
+    var anchor_index = 0u;
+
+    for (var i = 0u; i < 16u; i++) {
+        anchor_index = select(anchor_index, indices[i], i == anchor);
+    }
+
+    let flip0 = indices[0] >= upper;
+    let flip1 = two && anchor_index >= upper;
+
+    for (var i = 0u; i < 16u; i++) {
+        let in_second = ((mask >> i) & 1u) != 0u;
+
+        indices[i] = select(indices[i], top - indices[i], select(flip0, flip1, in_second));
+    }
+
+    let ea0 = select(qa0, qa1, flip0);
+    let ea1 = select(qa1, qa0, flip0);
+    let eb0 = select(qb0, qb1, flip1);
+    let eb1 = select(qb1, qb0, flip1);
+
+    if (two) {
+        return bc7_pack_mode1(pattern, vec3<u32>(ea0.xyz), vec3<u32>(ea1.xyz), vec3<u32>(eb0.xyz), vec3<u32>(eb1.xyz), indices);
+    }
+
+    return bc7_pack_mode6(vec4<u32>(ea0), vec4<u32>(ea1), indices);
+}
+`, [
+        chunk_bc7_partition_2,
+        chunk_bc7_pack_mode1,
+        chunk_bc7_pack_mode6,
+    ]);

package/src/shade/renderer/texture/encode/chunk_bc7_encode_block_mode6.d.ts

@@ -6,29 +6,43 @@
  * 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.
+ * 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. 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.
+ * 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,
- *    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
+ *    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;

package/src/shade/renderer/texture/encode/chunk_bc7_encode_block_mode6.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_bc7_encode_block_mode6.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/chunk_bc7_encode_block_mode6.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,2CAFU,SAAS,CAoSZ;0BAtUmB,oCAAoC"}
+{"version":3,"file":"chunk_bc7_encode_block_mode6.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/chunk_bc7_encode_block_mode6.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,2CAFU,SAAS,CAkPZ;0BAlSmB,oCAAoC"}