@woosh/meep-engine 3.30.0 → 3.31.0

package/src/shade/renderer/material/standard/fragment_gbuffer_vt.js

@@ -1,31 +1,23 @@
 import { GPUShaderStage } from "../../../descriptor/GPUShaderStage.js";
 import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { G_BUFFER_COLOR_TARGETS } from "../../gbuffer/G_BUFFER_COLOR_TARGETS.js";
+import { chunk_textureSampleBarycentric } from "../../shader/chunk/texture/sample/chunk_texture_sample_barycentric.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
 import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { VT_STACK_INFO_STRUCT } from "../../texture/virtual/VT_STACK_INFO_STRUCT.js";
 import { MATERIAL_METADATA_STRUCT } from "../MATERIAL_METADATA_STRUCT.js";
-import {
-    build_gbuffer_fragment_body,
-    g_buffer_scene_resources,
-    g_buffer_viz_resources,
-} from "./fragment_gbuffer.js";
-import { material_gbuffer_vertex_shader_code } from "./material_gbuffer_vertex.js";
+import { chunk_standard_material_compose } from "./chunk_standard_material_surface.js";
+import { build_gbuffer_pipeline_descriptor, build_gbuffer_shader_resources } from "./fragment_gbuffer.js";
 
 /**
- * Group 0 of the virtual-texture material variant. Replaces the four
- * per-material texture bindings of the standard group with the VT globals:
- * the shared page table, the stack info buffer and the physical cache
- * layers — identical for every VT material, which is what lets hundreds of
- * them share one pipeline and the same feedback/table infrastructure.
- * Emissive stays a regular per-material texture (emissive maps are rarely
- * the memory problem VT solves).
+ * Group 0 of the virtual-texture material template. Replaces the four per-material texture bindings
+ * of the standard group with the VT globals: the shared page table, the stack info buffer and the
+ * physical cache layers — identical for every VT material, which is what lets hundreds of them share
+ * one pipeline and the same feedback/table infrastructure. Emissive stays a regular per-material
+ * texture (emissive maps are rarely the memory problem VT solves).
  *
- * `material_info` must stay at binding 0 — the shared vertex stage
- * ({@link material_gbuffer_vertex_shader_code}) addresses it there.
+ * Fragment-visible, like every template's group 0 — see {@link SHADING_MATERIAL_RESOURCE_GROUP}.
  */
 export const SHADING_MATERIAL_VT_RESOURCE_GROUP = new ShaderResourceGroupDescriptor();
 
@@ -42,43 +34,45 @@ SHADING_MATERIAL_VT_RESOURCE_GROUP
     .addTexture("vt_cache_orm", "float")
     .addSampler("vt_cache_sampler");
 
-export const vt_gbuffer_shader_resources = new ShaderResourceSetDescriptor();
+SHADING_MATERIAL_VT_RESOURCE_GROUP.addVisibility(GPUShaderStage.FRAGMENT);
 
-// group order mirrors the standard material set — groups 1 and 2 are the
-// *same descriptor objects*, so the two pipelines are bind-group compatible
-// and the material pass can set viz/scene groups once for both
-vt_gbuffer_shader_resources.addGroup(SHADING_MATERIAL_VT_RESOURCE_GROUP);
-vt_gbuffer_shader_resources.addGroup(g_buffer_viz_resources);
-vt_gbuffer_shader_resources.addGroup(g_buffer_scene_resources);
-
-vt_gbuffer_shader_resources.addVisibility(GPUShaderStage.FRAGMENT);
-vt_gbuffer_shader_resources.getResourceByName("material_info").addVisibility(GPUShaderStage.VERTEX);
+/**
+ * Groups 1 and 2 are the *same descriptor objects* as the standard set's, so the two pipelines are
+ * bind-group compatible and the material pass sets viz/scene groups once for both.
+ *
+ * @type {ShaderResourceSetDescriptor}
+ */
+export const vt_gbuffer_shader_resources = build_gbuffer_shader_resources(SHADING_MATERIAL_VT_RESOURCE_GROUP);
 
