@woosh/meep-engine 3.68.0 → 3.70.0

package/src/shade/renderer/rasterize/native/avboit/avboit_unlit_draw.js

@@ -0,0 +1,144 @@
+import { GPUShaderStage } from "../../../../descriptor/GPUShaderStage.js";
+import { DepthStencilState } from "../../../../descriptor/pipeline/render/DepthStencilState.js";
+import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { assert } from "../../../../../core/assert.js";
+import { chunk_sample_volumetrics } from "../../../deferred/chunk_sample_volumetrics.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { SAMPLER_LINEAR_UPSCALE } from "../../../texture/SAMPLER_LINEAR_UPSCALE.js";
+import { VIEW_UNIFORM_STRUCT } from "../../../view/VIEW_UNIFORM_STRUCT.js";
+import { VOLUMETRICS_METADATA_STRUCT } from "../../../volumetrics/VOLUMETRICS_METADATA_STRUCT.js";
+import { AVBOIT_EXTINCT_TRANSMITTANCE } from "./AVBOIT_CONSTANTS.js";
+import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
+import { AVBOIT_DRAW_TARGETS } from "./avboit_draw_fragment_body.js";
+import { chunk_avboit_footprint_bias } from "./chunk_avboit_footprint_bias.js";
+import { chunk_avboit_premultiplied_contribution } from "./chunk_avboit_premultiplied_contribution.js";
+import { chunk_avboit_sample_transmittance } from "./chunk_avboit_sample_transmittance.js";
+import { chunk_avboit_unlit_varyings } from "./chunk_avboit_unlit_varyings.js";
+import { chunk_avboit_view_depth_to_virtual } from "./chunk_avboit_view_depth_to_virtual.js";
+
+/**
+ * What the unlit draw reads once per pass: the view, the warp, the integral and the fog.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const AVBOIT_UNLIT_DRAW_PASS_GROUP = new ShaderResourceGroupDescriptor();
+
+AVBOIT_UNLIT_DRAW_PASS_GROUP
+    .addUniform("view", VIEW_UNIFORM_STRUCT)
+    .addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
+    // sampled through sLinear: linear, clamped on every axis, which is what the integral needs
+    .addTexture("tIntegral", "float", "3d")
+    .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
+    // volumetrics (composited inline)
+    .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
+    .addTexture("tVolumetrics", "float", "3d")
+    .addTexture("tSTBN_vec3", "float", "3d");
+
+/**
+ * The unlit AVBOIT draw's fragment stage, `fs_main`: unlit straight-alpha geometry — a dynamic mesh, a
+ * trail — drawn at internal resolution into the four accumulators the transparent meshes and the
+ * particles draw into (`avboit_draw_fragment_body`), so it composites against both order-independently.
+ * Any vertex stage that hands it `AVBOITUnlitVaryings` (`chunk_avboit_unlit_varyings`) can be linked
+ * with it.
+ *
+ * Per fragment: nothing at all if it has faded out (the unlit splat recorded nothing for it either),
+ * then the transmittance of everything in front from the integral texture — a fragment the volume
+ * already calls extinct is discarded unshaded — the volumetric fog at its depth, and the accumulators
+ * through `avboit_premultiplied_contribution`, the routing every side channel shares.
+ *
+ * The colour is straight alpha and unlit: it is premultiplied here and never emits — a fragment that
+ * can get past the first test covers something — so {@link avboit_unlit_draw_pipeline} does not write
+ * the emission target at all rather than blend zeros into it over every covered pixel.
+ *
+ * The enclosing shader binds {@link AVBOIT_UNLIT_DRAW_PASS_GROUP} and names its vertex entry point
+ * anything but `fs_main`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_unlit_draw_fragment = CodeChunk.from(
+    //language=WGSL
+    `
+struct AVBOITUnlitDrawOutput {
+    @location(0) color : vec4<f32>,
+    @location(1) norm : vec4<f32>,
+    @location(2) extinction : vec4<f32>,
+    @location(3) emission : vec4<f32>,
+}
+
+@fragment
+fn fs_main(fragment : AVBOITUnlitVaryings) -> AVBOITUnlitDrawOutput {
+    // a ribbon seen at an angle runs through depth across a voxel; see avboit_footprint_bias. Taken
+    // first, in uniform control flow
+    let footprint = avboit_footprint_bias(&warp, fwidth(avboit_view_depth_to_virtual(&warp, fragment.view_depth)));
+
+    if (fragment.color.a <= 0.0) {
+        // faded out: covers nothing, and straight alpha carries no light without coverage
+        discard;
+    }
+
+    let screen_uv = fragment.clip.xy / vec2<f32>(f32(view.width), f32(view.height));
+
+    let transmittance = avboit_sample_transmittance(&warp, tIntegral, sLinear, screen_uv, fragment.view_depth, footprint);
+
+    if (all(transmittance <= vec3<f32>(${AVBOIT_EXTINCT_TRANSMITTANCE}))) {
+        // nothing this fragment contributes survives what is in front of it; skip the shading
+        discard;
+    }
+
+    let volumetrics = sample_volumetrics(fragment.view_depth, screen_uv, fragment.clip.xy);
+
+    let premultiplied = vec4<f32>(fragment.color.rgb * fragment.color.a, fragment.color.a);
+
+    let contribution = avboit_premultiplied_contribution(premultiplied, transmittance, volumetrics);
+
+    var out : AVBOITUnlitDrawOutput;
+
+    out.color = contribution.color;
+    out.norm = contribution.norm;
+    out.extinction = contribution.extinction;
+    out.emission = contribution.emission;
+
+    return out;
+}
+`, [
+        chunk_avboit_unlit_varyings,
+        chunk_avboit_view_depth_to_virtual,
+        chunk_avboit_footprint_bias,
+        chunk_avboit_sample_transmittance,
+        chunk_sample_volumetrics,
+        chunk_avboit_premultiplied_contribution,
+    ]
+);
+
+/**
+ * The render pipeline for an unlit draw shader: additive into the accumulators with the emission
+ * target masked off, the opaque scene's depth tested and never written, both faces.
+ *
+ * @param {object} params
+ * @param {string} params.label
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} params.resources
+ * the shader's resources; must hold {@link AVBOIT_UNLIT_DRAW_PASS_GROUP}
+ * @param {string} params.source the assembled shader, with a vertex entry point named `vs_main` and
+ * {@link chunk_avboit_unlit_draw_fragment}'s `fs_main`
+ * @returns {RenderPipelineDescriptor}
+ */
+export function avboit_unlit_draw_pipeline({ label, resources, source }) {
+    assert.isString(label, "label");
+    assert.isString(source, "source");
+    assert.notEqual(resources.groups.indexOf(AVBOIT_UNLIT_DRAW_PASS_GROUP), -1, "resources must hold the unlit draw's pass group");
+
+    return RenderPipelineDescriptor.from({
+        label,
+        layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+        vertex: { module: { code: source }, entryPoint: "vs_main" },
+        fragment: {
+            module: { code: source },
+            entryPoint: "fs_main",
+            // color, norm, extinction — and not emission
+            targets: AVBOIT_DRAW_TARGETS.map((target, i) => ({ ...target, writeMask: [0xF, 0xF, 0xF, 0][i] })),
+        },
+        depthStencil: DepthStencilState.from({ format: "depth32float", depthWriteEnabled: false, depthCompare: "greater" }),
+        primitive: { topology: "triangle-list", cullMode: "none" },
+    });
+}

