@woosh/meep-engine 3.15.0 → 3.17.0

package/src/shade/renderer/particles/shaders/chunk_particle_emitter_age.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_particle_emitter_age.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_emitter_age.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,yCAFU,SAAS,CAM6C;0BArBtC,oCAAoC"}

package/src/shade/renderer/particles/shaders/chunk_particle_emitter_age.js

@@ -0,0 +1,22 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { PARTICLE_EMITTER_STATE_DESCRIPTOR } from "../data/PARTICLE_DATABASE_SPEC.js";
+
+/**
+ * The emitter's age, as the tick pass left it this frame.
+ *
+ * It is the tick pass's running total, read off the `emitter_state` table of the same database the
+ * emitter record came from ({@link ../data/PARTICLE_EMITTER_STATE.js}) — one binding for both,
+ * through the table's single-field reader, so there is no second copy of the row layout here to
+ * drift from the table's.
+ *
+ * Kept apart from {@link ./chunk_particle_setup_context.js} because the context setup takes the age
+ * as a value: a caller that already has it (or that has no emitter-state binding at all) pulls in
+ * the setup without pulling in this table read.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_particle_emitter_age = CodeChunk.from(/* wgsl */ `
+fn particle_emitter_age(database : ptr<storage, array<u32>>, emitter_row : u32) -> f32 {
+    return ${PARTICLE_EMITTER_STATE_DESCRIPTOR.marshalling_method_read_field('age')}(database, emitter_row);
+}
+`, [PARTICLE_EMITTER_STATE_DESCRIPTOR.chunk_read_field('age')]);

package/src/shade/renderer/particles/shaders/chunk_particle_emitter_world_sphere.d.ts

@@ -0,0 +1,14 @@
+/**
+ * An emitter's bounds sphere in world space: the centre through the node's matrix, the radius
+ * scaled by the largest axis scale the matrix carries.
+ *
+ * The axes are read as transformed unit vectors rather than as matrix columns — the same numbers,
+ * in a form the WGSL emulator also evaluates. Shared by the tick pass (frustum culling of spawning)
+ * and the AVBOIT occupancy pass (which depth slices the emitter's particles can reach), so both
+ * test the same sphere.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_particle_emitter_world_sphere: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_particle_emitter_world_sphere.d.ts.map

package/src/shade/renderer/particles/shaders/chunk_particle_emitter_world_sphere.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_particle_emitter_world_sphere.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_emitter_world_sphere.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,kDAFU,SAAS,CAUU;0BAtBH,oCAAoC"}

package/src/shade/renderer/particles/shaders/chunk_particle_emitter_world_sphere.js

@@ -0,0 +1,23 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_particle_emitter } from "../data/chunk_particle_emitter.js";
+
+/**
+ * An emitter's bounds sphere in world space: the centre through the node's matrix, the radius
+ * scaled by the largest axis scale the matrix carries.
+ *
+ * The axes are read as transformed unit vectors rather than as matrix columns — the same numbers,
+ * in a form the WGSL emulator also evaluates. Shared by the tick pass (frustum culling of spawning)
+ * and the AVBOIT occupancy pass (which depth slices the emitter's particles can reach), so both
+ * test the same sphere.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_particle_emitter_world_sphere = CodeChunk.from(/* language=wgsl */ `
+fn particle_emitter_world_sphere(em : ParticleEmitter, transform : mat4x4<f32>) -> vec4<f32> {
+    let center = (transform * vec4<f32>(em.bounds_center, 1.0)).xyz;
+    let sx = length((transform * vec4<f32>(1.0, 0.0, 0.0, 0.0)).xyz);
+    let sy = length((transform * vec4<f32>(0.0, 1.0, 0.0, 0.0)).xyz);
+    let sz = length((transform * vec4<f32>(0.0, 0.0, 1.0, 0.0)).xyz);
+    return vec4<f32>(center, em.bounds_radius * max(sx, max(sy, sz)));
+}
+`, [chunk_particle_emitter]);

package/src/shade/renderer/particles/shaders/chunk_particle_render_math.js

