@woosh/meep-engine 3.33.0 → 3.35.0

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

@@ -1,185 +1,190 @@
-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, 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>,
-}
-
-// Each draw uses the same GPU-owned alive list. Clip the other modes before rasterization.
-fn particle_avboit_vertex(vi : u32, ii : u32, blend : u32) -> ParticleVertexOut {
-    var out = particle_billboard_vertex(vi, ii);
-    if (particle_avboit_draw_blend(out.color, out.blend) != blend) {
-        out.clip = vec4<f32>(2.0, 2.0, 2.0, 1.0);
-    }
-    return out;
-}
-
-@vertex
-fn vs_alpha(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
-    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_ALPHA);
-}
-
-@vertex
-fn vs_additive(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
-    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_ADDITIVE);
-}
-
-@vertex
-fn vs_general(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
-    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_PREMULTIPLIED);
-}
-
-@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 = particle_fade_color(color, in.blend, 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));
-    }
-
-    if (particle_avboit_is_empty(color, in.blend)) {
-        discard;
-    }
-
-    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 variants share WGSL, bindings and attachments; only the vertex entry point and target writes
- * differ. Disabling unused targets avoids blending zeros over every billboard pixel.
- * @param {string} label
- * @param {string} entryPoint
- * @param {number[]} writeMasks
- * @returns {RenderPipelineDescriptor}
- */
-function create_draw_pipeline(label, entryPoint, writeMasks) {
-    return RenderPipelineDescriptor.from({
-        label,
-        layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
-        vertex: { module: { code: descriptor.source }, entryPoint },
-        fragment: {
-            module: { code: descriptor.source },
-            entryPoint: "fs_main",
-            targets: AVBOIT_DRAW_TARGETS.map((target, i) => ({ ...target, writeMask: writeMasks[i] })),
-        },
-        depthStencil: DepthStencilState.from({ format: "depth32float", depthWriteEnabled: false, depthCompare: "greater" }),
-        primitive: { topology: "triangle-list", cullMode: "none" },
-    });
-}
-
-export const PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw Alpha", "vs_alpha", [0xF, 0xF, 0xF, 0]);
-export const PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw Additive", "vs_additive", [0, 0, 0, 0xF]);
-export const PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw General", "vs_general", [0xF, 0xF, 0xF, 0xF]);
-
-/** 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;
+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 } 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, lighting for an emitter flagged `EMITTER_FLAG.LIGHTING` (`chunk_particle_lighting`: the
+ * froxel irradiance volume: the lights and the indirect lighting), 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. An emitter without the
+ * flag is its own colour, which is what an additive one wants.
+ *
+ * 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")
+    // lighting (chunk_particle_lighting): the froxel irradiance volume, trilinear through sLinear
+    .addTexture("tIrradianceY", "float", "3d")
+    .addTexture("tIrradianceCoCg", "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>,
+}
+
+// Each draw uses the same GPU-owned alive list. Clip the other modes before rasterization.
+fn particle_avboit_vertex(vi : u32, ii : u32, blend : u32) -> ParticleVertexOut {
+    var out = particle_billboard_vertex(vi, ii);
+    if (particle_avboit_draw_blend(out.color, out.blend) != blend) {
+        out.clip = vec4<f32>(2.0, 2.0, 2.0, 1.0);
+    }
+    return out;
+}
+
+@vertex
+fn vs_alpha(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
+    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_ALPHA);
+}
+
+@vertex
+fn vs_additive(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
+    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_ADDITIVE);
+}
+
+@vertex
+fn vs_general(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
+    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_PREMULTIPLIED);
+}
+
+@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 = particle_fade_color(color, in.blend, 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));
+    }
+
+    if (particle_avboit_is_empty(color, in.blend)) {
+        discard;
+    }
+
+    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,
+    chunk_sample_volumetrics,
+    chunk_avboit_sample_transmittance,
+]);
+
+const descriptor = ShaderDescriptor.from({ label: "Particle AVBOIT Draw", body, resources });
+
+/**
+ * The variants share WGSL, bindings and attachments; only the vertex entry point and target writes
+ * differ. Disabling unused targets avoids blending zeros over every billboard pixel.
+ * @param {string} label
+ * @param {string} entryPoint
+ * @param {number[]} writeMasks
+ * @returns {RenderPipelineDescriptor}
+ */
+function create_draw_pipeline(label, entryPoint, writeMasks) {
+    return RenderPipelineDescriptor.from({
+        label,
+        layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+        vertex: { module: { code: descriptor.source }, entryPoint },
+        fragment: {
+            module: { code: descriptor.source },
+            entryPoint: "fs_main",
+            targets: AVBOIT_DRAW_TARGETS.map((target, i) => ({ ...target, writeMask: writeMasks[i] })),
+        },
+        depthStencil: DepthStencilState.from({ format: "depth32float", depthWriteEnabled: false, depthCompare: "greater" }),
+        primitive: { topology: "triangle-list", cullMode: "none" },
+    });
+}
+
+export const PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw Alpha", "vs_alpha", [0xF, 0xF, 0xF, 0]);
+export const PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw Additive", "vs_additive", [0, 0, 0, 0xF]);
+export const PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw General", "vs_general", [0xF, 0xF, 0xF, 0xF]);
+
+/** 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/rasterize/bucket/graph_meshlets_rasterize_by_bucket.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Draw one view's meshlets, of several opaque buckets at once, each bucket under its own pipeline
+ * state.
+ *
+ * The other half of cutting a view once (CUT_PLAN_2026_09_14 §7 6b). Expansion and the
+ * virtual-geometry cut run over every opaque instance of the view together, so what comes out is
+ * one collection with every bucket in it, and the buckets are separated here, after the fact: sort
+ * by bucket, then one draw per bucket over its slice.
+ *
+ * With a single bucket there is nothing to separate — every meshlet is in it — and the collection
+ * is drawn as it is.
+ *
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {GPUViewContext} options.view
+ * @param {number} options.input_meshlets every meshlet to draw, all of them in `buckets`
+ * @param {{draw_mode: number, side: number, bucket_id: number}[]} options.buckets the opaque
+ *     buckets drawn, as {@link rasterization_opaque_buckets} yields them; at least one
+ * @param {number} options.depth
+ * @param {number[]} options.color_targets
+ * @param {RenderPassDescriptor} options.pass_descriptor
+ * @param {boolean} options.clear_targets whether the first draw clears
+ * @param {Readonly<Record<number, GPUCullMode>>} options.cull_policy
+ * @param {number[]} [options.viewport]
+ * @param {GPUCollectionLimits} options.limits
+ * @returns {[number, number[]]} depth and colour handles, as {@link graph_meshlets_rasterize}
+ */
+export function graph_meshlets_rasterize_by_bucket({ graph, view, input_meshlets, buckets, depth, color_targets, pass_descriptor, clear_targets, cull_policy, viewport, limits, }: {
+    graph: FrameGraph;
+    view: GPUViewContext;
+    input_meshlets: number;
+    buckets: {
+        draw_mode: number;
+        side: number;
+        bucket_id: number;
+    }[];
+    depth: number;
+    color_targets: number[];
+    pass_descriptor: RenderPassDescriptor;
+    clear_targets: boolean;
+    cull_policy: Readonly<Record<number, GPUCullMode>>;
+    viewport?: number[];
+    limits: GPUCollectionLimits;
+}): [number, number[]];
+//# sourceMappingURL=graph_meshlets_rasterize_by_bucket.d.ts.map

