@woosh/meep-engine 3.61.2 → 3.61.3

package/src/shade/renderer/geometry/sdf/cards/chunk_mesh_cards.js

@@ -1,107 +0,0 @@
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { chunk_mesh_sdf } from "../chunk_mesh_sdf.js";
-import { MESH_SDF_STRUCT } from "../MESH_SDF_STRUCT.js";
-import {
-    MESH_CARD_DIRECTIONS,
-    MESH_CARD_LAYOUT_CARD_COUNT,
-    MESH_CARD_LAYOUT_COLUMN_COUNT,
-    MESH_CARD_LAYOUT_DIRECTION_FIRST,
-    MESH_CARD_LAYOUT_PAGE_COUNT,
-    MESH_CARD_LAYOUT_RECORDS,
-    MESH_CARD_LAYOUT_TABLES,
-    MESH_CARD_MAX,
-    MESH_CARD_NO_PAGE,
-    MESH_CARD_PAGE_TEXELS,
-    MESH_CARD_RECORD_DIRECTION,
-    MESH_CARD_RECORD_FAR,
-    MESH_CARD_RECORD_NEAR,
-    MESH_CARD_RECORD_TABLE,
-    MESH_CARD_RECORD_WORDS,
-    MESH_CARD_SPLITS_MAX
-} from "./MESH_CARDS.js";
-
-/**
- * A geometry's cards on the device (`MESH_CARDS.js`): the layout's constants, the placement's
- * scratch by the level-0 grid, a direction's axes and extent, and the brick a direction's column
- * holds at a layer. Pure: nothing here reads a binding.
- *
- * ```wgsl
- * fn mesh_card_placement_of(bricks: vec3<u32>) -> MeshCardPlacement  // offsets from the range's start
- * fn mesh_card_axes(direction: u32) -> vec3<u32>                // the axis looked along, then u, v
- * fn mesh_card_extent(bricks: vec3<u32>, direction: u32) -> vec3<u32>
- * fn mesh_card_brick(bricks: vec3<u32>, direction: u32, column: vec2<u32>, layer: u32) -> vec3<u32>
- * ```
- *
- * @type {CodeChunk}
- */
-export const chunk_mesh_cards = CodeChunk.from(
-    //language=WGSL
-    `
-const MESH_CARD_MAX = ${MESH_CARD_MAX}u;
-const MESH_CARD_DIRECTIONS = ${MESH_CARD_DIRECTIONS}u;
-const MESH_CARD_SPLITS_MAX = ${MESH_CARD_SPLITS_MAX}u;
-const MESH_CARD_PAGE_TEXELS = ${MESH_CARD_PAGE_TEXELS}u;
-const MESH_CARD_NO_PAGE = ${MESH_CARD_NO_PAGE}u;
-
-const MESH_CARD_LAYOUT_CARD_COUNT = ${MESH_CARD_LAYOUT_CARD_COUNT}u;
-const MESH_CARD_LAYOUT_PAGE_COUNT = ${MESH_CARD_LAYOUT_PAGE_COUNT}u;
-const MESH_CARD_LAYOUT_COLUMN_COUNT = ${MESH_CARD_LAYOUT_COLUMN_COUNT}u;
-const MESH_CARD_LAYOUT_DIRECTION_FIRST = ${MESH_CARD_LAYOUT_DIRECTION_FIRST}u;
-const MESH_CARD_LAYOUT_RECORDS = ${MESH_CARD_LAYOUT_RECORDS}u;
-const MESH_CARD_LAYOUT_TABLES = ${MESH_CARD_LAYOUT_TABLES}u;
-
-const MESH_CARD_RECORD_DIRECTION = ${MESH_CARD_RECORD_DIRECTION}u;
-const MESH_CARD_RECORD_NEAR = ${MESH_CARD_RECORD_NEAR}u;
-const MESH_CARD_RECORD_FAR = ${MESH_CARD_RECORD_FAR}u;
-const MESH_CARD_RECORD_TABLE = ${MESH_CARD_RECORD_TABLE}u;
-const MESH_CARD_RECORD_WORDS = ${MESH_CARD_RECORD_WORDS}u;
-
-struct MeshCardPlacement {
-    histograms: u32,
-    splits: u32,
-    layers: u32,
-}
-
-fn mesh_card_placement_of(bricks: vec3<u32>) -> MeshCardPlacement {
-    let layers = max(bricks.x, max(bricks.y, bricks.z));
-    let columns_max = max(bricks.x * bricks.y, max(bricks.y * bricks.z, bricks.x * bricks.z));
-
-    var parts: MeshCardPlacement;
-
-    parts.histograms = MESH_CARD_LAYOUT_TABLES + 2u * MESH_CARD_MAX * columns_max;
-    parts.splits = parts.histograms + MESH_CARD_DIRECTIONS * layers * layers;
-    parts.layers = layers;
-
-    return parts;
-}
-
-fn mesh_card_axes(direction: u32) -> vec3<u32> {
-    let axis = direction >> 1u;
-
-    return vec3<u32>(axis, (axis + 1u) % 3u, (axis + 2u) % 3u);
-}
-
-fn mesh_card_extent(bricks: vec3<u32>, direction: u32) -> vec3<u32> {
-    let axes = mesh_card_axes(direction);
-
-    return vec3<u32>(bricks[axes.x], bricks[axes.y], bricks[axes.z]);
-}
-
-fn mesh_card_brick(bricks: vec3<u32>, direction: u32, column: vec2<u32>, layer: u32) -> vec3<u32> {
-    let axes = mesh_card_axes(direction);
-
-    // an even direction looks toward +axis, so its layer 0 is the grid's first brick along it
-    let along = select(bricks[axes.x] - 1u - layer, layer, (direction & 1u) == 0u);
-
-    var brick = vec3<u32>(0u);
-
-    brick[axes.x] = along;
-    brick[axes.y] = column.x;
-    brick[axes.z] = column.y;
-
-    return brick;
-}
-`, [
-        chunk_mesh_sdf,
-        MESH_SDF_STRUCT.declaration_chunk,
-    ]);

