@woosh/meep-engine 3.14.6 → 3.16.0

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

@@ -0,0 +1,87 @@
+import { chunk_is_nan } from "../../../shader/chunk/math/chunk_is_nan.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addTexture("tScene")
+    .addTexture("tColor")
+    .addTexture("tNorm")
+    .addTexture("tExtinction")
+    .addTexture("tEmission")
+
+/**
+ * AVBOIT resolve: composites the four draw accumulators over the scene colour (plan §3.9).
+ *
+ * Per channel:
+ *
+ * ```
+ * T_total = exp(-Σ extinction)
+ * norm    = Σ norm > ε ? (1 - T_total) / Σ norm : 0
+ * out     = scene × T_total + Σ color × norm + Σ emission
+ * ```
+ *
+ * `emission` is light the draw already attenuated by the transmittance in front of it and that
+ * covers nothing, so it joins as it is — outside the normalization, which only redistributes the
+ * `1 - T_total` the surfaces took from the scene.
+ *
+ * The total transmittance is RGB, which fixed-function blending cannot apply to the destination
+ * without dual-source blending, so this reads the scene colour and writes a fresh target rather than
+ * blending in place. A NaN in any accumulator drops the transparency for that pixel and keeps the
+ * scene, the same backstop the MBOIT blend carries.
+ */
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>
+) -> @location(0) vec4<f32> {
+
+    let coord_u = vec2<u32>(coord.xy);
+
+    let scene = textureLoad(tScene, coord_u, 0);
+
+    let accum_color = textureLoad(tColor, coord_u, 0).rgb;
+    let accum_norm = textureLoad(tNorm, coord_u, 0).rgb;
+    let accum_extinction = textureLoad(tExtinction, coord_u, 0).rgb;
+    let accum_emission = textureLoad(tEmission, coord_u, 0).rgb;
+
+    if (is_nan(accum_color.r) || is_nan(accum_norm.r) || is_nan(accum_extinction.r) || is_nan(accum_emission.r)) {
+        // one NaN fragment poisons the whole pixel of an additive accumulator; keeping the opaque
+        // scene beats smearing NaN into the frame
+        return scene;
+    }
+
+    let total_transmittance = exp(-accum_extinction);
+
+    // sum of (1 - T_self) * T at each fragment; zero where nothing transparent was drawn
+    let safe = accum_norm > vec3<f32>(1e-4);
+    let renormalization = select(
+        vec3<f32>(0.0),
+        (vec3<f32>(1.0) - total_transmittance) / max(accum_norm, vec3<f32>(1e-4)),
+        safe
+    );
+
+    let transparent = accum_color * renormalization;
+
+    return vec4<f32>(scene.rgb * total_transmittance + transparent + accum_emission, scene.a);
+}
+    `, [
+        chunk_is_nan
+    ]
+)
+
+export const shader_avboit_resolve = ImageShader.from({
+    descriptor: ShaderDescriptor.from({
+        label: "AVBOIT / resolve",
+        resources,
+        body,
+    }),
+    targets: [{
+        label: "AVBOIT composited",
+        format: "rgba16float",
+    }]
+})

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

@@ -0,0 +1,15 @@
+/**
+ * Bind group index of the atomics the splat writes; the three below it are the rasterization
+ * path's fixed material / scene / view slots.
+ * @type {number}
+ */
+export const AVBOIT_SPLAT_BIND_GROUP_VOLUME: number;
+/**
+ * Format of the attachment the splat pass rasterizes against. It is never written (`writeMask: 0`);
+ * WebGPU requires at least one attachment and this is the cheapest one.
+ * @type {GPUTextureFormat}
+ */
+export const AVBOIT_SPLAT_DUMMY_FORMAT: GPUTextureFormat;
+export const shader_avboit_splat: RenderPassDescriptor;
+import { RenderPassDescriptor } from "../../../shader/pass/RenderPassDescriptor.js";
+//# sourceMappingURL=shader_avboit_splat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_avboit_splat.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_splat.js"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;GAIG;AACH,yDAAmD;AA4JnD,uDAA8D;qCAtLzB,8CAA8C"}

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

@@ -0,0 +1,202 @@
+import { PipelineLayoutDescriptor } from "../../../../descriptor/pipeline/PipelineLayoutDescriptor.js";
+import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { atomic_u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { SHADING_MATERIAL_RESOURCE_GROUP } from "../../../material/standard/SHADING_MATERIAL_RESOURCE_GROUP.js";
+import { chunk_F_Hauber } from "../../../shader/chunk/brdf/fresnel/chunk_F_Hauber.js";
+import { chunk_get_view_space_depth } from "../../../shader/chunk/depth/chunk_get_view_space_depth.js";
+import { chunk_mat4_extract_position } from "../../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+import { chunk_dielectric_specular_color } from "../../../shader/chunk/material/chunk_dielectric_specular_color.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { RenderPassColorAttachmentDescriptor } from "../../../shader/pass/RenderPassColorAttachmentDescriptor.js";
+import { RenderPassDescriptor } from "../../../shader/pass/RenderPassDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
+import { FORWARD_VERTEX_SHADER_STRUCT } from "../../forward/FORWARD_VERTEX_SHADER_STRUCT.js";
+import { SHADING_SCENE_RESOURCE_GROUP } from "../../forward/SHADING_SCENE_RESOURCE_GROUP.js";
+import { vertex_shader_chunk } from "../../forward/vertex_shader_chunk.js";
+import { OIT_COVERAGE_MAX } from "../oit/OIT_CONSTANTS.js";
+import { rasterization_primitive_state } from "../rasterization_primitive_state.js";
+import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
+import { chunk_avboit_splat_slice } from "./chunk_avboit_splat_slice.js";
+import { chunk_avboit_transmission_tint } from "./chunk_avboit_transmission_tint.js";
+import { chunk_avboit_transmittance_to_extinction } from "./chunk_avboit_transmittance_to_extinction.js";
+import { chunk_avboit_view_depth_to_physical } from "./chunk_avboit_view_depth_to_physical.js";
+
+/**
+ * Bind group index of the atomics the splat writes; the three below it are the rasterization
+ * path's fixed material / scene / view slots.
+ * @type {number}
+ */
+export const AVBOIT_SPLAT_BIND_GROUP_VOLUME = 3;
+
+/**
+ * Format of the attachment the splat pass rasterizes against. It is never written (`writeMask: 0`);
+ * WebGPU requires at least one attachment and this is the cheapest one.
+ * @type {GPUTextureFormat}
+ */
+export const AVBOIT_SPLAT_DUMMY_FORMAT = "r8unorm";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.addGroup(SHADING_MATERIAL_RESOURCE_GROUP);
+resources.addGroup(SHADING_SCENE_RESOURCE_GROUP);
+
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
+;
+
+resources.createGroup()
+    .addStorageBuffer("extinction_volume", WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer("overflow_slice", WebGPUArray.from(atomic_u32), true)
+;
+
+const shader_vertex = ShaderDescriptor.from({
+    label: 'AVBOIT / splat vertex shader',
+    body: vertex_shader_chunk,
+    resources,
+});
+
+/**
+ * AVBOIT splat: rasterizes the transparent buckets at 1/8 resolution and adds each fragment's RGB
+ * extinction into the voxel volume with atomics (plan §3.5).
+ *
+ * Coverage is computed the way `shader_oit_generate_moments` computes it — texture alpha, or the
+ * view-angle Fresnel when the material transmits — and then, new to this path, a per-channel
+ * self-transmittance: `(1 - coverage) × tint`, with `tint` the base colour weighted by
+ * `transmission_factor` — but only while `AVBOITSettings.transmission_tint_from_base_color` is on,
+ * which the warp header carries. A plain alpha-blended material lands exactly where it would under
+ * MBOIT (`tint = 1`), and so does glass unless the tint is opted into.
+ *
+ * Depth goes view-space → curve → warp → physical, and the extinction is linear-splat between the
+ * two physical slices around it (`c = p - 0.5`) so a surface crossing a slice boundary does not
+ * alias. The add itself, and the overflow it may record, is `chunk_avboit_splat_slice` — shared
+ * with every side channel's splat, so a particle reaches the volume through the same code.
+ *
+ * No depth attachment: a splat behind opaque geometry lies deeper than any visible transparent
+ * fragment and the integral at a depth only contains what is in front of it. No TAA un-jitter: the
+ * jitter is expressed in internal-resolution pixels and the derivative-based correction would be
+ * eight times too large here.
+ */
+const fragment_body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn main(
+    @builtin(front_facing) front_facing : bool,
+    vert: ${FORWARD_VERTEX_SHADER_STRUCT.wgsl_ref},
+) {
+    let uv = vert.uv;
+
+    let t_diffuse = textureSample(texture_diffuse, texture_diffuse_sampler, uv);
+    let surface_alpha = t_diffuse.a * material_info.albedo_color.a;
+
+    var opacity = surface_alpha;
+    var tint = vec3<f32>(1.0);
+
+    let f_transmission = material_info.transmission_factor;
+    if (f_transmission > 0.0) {
+        let t_pbr = textureSample(texture_orm, texture_orm_sampler, uv);
+        // undo premultiplication; vert.color already carries the material's albedo colour
+        let base_color = (t_diffuse.rgb / max(t_diffuse.a, 1e-7)) * vert.color;
+        let f_metalness = t_pbr.b * material_info.metallic_factor;
+        let specular_f0 = dielectric_specular_color(material_info.ior_factor, f_metalness, base_color);
+
+        let view_position = mat4_extract_position(camera.transform);
+        let view_direction = normalize(view_position - vert.position_ws);
+        let nov = saturate(abs(dot(normalize(vert.normal), view_direction)));
+        let f_view = F_Hauber(specular_f0, 1.0, nov);
+        let f_scalar = max(f_view.r, max(f_view.g, f_view.b));
+
+        opacity = mix(surface_alpha, f_scalar, f_transmission);
+        // what the surface lets through is coloured by what it is made of, when the renderer says
+        // so (AVBOITSettings.transmission_tint_from_base_color, carried in the warp header)
+        tint = avboit_transmission_tint(base_color, f_transmission * f32(warp.tint_from_base_color));
+    }
+
+    let coverage = min(opacity, ${OIT_COVERAGE_MAX});
+    let transmittance = (1.0 - coverage) * tint;
+    let extinction = avboit_transmittance_to_extinction(transmittance);
+
+    // vert.position is @builtin(position): .z is device depth, .xy the low-resolution pixel
+    let z_view = get_view_space_depth(vert.position.z, camera);
+    let p = avboit_view_depth_to_physical(&warp, z_view);
+
+    let texel = vec2<u32>(vert.position.xy);
+    let column = (texel.y * warp.voxel_width + texel.x) * warp.physical_count;
+
+    // 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);
+}
+    `, [
+        FORWARD_VERTEX_SHADER_STRUCT.declaration_chunk,
+        chunk_get_view_space_depth,
+        chunk_mat4_extract_position,
+        chunk_dielectric_specular_color,
+        chunk_F_Hauber,
+        chunk_avboit_splat_slice,
+        chunk_avboit_transmission_tint,
+        chunk_avboit_transmittance_to_extinction,
+        chunk_avboit_view_depth_to_physical,
+    ]
+);
+
+const shader_fragment = ShaderDescriptor.from({
+    label: "AVBOIT / splat",
+    resources,
+    body: fragment_body
+});
+
+/*
+ The pipeline layout is built group by group rather than with `generatePipelineLayout(stage)`, which
+ gives every group the same visibility: WebGPU refuses a read-write storage buffer that is visible to
+ the vertex stage, and the atomics group is fragment-only. The first three groups keep the
+ rasterization path's `VERTEX | FRAGMENT`, which is what the bind groups the orchestrator builds
+ against `SHADING_*_RESOURCE_GROUP` are laid out for.
+*/
+const groups = resources.groups;
+const layout = PipelineLayoutDescriptor.from([
+    groups[0].generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+    groups[1].generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+    groups[2].generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+    groups[AVBOIT_SPLAT_BIND_GROUP_VOLUME].generateBindGroupLayoutDescriptor(GPUShaderStage.FRAGMENT),
+], resources.immediateSize);
+
+const pipeline = RenderPipelineDescriptor.from({
+    label: "AVBOIT / splat",
+    layout,
+    vertex: {
+        module: {
+            code: shader_vertex.source
+        }
+    },
+    fragment: {
+        module: {
+            code: shader_fragment.source
+        },
+        targets: [
+            // never written; see AVBOIT_SPLAT_DUMMY_FORMAT
+            {
+                format: AVBOIT_SPLAT_DUMMY_FORMAT,
+                writeMask: 0,
+            }
+        ]
+    },
+    primitive: rasterization_primitive_state,
+});
+
+export const shader_avboit_splat = new RenderPassDescriptor();
+shader_avboit_splat.pipeline = pipeline;
+shader_avboit_splat.resources = resources;
+shader_avboit_splat.colorAttachments = [
+    RenderPassColorAttachmentDescriptor.from({
+        clearValue: [0, 0, 0, 0],
+    }),
+];