package/src/shade/renderer/rasterize/bucket/graph_meshlets_rasterize_by_bucket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph_meshlets_rasterize_by_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/graph_meshlets_rasterize_by_bucket.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAd+B,KAAK;IACD,IAAI;IACZ,cAAc,EAA9B,MAAM;IAC0D,OAAO,EAAvE;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,EAAE;IAEtC,KAAK,EAArB,MAAM;IACY,aAAa,EAA/B,MAAM,EAAE;IACsB,eAAe;IAC5B,aAAa,EAA9B,OAAO;IACwC,WAAW,EAA1D,SAAS,OAAO,MAAM,cAAc,CAAC;IAClB,QAAQ,GAA3B,MAAM,EAAE;IACqB,MAAM;IACjC,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAmE9B"}

package/src/shade/renderer/rasterize/bucket/graph_meshlets_rasterize_by_bucket.js

@@ -0,0 +1,99 @@
+import { assert } from "../../../../core/assert.js";
+import { graph_extract_meshlets_from_bucket } from "../expand/bucket/meshlet/graph_extract_meshlets_from_bucket.js";
+import { graph_sort_meshlets_by_bucket_id } from "../expand/bucket/meshlet/graph_sort_meshlets_by_bucket_id.js";
+import { graph_meshlets_rasterize } from "../expand/graph_meshlets_rasterize.js";
+import { construct_primitive_state } from "./construct_primitive_state.js";
+
+/**
+ * Draw one view's meshlets, of several opaque buckets at once, each bucket under its own pipeline
+ * state.
+ *
+ * The other half of cutting a view once (CUT_PLAN_2026_09_14 §7 6b). Expansion and the
+ * virtual-geometry cut run over every opaque instance of the view together, so what comes out is
+ * one collection with every bucket in it, and the buckets are separated here, after the fact: sort
+ * by bucket, then one draw per bucket over its slice.
+ *
+ * With a single bucket there is nothing to separate — every meshlet is in it — and the collection
+ * is drawn as it is.
+ *
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {GPUViewContext} options.view
+ * @param {number} options.input_meshlets every meshlet to draw, all of them in `buckets`
+ * @param {{draw_mode: number, side: number, bucket_id: number}[]} options.buckets the opaque
+ *     buckets drawn, as {@link rasterization_opaque_buckets} yields them; at least one
+ * @param {number} options.depth
+ * @param {number[]} options.color_targets
+ * @param {RenderPassDescriptor} options.pass_descriptor
+ * @param {boolean} options.clear_targets whether the first draw clears
+ * @param {Readonly<Record<number, GPUCullMode>>} options.cull_policy
+ * @param {number[]} [options.viewport]
+ * @param {GPUCollectionLimits} options.limits
+ * @returns {[number, number[]]} depth and colour handles, as {@link graph_meshlets_rasterize}
+ */
+export function graph_meshlets_rasterize_by_bucket({
+                                                       graph,
+                                                       view,
+                                                       input_meshlets,
+                                                       buckets,
+                                                       depth,
+                                                       color_targets,
+                                                       pass_descriptor,
+                                                       clear_targets,
+                                                       cull_policy,
+                                                       viewport,
+                                                       limits,
+                                                   }) {
+    assert.isArray(buckets, 'buckets');
+    assert.greaterThanOrEqual(buckets.length, 1, 'buckets.length');
+
+    if (buckets.length === 1) {
+        const { draw_mode, side } = buckets[0];
+
+        return graph_meshlets_rasterize({
+            graph,
+            view,
+            input_meshlets,
+            depth,
+            color_targets,
+            pass_descriptor,
+            clear_targets,
+            primitive_state: construct_primitive_state(draw_mode, side, cull_policy),
+            viewport,
+        });
+    }
+
+    const sorted = graph_sort_meshlets_by_bucket_id({
+        graph,
+        input_meshlets,
+        scene_ctx: view.scene,
+        limits,
+    });
+
+    let clear = clear_targets;
+
+    for (const { draw_mode, side, bucket_id } of buckets) {
+        const meshlets = graph_extract_meshlets_from_bucket({
+            graph,
+            buckets: sorted,
+            bucket_id,
+            limits,
+        });
+
+        [depth, color_targets] = graph_meshlets_rasterize({
+            graph,
+            view,
+            input_meshlets: meshlets,
+            depth,
+            color_targets,
+            pass_descriptor,
+            clear_targets: clear,
+            primitive_state: construct_primitive_state(draw_mode, side, cull_policy),
+            viewport,
+        });
+
+        clear = false;
+    }
+
+    return [depth, color_targets];
+}

