@woosh/meep-engine 3.30.0 → 3.32.0

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

@@ -1,36 +1,82 @@
 /**
- * Assemble the viz-buffer → G-buffer fragment shader body with pluggable
- * texture sampling. Everything else — vertex pulling, perspective-correct
- * barycentric UV derivatives, normal frame construction, roughness AA,
- * G-buffer encoding — is shared verbatim between variants (standard
- * per-material textures vs virtual-texture stacks), so it can only evolve
- * in one place.
- *
- * The `sampling` expressions run after `uv_info` (GradSamplingInfo with
- * biased analytic gradients) is available; `prelude` is spliced right
- * before the first sample for variant-specific setup.
- *
- * @param {Object} sampling
- * @param {string} [sampling.prelude] statements inserted before sampling
- * @param {string} sampling.orm vec4f expression
- * @param {string} sampling.normal vec3f expression, decoded to [-1,1]
- * @param {string} sampling.diffuse vec4f expression (premultiplied alpha)
- * @param {string} sampling.emissive vec3f expression
- * @param {CodeChunk[]} [extra_chunks]
+ * The resource set of a G-buffer pipeline whose group 0 is `material_group`.
+ *
+ * The group is the template's own and brings its own visibility — fragment only, because the shared
+ * vertex stage binds nothing.
+ *
+ * @param {ShaderResourceGroupDescriptor} material_group
+ * @returns {ShaderResourceSetDescriptor}
+ */
+export function build_gbuffer_shader_resources(material_group: ShaderResourceGroupDescriptor): ShaderResourceSetDescriptor;
+/**
+ * Assemble the viz-buffer → G-buffer fragment shader body around a template's surface function.
+ * Everything else — vertex pulling, perspective-correct barycentric derivatives, normal frame
+ * construction, roughness AA, G-buffer encoding — is shared verbatim between templates, so it can
+ * only evolve in one place.
+ *
+ * The body reconstructs the {@link chunk_material_surface_contract} input from the visibility buffer
+ * and calls `material_surface` once; what comes back is anti-aliased, dithered and encoded here.
+ *
+ * @param {CodeChunk} surface defines `fn material_surface(s: MaterialSurfaceInput) -> MaterialSurfaceOutput`
  * @returns {CodeChunk}
  */
-export function build_gbuffer_fragment_body(sampling: {
-    prelude?: string;
-    orm: string;
-    normal: string;
-    diffuse: string;
-    emissive: string;
-}, extra_chunks?: CodeChunk[]): CodeChunk;
+export function build_gbuffer_fragment_body(surface: CodeChunk): CodeChunk;
+/**
+ * The G-buffer pipeline of a template: its group 0 and surface function around the shared body,
+ * after the shared binding-free vertex stage.
+ *
+ * @param {Object} options
+ * @param {string} options.label
+ * @param {ShaderResourceGroupDescriptor} options.material_group the template's group 0
+ * @param {CodeChunk} options.surface defines `material_surface`
+ * @returns {RenderPipelineDescriptor}
+ */
+export function build_gbuffer_pipeline_descriptor({ label, material_group, surface }: {
+    label: string;
+    material_group: ShaderResourceGroupDescriptor;
+    surface: CodeChunk;
+}): RenderPipelineDescriptor;
+/**
+ * The G-buffer pipeline around an assembled fragment shader, whose resource set is one
+ * {@link build_gbuffer_shader_resources} made.
+ *
+ * @param {string} label
+ * @param {ShaderDescriptor} shader
+ * @returns {RenderPipelineDescriptor}
+ */
+export function gbuffer_pipeline_descriptor_for_shader(label: string, shader: ShaderDescriptor): RenderPipelineDescriptor;
+/**
+ * Group 1 of every material's G-buffer pipeline: the visibility buffer and the view that drew it.
+ *
+ * Groups 1 and 2 are single descriptor objects that every template's pipeline is built from, which
+ * is what keeps them bind-group compatible across templates: the material pass sets them once and
+ * switches pipelines under them. Their visibility is declared here, on the groups, and nothing
+ * calls a set-level `addVisibility` over them — that would change them under every pipeline.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const g_buffer_viz_resources: ShaderResourceGroupDescriptor;
+/**
+ * Group 2 of every material's G-buffer pipeline: what the body pulls vertices from.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const g_buffer_scene_resources: ShaderResourceGroupDescriptor;
+/**
+ * The standard material's G-buffer resource set.
+ *
+ * @type {ShaderResourceSetDescriptor}
+ */
 export const g_buffer_shader_resources: ShaderResourceSetDescriptor;