package/src/shade/renderer/geometry/sdf/cards/mesh_cards_raster_pass_descriptor.d.ts

@@ -1,65 +0,0 @@
-/**
- * @typedef {import("../../../../descriptor/binding/BindGroupLayoutDescriptor.js").BindGroupLayoutDescriptor} BindGroupLayoutDescriptor
- * @typedef {import("../../../material/template/ShadeMaterialTemplate.js").ShadeMaterialTemplate} ShadeMaterialTemplate
- */
-/**
- * Cells across a raster run's region: the region is MESH_CARD_MAX cells, this many a row.
- * @type {number}
- */
-export const MESH_CARD_RASTER_CELLS_X: number;
-/**
- * Rows of cells in a raster run's region.
- * @type {number}
- */
-export const MESH_CARD_RASTER_CELLS_Y: number;
-/**
- * The scratch the cards are drawn into, before the scatter moves their pages into the atlas.
- * @type {GPUTextureFormat[]}
- */
-export const MESH_CARD_RASTER_TARGET_FORMATS: GPUTextureFormat[];
-/**
- * @type {GPUTextureFormat}
- */
-export const MESH_CARD_RASTER_DEPTH_FORMAT: GPUTextureFormat;
-/**
- * @type {WebGPUStruct}
- */
-export const MESH_CARDS_RASTER_SETTINGS: WebGPUStruct;
-/**
- * Group 1: where the vertex stage pulls the geometry and its cards from. Vertex-only.
- *
- * `mesh_card_raster_runs` is a `vec4<u32>` a run: (first scatter thread, card set, the region's
- * corner in the scratch as x | y << 16, the side of its cells in texels).
- *
- * @type {ShaderResourceGroupDescriptor}
- */
-export const MESH_CARDS_RASTER_GROUP: ShaderResourceGroupDescriptor;
-/**
- * @type {BindGroupLayoutDescriptor}
- */
-export const MESH_CARDS_RASTER_LAYOUT: BindGroupLayoutDescriptor;
-/**
- * Card capture by raster ({@link MeshCardCaptureMode.Raster}): one pipeline per material template,
- * the template's group 0 — the material's one bind group, which the G-buffer pass binds — then
- * {@link MESH_CARDS_RASTER_GROUP}, and {@link MESH_CARDS_RASTER_SETTINGS} as immediate data.
- *
- * A run's draw covers every card of its card set, each into its cell of the run's region of the
- * scratch: `rgba8unorm` √(diffuse albedo) and depth, `rgba8unorm` emissive / s_e, and a
- * `depth32float` depth through the slab. Draw it with culling off: a card sees either side.
- *
- * Only a template with a surface function can be drawn.
- *
- * @type {TemplatePassDescriptor}
- */
-export const mesh_cards_raster_pass_descriptor: TemplatePassDescriptor;
-/**
- * Bytes of {@link MESH_CARDS_RASTER_SETTINGS} the draws hand `setImmediates`.
- * @type {number}
- */
-export const MESH_CARDS_RASTER_IMMEDIATE_SIZE: number;
-export type BindGroupLayoutDescriptor = import("../../../../descriptor/binding/BindGroupLayoutDescriptor.js").BindGroupLayoutDescriptor;
-export type ShadeMaterialTemplate = import("../../../material/template/ShadeMaterialTemplate.js").ShadeMaterialTemplate;
-import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
-import { TemplatePassDescriptor } from "../../../rasterize/TemplatePassDescriptor.js";
-//# sourceMappingURL=mesh_cards_raster_pass_descriptor.d.ts.map

