@woosh/meep-engine 3.14.2 → 3.14.3

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

@@ -0,0 +1,60 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { chunk_bc1_encode_block } from "./chunk_bc1_encode_block.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 `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.from({
+    label: 'texture_encode/bc1-rgba-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 = bc1_encode_block(rgb);
+
+    let word = level.word_offset + block_y * level.row_stride_words + block_x * 2u;
+
+    encode_output[word] = packed.x;
+    encode_output[word + 1u] = packed.y;
+}
+`, [
+            chunk_texture_encode_load_block,
+            chunk_bc1_encode_block,
+        ]),
+});

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

@@ -0,0 +1,28 @@
+/**
+ * Invocations per workgroup, one block each.
+ *
+ * Sixty-four is a multiple of every subgroup width in the field, and small enough that a block's
+ * sixteen texels and its candidate scores stay in registers without starving occupancy — the same
+ * choice `BC7Encode.hlsl` and betsy make for their one-block-per-lane passes.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const TEXTURE_ENCODE_WORKGROUP_SIZE: number;
+/**
+ * Every level of a texture to `bc4-r-unorm`, one invocation per block.
+ *
+ * The red channel of whatever `encode_source` samples as, fitted by {@link chunk_bc4_encode_block}
+ * and written to `encode_output` at the padded position {@link texture_encode_layout} assigned the
+ * block. The level table says which level a flat block index belongs to, so one dispatch covers the
+ * whole chain and the shader carries no per-dispatch state at all — no immediates, no uniforms.
+ *
+ * The grid is two-dimensional because one dimension is capped at
+ * `maxComputeWorkgroupsPerDimension`: workgroup `(x, y)` starts at block `(y * groups_x + x) * 64`,
+ * and the invocations past the last block return before touching anything.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_texture_encode_bc4: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_texture_encode_bc4.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_texture_encode_bc4.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/shader_texture_encode_bc4.js"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,4CAFU,MAAM,CAEgC;AAEhD;;;;;;;;;;;;;GAaG;AACH,wCAFU,aAAa,CA6CpB;8BA1E2B,+BAA+B"}

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

@@ -0,0 +1,76 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { chunk_bc4_encode_block } from "./chunk_bc4_encode_block.js";
+import { chunk_texture_encode_load_block } from "./chunk_texture_encode_load_block.js";
+import { texture_encode_resources } from "./texture_encode_resources.js";
+
+/**
+ * Invocations per workgroup, one block each.
+ *
+ * Sixty-four is a multiple of every subgroup width in the field, and small enough that a block's
+ * sixteen texels and its candidate scores stay in registers without starving occupancy — the same
+ * choice `BC7Encode.hlsl` and betsy make for their one-block-per-lane passes.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const TEXTURE_ENCODE_WORKGROUP_SIZE = 64;
+
+/**
+ * Every level of a texture to `bc4-r-unorm`, one invocation per block.
+ *
+ * The red channel of whatever `encode_source` samples as, fitted by {@link chunk_bc4_encode_block}
+ * and written to `encode_output` at the padded position {@link texture_encode_layout} assigned the
+ * block. The level table says which level a flat block index belongs to, so one dispatch covers the
+ * whole chain and the shader carries no per-dispatch state at all — no immediates, no uniforms.
+ *
+ * The grid is two-dimensional because one dimension is capped at
+ * `maxComputeWorkgroupsPerDimension`: workgroup `(x, y)` starts at block `(y * groups_x + x) * 64`,
+ * and the invocations past the last block return before touching anything.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_texture_encode_bc4 = ComputeShader.from({
+    label: 'texture_encode/bc4-r-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 red: array<f32, 16>;
+
+    for (var i = 0u; i < 16u; i++) {
+        red[i] = texels[i].x;
+    }
+
+    let packed = bc4_encode_block(red);
+
+    let word = level.word_offset + block_y * level.row_stride_words + block_x * 2u;
+
+    encode_output[word] = packed.x;
+    encode_output[word + 1u] = packed.y;
+}
+`, [
+            chunk_texture_encode_load_block,
+            chunk_bc4_encode_block,
+        ]),
+});

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

