@woosh/meep-engine 3.60.8 → 3.60.9

package/src/shade/renderer/material/dispatch/shader_material_dispatch_commands.js

@@ -0,0 +1,83 @@
+import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+import { chunk_folded_dispatch } from "../../gpu_primitive/indirect/chunk_folded_dispatch.js";
+import { chunk_divide_round_up_u32 } from "../../shader/chunk/math/chunk_divide_round_up_u32.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { MATERIAL_DISPATCH_QUADS_PER_GROUP, MATERIAL_DISPATCH_RECORD_STRIDE } from "./MATERIAL_DISPATCH_CONSTANTS.js";
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const MATERIAL_DISPATCH_COMMANDS_SETTINGS_STRUCT = WebGPUStruct.from({
+    tile_count: u32,
+    slot_count: u32,
+}, "MaterialDispatchCommandsSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addStorageBuffer("offsets", COLLECTION_U32_STRUCT_READ)
+    .addStorageBuffer("records", WebGPUArray.u32, true)
+    .addUniform("settings", MATERIAL_DISPATCH_COMMANDS_SETTINGS_STRUCT)
+;
+
+const RECORD_WORDS = MATERIAL_DISPATCH_RECORD_STRIDE / 4;
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(64)
+fn main(
+    @builtin(global_invocation_id) global_id : vec3<u32>,
+) {
+    let slot = global_id.x;
+
+    if (slot >= settings.slot_count) {
+        return;
+    }
+
+    // a material's lists are its tiles', one after another
+    let first = slot * settings.tile_count;
+    let last = first + settings.tile_count - 1u;
+
+    var start = 0u;
+
+    if (first > 0u) {
+        start = offsets.elements[first - 1u];
+    }
+
+    let count = offsets.elements[last] - start;
+
+    let groups = folded_dispatch(divide_round_up_u32(count, ${MATERIAL_DISPATCH_QUADS_PER_GROUP}u));
+
+    let at = slot * ${RECORD_WORDS}u;
+
+    records[at] = groups.x;
+    records[at + 1u] = groups.y;
+    records[at + 2u] = groups.z;
+    records[at + 3u] = start;
+    records[at + 4u] = count;
+}
+`, [
+        chunk_folded_dispatch,
+        chunk_divide_round_up_u32,
+    ]
+);
+
+/**
+ * Write each material's {@link MATERIAL_DISPATCH_RECORD_STRUCT}: its run of the pixel list, from
+ * the inclusive sums of the (material, tile) counts, and the folded workgroup counts its dispatch is
+ * issued with — `(0, 1, 1)` for a material with no pixel on screen. One invocation per material,
+ * dispatched directly over the G-buffer pass's list.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_material_dispatch_commands = ComputeShader.from({
+    label: "Material dispatch / commands",
+    body,
+    resources,
+});

package/src/shade/renderer/material/dispatch/shader_material_pixel_count.d.ts

@@ -0,0 +1,22 @@
+/**
+ * What both classification passes are told of the view and the material list.
+ *
+ * @type {WebGPUStruct}
+ */
+export const MATERIAL_CLASSIFY_SETTINGS_STRUCT: WebGPUStruct;
+/**
+ * Count every 2×2 quad of the visibility buffer into the (material, tile) list of each material it
+ * holds a pixel of — see {@link chunk_material_quad_keys} — and write the cleared G-buffer value
+ * to every pixel no material will shade. One invocation per quad, a
+ * {@link MATERIAL_CLASSIFY_GROUP_SIDE}² block of quads per workgroup, dispatched over the view's
+ * resolution.
+ *
+ * `counts` must start at zero; its count header is set to the number of lists, as
+ * {@link graph_prefix_scan_csdldf} reads it.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_material_pixel_count: ComputeShader;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_material_pixel_count.d.ts.map

package/src/shade/renderer/material/dispatch/shader_material_pixel_count.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_material_pixel_count.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/shader_material_pixel_count.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH,gDAFU,YAAY,CAgBS;AAgF/B;;;;;;;;;;;GAWG;AACH,0CAFU,aAAa,CAMpB;6BA1H0B,mCAAmC;8BAJlC,+BAA+B"}

package/src/shade/renderer/material/dispatch/shader_material_pixel_count.js

@@ -0,0 +1,133 @@
+import { G_BUFFER_COLOR_TARGETS } from "../../gbuffer/G_BUFFER_COLOR_TARGETS.js";
+import {
+    chunk_subgroup_keyed_append,
+    SUBGROUP_KEYED_APPEND_NONE
+} from "../../shader/chunk/subgroup/chunk_subgroup_keyed_append.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { atomic_u32, u32, vec2u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { WGSLAttribute } from "../../shader/type/WGSLAttribute.js";
+import { WGSLAttributes } from "../../shader/type/WGSLAttributes.js";
+import { WGSLStructField } from "../../shader/type/WGSLStructField.js";
+import { chunk_material_quad_keys } from "./chunk_material_quad_keys.js";
+import { MATERIAL_CLASSIFY_GROUP_SIDE } from "./MATERIAL_DISPATCH_CONSTANTS.js";
+
+/**
+ * What both classification passes are told of the view and the material list.
+ *
+ * @type {WebGPUStruct}
+ */
+export const MATERIAL_CLASSIFY_SETTINGS_STRUCT = WebGPUStruct.from({
+    resolution: vec2u,
+    /**
+     * Tile columns across the view.
+     */
+    tiles_x: u32,
+    /**
+     * Tiles across the whole view.
+     */
+    tile_count: u32,
+    /**
+     * Materials in the G-buffer pass's list, which is how many lists there are per tile.
+     */
+    slot_count: u32,
+}, "MaterialClassifySettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addTexture("viz_buffer_mesh", "uint")
+    .addStorageBuffer("material_slots", WebGPUArray.u32)
+    // laid out as graph_prefix_scan_csdldf takes its input, so the counts are scanned where they lie
+    .addStorageBuffer("counts", WebGPUStruct.fromFields(
+        WGSLStructField.from("count", u32),
+        WGSLStructField.from("elements", WebGPUArray.from(atomic_u32), WGSLAttribute.from(WGSLAttributes.Align, 16)),
+    ), true)
+    .addUniform("settings", MATERIAL_CLASSIFY_SETTINGS_STRUCT)
+    .addStorageTexture("g_buffer_pbr", G_BUFFER_COLOR_TARGETS[0].format, "2d", "write-only")
+    .addStorageTexture("g_buffer_normal", G_BUFFER_COLOR_TARGETS[1].format, "2d", "write-only")
+    .addStorageTexture("g_buffer_albedo", G_BUFFER_COLOR_TARGETS[2].format, "2d", "write-only")
+    .addStorageTexture("g_buffer_emissive", G_BUFFER_COLOR_TARGETS[3].format, "2d", "write-only")
+;
+
+resources.createGroup()
+    .addStorageBuffer("scene_database", WebGPUArray.u32);
+
+const NONE = `${SUBGROUP_KEYED_APPEND_NONE}u`;
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+// the later rounds run only where some lane of the subgroup holds a second, third or fourth
+// material, a uniform condition the analysis cannot see
+@diagnostic(off, subgroup_uniformity)
+@compute @workgroup_size(${MATERIAL_CLASSIFY_GROUP_SIDE}, ${MATERIAL_CLASSIFY_GROUP_SIDE})
+fn main(
+    @builtin(global_invocation_id) global_id : vec3<u32>,
+    @builtin(workgroup_id) workgroup_id : vec3<u32>,
+    @builtin(local_invocation_index) local_index : u32,
+) {
+    let quad = global_id.xy;
+    let resolution = settings.resolution;
+
+    let q = material_quad_keys(quad, resolution, settings.tiles_x, settings.tile_count);
+
+    let covered = q.masks.x | q.masks.y | q.masks.z | q.masks.w;
+
+    for (var corner = 0u; corner < 4u; corner++) {
+        let pixel = quad * 2u + vec2<u32>(corner & 1u, corner >> 1u);
+
+        if (all(pixel < resolution) && (covered & (1u << corner)) == 0u) {
+            // no material will shade it; the fragment dispatch's targets are cleared to this
+            textureStore(g_buffer_pbr, pixel, vec4<f32>(0.0));
+            textureStore(g_buffer_normal, pixel, vec4<u32>(0u));
+            textureStore(g_buffer_albedo, pixel, vec4<f32>(0.0));
+            textureStore(g_buffer_emissive, pixel, vec4<u32>(0u));
+        }
+    }
+
+    if (local_index == 0u && all(workgroup_id == vec3<u32>(0u))) {
+        counts.count = settings.slot_count * settings.tile_count;
+    }
+
+    // a quad counts once into the list of each material it holds a pixel of
+    subgroup_keyed_append(&counts.elements, q.keys.x);
+
+    if (subgroupAny(q.keys.y != ${NONE})) {
+        subgroup_keyed_append(&counts.elements, q.keys.y);
+
+        if (subgroupAny(q.keys.z != ${NONE})) {
+            subgroup_keyed_append(&counts.elements, q.keys.z);
+
+            if (subgroupAny(q.keys.w != ${NONE})) {
+                subgroup_keyed_append(&counts.elements, q.keys.w);
+            }
+        }
+    }
+}
+`, [
+        chunk_material_quad_keys,
+        chunk_subgroup_keyed_append,
+    ]
+);
+
+/**
+ * Count every 2×2 quad of the visibility buffer into the (material, tile) list of each material it
+ * holds a pixel of — see {@link chunk_material_quad_keys} — and write the cleared G-buffer value
+ * to every pixel no material will shade. One invocation per quad, a
+ * {@link MATERIAL_CLASSIFY_GROUP_SIDE}² block of quads per workgroup, dispatched over the view's
+ * resolution.
+ *
+ * `counts` must start at zero; its count header is set to the number of lists, as
+ * {@link graph_prefix_scan_csdldf} reads it.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_material_pixel_count = ComputeShader.from({
+    label: "Material dispatch / count quads",
+    body,
+    resources,
+});

package/src/shade/renderer/material/dispatch/shader_material_pixel_scatter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Write every 2×2 quad of the visibility buffer into the (material, tile) list of each material it
+ * holds a pixel of, with the mask of its pixels that are that material's, at the place the count
+ * pass made for it — `offsets` holds the inclusive sums of {@link shader_material_pixel_count}'s
+ * counts. Dispatched exactly as the count pass is, so it meets the same quads with the same keys and
+ * fills exactly the room that pass counted.
+ *
+ * `cursors` must start at zero, one word per list.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_material_pixel_scatter: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_material_pixel_scatter.d.ts.map

package/src/shade/renderer/material/dispatch/shader_material_pixel_scatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_material_pixel_scatter.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/shader_material_pixel_scatter.js"],"names":[],"mappings":"AAkFA;;;;;;;;;;GAUG;AACH,4CAFU,aAAa,CAMpB;8BA3F2B,+BAA+B"}

package/src/shade/renderer/material/dispatch/shader_material_pixel_scatter.js

@@ -0,0 +1,98 @@
+import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+import {
+    chunk_subgroup_keyed_append,
+    SUBGROUP_KEYED_APPEND_NONE
+} from "../../shader/chunk/subgroup/chunk_subgroup_keyed_append.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { atomic_u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_material_quad_keys } from "./chunk_material_quad_keys.js";
+import { chunk_material_quad_pack } from "./chunk_material_quad_pack.js";
+import { MATERIAL_CLASSIFY_GROUP_SIDE } from "./MATERIAL_DISPATCH_CONSTANTS.js";
+import { MATERIAL_CLASSIFY_SETTINGS_STRUCT } from "./shader_material_pixel_count.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addTexture("viz_buffer_mesh", "uint")
+    .addStorageBuffer("material_slots", WebGPUArray.u32)
+    .addUniform("settings", MATERIAL_CLASSIFY_SETTINGS_STRUCT)
+    // inclusive sums of the counts, so a list starts where the one before it ends
+    .addStorageBuffer("offsets", COLLECTION_U32_STRUCT_READ)
+    .addStorageBuffer("cursors", WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer("material_quads", WebGPUArray.u32, true)
+;
+
+resources.createGroup()
+    .addStorageBuffer("scene_database", WebGPUArray.u32);
+
+const NONE = `${SUBGROUP_KEYED_APPEND_NONE}u`;
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+// every lane of the subgroup calls it, with a key or with none
+fn material_quad_scatter(quad: vec2<u32>, key: u32, mask: u32) {
+    let at = subgroup_keyed_append(&cursors, key);
+
+    if (key != ${NONE}) {
+        var start = 0u;
+
+        if (key > 0u) {
+            start = offsets.elements[key - 1u];
+        }
+
+        material_quads[start + at] = material_quad_pack(quad, mask);
+    }
+}
+
+// the later rounds run only where some lane of the subgroup holds a second, third or fourth
+// material, a uniform condition the analysis cannot see
+@diagnostic(off, subgroup_uniformity)
+@compute @workgroup_size(${MATERIAL_CLASSIFY_GROUP_SIDE}, ${MATERIAL_CLASSIFY_GROUP_SIDE})
+fn main(
+    @builtin(global_invocation_id) global_id : vec3<u32>,
+) {
+    let quad = global_id.xy;
+
+    let q = material_quad_keys(quad, settings.resolution, settings.tiles_x, settings.tile_count);
+
+    material_quad_scatter(quad, q.keys.x, q.masks.x);
+
+    if (subgroupAny(q.keys.y != ${NONE})) {
+        material_quad_scatter(quad, q.keys.y, q.masks.y);
+
+        if (subgroupAny(q.keys.z != ${NONE})) {
+            material_quad_scatter(quad, q.keys.z, q.masks.z);
+
+            if (subgroupAny(q.keys.w != ${NONE})) {
+                material_quad_scatter(quad, q.keys.w, q.masks.w);
+            }
+        }
+    }
+}
+`, [
+        chunk_material_quad_keys,
+        chunk_material_quad_pack,
+        chunk_subgroup_keyed_append,
+    ]
+);
+
+/**
+ * Write every 2×2 quad of the visibility buffer into the (material, tile) list of each material it
+ * holds a pixel of, with the mask of its pixels that are that material's, at the place the count
+ * pass made for it — `offsets` holds the inclusive sums of {@link shader_material_pixel_count}'s
+ * counts. Dispatched exactly as the count pass is, so it meets the same quads with the same keys and
+ * fills exactly the room that pass counted.
+ *
+ * `cursors` must start at zero, one word per list.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_material_pixel_scatter = ComputeShader.from({
+    label: "Material dispatch / scatter quads",
+    body,
+    resources,
+});

package/src/shade/renderer/material/standard/VT_MATERIAL_TEMPLATE.d.ts

@@ -3,6 +3,7 @@
  */
 export const VT_MATERIAL_TEMPLATE: ShadeMaterialTemplate;
 export type RenderPipelineDescriptor = import("../../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor;
+export type CodeChunk = import("../../shader/compiler/CodeChunk.js").CodeChunk;
 export type GPUMaterialContext = import("../GPUMaterialContext.js").GPUMaterialContext;
 export type StandardShadeMaterial = import("../StandardShadeMaterial.js").StandardShadeMaterial;
 export type GPUMaterialServices = import("../template/GPUMaterialServices.js").GPUMaterialServices;

package/src/shade/renderer/material/standard/VT_MATERIAL_TEMPLATE.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VT_MATERIAL_TEMPLATE.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/VT_MATERIAL_TEMPLATE.js"],"names":[],"mappings":"AAoIA;;GAEG;AACH,mCAFU,qBAAqB,CAO5B;uCAnIU,OAAO,iEAAiE,EAAE,wBAAwB;iCAClG,OAAO,0BAA0B,EAAE,kBAAkB;oCACrD,OAAO,6BAA6B,EAAE,qBAAqB;kCAC3D,OAAO,oCAAoC,EAAE,mBAAmB;sCARvC,sCAAsC"}
+{"version":3,"file":"VT_MATERIAL_TEMPLATE.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/VT_MATERIAL_TEMPLATE.js"],"names":[],"mappings":"AA+IA;;GAEG;AACH,mCAFU,qBAAqB,CAO5B;uCA9IU,OAAO,iEAAiE,EAAE,wBAAwB;wBAClG,OAAO,oCAAoC,EAAE,SAAS;iCACtD,OAAO,0BAA0B,EAAE,kBAAkB;oCACrD,OAAO,6BAA6B,EAAE,qBAAqB;kCAC3D,OAAO,oCAAoC,EAAE,mBAAmB;sCATvC,sCAAsC"}