package/src/shade/renderer/rasterize/bucket/rasterization_opaque_buckets.d.ts

@@ -1,10 +1,10 @@
 /**
  * The opaque rasterization buckets a scene has anything in, once each.
  *
- * Every opaque path records one pass per bucket, and the pass is expensive — extract, expand to
- * meshlets, select a virtual-geometry cut, one render pass. So what is iterated has to be the
- * *buckets*, and iterating `ShadeDrawSide` is not that: `Front` and `Back` are one bucket, and a
- * loop over the enum visits it twice and draws the scene's single-sided geometry twice.
+ * Every opaque path records work per bucket — a filter, a slice of the sorted meshlets, a render
+ * pass. So what is iterated has to be the *buckets*, and iterating `ShadeDrawSide` is not that:
+ * `Front` and `Back` are one bucket, and a loop over the enum visits it twice and draws the scene's
+ * single-sided geometry twice.
  *
  * Which is why this exists rather than the three callers each writing the loop: the enum is the
  * obvious thing to reach for and it is wrong, and it is wrong in a way that costs a whole pass and

package/src/shade/renderer/rasterize/bucket/rasterization_opaque_buckets.js

@@ -1,36 +1,36 @@
-import { ShadeDrawMode } from "../../material/ShadeDrawMode.js";
-import { TransparencyMode } from "../../material/TransparencyMode.js";
-import { rasterization_material_bucket } from "../expand/bucket/chunk_rasterization_material_bucket.js";
-import { RASTERIZATION_BUCKET_SIDES } from "./construct_primitive_state.js";
-
-/**
- * The opaque rasterization buckets a scene has anything in, once each.
- *
- * Every opaque path records one pass per bucket, and the pass is expensive — extract, expand to
- * meshlets, select a virtual-geometry cut, one render pass. So what is iterated has to be the
- * *buckets*, and iterating `ShadeDrawSide` is not that: `Front` and `Back` are one bucket, and a
- * loop over the enum visits it twice and draws the scene's single-sided geometry twice.
- *
- * Which is why this exists rather than the three callers each writing the loop: the enum is the
- * obvious thing to reach for and it is wrong, and it is wrong in a way that costs a whole pass and
- * shows up in nothing but a frame time.
- *
- * @param {Set<number>} active_buckets bucket ids any material in the scene asks for
- * @yields {{draw_mode: ShadeDrawMode, side: ShadeDrawSide, bucket_id: number}} `side` is the
- *   bucket's representative, which is what {@link construct_primitive_state} wants
- */
-export function* rasterization_opaque_buckets(active_buckets) {
-    for (const draw_mode of Object.values(ShadeDrawMode)) {
-        for (const side of RASTERIZATION_BUCKET_SIDES) {
-
-            const bucket_id = rasterization_material_bucket(TransparencyMode.Opaque, draw_mode, side);
-
-            if (!active_buckets.has(bucket_id)) {
-                // no matching materials, skip
-                continue;
-            }
-
-            yield { draw_mode, side, bucket_id };
-        }
-    }
-}
+import { ShadeDrawMode } from "../../material/ShadeDrawMode.js";
+import { TransparencyMode } from "../../material/TransparencyMode.js";
+import { rasterization_material_bucket } from "../expand/bucket/chunk_rasterization_material_bucket.js";
+import { RASTERIZATION_BUCKET_SIDES } from "./construct_primitive_state.js";
+
+/**
+ * The opaque rasterization buckets a scene has anything in, once each.
+ *
+ * Every opaque path records work per bucket — a filter, a slice of the sorted meshlets, a render
+ * pass. So what is iterated has to be the *buckets*, and iterating `ShadeDrawSide` is not that:
+ * `Front` and `Back` are one bucket, and a loop over the enum visits it twice and draws the scene's
+ * single-sided geometry twice.
+ *
+ * Which is why this exists rather than the three callers each writing the loop: the enum is the
+ * obvious thing to reach for and it is wrong, and it is wrong in a way that costs a whole pass and
+ * shows up in nothing but a frame time.
+ *
+ * @param {Set<number>} active_buckets bucket ids any material in the scene asks for
+ * @yields {{draw_mode: ShadeDrawMode, side: ShadeDrawSide, bucket_id: number}} `side` is the
+ *   bucket's representative, which is what {@link construct_primitive_state} wants
+ */
+export function* rasterization_opaque_buckets(active_buckets) {
+    for (const draw_mode of Object.values(ShadeDrawMode)) {
+        for (const side of RASTERIZATION_BUCKET_SIDES) {
+
+            const bucket_id = rasterization_material_bucket(TransparencyMode.Opaque, draw_mode, side);
+
+            if (!active_buckets.has(bucket_id)) {
+                // no matching materials, skip
+                continue;
+            }
+
+            yield { draw_mode, side, bucket_id };
+        }
+    }
+}