package/src/shade/renderer/rasterize/native/material_draw_indirect.d.ts

@@ -0,0 +1,22 @@
+/**
+ * One indirect draw per material out of a command buffer built by
+ * `graph_prepare_meshlet_draw_commands_by_material`, with the material's bind group at slot 0.
+ * Materials whose GPU side is not built yet are skipped. Shared by the MBOIT and AVBOIT
+ * orchestrators, which call it once per render pass they record.
+ *
+ * @param {GPUMaterialManager} material_manager
+ * @param {number} material_count
+ * @param {ShadeMaterial[]} materials
+ * @param {RenderPassDescriptor} render_pass_descriptor its group 0 is the material group
+ * @param {BindGroupManager} bind_manager
+ * @param {ShadeGPURenderPassEncoder} pass_encoder
+ * @param {GPUBuffer} command_buffer_draw one `STRUCT_UNINDEXED_DRAW_COMMAND` per material, in order
+ */
+export function material_draw_indirect(material_manager: GPUMaterialManager, material_count: number, materials: ShadeMaterial[], render_pass_descriptor: RenderPassDescriptor, bind_manager: BindGroupManager, pass_encoder: ShadeGPURenderPassEncoder, command_buffer_draw: GPUBuffer): void;
+/**
+ * The material bind group layout every transparent draw binds at slot 0; hoisted so it is computed
+ * once and so the two transparency pipelines cannot disagree on it.
+ * @type {BindGroupLayoutDescriptor}
+ */
+export const BIND_GROUP_LAYOUT_MATERIAL: BindGroupLayoutDescriptor;
+//# sourceMappingURL=material_draw_indirect.d.ts.map

