@woosh/meep-engine 3.14.2 → 3.14.4

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

@@ -0,0 +1,327 @@
+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,
+    ]);

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

@@ -0,0 +1,22 @@
+/**
+ * One BC7 mode 6 block from its two endpoints and sixteen indices, as four little-endian words.
+ *
+ * The layout `bc7_write_block` states for mode 6, in the same order for every field: seven mode
+ * bits — six zeros and a one — then the colour endpoints by channel, red for both ends, then green,
+ * then blue, seven bits each; alpha likewise; one parity bit per endpoint; then the indices, four
+ * bits each except texel 0's three, because its top bit is implied zero. That last rule is the
+ * encoder's to honour, by swapping the ends when texel 0 lands in the upper half, and this does not
+ * check it.
+ *
+ * Endpoints are given as the eight-bit values they decode to — seven stored bits over the parity
+ * bit — so the parity is read off them rather than passed beside them, and a caller cannot hand in
+ * a pair that disagrees with itself.
+ *
+ * Bit by bit, as the JavaScript writer is, because the fields straddle word boundaries and a
+ * hundred and twenty-eight iterations are nothing.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bc7_pack_mode6: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_bc7_pack_mode6.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_bc7_pack_mode6.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/chunk_bc7_pack_mode6.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,mCAFU,SAAS,CAmDhB;0BAtEuB,oCAAoC"}

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

@@ -0,0 +1,71 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * One BC7 mode 6 block from its two endpoints and sixteen indices, as four little-endian words.
+ *
+ * The layout `bc7_write_block` states for mode 6, in the same order for every field: seven mode
+ * bits — six zeros and a one — then the colour endpoints by channel, red for both ends, then green,
+ * then blue, seven bits each; alpha likewise; one parity bit per endpoint; then the indices, four
+ * bits each except texel 0's three, because its top bit is implied zero. That last rule is the
+ * encoder's to honour, by swapping the ends when texel 0 lands in the upper half, and this does not
+ * check it.
+ *
+ * Endpoints are given as the eight-bit values they decode to — seven stored bits over the parity
+ * bit — so the parity is read off them rather than passed beside them, and a caller cannot hand in
+ * a pair that disagrees with itself.
+ *
+ * Bit by bit, as the JavaScript writer is, because the fields straddle word boundaries and a
+ * hundred and twenty-eight iterations are nothing.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bc7_pack_mode6 = CodeChunk.from(
+    //language=WGSL
+    `
+fn bc7_pack_mode6(e0: vec4<u32>, e1: vec4<u32>, indices: array<u32, 16>) -> vec4<u32> {
+    var values: array<u32, 27>;
+    var counts: array<u32, 27>;
+
+    // mode 6 is signalled by six zero bits and then a one
+    values[0] = 64u;
+    counts[0] = 7u;
+
+    for (var channel = 0u; channel < 4u; channel++) {
+        values[1u + channel * 2u] = e0[channel] >> 1u;
+        values[2u + channel * 2u] = e1[channel] >> 1u;
+        counts[1u + channel * 2u] = 7u;
+        counts[2u + channel * 2u] = 7u;
+    }
+
+    values[9] = e0.x & 1u;
+    values[10] = e1.x & 1u;
+    counts[9] = 1u;
+    counts[10] = 1u;
+
+    for (var texel = 0u; texel < 16u; texel++) {
+        values[11u + texel] = indices[texel];
+        counts[11u + texel] = select(4u, 3u, texel == 0u);
+    }
+
+    var words = array<u32, 4>(0u, 0u, 0u, 0u);
+
+    var bit = 0u;
+
+    for (var field = 0u; field < 27u; field++) {
+        let value = values[field];
+        let count = counts[field];
+
+        for (var k = 0u; k < count; k++) {
+            if (((value >> k) & 1u) != 0u) {
+                let at = bit + k;
+
+                words[at >> 5u] |= 1u << (at & 31u);
+            }
+        }
+
+        bit += count;
+    }
+
+    return vec4<u32>(words[0], words[1], words[2], words[3]);
+}
+`);

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

@@ -0,0 +1,20 @@
+/**
+ * Reads the level table {@link texture_encode_level_table} writes, from a binding named
+ * `encode_levels`.
+ *
+ * **Every level in one dispatch.** The alternative — one dispatch per level, each told where it is
+ * through a uniform or immediate — spends a whole pass on the 1x1 tail of a chain, and needs
+ * per-dispatch state this deliberately has none of: a shader with no immediates and no uniforms runs
+ * wherever a storage buffer binds, which includes a device offering no immediate data at all. So the
+ * flat block index is the only coordinate an invocation is given, and this turns it into a level and
+ * a position within it. The scan is linear because a chain has at most fourteen levels and the
+ * records are read from a buffer either way.
+ *
+ * The word positions are the JavaScript constants, interpolated — the reader and the writer share
+ * one statement of the table.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_texture_encode_level: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_texture_encode_level.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_texture_encode_level.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/chunk_texture_encode_level.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;GAgBG;AACH,yCAFU,SAAS,CAkDhB;0BAxEuB,oCAAoC"}

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

@@ -0,0 +1,73 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import {
+    TEXTURE_ENCODE_LEVEL_TABLE_HEADER_WORDS,
+    TEXTURE_ENCODE_LEVEL_TABLE_RECORD_WORDS,
+    TextureEncodeLevelWord
+} from "./texture_encode_layout.js";
+
+/**
+ * Reads the level table {@link texture_encode_level_table} writes, from a binding named
+ * `encode_levels`.
+ *
+ * **Every level in one dispatch.** The alternative — one dispatch per level, each told where it is
+ * through a uniform or immediate — spends a whole pass on the 1x1 tail of a chain, and needs
+ * per-dispatch state this deliberately has none of: a shader with no immediates and no uniforms runs
+ * wherever a storage buffer binds, which includes a device offering no immediate data at all. So the
+ * flat block index is the only coordinate an invocation is given, and this turns it into a level and
+ * a position within it. The scan is linear because a chain has at most fourteen levels and the
+ * records are read from a buffer either way.
+ *
+ * The word positions are the JavaScript constants, interpolated — the reader and the writer share
+ * one statement of the table.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_texture_encode_level = CodeChunk.from(
+    //language=WGSL
+    `
+struct TextureEncodeLevel {
+    mip: u32,
+    width: u32,
+    height: u32,
+    blocks_x: u32,
+    blocks_y: u32,
+    first_block: u32,
+    word_offset: u32,
+    row_stride_words: u32,
+}
+
+fn texture_encode_block_count() -> u32 {
+    return encode_levels[${TextureEncodeLevelWord.BLOCK_COUNT}u];
+}
+
+fn texture_encode_level_of_block(block: u32) -> TextureEncodeLevel {
+    let level_count = encode_levels[${TextureEncodeLevelWord.LEVEL_COUNT}u];
+
+    // records are in mip order, so first_block ascends: the level is the last one starting at or
+    // before this block
+    var index = 0u;
+
+    for (var i = 1u; i < level_count; i++) {
+        let first_block = encode_levels[${TEXTURE_ENCODE_LEVEL_TABLE_HEADER_WORDS}u + i * ${TEXTURE_ENCODE_LEVEL_TABLE_RECORD_WORDS}u + ${TextureEncodeLevelWord.FIRST_BLOCK}u];
+
+        if (block >= first_block) {
+            index = i;
+        }
+    }
+
+    let base = ${TEXTURE_ENCODE_LEVEL_TABLE_HEADER_WORDS}u + index * ${TEXTURE_ENCODE_LEVEL_TABLE_RECORD_WORDS}u;
+
+    var level: TextureEncodeLevel;
+
+    level.mip = encode_levels[base + ${TextureEncodeLevelWord.MIP}u];
+    level.width = encode_levels[base + ${TextureEncodeLevelWord.WIDTH}u];
+    level.height = encode_levels[base + ${TextureEncodeLevelWord.HEIGHT}u];
+    level.blocks_x = encode_levels[base + ${TextureEncodeLevelWord.BLOCKS_X}u];
+    level.blocks_y = encode_levels[base + ${TextureEncodeLevelWord.BLOCKS_Y}u];
+    level.first_block = encode_levels[base + ${TextureEncodeLevelWord.FIRST_BLOCK}u];
+    level.word_offset = encode_levels[base + ${TextureEncodeLevelWord.WORD_OFFSET}u];
+    level.row_stride_words = encode_levels[base + ${TextureEncodeLevelWord.ROW_STRIDE_WORDS}u];
+
+    return level;
+}
+`);

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

@@ -0,0 +1,16 @@
+/**
+ * The sixteen texels of one 4x4 block of one level, from a binding named `encode_source`.
+ *
+ * A level whose extent is not a multiple of four has partial blocks along its right and bottom
+ * edges. The texels past the edge are the edge texel repeated — `textureLoad` outside the level
+ * would return zero, and fitting a block against zeros it never contains would pull its endpoints
+ * towards black for texels nobody samples. Repeating the edge keeps every partial block's fit about
+ * the texels that exist.
+ *
+ * In raster order, texel `i` at `(i % 4, i / 4)` — the order every BC block stores its indices in.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_texture_encode_load_block: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_texture_encode_load_block.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_texture_encode_load_block.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/chunk_texture_encode_load_block.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,8CAFU,SAAS,CAqBZ;0BAnCmB,oCAAoC"}

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

@@ -0,0 +1,36 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_texture_encode_level } from "./chunk_texture_encode_level.js";
+
+/**
+ * The sixteen texels of one 4x4 block of one level, from a binding named `encode_source`.
+ *
+ * A level whose extent is not a multiple of four has partial blocks along its right and bottom
+ * edges. The texels past the edge are the edge texel repeated — `textureLoad` outside the level
+ * would return zero, and fitting a block against zeros it never contains would pull its endpoints
+ * towards black for texels nobody samples. Repeating the edge keeps every partial block's fit about
+ * the texels that exist.
+ *
+ * In raster order, texel `i` at `(i % 4, i / 4)` — the order every BC block stores its indices in.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_texture_encode_load_block = CodeChunk.from(
+    //language=WGSL
+    `
+fn texture_encode_load_block(level: TextureEncodeLevel, block_x: u32, block_y: u32) -> array<vec4<f32>, 16> {
+    var texels: array<vec4<f32>, 16>;
+
+    let last = vec2<i32>(i32(level.width) - 1, i32(level.height) - 1);
+    let origin = vec2<i32>(i32(block_x * 4u), i32(block_y * 4u));
+
+    for (var i = 0u; i < 16u; i++) {
+        let offset = vec2<i32>(i32(i & 3u), i32(i >> 2u));
+
+        texels[i] = textureLoad(encode_source, min(origin + offset, last), i32(level.mip));
+    }
+
+    return texels;
+}
+`, [
+        chunk_texture_encode_level,
+    ]);

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

@@ -0,0 +1,13 @@
+/**
+ * Every level of a texture to `astc-4x4-unorm` or its sRGB twin, one invocation per block.
+ *
+ * The RGB of whatever `encode_source` samples as, fitted by {@link chunk_astc_encode_block_4x4_rgb}
+ * into the one-partition, colour-endpoint-mode-8 block this tree reads. Alpha is not read: that
+ * mode carries none. The dispatch shape is {@link shader_texture_encode_bc4}'s; a block is four
+ * words.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_texture_encode_astc_4x4: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_texture_encode_astc_4x4.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_texture_encode_astc_4x4.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/shader_texture_encode_astc_4x4.js"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AACH,6CAFU,aAAa,CA+CpB;8BA7D2B,+BAA+B"}

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

@@ -0,0 +1,63 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { chunk_astc_encode_block_4x4_rgb } from "./chunk_astc_encode_block_4x4_rgb.js";
+import { chunk_texture_encode_load_block } from "./chunk_texture_encode_load_block.js";
+import { TEXTURE_ENCODE_WORKGROUP_SIZE } from "./shader_texture_encode_bc4.js";
+import { texture_encode_resources } from "./texture_encode_resources.js";
+
+/**
+ * Every level of a texture to `astc-4x4-unorm` or its sRGB twin, one invocation per block.
+ *
+ * The RGB of whatever `encode_source` samples as, fitted by {@link chunk_astc_encode_block_4x4_rgb}
+ * into the one-partition, colour-endpoint-mode-8 block this tree reads. Alpha is not read: that
+ * mode carries none. The dispatch shape is {@link shader_texture_encode_bc4}'s; a block is four
+ * words.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_texture_encode_astc_4x4 = ComputeShader.from({
+    label: 'texture_encode/astc-4x4-unorm',
+    resources: texture_encode_resources(),
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${TEXTURE_ENCODE_WORKGROUP_SIZE}, 1, 1)
+fn main(
+    @builtin(global_invocation_id) gid: vec3<u32>,
+    @builtin(num_workgroups) groups: vec3<u32>,
+) {
+    let block = gid.y * groups.x * ${TEXTURE_ENCODE_WORKGROUP_SIZE}u + gid.x;
+
+    if (block >= texture_encode_block_count()) {
+        return;
+    }
+
+    let level = texture_encode_level_of_block(block);
+
+    let local = block - level.first_block;
+
+    let block_x = local % level.blocks_x;
+    let block_y = local / level.blocks_x;
+
+    let texels = texture_encode_load_block(level, block_x, block_y);
+
+    var rgb: array<vec3<f32>, 16>;
+
+    for (var i = 0u; i < 16u; i++) {
+        rgb[i] = texels[i].xyz;
+    }
+
+    let packed = astc_encode_block_4x4_rgb(rgb);
+
+    let word = level.word_offset + block_y * level.row_stride_words + block_x * 4u;
+
+    encode_output[word] = packed.x;
+    encode_output[word + 1u] = packed.y;
+    encode_output[word + 2u] = packed.z;
+    encode_output[word + 3u] = packed.w;
+}
+`, [
+            chunk_texture_encode_load_block,
+            chunk_astc_encode_block_4x4_rgb,
+        ]),
+});

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

@@ -0,0 +1,12 @@
+/**
+ * Every level of a texture to `bc1-rgba-unorm` or its sRGB twin, one invocation per block.
+ *
+ * The RGB of whatever `encode_source` samples as, fitted by {@link chunk_bc1_encode_block}. Alpha is
+ * not read: BC1's only alpha is the three-colour mode's transparent black, which the encoder never
+ * writes. The dispatch shape is {@link shader_texture_encode_bc4}'s.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_texture_encode_bc1: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_texture_encode_bc1.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_texture_encode_bc1.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/shader_texture_encode_bc1.js"],"names":[],"mappings":"AAOA;;;;;;;;GAQG;AACH,wCAFU,aAAa,CA6CpB;8BA1D2B,+BAA+B"}