package/src/shade/renderer/geometry/sdf/cards/mesh_cards_raster_pass_descriptor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mesh_cards_raster_pass_descriptor.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/cards/mesh_cards_raster_pass_descriptor.js"],"names":[],"mappings":"AAkCA;;;GAGG;AAEH;;;GAGG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;GAGG;AACH,uCAFU,MAAM,CAE4E;AAE5F;;;GAGG;AACH,8CAFU,kBAAkB,CAEgD;AAE5E;;GAEG;AACH,6DAA4D;AAE5D;;GAEG;AACH,yCAFU,YAAY,CASQ;AAE9B;;;;;;;GAOG;AACH,sCAFU,6BAA6B,CAEoC;AAe3E;;GAEG;AACH,uCAFU,yBAAyB,CAEiE;AAiOpG;;;;;;;;;;;;GAYG;AACH,gDAFU,sBAAsB,CAiC7B;AAEH;;;GAGG;AACH,+CAFU,MAAM,CAE+D;wCApVlE,OAAO,6DAA6D,EAAE,yBAAyB;oCAC/F,OAAO,qDAAqD,EAAE,qBAAqB;6BAVnE,sCAAsC;8CALrB,2DAA2D;uCARlE,8CAA8C"}

package/src/shade/renderer/geometry/sdf/cards/mesh_cards_raster_pass_descriptor.js