-const chunk_vt_sample_layer = new WeakMap();
+/**
+ * @type {WeakMap<CodeChunk, CodeChunk>}
+ */
+const chunk_vt_surface = new WeakMap();
 
 /**
- * Build the VT variant of the G-buffer material pipeline for a concrete
- * cache geometry. Called (and memoized) by the VirtualTextureManager once
- * its configuration is frozen.
+ * The virtual-texture material's surface, for a concrete cache geometry.
  *
- * Sampling model (v1): one page-table fetch per pixel serves all three
- * layers — the stack's UV set, wrap mode and residency resolve once, then
- * albedo/normal/ORM are three bilinear fetches at the same physical
- * coordinate in their respective atlases. Missing layers and not-yet-
- * resident cells fall back to per-layer neutral values (albedo falls back
- * to the stack's average colour).
+ * Sampling model (v1): one page-table fetch per pixel serves all three layers — the stack's UV set,
+ * wrap mode and residency resolve once, then albedo/normal/ORM are three bilinear fetches at the
+ * same physical coordinate in their respective atlases. Missing layers and not-yet-resident cells
+ * fall back to per-layer neutral values (albedo falls back to the stack's average colour). What the
+ * samples become is the standard material's arithmetic, shared through
+ * {@link chunk_standard_material_compose}.
  *
  * @param {CodeChunk} chunk_vt_lookup from {@link build_chunk_vt_lookup}
- * @returns {RenderPipelineDescriptor}
+ * @returns {CodeChunk} defines `material_surface`
  */