package/src/shade/renderer/material/standard/VT_MATERIAL_TEMPLATE.js

@@ -8,6 +8,7 @@ import { SHADING_MATERIAL_VT_RESOURCE_GROUP } from "./fragment_gbuffer_vt.js";
 
 /**
  * @typedef {import("../../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor} RenderPipelineDescriptor
+ * @typedef {import("../../shader/compiler/CodeChunk.js").CodeChunk} CodeChunk
  * @typedef {import("../GPUMaterialContext.js").GPUMaterialContext} GPUMaterialContext
  * @typedef {import("../StandardShadeMaterial.js").StandardShadeMaterial} StandardShadeMaterial
  * @typedef {import("../template/GPUMaterialServices.js").GPUMaterialServices} GPUMaterialServices
@@ -33,6 +34,16 @@ class VirtualTextureMaterialTemplate extends ShadeMaterialTemplate {
         return services.virtual_textures.material_pipeline_descriptor;
     }
 
+    /**
+     * @param {GPUMaterialServices} services
+     * @returns {CodeChunk}
+     */
+    gbuffer_surface(services) {
+        assert.defined(services.virtual_textures, 'material uses a vt_stack but no VirtualTextureManager is wired');
+
+        return services.virtual_textures.material_surface;
+    }
+
     /**
      * @param {GPUMaterialContext} ctx
      * @param {GPUMaterialServices} services

package/src/shade/renderer/material/standard/fragment_gbuffer.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Declare in `group` what {@link build_gbuffer_laydown} reads of the visibility buffer and the
+ * view that drew it: the first four bindings of group 1, under the names the body reads them by.
+ *
+ * @param {ShaderResourceGroupDescriptor} group
+ * @returns {ShaderResourceGroupDescriptor} `group`
+ */
+export function add_g_buffer_viz_resources(group: ShaderResourceGroupDescriptor): ShaderResourceGroupDescriptor;
 /**
  * The resource set of a G-buffer pipeline whose group 0 is `material_group`.
  *
@@ -9,13 +17,33 @@
  */
 export function build_gbuffer_shader_resources(material_group: ShaderResourceGroupDescriptor): ShaderResourceSetDescriptor;
 /**
- * Assemble the viz-buffer → G-buffer fragment shader body around a template's surface function.
- * Everything else — vertex pulling, perspective-correct barycentric derivatives, normal frame
- * construction, roughness AA, G-buffer encoding — is shared verbatim between templates, so it can
- * only evolve in one place.
+ * The viz-buffer → G-buffer laydown of one pixel, around a template's surface function. Everything
+ * else — vertex pulling, perspective-correct barycentric derivatives, normal frame construction,
+ * roughness AA, G-buffer encoding — is shared verbatim between templates and between every entry
+ * point that runs it, so it can only evolve in one place.
+ *
+ * Reconstructs the {@link chunk_material_surface_contract} input from the visibility buffer and
+ * calls `material_surface` once; what comes back is anti-aliased, dithered and encoded here.
+ *
+ * ```wgsl
+ * fn gbuffer_laydown(coord: vec2<f32>) -> GBufferOutput
+ * ```
+ *
+ * `coord` is the pixel's centre in framebuffer coordinates — what a fragment's `position` holds.
+ *
+ * Every derivative it takes is analytic, from the barycentrics, except one: the specular
+ * anti-aliasing footprint, `fwidth` of the normal-mapped normal. That one the entry point supplies,
+ * by `derivatives`.
  *
- * The body reconstructs the {@link chunk_material_surface_contract} input from the visibility buffer
- * and calls `material_surface` once; what comes back is anti-aliased, dithered and encoded here.
+ * @param {CodeChunk} surface defines `fn material_surface(s: MaterialSurfaceInput) -> MaterialSurfaceOutput`
+ * @param {CodeChunk} derivatives defines `fn gbuffer_fwidth(v: vec2<f32>) -> vec2<f32>`, `fwidth` as
+ *   the stage can take it — {@link chunk_gbuffer_fwidth_fragment} in a fragment shader
+ * @returns {CodeChunk}
+ */
+export function build_gbuffer_laydown(surface: CodeChunk, derivatives: CodeChunk): CodeChunk;
+/**
+ * The fragment entry of a template's G-buffer pipeline: {@link build_gbuffer_laydown} at the
+ * fragment's own pixel, which the material-depth mask has already narrowed to the material's.
  *
  * @param {CodeChunk} surface defines `fn material_surface(s: MaterialSurfaceInput) -> MaterialSurfaceOutput`
  * @returns {CodeChunk}
@@ -72,6 +100,13 @@ export const g_buffer_scene_resources: ShaderResourceGroupDescriptor;
  * @type {ShaderResourceSetDescriptor}
  */
 export const g_buffer_shader_resources: ShaderResourceSetDescriptor;