-export const g_buffer_viz_resources: import("../../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor;
-export const g_buffer_scene_resources: import("../../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor;
+/**
+ * The standard material's G-buffer fragment shader.
+ *
+ * @type {ShaderDescriptor}
+ */
 export const gbuffer_shader: ShaderDescriptor;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
 //# sourceMappingURL=fragment_gbuffer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"fragment_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer.js"],"names":[],"mappings":"AA8EA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAR6B,OAAO,GAAzB,MAAM;IACW,GAAG,EAApB,MAAM;IACW,MAAM,EAAvB,MAAM;IACW,OAAO,EAAxB,MAAM;IACW,QAAQ,EAAzB,MAAM;kBACN,SAAS,EAAE,GACT,SAAS,CAwOrB;AAvRD,oEAA2E;AAI3E,oIAEG;AASH,sIAEG;AA+QH,8CAIE;0BAhTwB,oCAAoC;4CAClB,sDAAsD;iCACjE,kCAAkC"}
+{"version":3,"file":"fragment_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer.js"],"names":[],"mappings":"AAkGA;;;;;;;;GAQG;AACH,+DAHW,6BAA6B,GAC3B,2BAA2B,CAUvC;AASD;;;;;;;;;;;GAWG;AACH,qDAHW,SAAS,GACP,SAAS,CA8OrB;AAED;;;;;;;;;GASG;AACH;IAL2B,KAAK,EAArB,MAAM;IACiC,cAAc,EAArD,6BAA6B;IACV,OAAO,EAA1B,SAAS;IACP,wBAAwB,CAUpC;AAED;;;;;;;GAOG;AACH,8DAJW,MAAM,UACN,gBAAgB,GACd,wBAAwB,CA4BpC;AAnXD;;;;;;;;;GASG;AACH,qCAFU,6BAA6B,CAEmC;AAa1E;;;;GAIG;AACH,uCAFU,6BAA6B,CAEqC;AAgC5E;;;;GAIG;AACH,wCAFU,2BAA2B,CAEoE;AAoTzG;;;;GAIG;AACH,6BAFU,gBAAgB,CAMvB;8CA7Y2C,wDAAwD;4CAC1D,sDAAsD;0BAFxE,oCAAoC;yCAxCrB,iEAAiE;iCA2CzE,kCAAkC"}

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

@@ -1,5 +1,6 @@
 import { GPUShaderStage } from "../../../descriptor/GPUShaderStage.js";
-import { chunk_decode_tangent_normal } from "../../shader/chunk/geometry/normal/chunk_decode_tangent_normal.js";
+import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { G_BUFFER_COLOR_TARGETS } from "../../gbuffer/G_BUFFER_COLOR_TARGETS.js";
 import { 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";
@@ -32,14 +33,20 @@ import { chunk_encode_g_buffer_normal } from "../../shader/chunk/geometry/normal
 import {
     chunk_interpolate_attribute_3f32
 } from "../../shader/chunk/geometry/triangle/chunk_interpolate_attribute_3f32.js";
+import {
+    chunk_interpolate_with_derivatives
+} from "../../shader/chunk/geometry/triangle/chunk_interpolate_with_derivatives.js";
 import {
     chunk_dither_color_8bit_triangle_noise
 } from "../../shader/chunk/texture/dither/chunk_dither_color_8bit_triangle_noise.js";
-import { chunk_textureSampleBarycentric } from "../../shader/chunk/texture/sample/chunk_texture_sample_barycentric.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 { VIEW_UNIFORM_STRUCT } from "../../view/VIEW_UNIFORM_STRUCT.js";
+import { chunk_material_surface_contract } from "../template/chunk_material_surface.js";
+import { chunk_standard_material_surface } from "./chunk_standard_material_surface.js";
+import { material_gbuffer_vertex_shader_code } from "./material_gbuffer_vertex.js";
 import { SHADING_MATERIAL_RESOURCE_GROUP } from "./SHADING_MATERIAL_RESOURCE_GROUP.js";
 
 /**
@@ -48,13 +55,19 @@ import { SHADING_MATERIAL_RESOURCE_GROUP } from "./SHADING_MATERIAL_RESOURCE_GRO
  */
 const MIP_DERIVATIVE_BIAS = 1 / (1 - RENDER_GLOBAL_MIP_BIAS);
 
-export const g_buffer_shader_resources = new ShaderResourceSetDescriptor();
-
-g_buffer_shader_resources.addGroup(SHADING_MATERIAL_RESOURCE_GROUP);
+/**
+ * Group 1 of every material's G-buffer pipeline: the visibility buffer and the view that drew it.
+ *
+ * Groups 1 and 2 are single descriptor objects that every template's pipeline is built from, which
+ * is what keeps them bind-group compatible across templates: the material pass sets them once and
+ * switches pipelines under them. Their visibility is declared here, on the groups, and nothing
+ * calls a set-level `addVisibility` over them — that would change them under every pipeline.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const g_buffer_viz_resources = new ShaderResourceGroupDescriptor();
 
-export const g_buffer_viz_resources = g_buffer_shader_resources.createGroup({
-    label: "viz buffer"
-});
+g_buffer_viz_resources.label = "viz buffer";
 
 g_buffer_viz_resources
     .addTexture("viz_buffer_triangle", "uint")
@@ -63,41 +76,65 @@ g_buffer_viz_resources
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
 ;
 
-export const g_buffer_scene_resources = g_buffer_shader_resources.createGroup({
-    label: "Scene Data"
-});
+g_buffer_viz_resources.addVisibility(GPUShaderStage.FRAGMENT);
+
+/**
+ * Group 2 of every material's G-buffer pipeline: what the body pulls vertices from.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const g_buffer_scene_resources = new ShaderResourceGroupDescriptor();
+
+g_buffer_scene_resources.label = "Scene Data";
 
 g_buffer_scene_resources
     .addStorageBuffer("scene_database", WebGPUArray.from(u32))
     .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
     .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT))
     .addStorageBuffer("meshlet_data", GEOMETRY_ATTRIBUTE_DATA_TYPE)
+;
+
+g_buffer_scene_resources.addVisibility(GPUShaderStage.FRAGMENT);
+
+/**
+ * The resource set of a G-buffer pipeline whose group 0 is `material_group`.
+ *
+ * The group is the template's own and brings its own visibility — fragment only, because the shared
+ * vertex stage binds nothing.
+ *
+ * @param {ShaderResourceGroupDescriptor} material_group
+ * @returns {ShaderResourceSetDescriptor}
+ */
+export function build_gbuffer_shader_resources(material_group) {
+    const resources = new ShaderResourceSetDescriptor();
+
+    resources.addGroup(material_group);
+    resources.addGroup(g_buffer_viz_resources);
+    resources.addGroup(g_buffer_scene_resources);
+
+    return resources;
+}
 
-g_buffer_shader_resources.addVisibility(GPUShaderStage.FRAGMENT);
-g_buffer_shader_resources.getResourceByName("material_info").addVisibility(GPUShaderStage.VERTEX);
+/**
+ * The standard material's G-buffer resource set.
+ *
+ * @type {ShaderResourceSetDescriptor}
+ */
+export const g_buffer_shader_resources = build_gbuffer_shader_resources(SHADING_MATERIAL_RESOURCE_GROUP);
 
 /**
- * Assemble the viz-buffer → G-buffer fragment shader body with pluggable
- * texture sampling. Everything else — vertex pulling, perspective-correct
- * barycentric UV derivatives, normal frame construction, roughness AA,
- * G-buffer encoding — is shared verbatim between variants (standard
- * per-material textures vs virtual-texture stacks), so it can only evolve
- * in one place.
+ * Assemble the viz-buffer → G-buffer fragment shader body around a template's surface function.
+ * Everything else — vertex pulling, perspective-correct barycentric derivatives, normal frame
+ * construction, roughness AA, G-buffer encoding — is shared verbatim between templates, so it can
+ * only evolve in one place.
  *
- * The `sampling` expressions run after `uv_info` (GradSamplingInfo with
- * biased analytic gradients) is available; `prelude` is spliced right
- * before the first sample for variant-specific setup.
+ * The body reconstructs the {@link chunk_material_surface_contract} input from the visibility buffer
+ * and calls `material_surface` once; what comes back is anti-aliased, dithered and encoded here.
  *
- * @param {Object} sampling
- * @param {string} [sampling.prelude] statements inserted before sampling
- * @param {string} sampling.orm vec4f expression
- * @param {string} sampling.normal vec3f expression, decoded to [-1,1]
- * @param {string} sampling.diffuse vec4f expression (premultiplied alpha)
- * @param {string} sampling.emissive vec3f expression
- * @param {CodeChunk[]} [extra_chunks]
+ * @param {CodeChunk} surface defines `fn material_surface(s: MaterialSurfaceInput) -> MaterialSurfaceOutput`
  * @returns {CodeChunk}
  */
-export function build_gbuffer_fragment_body(sampling, extra_chunks = []) {
+export function build_gbuffer_fragment_body(surface) {
     return CodeChunk.from(
 // language=WGSL
         `
@@ -197,15 +234,17 @@ fn main(
     uv_info.ddx *= uv_derivative_bias.x;
     uv_info.ddy *= uv_derivative_bias.y;
 
-    ${sampling.prelude ?? ""}
-
-    let orm_sample = ${sampling.orm};
+    // the second set, with the same treatment
+    var uv1_info = barycentric_interpolate_uv(barycentric, vertex_0.uv1, vertex_1.uv1, vertex_2.uv1);
 
-    // roughness
-    var roughness = orm_sample.g * material_info.roughness_factor;
-    let metalness = orm_sample.b * material_info.metallic_factor;
+    uv1_info.ddx *= uv_derivative_bias.x;
+    uv1_info.ddy *= uv_derivative_bias.y;
 
-    let ambient = fma(orm_sample.r, material_info.ambient_factors.x, material_info.ambient_factors.y);
+    // geometry-space position with its exact screen gradients, unbiased — for a template that maps
+    // from position rather than from a UV set
+    let position_os_x = interpolate_with_derivatives(barycentric, geometry_vertex_position_0.x, geometry_vertex_position_1.x, geometry_vertex_position_2.x);
+    let position_os_y = interpolate_with_derivatives(barycentric, geometry_vertex_position_0.y, geometry_vertex_position_1.y, geometry_vertex_position_2.y);
+    let position_os_z = interpolate_with_derivatives(barycentric, geometry_vertex_position_0.z, geometry_vertex_position_1.z, geometry_vertex_position_2.z);
 
     let geometry_vertex_normal_0 = vertex_0.normal;
     let geometry_vertex_normal_1 = vertex_1.normal;
@@ -264,28 +303,36 @@ fn main(
 
     let world_tangent_frame = build_orthonormal_matrix_nt(world_vertex_normal, vec4(world_tangent, geometry_tangent_handedness));
 
-    let normal_sample = ${sampling.normal};
+    // what the template is given — see chunk_material_surface_contract
+    var surface_input: MaterialSurfaceInput;
 
-    // transform_global normal
-    let world_shading_normal:vec3<f32> = normalize( world_tangent_frame * normal_sample );
+    surface_input.uv = uv_info;
+    surface_input.uv1 = uv1_info;
+    surface_input.gradient_bias = uv_derivative_bias;
+    surface_input.position_os = vec3<f32>(position_os_x.x, position_os_y.x, position_os_z.x);
+    surface_input.position_os_ddx = vec3<f32>(position_os_x.y, position_os_y.y, position_os_z.y);
+    surface_input.position_os_ddy = vec3<f32>(position_os_x.z, position_os_y.z, position_os_z.z);
+    surface_input.position_ws = position_ws;
+    surface_input.normal_ws = world_vertex_normal;
+    surface_input.face_normal_ws = world_face_normal;
+    surface_input.view_direction_ws = view_direction;
+    surface_input.vertex_color = geometry_color;
+    surface_input.pixel = coord.xy;
 
+    let surface = material_surface(surface_input);
+
+    // transform_global normal
+    let world_shading_normal:vec3<f32> = normalize( world_tangent_frame * surface.normal );
 
     // let's filter rougness based on local normals
-    let filtered_roughness = anti_alias_roughness_kaplanyan(roughness, world_shading_normal, world_tangent_frame[0], world_tangent_frame[1]);
+    let filtered_roughness = anti_alias_roughness_kaplanyan(surface.roughness, world_shading_normal, world_tangent_frame[0], world_tangent_frame[1]);
 
     // apply dither
     let output_roughness = filtered_roughness + dither_color_8bit_triangle_noise(coord.xy);
 
-    let diffuse_sample = ${sampling.diffuse};
-
-    // undo alpha pre-multiplication (premultiplied alpha); fully transparent texels are
-    // rgb=0,a=0 and the resample here can disagree with the visibility pass's alpha test,
-    // so guard the division or NaN lands in the albedo G-buffer
-    let diffuse_sample_color = vec3(diffuse_sample.rgb / max(diffuse_sample.a, 1e-4));
-
     output.albedo = vec4<f32>(
-        diffuse_sample_color * geometry_color * material_info.albedo_color.rgb,
-        ambient
+        surface.albedo,
+        surface.ambient
     );
 
     output.normal = vec4u(
@@ -293,21 +340,20 @@ fn main(
         encode_g_buffer_normal(world_face_normal),
     );
 
+    output.pbr = vec2(surface.metalness, output_roughness);
 
-    output.pbr = vec2(metalness, output_roughness);
-
-    let emissive_color = (${sampling.emissive}) * material_info.emissive_factor;
-
-    output.emissive = rgbe9995_encode(emissive_color);
+    output.emissive = rgbe9995_encode(surface.emissive);
 
     return output;
 }`, [
+        surface,
+        chunk_material_surface_contract,
 
-        chunk_textureSampleBarycentric,
         chunk_mat4_extract_position,
         chunk_encode_g_buffer_normal,
 
         chunk_interpolate_attribute_3f32,
+        chunk_interpolate_with_derivatives,
 
         chunk_barycentric_full,
 
@@ -315,7 +361,6 @@ fn main(
         chunk_compute_normal_matrix_from_m4,
         chunk_anti_alias_roughness_kaplanyan,
         chunk_build_orthonormal_matrix_nt,
-        chunk_decode_tangent_normal,
         chunk_read_meshlet_triangle_vertices,
         chunk_decode_meshlet_element,
         chunk_compute_triangle_face_normal,
@@ -323,21 +368,74 @@ fn main(
         chunk_dither_color_8bit_triangle_noise,
         chunk_scene_database_access,
         chunk_node3d_flags,
-
-        ...extra_chunks,
     ]
     );
 }
 
-const body = build_gbuffer_fragment_body({
-    orm: `textureSampleBarycentric(texture_orm, texture_orm_sampler, uv_info)`,
-    normal: `decode_tangent_normal(textureSampleBarycentric(texture_normal, texture_normal_sampler, uv_info))`,
-    diffuse: `textureSampleBarycentric(texture_diffuse, texture_diffuse_sampler, uv_info)`,
-    emissive: `textureSampleBarycentric(texture_emissive, texture_emissive_sampler, uv_info).rgb`,
-});
+/**
+ * The G-buffer pipeline of a template: its group 0 and surface function around the shared body,
+ * after the shared binding-free vertex stage.
+ *
+ * @param {Object} options
+ * @param {string} options.label
+ * @param {ShaderResourceGroupDescriptor} options.material_group the template's group 0
+ * @param {CodeChunk} options.surface defines `material_surface`
+ * @returns {RenderPipelineDescriptor}
+ */
+export function build_gbuffer_pipeline_descriptor({ label, material_group, surface }) {
+    const shader = ShaderDescriptor.from({
+        label,
+        resources: build_gbuffer_shader_resources(material_group),
+        body: build_gbuffer_fragment_body(surface),
+    });
+
+    return gbuffer_pipeline_descriptor_for_shader(label, shader);
+}
+
+/**
+ * The G-buffer pipeline around an assembled fragment shader, whose resource set is one
+ * {@link build_gbuffer_shader_resources} made.
+ *
+ * @param {string} label
+ * @param {ShaderDescriptor} shader
+ * @returns {RenderPipelineDescriptor}
+ */
+export function gbuffer_pipeline_descriptor_for_shader(label, shader) {
+    return RenderPipelineDescriptor.from({
+        label,
+        layout: shader.resources.generatePipelineLayoutDescriptor(),
+        vertex: {
+            module: {
+                code: material_gbuffer_vertex_shader_code
+            }
+        },
+        fragment: {
+            module: {
+                code: shader.source,
+            },
+            targets: G_BUFFER_COLOR_TARGETS
+        },
+        depthStencil: {
+            // depth is actually a material mask, we use trick from Unreal to mask materials using depth
+            depthCompare: 'equal',
+            format: 'depth32float',
+            depthWriteEnabled: false
+        },
+        primitive: {
+            topology: 'triangle-list',
+            cullMode: 'none',
+        }
+    });
+}
 
+/**
+ * The standard material's G-buffer fragment shader.
+ *
+ * @type {ShaderDescriptor}
+ */
 export const gbuffer_shader = ShaderDescriptor.from({
     label: "Material / GBuffer laydown",
     resources: g_buffer_shader_resources,
-    body
-})
+    body: build_gbuffer_fragment_body(chunk_standard_material_surface)
+});
+

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

@@ -1,32 +1,41 @@
 /**
- * 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 {CodeChunk} defines `material_surface`
+ */
+export function build_chunk_vt_material_surface(chunk_vt_lookup: CodeChunk): CodeChunk;
+/**
+ * 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: CodeChunk): RenderPipelineDescriptor;
 /**
- * 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: ShaderResourceGroupDescriptor;
+/**
+ * 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: ShaderResourceSetDescriptor;
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";

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

@@ -1 +1 @@
-{"version":3,"file":"fragment_gbuffer_vt.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer_vt.js"],"names":[],"mappings":"AA0DA;;;;;;;;;;;;;;GAcG;AACH,uEAHW,SAAS,GACP,wBAAwB,CAiGpC;AAvJD;;;;;;;;;;;GAWG;AACH,+EAAsF;AAetF,sEAA6E;0BAxCnD,oCAAoC;yCAHrB,iEAAiE;8CAK5D,wDAAwD;4CAC1D,sDAAsD"}
+{"version":3,"file":"fragment_gbuffer_vt.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer_vt.js"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;GAYG;AACH,iEAHW,SAAS,GACP,SAAS,CAsErB;AAED;;;;;;GAMG;AACH,uEAHW,SAAS,GACP,wBAAwB,CAQpC;AAvID;;;;;;;;GAQG;AACH,+EAAsF;AAiBtF;;;;;GAKG;AACH,0CAFU,2BAA2B,CAEyE;0BAxCpF,oCAAoC;yCAHrB,iEAAiE;8CAI5D,wDAAwD;4CAC1D,sDAAsD"}