@@ -1,5 +1,5 @@
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { EMITTER_BLEND, EMITTER_PROJECTION } from "../data/PARTICLE_EMITTER_LAYOUT.js";
+import { EMITTER_BLEND, EMITTER_PROJECTION } from "../data/PARTICLE_EMITTER_STRUCT.js";
 
 /**
  * Pure render-math helpers for the billboard renderer, kept separate so they can be unit-tested in

package/src/shade/renderer/particles/shaders/chunk_particle_scene_view_depth.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The opaque scene's view-space depth behind a particle fragment, for the soft fade.
+ *
+ * The linearization is the engine's own (`get_view_space_depth`); what this adds is the reverse-Z
+ * background case. A device depth at or below zero is the cleared far plane — nothing opaque was
+ * drawn on that pixel — and dividing by it would put the scene *in front of* the particle and fade
+ * it out against empty space. Far away is the honest answer, so the fade returns 1 there.
+ *
+ * Shared by the AVBOIT splat and the AVBOIT draw so that the coverage the volume records and the
+ * coverage the accumulators are weighted by are the same number. They were not, before: the draw
+ * faded and the splat did not, so a card fading out where it met the floor still wrote full
+ * extinction there and darkened the floor through itself along the seam it exists to remove.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_particle_scene_view_depth: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_particle_scene_view_depth.d.ts.map

package/src/shade/renderer/particles/shaders/chunk_particle_scene_view_depth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_particle_scene_view_depth.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_scene_view_depth.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,8CAFU,SAAS,CAMc;0BArBP,oCAAoC"}

package/src/shade/renderer/particles/shaders/chunk_particle_scene_view_depth.js

@@ -0,0 +1,24 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_get_view_space_depth } from "../../shader/chunk/depth/chunk_get_view_space_depth.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The opaque scene's view-space depth behind a particle fragment, for the soft fade.
+ *
+ * The linearization is the engine's own (`get_view_space_depth`); what this adds is the reverse-Z
+ * background case. A device depth at or below zero is the cleared far plane — nothing opaque was
+ * drawn on that pixel — and dividing by it would put the scene *in front of* the particle and fade
+ * it out against empty space. Far away is the honest answer, so the fade returns 1 there.
+ *
+ * Shared by the AVBOIT splat and the AVBOIT draw so that the coverage the volume records and the
+ * coverage the accumulators are weighted by are the same number. They were not, before: the draw
+ * faded and the splat did not, so a card fading out where it met the floor still wrote full
+ * extinction there and darkened the floor through itself along the seam it exists to remove.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_particle_scene_view_depth = CodeChunk.from(/* language=wgsl */ `
+fn particle_scene_view_depth(device_depth : f32, camera : ${CAMERA_UNIFORM_STRUCT.wgsl_ref}) -> f32 {
+    return select(get_view_space_depth(device_depth, camera), 1e9, device_depth <= 0.0);
+}
+`, [chunk_get_view_space_depth]);

package/src/shade/renderer/particles/shaders/chunk_particle_setup_context.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Populates the VM's builtin context and seeds its RNG for one particle before a program section
+ * runs.
+ *
+ * The emitter's world position / direction / up come from its scene node — the `global` of its row
+ * in the scene database's `transforms` table, which the GPU hierarchy pass composed this frame from
+ * the node's own transform and its parents'. An emitter parented to an animated joint therefore
+ * spawns and simulates where the joint is *now*, with nothing copied through the CPU: the joint's
+ * pose was written by the animation passes and composed by the hierarchy pass, and this reads the
+ * result. The caller fetches the node with `scene_read_node(&scene_database, em.node)`, and the age
+ * with {@link ./chunk_particle_emitter_age.js}.
+ *
+ * The RNG seed is `hash_lowbias32_vec3u` over (emitter seed, slot, frame) — the engine's house
+ * hash, not a private one. It only has to be well mixed, since `random()` does the real work from
+ * here, and `rnd_state` feeds a PCG whose LCG step has a nonzero increment, so no seed value
+ * (zero included) is degenerate.
+ *
+ * Depends on {@link chunk_particle_vm} (owns `vm_ctx`, and pulls in the shared `rnd_state`),
+ * {@link chunk_particle_emitter} (the `ParticleEmitter` struct) and
+ * {@link chunk_scene_database_access} (the node struct + reader).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_particle_setup_context: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_particle_setup_context.d.ts.map