@@ -0,0 +1,16 @@
+/**
+ * Every level of a texture to `bc4-r-snorm`, one invocation per block.
+ *
+ * **A separate path, not a tag.** The signed format stores its endpoints as two's-complement bytes
+ * and the decoder interpolates them as signed values over `[-127, 127]`, with `-128` read as
+ * `-127` and the six-value mode's hard entries at `-1` and `+1` — so the same encoder fits the same
+ * line in a different domain, which {@link chunk_bc4_encode_block} takes as its bounds. The source
+ * is read as the sampler delivers a signed format, in `[-1, 1]`, so an `r8snorm` texture encodes
+ * without a conversion in between; a unorm source re-quantised to signed loses a level of precision
+ * and is the caller's decision, not this shader's.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_texture_encode_bc4_snorm: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_texture_encode_bc4_snorm.d.ts.map

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

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

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

@@ -0,0 +1,64 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { chunk_bc4_encode_block } from "./chunk_bc4_encode_block.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 `bc4-r-snorm`, one invocation per block.
+ *
+ * **A separate path, not a tag.** The signed format stores its endpoints as two's-complement bytes
+ * and the decoder interpolates them as signed values over `[-127, 127]`, with `-128` read as
+ * `-127` and the six-value mode's hard entries at `-1` and `+1` — so the same encoder fits the same
+ * line in a different domain, which {@link chunk_bc4_encode_block} takes as its bounds. The source
+ * is read as the sampler delivers a signed format, in `[-1, 1]`, so an `r8snorm` texture encodes
+ * without a conversion in between; a unorm source re-quantised to signed loses a level of precision
+ * and is the caller's decision, not this shader's.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_texture_encode_bc4_snorm = ComputeShader.from({
+    label: 'texture_encode/bc4-r-snorm',
+    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 red: array<f32, 16>;
+
+    for (var i = 0u; i < 16u; i++) {
+        red[i] = texels[i].x;
+    }
+
+    let packed = bc4_encode_block_snorm(red);
+
+    let word = level.word_offset + block_y * level.row_stride_words + block_x * 2u;
+
+    encode_output[word] = packed.x;
+    encode_output[word + 1u] = packed.y;
+}
+`, [
+            chunk_texture_encode_load_block,
+            chunk_bc4_encode_block,
+        ]),
+});

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

@@ -0,0 +1,14 @@
+/**
+ * Every level of a texture to `bc5-rg-unorm`, one invocation per block.
+ *
+ * **Two BC4 blocks, red then green**, each fitted by {@link chunk_bc4_encode_block} on its own —
+ * which is the whole of BC5, and the reason it is the format for a tangent-space normal map: two
+ * independent scalar channels, no line through colour space to place, and `chunk_decode_tangent_normal`
+ * rebuilding Z from the pair. The dispatch shape is {@link shader_texture_encode_bc4}'s; a block is
+ * four words rather than two.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_texture_encode_bc5: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_texture_encode_bc5.d.ts.map

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

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

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

@@ -0,0 +1,67 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { chunk_bc4_encode_block } from "./chunk_bc4_encode_block.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 `bc5-rg-unorm`, one invocation per block.
+ *
+ * **Two BC4 blocks, red then green**, each fitted by {@link chunk_bc4_encode_block} on its own —
+ * which is the whole of BC5, and the reason it is the format for a tangent-space normal map: two
+ * independent scalar channels, no line through colour space to place, and `chunk_decode_tangent_normal`
+ * rebuilding Z from the pair. The dispatch shape is {@link shader_texture_encode_bc4}'s; a block is
+ * four words rather than two.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_texture_encode_bc5 = ComputeShader.from({
+    label: 'texture_encode/bc5-rg-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 red: array<f32, 16>;
+    var green: array<f32, 16>;
+
+    for (var i = 0u; i < 16u; i++) {
+        red[i] = texels[i].x;
+        green[i] = texels[i].y;
+    }
+
+    let red_block = bc4_encode_block(red);
+    let green_block = bc4_encode_block(green);
+
+    let word = level.word_offset + block_y * level.row_stride_words + block_x * 4u;
+
+    encode_output[word] = red_block.x;
+    encode_output[word + 1u] = red_block.y;
+    encode_output[word + 2u] = green_block.x;
+    encode_output[word + 3u] = green_block.y;
+}
+`, [
+            chunk_texture_encode_load_block,
+            chunk_bc4_encode_block,
+        ]),
+});

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

@@ -0,0 +1,10 @@
+/**
+ * Every level of a texture to `bc5-rg-snorm`, one invocation per block: two signed BC4 blocks, red
+ * then green. See {@link shader_texture_encode_bc4_snorm} for what signed changes, and
+ * {@link shader_texture_encode_bc5} for what it does not.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_texture_encode_bc5_snorm: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_texture_encode_bc5_snorm.d.ts.map

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

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

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

@@ -0,0 +1,63 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { chunk_bc4_encode_block } from "./chunk_bc4_encode_block.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 `bc5-rg-snorm`, one invocation per block: two signed BC4 blocks, red
+ * then green. See {@link shader_texture_encode_bc4_snorm} for what signed changes, and
+ * {@link shader_texture_encode_bc5} for what it does not.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_texture_encode_bc5_snorm = ComputeShader.from({
+    label: 'texture_encode/bc5-rg-snorm',
+    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 red: array<f32, 16>;
+    var green: array<f32, 16>;
+
+    for (var i = 0u; i < 16u; i++) {
+        red[i] = texels[i].x;
+        green[i] = texels[i].y;
+    }
+
+    let red_block = bc4_encode_block_snorm(red);
+    let green_block = bc4_encode_block_snorm(green);
+
+    let word = level.word_offset + block_y * level.row_stride_words + block_x * 4u;
+
+    encode_output[word] = red_block.x;
+    encode_output[word + 1u] = red_block.y;
+    encode_output[word + 2u] = green_block.x;
+    encode_output[word + 3u] = green_block.y;
+}
+`, [
+            chunk_texture_encode_load_block,
+            chunk_bc4_encode_block,
+        ]),
+});

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

@@ -0,0 +1,12 @@
+/**
+ * Every level of an HDR texture to `bc6h-rgb-ufloat`, one invocation per block.
+ *
+ * The RGB of whatever `encode_source` samples as — an `rgba16float` texture, in practice — fitted
+ * by {@link chunk_bc6h_encode_block_mode11}. Alpha is not read: the format has none. Mode 11 only;
+ * the dispatch shape is {@link shader_texture_encode_bc4}'s and a block is four words.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_texture_encode_bc6h: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_texture_encode_bc6h.d.ts.map

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

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

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

@@ -0,0 +1,62 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { chunk_bc6h_encode_block_mode11 } from "./chunk_bc6h_encode_block_mode11.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 an HDR texture to `bc6h-rgb-ufloat`, one invocation per block.
+ *
+ * The RGB of whatever `encode_source` samples as — an `rgba16float` texture, in practice — fitted
+ * by {@link chunk_bc6h_encode_block_mode11}. Alpha is not read: the format has none. Mode 11 only;
+ * the dispatch shape is {@link shader_texture_encode_bc4}'s and a block is four words.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_texture_encode_bc6h = ComputeShader.from({
+    label: 'texture_encode/bc6h-rgb-ufloat',
+    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 = bc6h_encode_block_mode11(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_bc6h_encode_block_mode11,
+        ]),
+});

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

@@ -0,0 +1,14 @@
+/**
+ * Every level of a texture to `bc7-rgba-unorm` or its sRGB twin, one invocation per block.
+ *
+ * **Mode 6 only**, today: the single-subset mode with the finest indices, fitted by
+ * {@link chunk_bc7_encode_block_mode6} over all four channels. A mode search across the
+ * partitioned modes is a later quality step, and a separate chunk — this shader would call it
+ * instead, and nothing about the format or the bytes it produces changes. The dispatch shape is
+ * {@link shader_texture_encode_bc4}'s; a block is four words.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_texture_encode_bc7: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_texture_encode_bc7.d.ts.map

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

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

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

@@ -0,0 +1,58 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { chunk_bc7_encode_block_mode6 } from "./chunk_bc7_encode_block_mode6.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 `bc7-rgba-unorm` or its sRGB twin, one invocation per block.
+ *
+ * **Mode 6 only**, today: the single-subset mode with the finest indices, fitted by
+ * {@link chunk_bc7_encode_block_mode6} over all four channels. A mode search across the
+ * partitioned modes is a later quality step, and a separate chunk — this shader would call it
+ * instead, and nothing about the format or the bytes it produces changes. The dispatch shape is
+ * {@link shader_texture_encode_bc4}'s; a block is four words.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_texture_encode_bc7 = ComputeShader.from({
+    label: 'texture_encode/bc7-rgba-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);
+
+    let packed = bc7_encode_block_mode6(texels);
+
+    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_bc7_encode_block_mode6,
+        ]),
+});

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

@@ -0,0 +1,84 @@
+/**
+ * What {@link texture_encode} produced.
+ *
+ * @typedef {Object} TextureEncodeResult
+ * @property {GPUTexture} texture the block-compressed texture, every requested level written once
+ * the context is submitted. The caller's, to keep and to destroy
+ * @property {GPUBuffer} blocks the block buffer the encoder wrote and the copies read, laid out as
+ * `layout` says. **Transient**: released back to the context's pool when the context finishes, so
+ * anything wanting the raw blocks — a container writer, a cross-check — copies them out before then
+ * @property {TextureEncodeLayout} layout where each level's blocks sit in `blocks`
+ */
+/**
+ * Encode a sampleable texture into a block-compressed one, on the device.
+ *
+ * **A texture in, a texture out, and nothing about who wants it.** The caller names the target
+ * format outright — `bc4-r-unorm`, `bc7-rgba-unorm-srgb` — and gets a texture in that format with
+ * `level_count` levels, each encoded from the same level of the source. No role, no preference list,
+ * no material: a subsystem that can encode anything to a named format is what the texture manager, a
+ * container writer, a procedural generator and a test can all stand on, and none of those want it to
+ * have opinions about content.
+ *
+ * WebGPU has no writable block-compressed storage texture, so the shape is the plan's §4.4: one
+ * compute dispatch writes every level's blocks into one storage buffer, and one `copyBufferToTexture`
+ * per level moves them into the texture. The buffer is laid out by {@link texture_encode_layout}
+ * with its rows padded to the copy's 256-byte stride before anything runs — the encoder writes to
+ * the stride the copy will read, and each copy is a whole level, sized in whole blocks as the copy
+ * commands count them.
+ *
+ * **The source is read as stored, not as decoded.** An `-srgb` source would arrive through
+ * `textureLoad` already converted to linear, and an encoder fitting those values into bytes that the
+ * sampler will then decode as sRGB again would encode the wrong picture. So an sRGB source is bound
+ * through a view in its linear twin format, which needs the texture to have been created with that
+ * format in its `viewFormats`; the device refuses the view otherwise, by validation error. The
+ * `-srgb`-ness of the *target* is likewise nothing but the tag the texture is created with: the
+ * encoded bytes are identical for both spellings.
+ *
+ * Everything is recorded into `cmd` and nothing runs until it is submitted. The transient buffers
+ * are the context's and go back to its pool when it finishes.
+ *
+ * @param {ShadeGPUCommandContext} cmd
+ * @param {Object} options
+ * @param {GPUTexture} options.source a 2D, single-layer texture with `TEXTURE_BINDING`, holding at
+ * least `level_count` levels
+ * @param {GPUTextureFormat} options.format the target block format, exactly as the texture is to be
+ * created
+ * @param {number} options.level_count how many levels to encode, from level 0 down
+ * @param {GPUTextureUsageFlags} options.usage the target texture's usage; must include `COPY_DST`,
+ * which is how the blocks get in
+ * @param {string} [options.label] for the target texture
+ * @returns {TextureEncodeResult}
+ * @throws {Error} naming the format, for a target this cannot write; naming the source, for one the
+ * encoder cannot read
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function texture_encode(cmd: ShadeGPUCommandContext, { source, format, level_count, usage, label }: {
+    source: GPUTexture;
+    format: GPUTextureFormat;
+    level_count: number;
+    usage: GPUTextureUsageFlags;
+    label?: string;
+}): TextureEncodeResult;
+/**
+ * What {@link texture_encode } produced.
+ */
+export type TextureEncodeResult = {
+    /**
+     * the block-compressed texture, every requested level written once
+     * the context is submitted. The caller's, to keep and to destroy
+     */
+    texture: GPUTexture;
+    /**
+     * the block buffer the encoder wrote and the copies read, laid out as
+     * `layout` says. **Transient**: released back to the context's pool when the context finishes, so
+     * anything wanting the raw blocks — a container writer, a cross-check — copies them out before then
+     */
+    blocks: GPUBuffer;
+    /**
+     * where each level's blocks sit in `blocks`
+     */
+    layout: TextureEncodeLayout;
+};
+//# sourceMappingURL=texture_encode.d.ts.map