package/src/shade/renderer/rasterize/native/avboit/avboit_unlit_splat.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The render pipeline for an unlit splat shader: no depth, one never-written attachment to size the
+ * raster ({@link AVBOIT_UNLIT_SPLAT_SAMPLES} samples, not the volume's single-sampled one the meshlet
+ * and particle splats share), both faces — a trail is seen from inside and out.
+ *
+ * The layout is built group by group: the volume's atomics are fragment-only, and WebGPU refuses a
+ * read-write storage buffer that is visible to the vertex stage. Every other group is visible to both
+ * stages, so a group the shader shares with other pipelines keeps the one layout they all declare.
+ *
+ * @param {object} params
+ * @param {string} params.label
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} params.resources
+ * the shader's resources; must hold {@link AVBOIT_UNLIT_SPLAT_PASS_GROUP} and `AVBOIT_SPLAT_VOLUME_GROUP`
+ * @param {string} params.source the assembled shader, with a vertex entry point named `vs_main` and
+ * {@link chunk_avboit_unlit_splat_fragment}'s `fs_main`
+ * @returns {RenderPipelineDescriptor}
+ */
+export function avboit_unlit_splat_pipeline({ label, resources, source }: {
+    label: string;
+    resources: import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor;
+    source: string;
+}): RenderPipelineDescriptor;
+/**
+ * Samples per pixel of the unlit splat's raster, which is what a fragment's extinction is weighted by
+ * the share of. Four, being the only count above one that WebGPU guarantees.
+ * @type {number}
+ */
+export const AVBOIT_UNLIT_SPLAT_SAMPLES: number;
+/**
+ * What the unlit splat reads once per pass: the warp, which places a view depth in the volume.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const AVBOIT_UNLIT_SPLAT_PASS_GROUP: ShaderResourceGroupDescriptor;
+/**
+ * The unlit AVBOIT splat's fragment stage, `fs_main`: unlit straight-alpha geometry — a dynamic mesh,
+ * a trail — adding its extinction into the voxel volume through `avboit_splat_slice`, the same write
+ * path as the meshlet and particle splats, so a trail, a particle and a surface at one depth pile up in
+ * one field. Any vertex stage that hands it `AVBOITUnlitVaryings` (`chunk_avboit_unlit_varyings`) can
+ * be linked with it.
+ *
+ * Coverage is the varyings' alpha through `avboit_coverage` — the function the unlit draw weights the
+ * same fragment by — and `T_self = 1 - coverage`, untinted. A fragment that has faded to nothing covers
+ * nothing and writes nothing, which on a trail is its whole aged-out tail.
+ *
+ * **Weighted by the share of the voxel the triangle covers.** A voxel is eight pixels across, and a
+ * trail is often narrower than that. Sampled at the voxel's centre alone, a thin trail either crosses
+ * the centre and writes its full extinction there or misses it and writes nothing, so its occlusion of
+ * what lies behind it comes and goes as it moves by a fraction of a voxel. The raster has
+ * {@link AVBOIT_UNLIT_SPLAT_SAMPLES} samples per pixel, the fragment runs wherever any of them is
+ * covered, and its extinction is scaled by the covered fraction: the voxel gets the triangle's
+ * extinction averaged over its footprint, as a volume that coarse can hold it. The triangles of one
+ * mesh cover disjoint samples, so the fractions of the triangles sharing a voxel add up to at most one
+ * layer; a fully covered voxel is written exactly as an unweighted splat would write it. What remains
+ * is the average's own bias — a trail a fraction of a voxel wide occludes what is behind it by that
+ * fraction of its extinction — which holds still as the trail moves.
+ *
+ * Depth is the fragment's own view depth from the varyings, through curve → warp → physical and the
+ * two-slice linear split the other splats make. No depth attachment, for the reason the meshlet splat
+ * has none: a splat behind an opaque surface lies deeper than anything the draw will look it up for.
+ *
+ * The enclosing shader binds {@link AVBOIT_UNLIT_SPLAT_PASS_GROUP} and `AVBOIT_SPLAT_VOLUME_GROUP`,
+ * and names its vertex entry point anything but `fs_main`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_unlit_splat_fragment: CodeChunk;
+import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=avboit_unlit_splat.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/avboit_unlit_splat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avboit_unlit_splat.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/avboit_unlit_splat.js"],"names":[],"mappings":"AAwGA;;;;;;;;;;;;;;;;GAgBG;AACH;IAP0B,KAAK,EAApB,MAAM;IACgG,SAAS,EAA/G,OAAO,yDAAyD,EAAE,2BAA2B;IAE9E,MAAM,EAArB,MAAM;IAEJ,wBAAwB,CAgCpC;AAzID;;;;GAIG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;;GAIG;AACH,4CAFU,6BAA6B,CAE0C;AAKjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,gDAFU,SAAS,CAyCjB;yCApGuC,oEAAoE;8CAG/D,2DAA2D;0BAD/E,uCAAuC"}

package/src/shade/renderer/rasterize/native/avboit/avboit_unlit_splat.js

@@ -0,0 +1,152 @@
+import { GPUShaderStage } from "../../../../descriptor/GPUShaderStage.js";
+import { PipelineLayoutDescriptor } from "../../../../descriptor/pipeline/PipelineLayoutDescriptor.js";
+import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { assert } from "../../../../../core/assert.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
+import { chunk_avboit_coverage } from "./chunk_avboit_coverage.js";
+import { chunk_avboit_splat_slice } from "./chunk_avboit_splat_slice.js";
+import { chunk_avboit_transmittance_to_extinction } from "./chunk_avboit_transmittance_to_extinction.js";
+import { chunk_avboit_unlit_varyings } from "./chunk_avboit_unlit_varyings.js";
+import { chunk_avboit_view_depth_to_physical } from "./chunk_avboit_view_depth_to_physical.js";
+import { AVBOIT_SPLAT_DUMMY_FORMAT, AVBOIT_SPLAT_VOLUME_GROUP } from "./shader_avboit_splat.js";
+
+/**
+ * Samples per pixel of the unlit splat's raster, which is what a fragment's extinction is weighted by
+ * the share of. Four, being the only count above one that WebGPU guarantees.
+ * @type {number}
+ */
+export const AVBOIT_UNLIT_SPLAT_SAMPLES = 4;
+
+/**
+ * What the unlit splat reads once per pass: the warp, which places a view depth in the volume.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const AVBOIT_UNLIT_SPLAT_PASS_GROUP = new ShaderResourceGroupDescriptor();
+
+AVBOIT_UNLIT_SPLAT_PASS_GROUP
+    .addStorageBuffer("warp", AVBOIT_WARP_STRUCT);
+
+/**
+ * The unlit AVBOIT splat's fragment stage, `fs_main`: unlit straight-alpha geometry — a dynamic mesh,
+ * a trail — adding its extinction into the voxel volume through `avboit_splat_slice`, the same write
+ * path as the meshlet and particle splats, so a trail, a particle and a surface at one depth pile up in
+ * one field. Any vertex stage that hands it `AVBOITUnlitVaryings` (`chunk_avboit_unlit_varyings`) can
+ * be linked with it.
+ *
+ * Coverage is the varyings' alpha through `avboit_coverage` — the function the unlit draw weights the
+ * same fragment by — and `T_self = 1 - coverage`, untinted. A fragment that has faded to nothing covers
+ * nothing and writes nothing, which on a trail is its whole aged-out tail.
+ *
+ * **Weighted by the share of the voxel the triangle covers.** A voxel is eight pixels across, and a
+ * trail is often narrower than that. Sampled at the voxel's centre alone, a thin trail either crosses
+ * the centre and writes its full extinction there or misses it and writes nothing, so its occlusion of
+ * what lies behind it comes and goes as it moves by a fraction of a voxel. The raster has
+ * {@link AVBOIT_UNLIT_SPLAT_SAMPLES} samples per pixel, the fragment runs wherever any of them is
+ * covered, and its extinction is scaled by the covered fraction: the voxel gets the triangle's
+ * extinction averaged over its footprint, as a volume that coarse can hold it. The triangles of one
+ * mesh cover disjoint samples, so the fractions of the triangles sharing a voxel add up to at most one
+ * layer; a fully covered voxel is written exactly as an unweighted splat would write it. What remains
+ * is the average's own bias — a trail a fraction of a voxel wide occludes what is behind it by that
+ * fraction of its extinction — which holds still as the trail moves.
+ *
+ * Depth is the fragment's own view depth from the varyings, through curve → warp → physical and the
+ * two-slice linear split the other splats make. No depth attachment, for the reason the meshlet splat
+ * has none: a splat behind an opaque surface lies deeper than anything the draw will look it up for.
+ *
+ * The enclosing shader binds {@link AVBOIT_UNLIT_SPLAT_PASS_GROUP} and `AVBOIT_SPLAT_VOLUME_GROUP`,
+ * and names its vertex entry point anything but `fs_main`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_unlit_splat_fragment = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn fs_main(fragment : AVBOITUnlitVaryings, @builtin(sample_mask) sample_mask : u32) {
+    // the coverage the draw weights this fragment by, through the same function
+    let coverage = avboit_coverage(fragment.color.a);
+
+    if (coverage <= 0.0) {
+        // faded out: occludes nothing
+        return;
+    }
+
+    // the share of the voxel's samples this triangle covers
+    let footprint = f32(countOneBits(sample_mask)) / ${AVBOIT_UNLIT_SPLAT_SAMPLES}.0;
+
+    let extinction = avboit_transmittance_to_extinction(vec3<f32>(1.0 - coverage)) * footprint;
+
+    let p = avboit_view_depth_to_physical(&warp, fragment.view_depth);
+
+    // fragment.clip is @builtin(position): .xy the low-resolution pixel
+    let texel = vec2<u32>(fragment.clip.xy);
+    let column = texel.y * warp.voxel_width + texel.x;
+
+    // linear splat between the two slices around the fragment
+    let c = p - 0.5;
+    let slice = i32(floor(c));
+    let fraction = c - floor(c);
+
+    avboit_splat_slice(column, slice, extinction * (1.0 - fraction), texel);
+    avboit_splat_slice(column, slice + 1, extinction * fraction, texel);
+}
+`, [
+        chunk_avboit_unlit_varyings,
+        chunk_avboit_coverage,
+        chunk_avboit_transmittance_to_extinction,
+        chunk_avboit_view_depth_to_physical,
+        chunk_avboit_splat_slice,
+    ]
+);
+
+/**
+ * The render pipeline for an unlit splat shader: no depth, one never-written attachment to size the
+ * raster ({@link AVBOIT_UNLIT_SPLAT_SAMPLES} samples, not the volume's single-sampled one the meshlet
+ * and particle splats share), both faces — a trail is seen from inside and out.
+ *
+ * The layout is built group by group: the volume's atomics are fragment-only, and WebGPU refuses a
+ * read-write storage buffer that is visible to the vertex stage. Every other group is visible to both
+ * stages, so a group the shader shares with other pipelines keeps the one layout they all declare.
+ *
+ * @param {object} params
+ * @param {string} params.label
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} params.resources
+ * the shader's resources; must hold {@link AVBOIT_UNLIT_SPLAT_PASS_GROUP} and `AVBOIT_SPLAT_VOLUME_GROUP`
+ * @param {string} params.source the assembled shader, with a vertex entry point named `vs_main` and
+ * {@link chunk_avboit_unlit_splat_fragment}'s `fs_main`
+ * @returns {RenderPipelineDescriptor}
+ */
+export function avboit_unlit_splat_pipeline({ label, resources, source }) {
+    assert.isString(label, "label");
+    assert.isString(source, "source");
+
+    const groups = resources.groups;
+
+    assert.notEqual(groups.indexOf(AVBOIT_UNLIT_SPLAT_PASS_GROUP), -1, "resources must hold the unlit splat's pass group");
+    assert.notEqual(groups.indexOf(AVBOIT_SPLAT_VOLUME_GROUP), -1, "resources must hold the splat volume group");
+
+    const layout = PipelineLayoutDescriptor.from(
+        groups.map(group => group.generateBindGroupLayoutDescriptor(
+            group === AVBOIT_SPLAT_VOLUME_GROUP
+                ? GPUShaderStage.FRAGMENT
+                : GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT
+        )),
+        resources.immediateSize
+    );
+
+    return RenderPipelineDescriptor.from({
+        label,
+        layout,
+        vertex: { module: { code: source }, entryPoint: "vs_main" },
+        fragment: {
+            module: { code: source },
+            entryPoint: "fs_main",
+            targets: [{ format: AVBOIT_SPLAT_DUMMY_FORMAT, writeMask: 0 }],
+        },
+        primitive: { topology: "triangle-list", cullMode: "none" },
+        multisample: { count: AVBOIT_UNLIT_SPLAT_SAMPLES },
+    });
+}

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_unlit_varyings.d.ts