+/**
+ * `fn gbuffer_fwidth(v: vec2<f32>) -> vec2<f32>` for {@link build_gbuffer_laydown} in a fragment
+ * shader: the fragment's own `fwidth`, across its quad.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_gbuffer_fwidth_fragment: CodeChunk;
 /**
  * The standard material's G-buffer fragment shader.
  *

package/src/shade/renderer/material/standard/fragment_gbuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fragment_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer.js"],"names":[],"mappings":"AAkGA;;;;;;;;GAQG;AACH,+DAHW,6BAA6B,GAC3B,2BAA2B,CAUvC;AASD;;;;;;;;;;;GAWG;AACH,qDAHW,SAAS,GACP,SAAS,CA+OrB;AAED;;;;;;;;;GASG;AACH;IAL2B,KAAK,EAArB,MAAM;IACiC,cAAc,EAArD,6BAA6B;IACV,OAAO,EAA1B,SAAS;IACP,wBAAwB,CAUpC;AAED;;;;;;;GAOG;AACH,8DAJW,MAAM,UACN,gBAAgB,GACd,wBAAwB,CA4BpC;AA1XD;;;GAGG;AAGH;;;;;;;;;GASG;AACH,qCAFU,6BAA6B,CAEmC;AAa1E;;;;GAIG;AACH,uCAFU,6BAA6B,CAEqC;AAgC5E;;;;GAIG;AACH,wCAFU,2BAA2B,CAEoE;AAqTzG;;;;GAIG;AACH,6BAFU,gBAAgB,CAMvB;8CA9Y2C,wDAAwD;4CAC1D,sDAAsD;0BAFxE,oCAAoC;yCAxCrB,iEAAiE;iCA2CzE,kCAAkC"}
+{"version":3,"file":"fragment_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer.js"],"names":[],"mappings":"AA2EA;;;;;;GAMG;AACH,kDAHW,6BAA6B,GAC3B,6BAA6B,CASzC;AAoBD;;;;;;;;GAQG;AACH,+DAHW,6BAA6B,GAC3B,2BAA2B,CAUvC;AASD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CALW,SAAS,eACT,SAAS,GAEP,SAAS,CA+OrB;AAgBD;;;;;;GAMG;AACH,qDAHW,SAAS,GACP,SAAS,CAerB;AAED;;;;;;;;;GASG;AACH;IAL2B,KAAK,EAArB,MAAM;IACiC,cAAc,EAArD,6BAA6B;IACV,OAAO,EAA1B,SAAS;IACP,wBAAwB,CAUpC;AAED;;;;;;;GAOG;AACH,8DAJW,MAAM,UACN,gBAAgB,GACd,wBAAwB,CA4BpC;AArbD;;;GAGG;AAGH;;;;;;;;;GASG;AACH,qCAFU,6BAA6B,CAEmC;AAwB1E;;;;GAIG;AACH,uCAFU,6BAA6B,CAEqC;AAgC5E;;;;GAIG;AACH,wCAFU,2BAA2B,CAEoE;AAyQzG;;;;;GAKG;AACH,4CAFU,SAAS,CAQhB;AAgFH;;;;GAIG;AACH,6BAFU,gBAAgB,CAMvB;8CAzc2C,wDAAwD;4CAC1D,sDAAsD;0BAFxE,oCAAoC;yCAxCrB,iEAAiE;iCA2CzE,kCAAkC"}