package/src/shade/renderer/particles/shaders/chunk_particle_setup_context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_particle_setup_context.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_setup_context.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,2CAFU,SAAS,CA8BhB;0BA1DuB,oCAAoC"}

package/src/shade/renderer/particles/shaders/chunk_particle_setup_context.js

@@ -0,0 +1,59 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_hash_lowbias32_vec3u } from "../../shader/chunk/random/lowbias/chunk_hash_lowbias32_vec3u.js";
+import { NODE3D_STRUCT } from "../../scene/NODE3D_STRUCT.js";
+import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
+import { chunk_particle_emitter } from "../data/chunk_particle_emitter.js";
+import { chunk_particle_vm } from "../vm/chunk_particle_vm.js";
+
+/**
+ * Populates the VM's builtin context and seeds its RNG for one particle before a program section
+ * runs.
+ *
+ * The emitter's world position / direction / up come from its scene node — the `global` of its row
+ * in the scene database's `transforms` table, which the GPU hierarchy pass composed this frame from
+ * the node's own transform and its parents'. An emitter parented to an animated joint therefore
+ * spawns and simulates where the joint is *now*, with nothing copied through the CPU: the joint's
+ * pose was written by the animation passes and composed by the hierarchy pass, and this reads the
+ * result. The caller fetches the node with `scene_read_node(&scene_database, em.node)`, and the age
+ * with {@link ./chunk_particle_emitter_age.js}.
+ *
+ * The RNG seed is `hash_lowbias32_vec3u` over (emitter seed, slot, frame) — the engine's house
+ * hash, not a private one. It only has to be well mixed, since `random()` does the real work from
+ * here, and `rnd_state` feeds a PCG whose LCG step has a nonzero increment, so no seed value
+ * (zero included) is degenerate.
+ *
+ * Depends on {@link chunk_particle_vm} (owns `vm_ctx`, and pulls in the shared `rnd_state`),
+ * {@link chunk_particle_emitter} (the `ParticleEmitter` struct) and
+ * {@link chunk_scene_database_access} (the node struct + reader).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_particle_setup_context = CodeChunk.from(/* wgsl */ `
+fn particle_setup_context(
+    em : ParticleEmitter,
+    node : ${NODE3D_STRUCT.wgsl_ref},
+    slot : u32,
+    dt : f32,
+    time : f32,
+    emitter_age : f32,
+    spawn_fraction : f32,
+    frame : u32,
+) {
+    let transform = node.global;
+
+    vm_ctx.delta_time = dt;
+    vm_ctx.time = time;
+    vm_ctx.emitter_age = emitter_age;
+    vm_ctx.spawn_fraction = spawn_fraction;
+    vm_ctx.particle_index = f32(slot);
+    vm_ctx.emitter_position = (transform * vec4<f32>(0.0, 0.0, 0.0, 1.0)).xyz;
+    vm_ctx.emitter_direction = normalize((transform * vec4<f32>(0.0, 0.0, -1.0, 0.0)).xyz);
+    vm_ctx.emitter_up = normalize((transform * vec4<f32>(0.0, 1.0, 0.0, 0.0)).xyz);
+    rnd_state = hash_lowbias32_vec3u(vec3<u32>(em.seed, slot, frame));
+}
+`, [
+    chunk_particle_vm,
+    chunk_particle_emitter,
+    chunk_scene_database_access,
+    chunk_hash_lowbias32_vec3u,
+]);

package/src/shade/renderer/particles/shaders/chunk_particle_simulate_step.d.ts