@@ -1,376 +0,0 @@
-import { GPUShaderStage } from "../../../../descriptor/GPUShaderStage.js";
-import { PipelineLayoutDescriptor } from "../../../../descriptor/pipeline/PipelineLayoutDescriptor.js";
-import { DepthStencilState } from "../../../../descriptor/pipeline/render/DepthStencilState.js";
-import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
-import { GEOMETRY_ATTRIBUTE_DATA_RESOURCE } from "../../GEOMETRY_ATTRIBUTE_DATA_RESOURCE.js";
-import { GEOMETRY_METADATA_STRUCT } from "../../GEOMETRY_METADATA_STRUCT.js";
-import { MESHLET_METADATA_RESOURCE } from "../../meshlet/MESHLET_METADATA_RESOURCE.js";
-import {
-    chunk_material_opacity_contract,
-    chunk_material_opacity_opaque,
-    chunk_material_surface_contract
-} from "../../../material/template/chunk_material_surface.js";
-import { rasterization_primitive_state } from "../../../rasterize/native/rasterization_primitive_state.js";
-import { TemplatePassDescriptor } from "../../../rasterize/TemplatePassDescriptor.js";
-import {
-    chunk_read_meshlet_vertex_by_draw_index
-} from "../../../shader/chunk/geometry/meshlet/chunk_read_meshlet_vertex_by_draw_index.js";
-import { chunk_random } from "../../../shader/chunk/random/chunk_random.js";
-import { chunk_random_initialize } from "../../../shader/chunk/random/chunk_random_initialize.js";
-import { GRADIENT_SAMPLING_INFO_STRUCT } from "../../../shader/chunk/texture/GRADIENT_SAMPLING_INFO_STRUCT.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
-import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
-import { f32, u32, vec4u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { MESH_SDF_HEADERS_RESOURCE, MESH_SDF_INDIRECTION_RESOURCE } from "../MESH_SDF_RESOURCES.js";
-import { MESH_SDF_STRUCT } from "../MESH_SDF_STRUCT.js";
-import { chunk_mesh_cards } from "./chunk_mesh_cards.js";
-import { MESH_CARD_SETS_RESOURCE } from "./MESH_CARD_RESOURCES.js";
-import { MESH_CARD_SET_STRUCT } from "./MESH_CARD_SET_STRUCT.js";
-import { MESH_CARD_MAX } from "./MESH_CARDS.js";
-
-/**
- * @typedef {import("../../../../descriptor/binding/BindGroupLayoutDescriptor.js").BindGroupLayoutDescriptor} BindGroupLayoutDescriptor
- * @typedef {import("../../../material/template/ShadeMaterialTemplate.js").ShadeMaterialTemplate} ShadeMaterialTemplate
- */
-
-/**
- * Cells across a raster run's region: the region is MESH_CARD_MAX cells, this many a row.
- * @type {number}
- */
-export const MESH_CARD_RASTER_CELLS_X = 8;
-
-/**
- * Rows of cells in a raster run's region.
- * @type {number}
- */
-export const MESH_CARD_RASTER_CELLS_Y = Math.ceil(MESH_CARD_MAX / MESH_CARD_RASTER_CELLS_X);
-
-/**
- * The scratch the cards are drawn into, before the scatter moves their pages into the atlas.
- * @type {GPUTextureFormat[]}
- */
-export const MESH_CARD_RASTER_TARGET_FORMATS = ["rgba8unorm", "rgba8unorm"];
-
-/**
- * @type {GPUTextureFormat}
- */
-export const MESH_CARD_RASTER_DEPTH_FORMAT = "depth32float";
-
-/**
- * @type {WebGPUStruct}
- */
-export const MESH_CARDS_RASTER_SETTINGS = WebGPUStruct.from({
-    /** the run drawn, its entry in `mesh_card_raster_runs` */
-    run: u32,
-    /** the scratch's texels across */
-    width: f32,
-    /** the scratch's texels down */
-    height: f32,
-}, "MeshCardsRasterSettings");
-
-/**
- * Group 1: where the vertex stage pulls the geometry and its cards from. Vertex-only.
- *
- * `mesh_card_raster_runs` is a `vec4<u32>` a run: (first scatter thread, card set, the region's
- * corner in the scratch as x | y << 16, the side of its cells in texels).
- *
- * @type {ShaderResourceGroupDescriptor}
- */
-export const MESH_CARDS_RASTER_GROUP = new ShaderResourceGroupDescriptor();
-
-MESH_CARDS_RASTER_GROUP.label = "mesh cards raster";
-
-MESH_CARDS_RASTER_GROUP
-    .add(MESH_SDF_HEADERS_RESOURCE)
-    .add(MESH_SDF_INDIRECTION_RESOURCE)
-    .add(MESH_CARD_SETS_RESOURCE)
-    .addStorageBuffer("mesh_card_raster_runs", WebGPUArray.from(vec4u))
-    .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
-    .add(MESHLET_METADATA_RESOURCE)
-    .add(GEOMETRY_ATTRIBUTE_DATA_RESOURCE);
-
-MESH_CARDS_RASTER_GROUP.addVisibility(GPUShaderStage.VERTEX);
-
-/**
- * @type {BindGroupLayoutDescriptor}
- */
-export const MESH_CARDS_RASTER_LAYOUT = MESH_CARDS_RASTER_GROUP.generateBindGroupLayoutDescriptor();
-
-const vertex_resources = new ShaderResourceSetDescriptor();
-
-vertex_resources.setImmediate("settings", MESH_CARDS_RASTER_SETTINGS);
-vertex_resources.createGroup({ index: 0, label: "material (fragment only)" });
-vertex_resources.addGroup(MESH_CARDS_RASTER_GROUP);
-
-const VARYINGS = `
-struct MeshCardRasterVertex {
-    @builtin(position) position: vec4<f32>,
-    @location(0) uv: vec2<f32>,
-    @location(1) uv1: vec2<f32>,
-    @location(2) position_os: vec3<f32>,
-    @location(3) normal: vec3<f32>,
-    @location(4) color: vec3<f32>,
-    @location(5) @interpolate(flat) card_set: u32,
-    @location(6) @interpolate(flat) card: u32,
-    @location(7) @interpolate(flat) emissive_scale: f32,
-    @location(8) @interpolate(flat) along: vec3<f32>,
-}
-`;
-
-/*
- Instance i of run r's draw is card i / m's meshlet i mod m, m the geometry's meshlets; vertex v is
- its triangle v / 3's corner, as the alpha-tested raster reads a meshlet. A card maps the geometry's
- local space onto its cell: lattice (u, v) across the card to texel (u, v) of the cell, its centre on
- the lattice point, which is where the trace starts its ray; depth from the near face over the slab's
- depth to [0, 1], so the hardware clips to the slab as the trace's t ≤ depth does. The geometry lies
- inside its grid, so nothing it draws falls outside the card's face, and the cells need no clip.
-*/
-const vertex_body = CodeChunk.from(
-    //language=WGSL
-    `
-${VARYINGS}
-
-@vertex
-fn main(
-    @builtin(vertex_index) vertex_draw_index: u32,
-    @builtin(instance_index) instance: u32,
-) -> MeshCardRasterVertex {
-    var out: MeshCardRasterVertex;
-
-    let run = mesh_card_raster_runs[settings.run];
-    let card_set = mesh_card_sets[run.y];
-    let geometry = geometries[card_set.geometry];
-    let header = mesh_sdf_headers[card_set.geometry];
-
-    // the args draw no instance of a geometry without meshlets
-    let meshlets = max(geometry.meshlets_count, 1u);
-    let card = instance / meshlets;
-    let meshlet_header = meshlet_metadata[geometry.meshlets_address + instance % meshlets];
-
-    if (vertex_draw_index >= meshlet_header.primitive_count * 3u) {
-        // past the meshlet's triangles: a degenerate one, which draws nothing
-        return out;
-    }
-
-    let attributes = read_meshlet_vertex_by_draw_index(meshlet_header, vertex_draw_index);
-
-    let record = header.cards + MESH_CARD_LAYOUT_RECORDS + card * MESH_CARD_RECORD_WORDS;
-    let direction = mesh_sdf_indirection[record + MESH_CARD_RECORD_DIRECTION];
-    let near = mesh_sdf_indirection[record + MESH_CARD_RECORD_NEAR];
-    let far = mesh_sdf_indirection[record + MESH_CARD_RECORD_FAR];
-
-    let axes = mesh_card_axes(direction);
-    let toward_plus = (direction & 1u) == 0u;
-
-    // voxels from the grid's corner
-    let p = (attributes.position - header.origin) / header.voxel;
-
-    let face = f32(select(header.bricks[axes.x] - near, near, toward_plus) * MESH_SDF_BRICK_VOXELS);
-    let depth = select(face - p[axes.x], p[axes.x] - face, toward_plus);
-    let slab = f32((far - near) * MESH_SDF_BRICK_VOXELS);
-
-    let corner = vec2<f32>(f32(run.z & 0xffffu), f32(run.z >> 16u))
-        + vec2<f32>(f32(card % ${MESH_CARD_RASTER_CELLS_X}u), f32(card / ${MESH_CARD_RASTER_CELLS_X}u)) * f32(run.w);
-    let texel = corner + vec2<f32>(p[axes.y], p[axes.z]) + 0.5;
-
-    out.position = vec4<f32>(
-        texel.x / settings.width * 2.0 - 1.0,
-        1.0 - texel.y / settings.height * 2.0,
-        depth / slab,
-        1.0
-    );
-
-    var along = vec3<f32>(0.0);
-
-    along[axes.x] = select(-1.0, 1.0, toward_plus);
-
-    out.uv = attributes.uv;
-    out.uv1 = attributes.uv1;
-    out.position_os = attributes.position;
-    out.normal = attributes.normal;
-    out.color = attributes.color;
-    out.card_set = run.y;
-    out.card = card;
-    out.emissive_scale = card_set.emissive_scale;
-    out.along = along;
-
-    return out;
-}
-`, [
-        MESH_SDF_STRUCT.declaration_chunk,
-        MESH_CARD_SET_STRUCT.declaration_chunk,
-        GEOMETRY_METADATA_STRUCT.declaration_chunk,
-        chunk_mesh_cards,
-        chunk_read_meshlet_vertex_by_draw_index,
-    ]);
-
-const vertex_code = ShaderDescriptor.from({
-    label: "Mesh Cards Raster / vertex",
-    resources: vertex_resources,
-    body: vertex_body,
-}).source;
-
-/*
- The template is handed what the G-buffer pass hands it, in the geometry's local space, the card
- being there: real derivatives, as this is a raster with neighbours of its own triangle, unbiased (mip
- bias at 0). Both functions run first, in uniform control
- flow, so a template may sample with implicit derivatives.
-
- Coverage is drawn as the trace draws it, a texel's surface opaque with probability its opacity, from
- a seed fixed by the card set, the card and the texel; the depth test keeps the nearest opaque draw.
- The planes are the trace's: √(albedo × (1 − metalness)) and depth through the slab on [1/255, 1];
- emissive over s_e.
-*/
-const fragment_body = CodeChunk.from(
-    //language=WGSL
-    `
-${VARYINGS}
-
-struct MeshCardRasterTargets {
-    @location(0) albedo: vec4<f32>,
-    @location(1) emissive: vec4<f32>,
-}
-
-@fragment
-fn main(in: MeshCardRasterVertex) -> MeshCardRasterTargets {
-    let uv = ${GRADIENT_SAMPLING_INFO_STRUCT.wgsl_ref}(in.uv, dpdx(in.uv), dpdy(in.uv));
-    let uv1 = ${GRADIENT_SAMPLING_INFO_STRUCT.wgsl_ref}(in.uv1, dpdx(in.uv1), dpdy(in.uv1));
-    let position_ddx = dpdx(in.position_os);
-    let position_ddy = dpdy(in.position_os);
-
-    var opacity_input: MaterialOpacityInput;
-
-    opacity_input.uv = uv;
-    opacity_input.mip_bias = 0.0;
-    opacity_input.position_ws = in.position_os;
-
-    let opacity = material_opacity(opacity_input);
-
-    var surface_input: MaterialSurfaceInput;
-
-    surface_input.uv = uv;
-    surface_input.uv1 = uv1;
-    surface_input.gradient_bias = vec2<f32>(1.0);
-    surface_input.position_os = in.position_os;
-    surface_input.position_os_ddx = position_ddx;
-    surface_input.position_os_ddy = position_ddy;
-    surface_input.position_ws = in.position_os;
-    surface_input.normal_ws = normalize(in.normal);
-    surface_input.face_normal_ws = normalize(cross(position_ddx, position_ddy));
-    surface_input.view_direction_ws = -in.along;
-    surface_input.vertex_color = in.color;
-    surface_input.pixel = in.position.xy;
-
-    let surface = material_surface(surface_input);
-
-    random_initialize(vec3<u32>(vec2<u32>(in.position.xy), in.card), vec3<u32>(in.card_set, 0u, 0u));
-
-    if (random() >= opacity) {
-        discard;
-    }
-
-    let diffuse = surface.albedo * (1.0 - surface.metalness);
-
-    var out: MeshCardRasterTargets;
-
-    out.albedo = vec4<f32>(sqrt(max(diffuse, vec3<f32>(0.0))), (1.0 + 254.0 * saturate(in.position.z)) / 255.0);
-
-    if (in.emissive_scale > 0.0) {
-        out.emissive = vec4<f32>(surface.emissive / in.emissive_scale, 0.0);
-    }
-
-    return out;
-}
-`, [
-        GRADIENT_SAMPLING_INFO_STRUCT.declaration_chunk,
-        chunk_material_surface_contract,
-        chunk_material_opacity_contract,
-        chunk_random,
-        chunk_random_initialize,
-    ]);
-
-/**
- * @type {WeakMap<ShadeMaterialTemplate, ShaderResourceSetDescriptor>}
- */
-const fragment_resources = new WeakMap();
-
-/**
- * @param {ShadeMaterialTemplate} template
- * @returns {ShaderResourceSetDescriptor}
- */
-function fragment_resources_of(template) {
-    let resources = fragment_resources.get(template);
-
-    if (resources === undefined) {
-        resources = new ShaderResourceSetDescriptor();
-
-        resources.addGroup(template.resources);
-
-        fragment_resources.set(template, resources);
-    }
-
-    return resources;
-}
-
-const depth_state = DepthStencilState.from({
-    depthWriteEnabled: true,
-    // depth through the slab from its near face: the nearest is the least
-    depthCompare: 'less',
-    format: MESH_CARD_RASTER_DEPTH_FORMAT,
-});
-
-/**
- * Card capture by raster ({@link MeshCardCaptureMode.Raster}): one pipeline per material template,
- * the template's group 0 — the material's one bind group, which the G-buffer pass binds — then
- * {@link MESH_CARDS_RASTER_GROUP}, and {@link MESH_CARDS_RASTER_SETTINGS} as immediate data.
- *
- * A run's draw covers every card of its card set, each into its cell of the run's region of the
- * scratch: `rgba8unorm` √(diffuse albedo) and depth, `rgba8unorm` emissive / s_e, and a
- * `depth32float` depth through the slab. Draw it with culling off: a card sees either side.
- *
- * Only a template with a surface function can be drawn.
- *
- * @type {TemplatePassDescriptor}
- */
-export const mesh_cards_raster_pass_descriptor = new TemplatePassDescriptor("Mesh Card Capture / Raster", template => {
-    const fragment_code = ShaderDescriptor.from({
-        label: `Mesh Cards Raster / ${template.name}`,
-        resources: fragment_resources_of(template),
-        body: CodeChunk.from('', [
-            template.surface,
-            template.opacity ?? chunk_material_opacity_opaque,
-            fragment_body,
-        ]),
-    }).source;
-
-    return RenderPipelineDescriptor.from({
-        label: `Mesh Card Capture / Raster / ${template.name}`,
-        layout: PipelineLayoutDescriptor.from([
-            template.resources.generateBindGroupLayoutDescriptor(),
-            MESH_CARDS_RASTER_LAYOUT,
-        ], vertex_resources.immediateSize),
-        vertex: {
-            module: {
-                code: vertex_code
-            }
-        },
-        fragment: {
-            module: {
-                code: fragment_code
-            },
-            targets: MESH_CARD_RASTER_TARGET_FORMATS.map(format => ({ format })),
-        },
-        depthStencil: depth_state,
-        primitive: rasterization_primitive_state,
-    });
-});
-
-/**
- * Bytes of {@link MESH_CARDS_RASTER_SETTINGS} the draws hand `setImmediates`.
- * @type {number}
- */
-export const MESH_CARDS_RASTER_IMMEDIATE_SIZE = vertex_resources.immediateSize;

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_capture.d.ts

@@ -1,40 +0,0 @@
-/**
- * Transparent hits a capture ray steps past, at most, before the texel is empty.
- * @type {number}
- */
-export const MESH_CARD_ALPHA_CONTINUATIONS: number;
-/**
- * @type {WebGPUStruct}
- */
-export const MESH_CARDS_CAPTURE_SETTINGS: WebGPUStruct;
-/**
- * Card capture (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.5): a thread a texel of each page captured
- * this frame, the frame's pages being stretches of card sets, a run each in `mesh_card_runs`.
- *
- * 1. A ray in the geometry's local space starts on the card's near face, at the texel — the corner
- *    lattice of the bricks' faces, as a brick's texels sit on its voxels — and runs along the card's
- *    direction through its slab, t ≤ the slab's depth, by `ray_query_blas_nearest`.
- * 2. A hit is opaque with probability its opacity (`sample_material_alpha`), as the path tracer takes
- *    alpha. A transparent draw steps the ray past the hit, MESH_CARD_ALPHA_CONTINUATIONS times at
- *    most; past that the texel is empty.
- * 3. At the opaque hit, `sample_material_data` with the material's resident row and an identity
- *    transform, the card being in local space.
- *
- * Both read the material's textures at the texel's footprint (`mesh_card_texture_level`), filtered
- * exactly ({@link IndirectTextureFilter.Exact}): nothing averages a card texel after it is stored, so a
- * single tap would be kept as the texel, and a tap landing on a thin feature of the texture would put
- * it in one row of texels and not the next.
- *
- * The random state is seeded from the card set and the texel, which fixes every draw: the alpha's and
- * the material's dither. A recapture of an unchanged material therefore writes the same bytes.
- *
- * The albedo plane holds √(albedo × (1 − metalness)), Lumen's diffuse colour as UE stores it, and
- * the hit's depth through the slab mapped onto [1/255, 1]. The emissive plane holds emissive / s_e.
- * A texel whose ray found nothing stores 0 throughout.
- *
- * @type {ComputeShader}
- */
-export const shader_mesh_cards_capture: ComputeShader;
-import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { ComputeShader } from "../../../shader/ComputeShader.js";
-//# sourceMappingURL=shader_mesh_cards_capture.d.ts.map

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_capture.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader_mesh_cards_capture.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_capture.js"],"names":[],"mappings":"AA8BA;;;GAGG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;GAEG;AACH,0CAFU,YAAY,CASS;AAqB/B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wCAFU,aAAa,CAgNsE;6BArRhE,sCAAsC;8BAJrC,kCAAkC"}