@@ -0,0 +1,21 @@
+/**
+ * What a vertex stage hands the unlit AVBOIT fragment stages (`chunk_avboit_unlit_splat_fragment`,
+ * `chunk_avboit_unlit_draw_fragment`): `struct AVBOITUnlitVaryings`.
+ *
+ * - `clip` is the clip-space position.
+ * - `color` is straight, not premultiplied: RGB and the fragment's own opacity.
+ * - `view_depth` is the vertex's view-space depth, interpolated across the triangle. The splat
+ *   positions a fragment's extinction by it and the draw looks the volume up at it, so both take it
+ *   from here rather than reconstructing it from `@builtin(position).z`.
+ *
+ * `color` and `view_depth` are interpolated at the **centroid** of the samples a triangle covers. The
+ * splat is multisampled, and a thin triangle can cover some of a pixel's samples but not its centre;
+ * at the centre its depth and alpha would be extrapolated off the triangle's edge, which on a ribbon
+ * seen nearly edge-on lands the extinction slices away from the ribbon. The draw has one sample, where
+ * a fragment exists only if the centre is covered and the centroid is the centre.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_unlit_varyings: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_unlit_varyings.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_unlit_varyings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_unlit_varyings.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_unlit_varyings.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,0CAFU,SAAS,CAWjB;0BA7BwB,uCAAuC"}

package/src/shade/renderer/rasterize/native/avboit/chunk_avboit_unlit_varyings.js

@@ -0,0 +1,30 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+
+/**
+ * What a vertex stage hands the unlit AVBOIT fragment stages (`chunk_avboit_unlit_splat_fragment`,
+ * `chunk_avboit_unlit_draw_fragment`): `struct AVBOITUnlitVaryings`.
+ *
+ * - `clip` is the clip-space position.
+ * - `color` is straight, not premultiplied: RGB and the fragment's own opacity.
+ * - `view_depth` is the vertex's view-space depth, interpolated across the triangle. The splat
+ *   positions a fragment's extinction by it and the draw looks the volume up at it, so both take it
+ *   from here rather than reconstructing it from `@builtin(position).z`.
+ *
+ * `color` and `view_depth` are interpolated at the **centroid** of the samples a triangle covers. The
+ * splat is multisampled, and a thin triangle can cover some of a pixel's samples but not its centre;
+ * at the centre its depth and alpha would be extrapolated off the triangle's edge, which on a ribbon
+ * seen nearly edge-on lands the extinction slices away from the ribbon. The draw has one sample, where
+ * a fragment exists only if the centre is covered and the centroid is the centre.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_unlit_varyings = CodeChunk.from(
+    //language=WGSL
+    `
+struct AVBOITUnlitVaryings {
+    @builtin(position) clip : vec4<f32>,
+    @location(0) @interpolate(perspective, centroid) color : vec4<f32>,
+    @location(1) @interpolate(perspective, centroid) view_depth : f32,
+}
+    `
+);

package/src/shade/renderer/rasterize/native/avboit/graph_avboit_unlit.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Splat a channel's unlit geometry into the voxel volume.
+ *
+ * The raster is multisampled ({@link AVBOIT_UNLIT_SPLAT_SAMPLES}), so it cannot use the volume's
+ * single-sampled splat target: the pass makes its own at the volume's resolution, never written,
+ * cleared and discarded, and hands the volume's back untouched.
+ *
+ * @param {object} params
+ * @param {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {string} params.label the pass's label; its target is labelled after it
+ * @param {import("../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor} params.pipeline
+ * from `avboit_unlit_splat_pipeline`
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} params.resources
+ * the pipeline's shader resources
+ * @param {Object<string, number>} params.inputs graph handles the channel's draws read, by name
+ * @param {number} params.warp graph handle
+ * @param {number[]} params.voxel_resolution the volume's width and height, which the raster is
+ * @param {{extinction: number, overflow: number, dummy: number}} params.volume the volume, to add to
+ * @param {function(): boolean} params.is_empty asked when the pass executes; `true` records no render pass
+ * @param {function(GPURenderPassEncoder, GraphicsContext, Object<string, *>): void} params.record issues
+ * the draws into the open pass, whose pass-level groups are set, with `inputs` resolved
+ * @returns {{extinction: number, overflow: number, dummy: number}} the volume after the write
+ */
+export function graph_avboit_unlit_splat({ graph, label, pipeline, resources, inputs, warp, voxel_resolution, volume, is_empty, record, }: {
+    graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    label: string;
+    pipeline: import("../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor;
+    resources: import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor;
+    inputs: {
+        [x: string]: number;
+    };
+    warp: number;
+    voxel_resolution: number[];
+    volume: {
+        extinction: number;
+        overflow: number;
+        dummy: number;
+    };
+    is_empty: () => boolean;
+    record: (arg0: GPURenderPassEncoder, arg1: GraphicsContext, arg2: {
+        [x: string]: any;
+    }) => void;
+}): {
+    extinction: number;
+    overflow: number;
+    dummy: number;
+};
+/**
+ * Draw a channel's unlit geometry into the four accumulators, depth-tested against the opaque scene.
+ *
+ * @param {object} params
+ * @param {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {string} params.label
+ * @param {import("../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor} params.pipeline
+ * from `avboit_unlit_draw_pipeline`
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} params.resources
+ * the pipeline's shader resources
+ * @param {Object<string, number>} params.inputs graph handles the channel's draws read, by name
+ * @param {import("../../../view/GPUViewContext.js").GPUViewContext} params.view_ctx
+ * @param {number} params.depth_texture graph handle of the opaque scene's depth — tested, never written
+ * @param {number} params.warp graph handle
+ * @param {number} params.integral graph handle of the integral texture
+ * @param {number} params.volumetrics_lut graph handle
+ * @param {number} params.volumetrics_metadata graph handle
+ * @param {{color: number, norm: number, extinction: number, emission: number}} params.accumulators to add to
+ * @param {function(): boolean} params.is_empty asked when the pass executes; `true` records no render pass
+ * @param {function(GPURenderPassEncoder, GraphicsContext, Object<string, *>): void} params.record issues
+ * the draws into the open pass, whose pass-level group is set, with `inputs` resolved
+ * @returns {{color: number, norm: number, extinction: number, emission: number}} the accumulators after the draw
+ */
+export function graph_avboit_unlit_draw({ graph, label, pipeline, resources, inputs, view_ctx, depth_texture, warp, integral, volumetrics_lut, volumetrics_metadata, accumulators, is_empty, record, }: {
+    graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    label: string;
+    pipeline: import("../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor;
+    resources: import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor;
+    inputs: {
+        [x: string]: number;
+    };
+    view_ctx: import("../../../view/GPUViewContext.js").GPUViewContext;
+    depth_texture: number;
+    warp: number;
+    integral: number;
+    volumetrics_lut: number;
+    volumetrics_metadata: number;
+    accumulators: {
+        color: number;
+        norm: number;
+        extinction: number;
+        emission: number;
+    };
+    is_empty: () => boolean;
+    record: (arg0: GPURenderPassEncoder, arg1: GraphicsContext, arg2: {
+        [x: string]: any;
+    }) => void;
+}): {
+    color: number;
+    norm: number;
+    extinction: number;
+    emission: number;
+};
+//# sourceMappingURL=graph_avboit_unlit.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/graph_avboit_unlit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph_avboit_unlit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_avboit_unlit.js"],"names":[],"mappings":"AAuEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAfwG,KAAK,EAAlG,OAAO,iEAAiE,EAAE,UAAU;IACrE,KAAK,EAApB,MAAM;IACwG,QAAQ,EAAtH,OAAO,oEAAoE,EAAE,wBAAwB;IAEC,SAAS,EAA/G,OAAO,yDAAyD,EAAE,2BAA2B;IAE9D,MAAM;YAA9B,MAAM,GAAE,MAAM;;IACN,IAAI,EAAnB,MAAM;IACW,gBAAgB,EAAjC,MAAM,EAAE;IACsD,MAAM,EAApE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IACzB,QAAQ,QAAxB,OAAO;IAC8D,MAAM;YAAhC,MAAM;UAAO,IAAI;IAEtE;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CA4FjE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAnBwG,KAAK,EAAlG,OAAO,iEAAiE,EAAE,UAAU;IACrE,KAAK,EAApB,MAAM;IACwG,QAAQ,EAAtH,OAAO,oEAAoE,EAAE,wBAAwB;IAEC,SAAS,EAA/G,OAAO,yDAAyD,EAAE,2BAA2B;IAE9D,MAAM;YAA9B,MAAM,GAAE,MAAM;;IAC4C,QAAQ,EAAzE,OAAO,iCAAiC,EAAE,cAAc;IACzC,aAAa,EAA5B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,eAAe,EAA9B,MAAM;IACS,oBAAoB,EAAnC,MAAM;IACsE,YAAY,EAAxF;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IACvC,QAAQ,QAAxB,OAAO;IAC8D,MAAM;YAAhC,MAAM;UAAO,IAAI;IAEtE;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAkG/E"}