@@ -0,0 +1,35 @@
+/**
+ * What the simulate pass does to one particle — everything between reading its slot out of the
+ * coherence list and deciding whether it lives.
+ *
+ * It is a chunk rather than the body of a shader because there are two simulate shaders and only one
+ * simulation. {@link ./shader_particle_simulate.js} runs one invocation per particle over the fast
+ * register file; {@link ./shader_particle_simulate_wide.js} runs a bounded launch with a grid-stride
+ * loop over the wide one. They differ in how they get an index and in nothing else, and everything
+ * that is not "how do I get an index" lives here so it cannot drift between them.
+ *
+ * ## What stays in the entry points
+ *
+ * The compaction atomics. `particle_simulate_one` returns a verdict and the caller acts on it, so
+ * the two `atomicAdd`s and the list appends sit in `main` where the dispatch shape can be seen next
+ * to them. That is also why this chunk takes no pointer to `counters`: an atomic array behind a
+ * pointer parameter is a shape nothing else in the engine uses, and the seam is not worth being the
+ * first.
+ *
+ * ## The padding verdict is a verdict, not an early exit
+ *
+ * A lane the coherence pass padded a bucket out with returns {@link PARTICLE_SIM_SKIP}, and the
+ * caller then does nothing at all with it. Getting this wrong is not subtle in its consequences:
+ * appending a padding lane would put {@link PARTICLE_SIM_PAD_SLOT} — `0xffffffff` — on the alive
+ * list or the free list, and a later emit would take it off the free list and use it as a record
+ * base.
+ *
+ * Returning early from this function leaves the lane inactive for the rest of it, which is exactly
+ * what the wave-uniform read below needs, and is the same active set the old inline early-`return`
+ * produced.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_particle_simulate_step: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_particle_simulate_step.d.ts.map

package/src/shade/renderer/particles/shaders/chunk_particle_simulate_step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_particle_simulate_step.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_simulate_step.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,2CAFU,SAAS,CA2FhB;0BApIuB,oCAAoC"}

package/src/shade/renderer/particles/shaders/chunk_particle_simulate_step.js

@@ -0,0 +1,133 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import {
+    PARTICLE_RECORD_HEADER_EMITTER,
+    PARTICLE_RECORD_WORD_COUNT,
+    PARTICLE_SIM_PAD_SLOT,
+    PARTICLE_VM_INSTRUCTION_WORDS,
+} from "../ParticleConstants.js";
+import { chunk_particle_header } from "../data/particle_header.js";
+import { chunk_particle_emitter_age } from "./chunk_particle_emitter_age.js";
+import { chunk_particle_setup_context } from "./chunk_particle_setup_context.js";
+
+/**
+ * What the simulate pass does to one particle — everything between reading its slot out of the
+ * coherence list and deciding whether it lives.
+ *
+ * It is a chunk rather than the body of a shader because there are two simulate shaders and only one
+ * simulation. {@link ./shader_particle_simulate.js} runs one invocation per particle over the fast
+ * register file; {@link ./shader_particle_simulate_wide.js} runs a bounded launch with a grid-stride
+ * loop over the wide one. They differ in how they get an index and in nothing else, and everything
+ * that is not "how do I get an index" lives here so it cannot drift between them.
+ *
+ * ## What stays in the entry points
+ *
+ * The compaction atomics. `particle_simulate_one` returns a verdict and the caller acts on it, so
+ * the two `atomicAdd`s and the list appends sit in `main` where the dispatch shape can be seen next
+ * to them. That is also why this chunk takes no pointer to `counters`: an atomic array behind a
+ * pointer parameter is a shape nothing else in the engine uses, and the seam is not worth being the
+ * first.
+ *
+ * ## The padding verdict is a verdict, not an early exit
+ *
+ * A lane the coherence pass padded a bucket out with returns {@link PARTICLE_SIM_SKIP}, and the
+ * caller then does nothing at all with it. Getting this wrong is not subtle in its consequences:
+ * appending a padding lane would put {@link PARTICLE_SIM_PAD_SLOT} — `0xffffffff` — on the alive
+ * list or the free list, and a later emit would take it off the free list and use it as a record
+ * base.
+ *
+ * Returning early from this function leaves the lane inactive for the rest of it, which is exactly
+ * what the wave-uniform read below needs, and is the same active set the old inline early-`return`
+ * produced.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_particle_simulate_step = CodeChunk.from(/* language=wgsl */ `
+const PARTICLE_RECORD_WORDS : u32 = ${PARTICLE_RECORD_WORD_COUNT}u;
+const PARTICLE_HEADER_EMITTER : u32 = ${PARTICLE_RECORD_HEADER_EMITTER}u;
+const PARTICLE_INSTRUCTION_WORDS : u32 = ${PARTICLE_VM_INSTRUCTION_WORDS}u;
+const PARTICLE_SIM_PAD_SLOT : u32 = ${PARTICLE_SIM_PAD_SLOT}u;
+
+// Verdicts particle_simulate_one returns. SKIP is a lane that never held a particle.
+const PARTICLE_SIM_SKIP : u32 = 0u;
+const PARTICLE_SIM_ALIVE : u32 = 1u;
+const PARTICLE_SIM_KILLED : u32 = 2u;
+
+// The value the wave's first live lane holds, in every lane.
+//
+// Everything that reaches the interpreter in one wave belongs to one bucket of sim_list: the
+// coherence pass grouped the list by program and padded each group to a whole workgroup, and the
+// padding and orphan lanes have left by the time a program runs. So the three numbers that pick a
+// section are the same in every lane. The compiler cannot see that — they come out of a table row
+// found through a per-lane header, which is as divergent as a value gets — and reading them from
+// the first lane is what tells it. The rest follows on its own: the instruction words are then
+// fetched through the scalar unit, the opcode switch branches on a scalar, and the fast register
+// file is indexed through M0 directly instead of through a waterfall loop over the lanes' indices.
+// (The wide file is indexed per-lane whatever happens, and keeps the other two.) Emit keeps its
+// per-lane decode, because its waves span emitters.
+//
+// The grid-stride caller preserves this: its stride is a whole number of workgroups, so an
+// iteration covers a workgroup-aligned span of the list and a wave still sees one bucket.
+//
+// The uniformity diagnostic is off because the call sits behind per-lane early returns. That is the
+// situation the builtin is defined for — it reads the first ACTIVE lane — and the one WGSL's
+// analysis over-approximates.
+@diagnostic(off, subgroup_uniformity)
+fn particle_wave_uniform(value : u32) -> u32 {
+    return subgroupBroadcastFirst(value);
+}
+
+// Run one particle's UPDATE program and say what became of it. Everything the caller then has to do
+// is atomic.
+fn particle_simulate_one(
+    scene_database : ptr<storage, array<u32>>,
+    emitter_database : ptr<storage, array<u32>>,
+    program : ptr<storage, array<u32>>,
+    pool : ptr<storage, array<u32>, read_write>,
+    slot : u32,
+    dt : f32,
+    time : f32,
+    frame : u32,
+) -> u32 {
+    // A lane the coherence pass padded the bucket out with. It owns no slot, so it has no verdict
+    // and the caller must not book one for it. Padding only ever appears in the tail of a bucket, so
+    // every real lane in this wave still belongs to the one bucket, and the switch the survivors
+    // execute is uniform regardless.
+    if (slot == PARTICLE_SIM_PAD_SLOT) { return PARTICLE_SIM_SKIP; }
+
+    let record_base = slot * PARTICLE_RECORD_WORDS;
+    let header = (*pool)[record_base + PARTICLE_HEADER_EMITTER];
+    let emitter_index = particle_header_emitter(header);
+
+    let em = particle_emitter_read(emitter_database, emitter_index);
+
+    // An orphan: its emitter is gone and the row is free or somebody else's. Freed without running
+    // a program — there is no program of its own left to run.
+    if (particle_header_generation(header) != em.generation) { return PARTICLE_SIM_KILLED; }
+
+    let node = scene_read_node(scene_database, em.node);
+
+    particle_vm_reset();
+    particle_setup_context(
+        em, node, slot,
+        dt, time,
+        particle_emitter_age(emitter_database, emitter_index),
+        0.0, frame,
+    );
+    particle_vm_execute(
+        program,
+        particle_wave_uniform(em.update_offset) * PARTICLE_INSTRUCTION_WORDS,
+        particle_wave_uniform(em.update_count),
+        particle_wave_uniform(em.constant_offset),
+        pool,
+        record_base,
+    );
+
+    if (vm_killed) { return PARTICLE_SIM_KILLED; }
+
+    return PARTICLE_SIM_ALIVE;
+}
+`, [
+    chunk_particle_setup_context,
+    chunk_particle_emitter_age,
+    chunk_particle_header,
+]);