package/src/shade/renderer/rasterize/native/material_draw_indirect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"material_draw_indirect.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/native/material_draw_indirect.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;GAaG;AACH,6FAPW,MAAM,aACN,eAAe,+JA8CzB;AA7DD;;;;GAIG;AACH,mEAA6J"}

package/src/shade/renderer/rasterize/native/material_draw_indirect.js

@@ -0,0 +1,69 @@
+import { assert } from "../../../../core/assert.js";
+import { STRUCT_UNINDEXED_DRAW_COMMAND } from "../../gpu_primitive/indirect/STRUCT_UNINDEXED_DRAW_COMMAND.js";
+import { BindGroupDescriptor } from "../../binding/BindGroupDescriptor.js";
+import { SHADING_MATERIAL_RESOURCE_GROUP } from "../../material/standard/SHADING_MATERIAL_RESOURCE_GROUP.js";
+
+const DRAW_COMMAND_BYTE_SIZE = STRUCT_UNINDEXED_DRAW_COMMAND.aligned_size;
+
+/**
+ * The material bind group layout every transparent draw binds at slot 0; hoisted so it is computed
+ * once and so the two transparency pipelines cannot disagree on it.
+ * @type {BindGroupLayoutDescriptor}
+ */
+export const BIND_GROUP_LAYOUT_MATERIAL = SHADING_MATERIAL_RESOURCE_GROUP.generateBindGroupLayoutDescriptor(GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX);
+
+/**
+ * One indirect draw per material out of a command buffer built by
+ * `graph_prepare_meshlet_draw_commands_by_material`, with the material's bind group at slot 0.
+ * Materials whose GPU side is not built yet are skipped. Shared by the MBOIT and AVBOIT
+ * orchestrators, which call it once per render pass they record.
+ *
+ * @param {GPUMaterialManager} material_manager
+ * @param {number} material_count
+ * @param {ShadeMaterial[]} materials
+ * @param {RenderPassDescriptor} render_pass_descriptor its group 0 is the material group
+ * @param {BindGroupManager} bind_manager
+ * @param {ShadeGPURenderPassEncoder} pass_encoder
+ * @param {GPUBuffer} command_buffer_draw one `STRUCT_UNINDEXED_DRAW_COMMAND` per material, in order
+ */
+export function material_draw_indirect(
+    material_manager,
+    material_count,
+    materials,
+    render_pass_descriptor,
+    bind_manager,
+    pass_encoder,
+    command_buffer_draw
+) {
+
+    assert.defined(material_manager, 'material_manager');
+    assert.isNonNegativeInteger(material_count, 'material_count');
+    assert.isArray(materials, 'materials');
+
+    for (let i = 0; i < material_count; i++) {
+
+        const material = materials[i];
+        const gpu_material = material_manager.obtain(material);
+
+        if (!gpu_material.is_built) {
+            // skip, not ready for rendering
+            continue;
+        }
+
+        const material_resource_group = render_pass_descriptor.resources.groups[0];
+        const binding_entries = material_resource_group.generateBindings(gpu_material.binding_data);
+        const material_bindings = bind_manager.obtain(BindGroupDescriptor.from(
+            BIND_GROUP_LAYOUT_MATERIAL,
+            binding_entries
+        ));
+
+        // set material-specific bind group at 0
+        pass_encoder.setBindGroup(0, material_bindings)
+
+        pass_encoder.drawIndirect(
+            command_buffer_draw,
+            i * DRAW_COMMAND_BYTE_SIZE,
+        );
+
+    }
+}

package/src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_transparent_oit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js"],"names":[],"mappings":"AA6dA;;;;;;;;;;;;;;;;GAgBG;AACH,uSAFa,MAAM,CAsOlB"}
+{"version":3,"file":"graph_rasterize_meshes_transparent_oit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js"],"names":[],"mappings":"AAoaA;;;;;;;;;;;;;;;;GAgBG;AACH,uSAFa,MAAM,CAsOlB"}