-export function build_vt_material_pipeline_descriptor(chunk_vt_lookup) {
+export function build_chunk_vt_material_surface(chunk_vt_lookup) {
+
+    let surface = chunk_vt_surface.get(chunk_vt_lookup);
 
-    let sample_chunk = chunk_vt_sample_layer.get(chunk_vt_lookup);
+    if (surface !== undefined) {
+        return surface;
+    }
 
-    if (sample_chunk === undefined) {
-        sample_chunk = CodeChunk.from(
-            //language=WGSL
-            `
+    surface = CodeChunk.from(
+        //language=WGSL
+        `
 fn vt_sample_layer(
     cache: texture_2d<f32>,
     cache_sampler: sampler,
@@ -94,25 +88,17 @@ fn vt_sample_layer(
     // happened through the page table
     return textureSampleLevel(cache, cache_sampler, phys.uv, 0.0);
 }
-`,
-            [chunk_vt_lookup]
-        );
-
-        chunk_vt_sample_layer.set(chunk_vt_lookup, sample_chunk);
-    }
 
-    const body = build_gbuffer_fragment_body(
-        {
-            prelude: `
+fn material_surface(s: MaterialSurfaceInput) -> MaterialSurfaceOutput {
     // ── virtual texture resolve, once per pixel for all layers ──────
     let vt_info = vt_stacks[material_info.vt_stack];
     let vt_layer_mask = vt_info.flags >> 8u;
 
+    // the stack binds one of the two UV sets; both arrive with the same bias
+    var uv_info = s.uv;
+
     if ((vt_info.flags & VT_STACK_FLAG_UV_SET_1) != 0u) {
-        // stack binds the second UV set — re-interpolate and re-bias
-        uv_info = barycentric_interpolate_uv(barycentric, vertex_0.uv1, vertex_1.uv1, vertex_2.uv1);
-        uv_info.ddx *= uv_derivative_bias.x;
-        uv_info.ddy *= uv_derivative_bias.y;
+        uv_info = s.uv1;
     }
 
     let vt_uv = vt_stack_wrap_uv(uv_info.uv, vt_info.flags);
@@ -124,46 +110,39 @@ fn vt_sample_layer(
     if (vt_entry.valid) {
         vt_phys = vt_physical_uv(vt_entry, vt_info, vt_uv);
     }
+
+    return standard_material_compose(
+        s,
+        vt_sample_layer(vt_cache_orm, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 4u) != 0u, vec4<f32>(1.0, 1.0, 0.0, 1.0)),
+        vt_sample_layer(vt_cache_albedo, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 1u) != 0u, vt_info.average_color),
+        vt_sample_layer(vt_cache_normal, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 2u) != 0u, vec4<f32>(0.5, 0.5, 1.0, 1.0)),
+        textureSampleBarycentric(texture_emissive, texture_emissive_sampler, uv_info).rgb,
+    );
+}
 `,
-            orm: `vt_sample_layer(vt_cache_orm, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 4u) != 0u, vec4<f32>(1.0, 1.0, 0.0, 1.0))`,
-            normal: `decode_tangent_normal(vt_sample_layer(vt_cache_normal, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 2u) != 0u, vec4<f32>(0.5, 0.5, 1.0, 1.0)))`,
-            diffuse: `vt_sample_layer(vt_cache_albedo, vt_cache_sampler, vt_phys, vt_entry.valid && (vt_layer_mask & 1u) != 0u, vt_info.average_color)`,
-            emissive: `textureSampleBarycentric(texture_emissive, texture_emissive_sampler, uv_info).rgb`,
-        },
         [
-            sample_chunk,
+            chunk_vt_lookup,
+            chunk_standard_material_compose,
+            chunk_textureSampleBarycentric,
         ]
     );
 
-    const shader = ShaderDescriptor.from({
-        label: "Material / GBuffer laydown (virtual texture)",
-        resources: vt_gbuffer_shader_resources,
-        body,
-    });
+    chunk_vt_surface.set(chunk_vt_lookup, surface);
+
+    return surface;
+}
 
-    return RenderPipelineDescriptor.from({
+/**
+ * Build the VT template's G-buffer pipeline for a concrete cache geometry. Called (and memoized) by
+ * the VirtualTextureManager once its configuration is frozen.
+ *
+ * @param {CodeChunk} chunk_vt_lookup from {@link build_chunk_vt_lookup}
+ * @returns {RenderPipelineDescriptor}
+ */
+export function build_vt_material_pipeline_descriptor(chunk_vt_lookup) {
+    return build_gbuffer_pipeline_descriptor({
         label: "VT material / Viz-Buffer to G-Buffer laydown",
-        layout: vt_gbuffer_shader_resources.generatePipelineLayoutDescriptor(),
-        vertex: {
-            module: {
-                code: material_gbuffer_vertex_shader_code
-            }
-        },
-        fragment: {
-            module: {
-                code: shader.source,
-            },
-            targets: G_BUFFER_COLOR_TARGETS
-        },
-        depthStencil: {
-            // depth is a material mask — see the standard material pipeline
-            depthCompare: 'equal',
-            format: 'depth32float',
-            depthWriteEnabled: false
-        },
-        primitive: {
-            topology: 'triangle-list',
-            cullMode: 'none',
-        }
+        material_group: SHADING_MATERIAL_VT_RESOURCE_GROUP,
+        surface: build_chunk_vt_material_surface(chunk_vt_lookup),
     });
 }

package/src/shade/renderer/material/standard/material_gbuffer_vertex.d.ts

@@ -1,11 +1,14 @@
 /**
- * Shared vertex stage of every viz-buffer material variant: a fullscreen
- * triangle placed at depth `material.id / 2^24`, matched against the
- * material-depth mask with `depthCompare: 'equal'` so the fragment stage
- * only runs on this material's pixels.
+ * Shared vertex stage of every material template's G-buffer pipeline: a fullscreen triangle placed
+ * at depth `material.id / 2^24`, matched against the material-depth mask with `depthCompare: 'equal'`
+ * so the fragment stage only runs on this material's pixels.
  *
- * Extracted from GPUMaterialContext so the virtual-texture material variant
- * shares the exact same stage.
+ * **It binds nothing.** The material id rides in the instance index — the material pass draws
+ * `draw(3, 1, 0, id)` — so a template's group 0 can be laid out however the template needs, and is
+ * visible to the fragment stage alone. A direct draw's `firstInstance` needs no device feature.
+ *
+ * `id / 16777216` is the expression the material-depth pass writes, and a division by a power of two
+ * is exact for every id below 2^24, so the two meet at depth-equal.
  *
  * @type {string}
  */

package/src/shade/renderer/material/standard/material_gbuffer_vertex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"material_gbuffer_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/material_gbuffer_vertex.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,kDAFU,MAAM,CAgCM"}
+{"version":3,"file":"material_gbuffer_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/material_gbuffer_vertex.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,kDAFU,MAAM,CA6BE"}

package/src/shade/renderer/material/standard/material_gbuffer_vertex.js

@@ -1,14 +1,16 @@
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { MATERIAL_METADATA_STRUCT } from "../MATERIAL_METADATA_STRUCT.js";
 
 /**
- * Shared vertex stage of every viz-buffer material variant: a fullscreen
- * triangle placed at depth `material.id / 2^24`, matched against the
- * material-depth mask with `depthCompare: 'equal'` so the fragment stage
- * only runs on this material's pixels.
+ * Shared vertex stage of every material template's G-buffer pipeline: a fullscreen triangle placed
+ * at depth `material.id / 2^24`, matched against the material-depth mask with `depthCompare: 'equal'`
+ * so the fragment stage only runs on this material's pixels.
  *
- * Extracted from GPUMaterialContext so the virtual-texture material variant
- * shares the exact same stage.
+ * **It binds nothing.** The material id rides in the instance index — the material pass draws
+ * `draw(3, 1, 0, id)` — so a template's group 0 can be laid out however the template needs, and is
+ * visible to the fragment stage alone. A direct draw's `firstInstance` needs no device feature.
+ *
+ * `id / 16777216` is the expression the material-depth pass writes, and a division by a power of two
+ * is exact for every id below 2^24, so the two meet at depth-equal.
  *
  * @type {string}
  */
@@ -21,25 +23,22 @@ const pos : array< vec2<f32>, 3 > = array< vec2<f32>, 3 >(
   vec2<f32>(-1.0, 3.0)
 );
 
-@group(0) @binding(0) var<uniform> material_info: ${MATERIAL_METADATA_STRUCT.wgsl_ref};
-
 struct VertexOutput {
     @builtin(position) position : vec4<f32>,
 }
 
 @vertex
 fn main(
-  @builtin(vertex_index) id : u32
+  @builtin(vertex_index) id : u32,
+  @builtin(instance_index) material_id : u32,
 ) -> VertexOutput {
 
   var out: VertexOutput;
 
   let ndc = pos[id];
 
-  out.position = vec4<f32>(ndc, f32(material_info.id)/16777216 , 1.0);
+  out.position = vec4<f32>(ndc, f32(material_id)/16777216 , 1.0);
 
   return out;
 }
-`, [
-        MATERIAL_METADATA_STRUCT.declaration_chunk,
-    ]).compile().text;
+`).compile().text;

package/src/shade/renderer/material/template/GPUMaterialServices.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @typedef {import("../../../device/pipeline/RenderPipelineManager.js").RenderPipelineManager} RenderPipelineManager
+ * @typedef {import("../../GPUSamplerManager.js").GPUSamplerManager} GPUSamplerManager
+ * @typedef {import("../../texture/GPUTextureContext.js").GPUTextureContext} GPUTextureContext
+ * @typedef {import("../../texture/TextureManager.js").TextureManager} TextureManager
+ * @typedef {import("../../texture/virtual/VirtualTextureManager.js").VirtualTextureManager} VirtualTextureManager
+ */
+/**
+ * What a material falls back to for a texture slot it leaves empty.
+ */
+export class MaterialGPUDefaults {
+    /**
+     * @type {GPUTextureContext}
+     */
+    texture: GPUTextureContext;
+    /**
+     * @type {GPUTextureContext}
+     */
+    texture_pixel_white: GPUTextureContext;
+    /**
+     * @type {GPUTextureContext}
+     */
+    texture_pixel_black: GPUTextureContext;
+    /**
+     * @type {GPUTextureContext}
+     */
+    texture_pixel_normal: GPUTextureContext;
+    /**
+     * @type {GPUTextureContext}
+     */
+    texture_orm: GPUTextureContext;
+    /**
+     * @type {GPUSampler}
+     */
+    sampler: GPUSampler;
+}
+/**
+ * Everything a {@link ShadeMaterialTemplate}'s hooks reach the GPU through. One per
+ * {@link GPUMaterialManager}, frozen at its construction.
+ */
+export class GPUMaterialServices {
+    /**
+     * @type {GPUDevice}
+     */
+    device: GPUDevice;
+    /**
+     * @type {TextureManager}
+     */
+    textures: TextureManager;
+    /**
+     * @type {GPUSamplerManager}
+     */
+    samplers: GPUSamplerManager;
+    /**
+     * @type {RenderPipelineManager}
+     */
+    render_pipelines: RenderPipelineManager;
+    /**
+     * Wired when the graphics context carries a virtual texture system.
+     * @type {VirtualTextureManager|undefined}
+     */
+    virtual_textures: VirtualTextureManager | undefined;
+    /**
+     * @type {MaterialGPUDefaults}
+     */
+    defaults: MaterialGPUDefaults;
+}
+export type RenderPipelineManager = import("../../../device/pipeline/RenderPipelineManager.js").RenderPipelineManager;
+export type GPUSamplerManager = import("../../GPUSamplerManager.js").GPUSamplerManager;
+export type GPUTextureContext = import("../../texture/GPUTextureContext.js").GPUTextureContext;
+export type TextureManager = import("../../texture/TextureManager.js").TextureManager;
+export type VirtualTextureManager = import("../../texture/virtual/VirtualTextureManager.js").VirtualTextureManager;
+//# sourceMappingURL=GPUMaterialServices.d.ts.map

package/src/shade/renderer/material/template/GPUMaterialServices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GPUMaterialServices.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/template/GPUMaterialServices.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;GAEG;AACH;IACI;;OAEG;IACH,SAFU,iBAAiB,CAEnB;IAER;;OAEG;IACH,qBAFU,iBAAiB,CAEP;IAEpB;;OAEG;IACH,qBAFU,iBAAiB,CAEP;IAEpB;;OAEG;IACH,sBAFU,iBAAiB,CAEN;IAErB;;OAEG;IACH,aAFU,iBAAiB,CAEf;IAEZ;;OAEG;IACH,oBAAQ;CACX;AAED;;;GAGG;AACH;IACI;;OAEG;IACH,kBAAO;IAEP;;OAEG;IACH,UAFU,cAAc,CAEf;IAET;;OAEG;IACH,UAFU,iBAAiB,CAElB;IAET;;OAEG;IACH,kBAFU,qBAAqB,CAEd;IAEjB;;;OAGG;IACH,kBAFU,qBAAqB,GAAC,SAAS,CAExB;IAEjB;;OAEG;IACH,UAFU,mBAAmB,CAEpB;CACZ;oCA7EY,OAAO,mDAAmD,EAAE,qBAAqB;gCACjF,OAAO,4BAA4B,EAAE,iBAAiB;gCACtD,OAAO,oCAAoC,EAAE,iBAAiB;6BAC9D,OAAO,iCAAiC,EAAE,cAAc;oCACxD,OAAO,gDAAgD,EAAE,qBAAqB"}

package/src/shade/renderer/material/template/GPUMaterialServices.js

@@ -0,0 +1,79 @@
+/**
+ * @typedef {import("../../../device/pipeline/RenderPipelineManager.js").RenderPipelineManager} RenderPipelineManager
+ * @typedef {import("../../GPUSamplerManager.js").GPUSamplerManager} GPUSamplerManager
+ * @typedef {import("../../texture/GPUTextureContext.js").GPUTextureContext} GPUTextureContext
+ * @typedef {import("../../texture/TextureManager.js").TextureManager} TextureManager
+ * @typedef {import("../../texture/virtual/VirtualTextureManager.js").VirtualTextureManager} VirtualTextureManager
+ */
+
+/**
+ * What a material falls back to for a texture slot it leaves empty.
+ */
+export class MaterialGPUDefaults {
+    /**
+     * @type {GPUTextureContext}
+     */
+    texture;
+
+    /**
+     * @type {GPUTextureContext}
+     */
+    texture_pixel_white;
+
+    /**
+     * @type {GPUTextureContext}
+     */
+    texture_pixel_black;
+
+    /**
+     * @type {GPUTextureContext}
+     */
+    texture_pixel_normal;
+
+    /**
+     * @type {GPUTextureContext}
+     */
+    texture_orm;
+
+    /**
+     * @type {GPUSampler}
+     */
+    sampler;
+}
+
+/**
+ * Everything a {@link ShadeMaterialTemplate}'s hooks reach the GPU through. One per
+ * {@link GPUMaterialManager}, frozen at its construction.
+ */
+export class GPUMaterialServices {
+    /**
+     * @type {GPUDevice}
+     */
+    device;
+
+    /**
+     * @type {TextureManager}
+     */
+    textures;
+
+    /**
+     * @type {GPUSamplerManager}
+     */
+    samplers;
+
+    /**
+     * @type {RenderPipelineManager}
+     */
+    render_pipelines;
+
+    /**
+     * Wired when the graphics context carries a virtual texture system.
+     * @type {VirtualTextureManager|undefined}
+     */
+    virtual_textures;
+
+    /**
+     * @type {MaterialGPUDefaults}
+     */
+    defaults;
+}

package/src/shade/renderer/material/template/ShadeMaterialTemplate.d.ts

@@ -0,0 +1,170 @@
+/**
+ * A kind of surface: the shader code that turns a visibility-buffer pixel into G-buffer values, the
+ * group-0 resources that code reads, and the CPU hooks that fill those resources for one material.
+ *
+ * A template is created once and shared; a {@link ShadeMaterial} is an instance of one, and its
+ * {@link GPUMaterialContext} holds that instance's uniform buffer and bind group, built by the
+ * template's hooks. There are only ever a handful of templates, and every G-buffer pipeline, every
+ * alpha-tested pipeline and every compile is per template — never per material.
+ *
+ * **Group 0 is the template's.** It is declared with fragment visibility, and one bind group per
+ * material built on it serves the G-buffer pass and both alpha-tested passes. Groups 1 and 2 belong
+ * to the passes, so a template must not reuse their names (`viz_buffer_triangle`, `viz_buffer_mesh`,
+ * `view`, `camera`, `scene_database`, `geometries`, `meshlets`, `meshlet_metadata`, `meshlet_data`,
+ * `materials`, `t_noise`).
+ *
+ * **The surface function** — `fn material_surface(s: MaterialSurfaceInput) -> MaterialSurfaceOutput`,
+ * see {@link chunk_material_surface_contract} — is all a template contributes to the G-buffer pass.
+ * **The opacity function** — `fn material_opacity(s: MaterialOpacityInput) -> f32` — is optional;
+ * without one the template is opaque-only, and a material of it set to alpha-tested draws fully
+ * covered rather than vanishing.
+ */
+export class ShadeMaterialTemplate {
+    /**
+     * @param {Object} options
+     * @param {string} options.name
+     * @param {ShaderResourceGroupDescriptor} options.resources
+     * @param {CodeChunk|null} options.surface
+     * @param {WebGPUType|null} [options.uniform_type]
+     * @param {CodeChunk|null} [options.opacity]
+     * @param {boolean} [options.forward]
+     * @param {boolean} [options.dynamic]
+     */
+    constructor({ name, resources, surface, uniform_type, opacity, forward, dynamic, }: {
+        name: string;
+        resources: ShaderResourceGroupDescriptor;
+        surface: CodeChunk | null;
+        uniform_type?: WebGPUType | null;
+        opacity?: CodeChunk | null;
+        forward?: boolean;
+        dynamic?: boolean;
+    });
+    /**
+     * Small, unique and stable: the draw lists sort by it, so every material of a template draws
+     * together and pipeline switches are one per template.
+     *
+     * @readonly
+     * @type {number}
+     */
+    readonly ordinal: number;
+    /**
+     * @type {string}
+     */
+    name: string;
+    /**
+     * Group 0, with fragment visibility.
+     *
+     * @type {ShaderResourceGroupDescriptor}
+     */
+    resources: ShaderResourceGroupDescriptor;
+    /**
+     * Type of the per-material uniform buffer the context allocates, or `null` for a template that
+     * has none. The buffer is written from {@link uniform_value} when the context is created and
+     * again whenever the material's version moves; binding it is the template's, in
+     * {@link create_bind_group}.
+     *
+     * @type {WebGPUType|null}
+     */
+    uniform_type: WebGPUType | null;
+    /**
+     * Defines `material_surface`. `null` only for a template that builds its G-buffer pipeline itself
+     * — the virtual-texture one, whose surface depends on the cache geometry.
+     *
+     * @type {CodeChunk|null}
+     */
+    surface: CodeChunk | null;
+    /**
+     * Defines `material_opacity`, or `null` when the template cannot cut out.
+     *
+     * @type {CodeChunk|null}
+     */
+    opacity: CodeChunk | null;
+    /**
+     * Whether the transparent passes can draw it. They are standard-only for now, and skip a
+     * material whose template is not.
+     *
+     * @type {boolean}
+     */
+    forward: boolean;
+    /**
+     * Whether {@link update} runs once a frame for each of its materials. Only a template with
+     * resources that change without the material's version moving — terrain's weight and overlay
+     * maps — says so.
+     *
+     * @type {boolean}
+     */
+    dynamic: boolean;
+    /**
+     * The template's G-buffer pipeline. Built once, from {@link resources} and {@link surface}.
+     *
+     * @param {GPUMaterialServices} services
+     * @returns {RenderPipelineDescriptor}
+     */
+    gbuffer_pipeline_descriptor(services: GPUMaterialServices): RenderPipelineDescriptor;
+    /**
+     * Once, when the material's context is created and before its uniform is written: obtain what
+     * the bind group will name, and upload anything the template owns, so the first bind group
+     * binds real resources.
+     *
+     * @param {GPUMaterialContext} ctx
+     * @param {GPUMaterialServices} services
+     */
+    build(ctx: GPUMaterialContext, services: GPUMaterialServices): void;
+    /**
+     * The value of the material's uniform, of {@link uniform_type}.
+     *
+     * @param {ShadeMaterial} material
+     * @param {Object} [metadata] the metadata row just written for the same version of the material,
+     *        when the uniform is being rewritten — a template whose uniform is that row returns it as
+     *        is, rather than building it twice
+     * @returns {Object}
+     */
+    uniform_value(material: ShadeMaterial, metadata?: any): any;
+    /**
+     * The material's row of the metadata table — every field the GPU reads from it, always, because
+     * the table's upload stream is rewound rather than cleared and a skipped field would carry the
+     * previous record's bytes.
+     *
+     * @param {ShadeMaterial} material
+     * @returns {Object} a {@link MATERIAL_METADATA_STRUCT} value
+     */
+    metadata_value(material: ShadeMaterial): any;
+    /**
+     * @param {GPUMaterialContext} ctx
+     * @param {GPUBindGroupLayout} layout group 0 of the template's G-buffer pipeline, which is the
+     *        same layout object as group 0 of its alpha-tested pipelines
+     * @param {GPUMaterialServices} services
+     * @returns {GPUBindGroup}
+     */
+    create_bind_group(ctx: GPUMaterialContext, layout: GPUBindGroupLayout, services: GPUMaterialServices): GPUBindGroup;
+    /**
+     * Once a frame, before any pass, for each material of a {@link dynamic} template.
+     *
+     * @param {GPUMaterialContext} ctx
+     * @param {GPUMaterialServices} services
+     * @returns {boolean} true when a resource the bind group names was replaced, so it has to be
+     *          rebuilt
+     */
+    update(ctx: GPUMaterialContext, services: GPUMaterialServices): boolean;
+    /**
+     * Give back what {@link build} and {@link update} created.
+     *
+     * @param {GPUMaterialContext} ctx
+     * @param {GPUMaterialServices} services
+     */
+    destroy(ctx: GPUMaterialContext, services: GPUMaterialServices): void;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isShadeMaterialTemplate: boolean;
+    #private;
+}
+export type RenderPipelineDescriptor = import("../../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor;
+export type CodeChunk = import("../../shader/compiler/CodeChunk.js").CodeChunk;
+export type ShaderResourceGroupDescriptor = import("../../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor;
+export type WebGPUType = import("../../shader/type/WebGPUType.js").WebGPUType;
+export type GPUMaterialContext = import("../GPUMaterialContext.js").GPUMaterialContext;
+export type ShadeMaterial = import("../ShadeMaterial.js").ShadeMaterial;
+export type GPUMaterialServices = import("./GPUMaterialServices.js").GPUMaterialServices;
+//# sourceMappingURL=ShadeMaterialTemplate.d.ts.map

package/src/shade/renderer/material/template/ShadeMaterialTemplate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShadeMaterialTemplate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/template/ShadeMaterialTemplate.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAqEI;;;;;;;;;OASG;IACH;QAR2B,IAAI,EAApB,MAAM;QACiC,SAAS,EAAhD,6BAA6B;QACL,OAAO,EAA/B,SAAS,GAAC,IAAI;QACY,YAAY,GAAtC,UAAU,GAAC,IAAI;QACU,OAAO,GAAhC,SAAS,GAAC,IAAI;QACI,OAAO,GAAzB,OAAO;QACW,OAAO,GAAzB,OAAO;OAwBjB;IApGD;;;;;;OAMG;IACH,kBAFU,MAAM,CAEY;IAE5B;;OAEG;IACH,MAFU,MAAM,CAEX;IAEL;;;;OAIG;IACH,WAFU,6BAA6B,CAE7B;IAEV;;;;;;;OAOG;IACH,cAFU,UAAU,GAAC,IAAI,CAEL;IAEpB;;;;;OAKG;IACH,SAFU,SAAS,GAAC,IAAI,CAEhB;IAER;;;;OAIG;IACH,SAFU,SAAS,GAAC,IAAI,CAET;IAEf;;;;;OAKG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;OAMG;IACH,SAFU,OAAO,CAED;IAyChB;;;;;OAKG;IACH,sCAHW,mBAAmB,GACjB,wBAAwB,CAcpC;IAED;;;;;;;OAOG;IACH,WAHW,kBAAkB,YAClB,mBAAmB,QAG7B;IAED;;;;;;;;OAQG;IACH,wBANW,aAAa,uBAQvB;IAED;;;;;;;OAOG;IACH,yBAHW,aAAa,OAKvB;IAED;;;;;;OAMG;IACH,uBANW,kBAAkB,wCAGlB,mBAAmB,gBAK7B;IAED;;;;;;;OAOG;IACH,YALW,kBAAkB,YAClB,mBAAmB,GACjB,OAAO,CAKnB;IAED;;;;;OAKG;IACH,aAHW,kBAAkB,YAClB,mBAAmB,QAG7B;IAGL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;;CANtD;uCA9NY,OAAO,iEAAiE,EAAE,wBAAwB;wBAClG,OAAO,oCAAoC,EAAE,SAAS;4CACtD,OAAO,wDAAwD,EAAE,6BAA6B;yBAC9F,OAAO,iCAAiC,EAAE,UAAU;iCACpD,OAAO,0BAA0B,EAAE,kBAAkB;4BACrD,OAAO,qBAAqB,EAAE,aAAa;kCAC3C,OAAO,0BAA0B,EAAE,mBAAmB"}