package/src/shade/renderer/particles/shaders/shader_particle_avboit_draw.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The draw pipeline: the four additive accumulators, reverse-Z depth test against the scene, no
+ * depth write.
+ * @type {RenderPipelineDescriptor}
+ */
+export const PARTICLE_AVBOIT_DRAW_PIPELINE: RenderPipelineDescriptor;
+/** The draw shader's resource set, for building its bind group. */
+export const PARTICLE_AVBOIT_DRAW_RESOURCES: ShaderResourceSetDescriptor;
+/** The assembled shader, for the validity tier. */
+export const shader_particle_avboit_draw: ShaderDescriptor;
+import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+//# sourceMappingURL=shader_particle_avboit_draw.d.ts.map

package/src/shade/renderer/particles/shaders/shader_particle_avboit_draw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_particle_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_avboit_draw.js"],"names":[],"mappings":"AAkIA;;;;GAIG;AACH,4CAFU,wBAAwB,CAa/B;AAEH,mEAAmE;AACnE,yEAAwD;AAExD,mDAAmD;AACnD,2DAAsD;yCAxJb,iEAAiE;4CAW9D,sDAAsD;iCAFjE,kCAAkC"}

package/src/shade/renderer/particles/shaders/shader_particle_avboit_draw.js

@@ -0,0 +1,153 @@
+import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { DepthStencilState } from "../../../descriptor/pipeline/render/DepthStencilState.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_sample_volumetrics } from "../../deferred/chunk_sample_volumetrics.js";
+import { AVBOIT_EXTINCT_TRANSMITTANCE } from "../../rasterize/native/avboit/AVBOIT_CONSTANTS.js";
+import { AVBOIT_WARP_STRUCT } from "../../rasterize/native/avboit/AVBOIT_WARP_STRUCT.js";
+import { AVBOIT_DRAW_TARGETS } from "../../rasterize/native/avboit/avboit_draw_fragment_body.js";
+import { chunk_avboit_sample_transmittance } from "../../rasterize/native/avboit/chunk_avboit_sample_transmittance.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.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 { EMITTER_FLAG } from "../data/PARTICLE_EMITTER_STRUCT.js";
+import { PARTICLE_SOFT_FADE_RANGE } from "../ParticleConstants.js";
+import { chunk_particle_avboit_contribution } from "./chunk_particle_avboit_contribution.js";
+import { chunk_particle_scene_view_depth } from "./chunk_particle_scene_view_depth.js";
+import { chunk_particle_billboard_vertex } from "./chunk_particle_billboard_vertex.js";
+import { chunk_particle_lighting_unlit } from "./chunk_particle_lighting.js";
+
+/**
+ * The particles' AVBOIT draw: the billboard quads at internal resolution, depth-tested against the
+ * opaque scene, into the four accumulators the transparent meshes draw into
+ * (`avboit_draw_fragment_body`). The particle counterpart of `shader_avboit_draw_ibl`.
+ *
+ * Per fragment: the atlas sample times the particle colour, the soft-depth fade against the scene
+ * depth and the lighting hook exactly as the standalone renderer applies them, the volumetric fog
+ * composite exactly as the mesh draw applies it, then the transmittance of everything in front from
+ * the integral texture — and a fragment the volume already calls extinct is discarded unshaded.
+ *
+ * What is written depends on how the particle blends:
+ *
+ * - **alpha / premultiplied** — a surface: `color += premultiplied × T`, `norm += coverage × T`,
+ *   `extinction += -log(1 - coverage)`, the same three the meshes write, with an untinted
+ *   `T_self = 1 - coverage`; the splat recorded exactly that.
+ * - **additive** — light: `emission += premultiplied × T`, nothing else. It joins the resolve
+ *   attenuated by what is in front of it and outside the coverage normalization, which is what an
+ *   additive fragment means.
+ *
+ * The scene depth is bound twice: as the read-only depth attachment the pipeline tests against, and
+ * as the texture the soft fade reads. Both are reads, which WebGPU allows within one pass; the pass
+ * is recorded with the attachment read-only for that reason.
+ */
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("view", VIEW_UNIFORM_STRUCT)
+    .addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
+    .addStorageBuffer("pool", WebGPUArray.u32, false)
+    .addStorageBuffer("draw_list", WebGPUArray.u32, false)
+    .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
+    .addTexture("atlas", "float")
+    .addSampler("atlas_sampler", "filtering")
+    .addTexture("scene_depth", "unfilterable-float")
+    // 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");
+
+const body = CodeChunk.from(
+    /* language=wgsl */ `
+const PARTICLE_FLAG_SOFT_DEPTH : u32 = ${EMITTER_FLAG.SOFT_DEPTH}u;
+const PARTICLE_FLAG_LIGHTING : u32 = ${EMITTER_FLAG.LIGHTING}u;
+const PARTICLE_SOFT_FADE_RANGE : f32 = ${PARTICLE_SOFT_FADE_RANGE};
+
+struct ParticleAVBOITDrawOutput {
+    @location(0) color : vec4<f32>,
+    @location(1) norm : vec4<f32>,
+    @location(2) extinction : vec4<f32>,
+    @location(3) emission : vec4<f32>,
+}
+
+@vertex
+fn vs_main(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
+    return particle_billboard_vertex(vi, ii);
+}
+
+@fragment
+fn fs_main(in : ParticleVertexOut) -> ParticleAVBOITDrawOutput {
+    let screen_uv = in.clip.xy / vec2<f32>(f32(view.width), f32(view.height));
+
+    let transmittance = avboit_sample_transmittance(&warp, tIntegral, sLinear, screen_uv, in.view_depth);
+
+    if (all(transmittance <= vec3<f32>(${AVBOIT_EXTINCT_TRANSMITTANCE}))) {
+        // nothing this fragment contributes survives what is in front of it; skip the shading
+        discard;
+    }
+
+    var color = textureSample(atlas, atlas_sampler, in.uv) * in.color;
+
+    if ((in.flags & PARTICLE_FLAG_SOFT_DEPTH) != 0u) {
+        let scene_vd = particle_scene_view_depth(textureLoad(scene_depth, vec2<i32>(in.clip.xy), 0).r, camera);
+        color.a = color.a * particle_soft_fade(scene_vd, in.view_depth, PARTICLE_SOFT_FADE_RANGE);
+    }
+
+    if ((in.flags & PARTICLE_FLAG_LIGHTING) != 0u) {
+        color = particle_apply_lighting(color, in.world_position, normalize(in.normal));
+    }
+
+    let volumetrics = sample_volumetrics(in.view_depth, screen_uv, in.clip.xy);
+
+    let contribution = particle_avboit_contribution(color, in.blend, transmittance, volumetrics);
+
+    var out : ParticleAVBOITDrawOutput;
+
+    out.color = contribution.color;
+    out.norm = contribution.norm;
+    out.extinction = contribution.extinction;
+    out.emission = contribution.emission;
+
+    return out;
+}
+`, [
+    chunk_particle_avboit_contribution,
+    chunk_particle_scene_view_depth,
+    chunk_particle_billboard_vertex,
+    chunk_particle_lighting_unlit,
+    chunk_sample_volumetrics,
+    chunk_avboit_sample_transmittance,
+]);
+
+const descriptor = ShaderDescriptor.from({ label: "Particle AVBOIT Draw", body, resources });
+
+/**
+ * The draw pipeline: the four additive accumulators, reverse-Z depth test against the scene, no
+ * depth write.
+ * @type {RenderPipelineDescriptor}
+ */
+export const PARTICLE_AVBOIT_DRAW_PIPELINE = RenderPipelineDescriptor.from({
+    label: "Particle AVBOIT Draw",
+    layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+    vertex: { module: { code: descriptor.source }, entryPoint: "vs_main" },
+    fragment: {
+        module: { code: descriptor.source },
+        entryPoint: "fs_main",
+        targets: AVBOIT_DRAW_TARGETS,
+    },
+    depthStencil: DepthStencilState.from({ format: "depth32float", depthWriteEnabled: false, depthCompare: "greater" }),
+    primitive: { topology: "triangle-list", cullMode: "none" },
+});
+
+/** The draw shader's resource set, for building its bind group. */
+export const PARTICLE_AVBOIT_DRAW_RESOURCES = resources;
+
+/** The assembled shader, for the validity tier. */
+export const shader_particle_avboit_draw = descriptor;

package/src/shade/renderer/particles/shaders/shader_particle_avboit_occupancy.d.ts

@@ -0,0 +1,3 @@
+export const shader_particle_avboit_occupancy: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_particle_avboit_occupancy.d.ts.map

package/src/shade/renderer/particles/shaders/shader_particle_avboit_occupancy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_particle_avboit_occupancy.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_avboit_occupancy.js"],"names":[],"mappings":"AAuHA,6DAIG;8BAlH2B,+BAA+B"}