@woosh/meep-engine 3.61.3 → 3.62.0

package/src/shade/renderer/Renderer.js

@@ -35,12 +35,12 @@ import { TonemapDisplaySettings } from "./deferred/tonemap/TonemapDisplaySetting
 import { FrameContext } from "./extension/FrameContext.js";
 import { FramePhase } from "./extension/FramePhase.js";
 import { GBufferTextures } from "./extension/GBufferTextures.js";
+import { VISIBILITY_FORMAT } from "./rasterize/visibility/VISIBILITY_BUFFER.js";
 import { PresentTarget } from "./extension/PresentTarget.js";
 import { RenderExtensionRegistry } from "./extension/RenderExtensionRegistry.js";
 import { SceneColor } from "./extension/SceneColor.js";
 import { ViewTextures } from "./extension/ViewTextures.js";
 import { G_BUFFER_COLOR_TARGETS } from "./gbuffer/G_BUFFER_COLOR_TARGETS.js";
-import { G_BUFFER_MIP_LEVELS } from "./gbuffer/G_BUFFER_MIP_LEVELS.js";
 import { shader_brick4_diffuse } from "./global_illumination/brick4/gpu/draw/shader_brick4_diffuse.js";
 import {
     shader_brick4_indirect_lighting
@@ -142,13 +142,10 @@ const METRICS = new MetricCollection();
 METRICS.create({ name: 'frame_time' });
 
 /**
- * Depth and G-buffer textures carry {@link G_BUFFER_MIP_LEVELS} mip levels.
- * WebGPU's createTexture validation requires mipLevelCount <= floor(log2(max(w,h))) + 1,
- * so the internal resolution must never drop below 2^(G_BUFFER_MIP_LEVELS - 1)
- * or texture allocation will fail.
+ * The smallest internal resolution along either axis: a texture is at least one texel wide.
  * @type {number}
  */
-const INTERNAL_RESOLUTION_MIN = 1 << (G_BUFFER_MIP_LEVELS - 1);
+const INTERNAL_RESOLUTION_MIN = 1;
 
 MetricCollectionConsoleMonitor.from(METRICS);
 
@@ -869,18 +866,18 @@ export class Renderer {
     #textures_taa_history = new Array(2);
 
     /**
-     * The G-buffer normal, ping-ponged as depth is: reprojection asks which surface a history texel was
-     * written on, and only last frame's normal says.
+     * The G-buffer's PBR target, ping-ponged as depth is: it holds the face normal, and reprojection
+     * asks which surface a history texel was written on, which only last frame's face normal says.
      * @type {GPUTextureContext[]}
      */
-    #textures_normal = new Array(2);
+    #textures_pbr = new Array(2);
 
     /**
      *
      * @returns {GPUTextureContext}
      */
-    get texture_normal_current() {
-        const tx = this.#textures_normal;
+    get texture_pbr_current() {
+        const tx = this.#textures_pbr;
 
         return tx[this.#frame_count % tx.length];
     }
@@ -890,8 +887,8 @@ export class Renderer {
      *
      * @returns {GPUTextureContext}
      */
-    get texture_normal_previous() {
-        const tx = this.#textures_normal;
+    get texture_pbr_previous() {
+        const tx = this.#textures_pbr;
 
         return tx[(this.#frame_count - 1 + tx.length) % tx.length];
     }
@@ -1859,9 +1856,9 @@ export class Renderer {
         this.#update_output_resolution();
 
         // The depth ping-pong and the visibility target are created at the internal resolution
-        // below, so it has to be real by then rather than the 1x1 it is declared at: a 1x1 texture
-        // cannot carry G_BUFFER_MIP_LEVELS mips. Only the texture drawn into is resized per frame,
-        // so frame 0's previous depth is used at the size it was created at.
+        // below, so it has to be real by then rather than the 1x1 it is declared at. Only the
+        // texture drawn into is resized per frame, so frame 0's previous depth is used at the size
+        // it was created at.
         this.#update_internal_resolution();
 
         this.#graphics = new GraphicsContext(device);
@@ -1886,14 +1883,14 @@ export class Renderer {
                 label: `Depth ${i}`,
                 size: resolution_internal,
                 format: 'depth32float',
-                mipLevelCount: G_BUFFER_MIP_LEVELS,
+                mipLevelCount: 1,
                 usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC,
             }));
 
-            this.#textures_normal[i] = graphics.textures.contextFromDescriptor(TextureDescriptor.from({
-                label: `Normal ${i}`,
+            this.#textures_pbr[i] = graphics.textures.contextFromDescriptor(TextureDescriptor.from({
+                label: `PBR ${i}`,
                 size: resolution_internal,
-                format: G_BUFFER_COLOR_TARGETS[1].format,
+                format: G_BUFFER_COLOR_TARGETS[0].format,
                 mipLevelCount: 1,
                 // storage too, for the compute material dispatch, which can be chosen on any frame
                 usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING,
@@ -2145,7 +2142,7 @@ export class Renderer {
     #destroy_render_targets() {
         const targets = [
             ...this.#textures_depth,
-            ...this.#textures_normal,
+            ...this.#textures_pbr,
             ...this.#textures_taa_history,
             ...(this.#vis_render_target?.color_attachments ?? []),
         ];
@@ -2155,7 +2152,7 @@ export class Renderer {
         }
 
         this.#textures_depth.fill(undefined);
-        this.#textures_normal.fill(undefined);
+        this.#textures_pbr.fill(undefined);
         this.#textures_taa_history.fill(undefined);
 
         this.#vis_render_target = undefined;
@@ -2178,13 +2175,9 @@ export class Renderer {
 
         vis_rt.color_attachments = [
             textures.contextFromDescriptor(TextureDescriptor.from({
+                label: "Visibility",
                 size: internal_resolution_array,
-                format: "r32uint",
-                usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
-            })),
-            textures.contextFromDescriptor(TextureDescriptor.from({
-                size: internal_resolution_array,
-                format: "r32uint",
+                format: VISIBILITY_FORMAT,
                 usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
             })),
         ];
@@ -2395,10 +2388,10 @@ export class Renderer {
         }
 
         // cycle depth attachment, then size the target this frame draws into. Previous depth is not
-        // attached, so it keeps the size it was drawn at. The normal cycles with it, the same way.
+        // attached, so it keeps the size it was drawn at. The PBR target cycles with it, the same way.
         this.#vis_render_target.depth_attachment = this.texture_depth_current;
         this.#vis_render_target.resize(this.#internal_resolution.x, this.#internal_resolution.y);
-        this.texture_normal_current.resize(this.#internal_resolution.x, this.#internal_resolution.y);
+        this.texture_pbr_current.resize(this.#internal_resolution.x, this.#internal_resolution.y);
         this.#postprocess.update(this.#frame_count);
 
         // Advance whichever upscaler we're going to ask for jitter on this
@@ -2788,6 +2781,7 @@ export class Renderer {
             buckets: gr_render_buckets,
             depth: gr_raster_depth,
             color_targets: gr_raster_color_targets,
+            visible_meshlets: gr_raster_visible_meshlets,
         } = graph_rasterize_scene({
             job: raster_main,
             graph,
@@ -2795,8 +2789,8 @@ export class Renderer {
         });
 
         // `let` rather than `const` because an extension at `AfterGBuffer` may publish replacements
-        let gr_viz_buffer_triangle = gr_raster_color_targets[0];
-        let gr_viz_buffer_mesh = gr_raster_color_targets[1];
+        let gr_visibility = gr_raster_color_targets[0];
+        let gr_visible_meshlets = gr_raster_visible_meshlets;
 
         // Virtual texture feedback: derive per-pixel page usage from the viz
         // buffer (no extra geometry pass) into a unique-request hash set and
@@ -2805,8 +2799,8 @@ export class Renderer {
             graphics.virtual_textures.graph_feedback({
                 graph,
                 view: view_ctx,
-                texture_viz_mesh: gr_viz_buffer_mesh,
-                texture_viz_triangle: gr_viz_buffer_triangle,
+                texture_visibility: gr_visibility,
+                visible_meshlets: gr_visible_meshlets,
                 material_metadata_buffer: graphics.materials.metadata_table.buffer,
             });
         }
@@ -2836,9 +2830,9 @@ export class Renderer {
         const mat_g = material_pass.graph_viz_render({
             graph,
             view: view_ctx,
-            texture_viz_mesh: gr_viz_buffer_mesh,
-            texture_viz_triangle: gr_viz_buffer_triangle,
-            texture_normal: graph_import_texture(graph, this.texture_normal_current, "normal"),
+            texture_visibility: gr_visibility,
+            visible_meshlets: gr_visible_meshlets,
+            texture_pbr: graph_import_texture(graph, this.texture_pbr_current, "pbr"),
         });
 
         // update texture references
@@ -2849,10 +2843,6 @@ export class Renderer {
         let gr_texture_material_albedo_ao = mat_g.g_albedo;
         let gr_texture_material_emissive = mat_g.g_emissive;
 
-        // do mips for G-buffer
-        // mipmap_nearest(command_ctx, this.texture_depth_current);
-        // this.gBuffer.mipmap(command_ctx);
-
         // Update lights position
         command_ctx.pushDebugGroup("Shade");
 
@@ -2900,8 +2890,8 @@ export class Renderer {
 
         record_view_textures.depth = gr_texture_depth_current;
         record_view_textures.depth_previous = gr_texture_depth_previous;
-        record_view_textures.visibility_mesh = gr_viz_buffer_mesh;
-        record_view_textures.visibility_triangle = gr_viz_buffer_triangle;
+        record_view_textures.visibility = gr_visibility;
+        record_view_textures.visible_meshlets = gr_visible_meshlets;
 
         this.#extensions.run(frame);
 
@@ -2926,8 +2916,8 @@ export class Renderer {
 
         gr_texture_depth_current = record_view_textures.depth;
         gr_texture_depth_previous = record_view_textures.depth_previous;
-        gr_viz_buffer_mesh = record_view_textures.visibility_mesh;
-        gr_viz_buffer_triangle = record_view_textures.visibility_triangle;
+        gr_visibility = record_view_textures.visibility;
+        gr_visible_meshlets = record_view_textures.visible_meshlets;
 
         // Velocity pass with three branches: rotation-reprojection
         // background, rigid per-object foreground (mesh.global delta),
@@ -2974,8 +2964,8 @@ export class Renderer {
         let gr_velocity = graph_add_per_object_velocity({
             graph,
             texture_depth: gr_texture_depth_current,
-            texture_viz_mesh: gr_viz_buffer_mesh,
-            texture_viz_triangle: gr_viz_buffer_triangle,
+            texture_visibility: gr_visibility,
+            buffer_visible_meshlets: gr_visible_meshlets,
             buffer_scene_database: gr_scene_database_for_velocity,
             buffer_meshlet_metadata: gr_meshlet_metadata_for_velocity,
             buffer_meshlet_data: gr_meshlet_data_for_velocity,
@@ -2984,19 +2974,14 @@ export class Renderer {
             skinning_active,
             resolution,
             view: view_ctx,
-            enable_mipmap: true
         });
 
-        // gr_velocity = graph_mipmap_nearest(graph, gr_velocity, G_BUFFER_MIP_LEVELS);
-
         // rg8unorm: r is the history confidence, g records which texel won the nearest-depth search,
         // so the TAA resolve can reproject with exactly the velocity this pass validated.
         let [gr_occlusion_clip] = graph_image_pass({
             graph,
             shader: shader_depth_occlusion_clip,
             output_resolution: view_ctx.resolution,
-            // mipmaps are going to be necessary for half-resolution post-process passes
-            output_mipmaps: true,
             inputs: {
                 camera_current: gr_buffer_camera_current,
                 camera_previous: gr_buffer_camera_previous,
@@ -3129,7 +3114,8 @@ export class Renderer {
                 input_depth: gr_texture_depth_current,
                 input_velocity: gr_velocity,
                 input_normal: gr_texture_normal,
-                input_normal_previous: graph_import_texture(graph, this.texture_normal_previous, "normal previous"),
+                input_pbr: gr_texture_pbr,
+                input_pbr_previous: graph_import_texture(graph, this.texture_pbr_previous, "pbr previous"),
                 input_occlusion: gr_occlusion_clip,
                 input_hzb: gr_texture_hzb,
                 // NOTE: AO is blended into the G-buffer
@@ -3295,6 +3281,7 @@ export class Renderer {
                 depth_texture: gr_texture_depth_current,
 
                 normal_texture: gr_texture_normal,
+                pbr_texture: gr_texture_pbr,
                 hzb_texture: gr_texture_hzb,
                 environment_texture: gr_texture_environment,
 

package/src/shade/renderer/deferred/chunk_read_gBuffer_material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_read_gBuffer_material.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_read_gBuffer_material.js"],"names":[],"mappings":"AAUA,oDAwDE;0BA3DwB,iCAAiC"}
+{"version":3,"file":"chunk_read_gBuffer_material.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_read_gBuffer_material.js"],"names":[],"mappings":"AAWA,oDAyDE;0BA5DwB,iCAAiC"}

package/src/shade/renderer/deferred/chunk_read_gBuffer_material.js

@@ -1,6 +1,7 @@
 import { BSDF_ROUGHNESS_MINIMUM } from "../light/environment/DEFINES.js";
 import { chunk_MIN_DIELECTRICS_F0 } from "../shader/chunk/brdf/chunk_MIN_DIELECTRICS_F0.js";
 import { chunk_rgbe9995_decode } from "../shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.js";
+import { chunk_decode_g_buffer_albedo } from "../shader/chunk/material/chunk_decode_g_buffer_albedo.js";
 import { chunk_decode_g_buffer_metalness } from "../shader/chunk/material/chunk_decode_g_buffer_metalness.js";
 import { chunk_decode_g_buffer_roughness } from "../shader/chunk/material/chunk_decode_g_buffer_roughness.js";
 import { chunk_metalness_to_specular_color } from "../shader/chunk/material/chunk_metalness_to_specular_color.js";
@@ -27,7 +28,7 @@ fn read_gBuffer_material(
         0
     );
 
-    let albedo = albedo_ao_sample.rgb;
+    let albedo = decode_g_buffer_albedo(albedo_ao_sample.rgb);
     
     let emissive = rgbe9995_decode( textureLoad(
         gBufferEmissive,
@@ -61,6 +62,7 @@ fn read_gBuffer_material(
         chunk_metalness_to_specular_color,
         chunk_MIN_DIELECTRICS_F0,
         chunk_decode_g_buffer_roughness,
+        chunk_decode_g_buffer_albedo,
         chunk_decode_g_buffer_metalness,
         chunk_rgbe9995_decode
     ]

package/src/shade/renderer/deferred/chunk_ss_trace_contact_shadow_soft.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ss_trace_contact_shadow_soft.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_ss_trace_contact_shadow_soft.js"],"names":[],"mappings":"AAUA;;;;;;GAMG;AACH,6CAFU,SAAS,CAsMlB;AAED,2DAiDC;0BAhQyB,iCAAiC"}
+{"version":3,"file":"chunk_ss_trace_contact_shadow_soft.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/chunk_ss_trace_contact_shadow_soft.js"],"names":[],"mappings":"AAYA;;;;;;GAMG;AACH,6CAFU,SAAS,CAqMlB;AAED,2DAiDC;0BA/PyB,iCAAiC"}

package/src/shade/renderer/deferred/chunk_ss_trace_contact_shadow_soft.js

@@ -1,7 +1,9 @@
 import { chunk_project_position_from_depth } from "../shader/chunk/camera/chunk_project_position_from_depth.js";
 import { chunk_get_view_space_depth } from "../shader/chunk/depth/chunk_get_view_space_depth.js";
 import { chunk_cone_sample_direction } from "../shader/chunk/geometry/cone/chunk_cone_sample_direction.js";
-import { chunk_decode_g_buffer_normal } from "../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import {
+    chunk_decode_g_buffer_face_normal
+} from "../shader/chunk/geometry/normal/chunk_decode_g_buffer_face_normal.js";
 import { PI_DECLARATION } from "../shader/chunk/math/PI_DECLARATION.js";
 import { chunk_random } from "../shader/chunk/random/chunk_random.js";
 import { chunk_ndc_to_texel_coordinate } from "../shader/chunk/texture/chunk_ndc_to_texel_coordinate.js";
@@ -177,8 +179,7 @@ fn ss_trace_pixel_occlusion(
             var confidence = 1.0;
             
             // validate hit
-            let hit_normal_texel = textureLoad(gBufferNormal, screen_coord_u, 0);
-            let hit_geometric_normal = decode_g_buffer_normal(hit_normal_texel.zw);
+            let hit_geometric_normal = decode_g_buffer_face_normal(textureLoad(gBufferPBR, screen_coord_u, 0));
             
             const DEG2RAD = 0.017453292519943295;
             const NORMAL_HIT_THRESHOLD = cos( 15.0 * DEG2RAD );
@@ -209,7 +210,7 @@ fn ss_trace_pixel_occlusion(
         chunk_get_view_space_depth,
         chunk_texel_coordinate_to_uv,
         chunk_project_position_from_depth,
-        chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
     ]
 )
 

package/src/shade/renderer/deferred/shader_deferred_main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_deferred_main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/shader_deferred_main.js"],"names":[],"mappings":"AAwBA;;;;GAIG;AACH,oCAFU,MAAM,CAEwB;AAgGxC;;;;;;;;GAQG;AACH,mCAFU,WAAW,CAelB;4BAtIyB,0BAA0B"}
+{"version":3,"file":"shader_deferred_main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/shader_deferred_main.js"],"names":[],"mappings":"AA2BA;;;;GAIG;AACH,oCAFU,MAAM,CAEwB;AA+FxC;;;;;;;;GAQG;AACH,mCAFU,WAAW,CAelB;4BArIyB,0BAA0B"}

package/src/shade/renderer/deferred/shader_deferred_main.js

@@ -4,6 +4,9 @@ import { chunk_project_position_from_depth } from "../shader/chunk/camera/chunk_
 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_decode_g_buffer_normal } from "../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import {
+    chunk_decode_g_buffer_face_normal
+} from "../shader/chunk/geometry/normal/chunk_decode_g_buffer_face_normal.js";
 import { DIRECTIONAL_LIGHT_STRUCT } from "../shader/chunk/light/DIRECTIONAL_LIGHT_STRUCT.js";
 import { INCIDENT_LIGHT_STRUCT } from "../shader/chunk/light/INCIDENT_LIGHT_STRUCT.js";
 import { POINT_LIGHT_STRUCT } from "../shader/chunk/light/POINT_LIGHT_STRUCT.js";
@@ -80,10 +83,8 @@ fn main(
 
     let view_direction = normalize(camera_position_ws - position_ws);
 
-    let g_buffer_sample_normal = textureLoad(gBufferNormal, i_coord, 0);
-
-    let shading_normal = decode_g_buffer_normal(g_buffer_sample_normal.xy);
-    let geometric_normal = decode_g_buffer_normal(g_buffer_sample_normal.zw);
+    let shading_normal = decode_g_buffer_normal(textureLoad(gBufferNormal, i_coord, 0).x);
+    let geometric_normal = decode_g_buffer_face_normal(textureLoad(gBufferPBR, i_coord, 0));
 
     let geometry = ${GEOMETRIC_SHADING_INFO_STRUCT.wgsl_ref}(
         shading_normal,
@@ -113,6 +114,7 @@ fn main(
         GEOMETRIC_SHADING_INFO_STRUCT.declaration_chunk,
         MATERIAL_SHADING_INFO_STRUCT.declaration_chunk,
         chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_project_position_from_depth,
         chunk_mat4_extract_position,
         chunk_read_gBuffer_material,

package/src/shade/renderer/extension/GBufferTextures.d.ts

@@ -36,12 +36,16 @@ export class GBufferTextures extends FrameRecord {
     republish_albedo(handle: number): void;
     set normal(handle: number);
     /**
+     * The shading normal, octahedral at 16 bits per axis packed into one `r32uint`
+     * (`decode_g_buffer_normal`).
+     *
      * @returns {number}
      */
     get normal(): number;
     set pbr(handle: number);
     /**
-     * Roughness, metalness and what else the standard material carries.
+     * Metalness and roughness, and in `ba` the face normal: octahedral at 8 bits per axis
+     * (`decode_g_buffer_face_normal`).
      *
      * @returns {number}
      */

package/src/shade/renderer/extension/GBufferTextures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GBufferTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/GBufferTextures.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH;IAMI,0CAKC;IAED,2CAEC;IAWD,2BAEC;IAXD;;;;OAIG;IACH,qBAEC;IAMD;;;;;;;;;OASG;IACH,yBAFW,MAAM,QAIhB;IASD,2BAEC;IATD;;OAEG;IACH,qBAEC;IAeD,wBAEC;IAXD;;;;OAIG;IACH,kBAEC;IAaD,6BAEC;IATD;;OAEG;IACH,uBAEC;;CAKJ;4BA/F2B,kBAAkB"}
+{"version":3,"file":"GBufferTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/GBufferTextures.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH;IAMI,0CAKC;IAED,2CAEC;IAWD,2BAEC;IAXD;;;;OAIG;IACH,qBAEC;IAMD;;;;;;;;;OASG;IACH,yBAFW,MAAM,QAIhB;IAYD,2BAEC;IAZD;;;;;OAKG;IACH,qBAEC;IAgBD,wBAEC;IAZD;;;;;OAKG;IACH,kBAEC;IAaD,6BAEC;IATD;;OAEG;IACH,uBAEC;;CAKJ;4BAnG2B,kBAAkB"}

package/src/shade/renderer/extension/GBufferTextures.js

@@ -61,6 +61,9 @@ export class GBufferTextures extends FrameRecord {
     }
 
     /**
+     * The shading normal, octahedral at 16 bits per axis packed into one `r32uint`
+     * (`decode_g_buffer_normal`).
+     *
      * @returns {number}
      */
     get normal() {
@@ -72,7 +75,8 @@ export class GBufferTextures extends FrameRecord {
     }
 
     /**
-     * Roughness, metalness and what else the standard material carries.
+     * Metalness and roughness, and in `ba` the face normal: octahedral at 8 bits per axis
+     * (`decode_g_buffer_face_normal`).
      *
      * @returns {number}
      */

package/src/shade/renderer/extension/ViewTextures.d.ts

@@ -1,6 +1,6 @@
 /**
  * What the frame knows about where each pixel came from: this frame's depth, last frame's depth,
- * and the visibility buffer's mesh and triangle rows.
+ * the visibility buffer, and the visible-meshlet table that resolves it.
  *
  * Carried from {@link FramePhase.AfterGBuffer} through {@link FramePhase.BeforePresent}, and
  * writable wherever it is carried — an extension that rasterizes geometry which should own depth
@@ -25,20 +25,24 @@ export class ViewTextures extends FrameRecord {
      * @returns {number}
      */
     get depth_previous(): number;
-    set visibility_mesh(handle: number);
+    set visibility(handle: number);
     /**
-     * Which mesh each pixel came from. What an outline or a selection highlight is derived from.
+     * Which triangle of which mesh each pixel came from: one word a pixel, `VISIBILITY_FORMAT`, a slot of
+     * {@link visible_meshlets} and the triangle within that meshlet, or `VISIBILITY_NONE` where no surface
+     * is. `visibility_decode` reads it. What an outline or a selection highlight is derived from.
      *
      * @returns {number}
      */
-    get visibility_mesh(): number;
-    set visibility_triangle(handle: number);
+    get visibility(): number;
+    set visible_meshlets(handle: number);
     /**
-     * Which triangle each pixel came from.
+     * The frame's visible-meshlet table: the meshlet, and the mesh row it was drawn for, at each slot
+     * {@link visibility} names. Published with it: a pass that writes its own words into the visibility
+     * buffer appends its meshlets here.
      *
      * @returns {number}
      */
-    get visibility_triangle(): number;
+    get visible_meshlets(): number;
     #private;
 }
 import { FrameRecord } from "./FrameRecord.js";

package/src/shade/renderer/extension/ViewTextures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/ViewTextures.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH;IAMI,0CAKC;IASD,0BAEC;IATD;;OAEG;IACH,oBAEC;IAgBD,mCAEC;IAZD;;;;;OAKG;IACH,6BAEC;IAeD,oCAEC;IAXD;;;;OAIG;IACH,8BAEC;IAeD,wCAEC;IAXD;;;;OAIG;IACH,kCAEC;;CAKJ;4BA7E2B,kBAAkB"}
+{"version":3,"file":"ViewTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/ViewTextures.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH;IAMI,0CAKC;IASD,0BAEC;IATD;;OAEG;IACH,oBAEC;IAgBD,mCAEC;IAZD;;;;;OAKG;IACH,6BAEC;IAiBD,+BAEC;IAbD;;;;;;OAMG;IACH,yBAEC;IAiBD,qCAEC;IAbD;;;;;;OAMG;IACH,+BAEC;;CAKJ;4BAjF2B,kBAAkB"}

package/src/shade/renderer/extension/ViewTextures.js

@@ -3,7 +3,7 @@ import { FrameRecord } from "./FrameRecord.js";
 
 /**
  * What the frame knows about where each pixel came from: this frame's depth, last frame's depth,
- * and the visibility buffer's mesh and triangle rows.
+ * the visibility buffer, and the visible-meshlet table that resolves it.
  *
  * Carried from {@link FramePhase.AfterGBuffer} through {@link FramePhase.BeforePresent}, and
  * writable wherever it is carried — an extension that rasterizes geometry which should own depth
@@ -16,8 +16,8 @@ import { FrameRecord } from "./FrameRecord.js";
 export class ViewTextures extends FrameRecord {
     #depth = -1;
     #depth_previous = -1;
-    #visibility_mesh = -1;
-    #visibility_triangle = -1;
+    #visibility = -1;
+    #visible_meshlets = -1;
 
     static is_present_at(phase) {
         return phase === FramePhase.AfterGBuffer
@@ -52,28 +52,32 @@ export class ViewTextures extends FrameRecord {
     }
 
     /**
-     * Which mesh each pixel came from. What an outline or a selection highlight is derived from.
+     * Which triangle of which mesh each pixel came from: one word a pixel, `VISIBILITY_FORMAT`, a slot of
+     * {@link visible_meshlets} and the triangle within that meshlet, or `VISIBILITY_NONE` where no surface
+     * is. `visibility_decode` reads it. What an outline or a selection highlight is derived from.
      *
      * @returns {number}
      */
-    get visibility_mesh() {
-        return this.read(this.#visibility_mesh);
+    get visibility() {
+        return this.read(this.#visibility);
     }
 
-    set visibility_mesh(handle) {
-        this.#visibility_mesh = this.publish(handle);
+    set visibility(handle) {
+        this.#visibility = this.publish(handle);
     }
 
     /**
-     * Which triangle each pixel came from.
+     * The frame's visible-meshlet table: the meshlet, and the mesh row it was drawn for, at each slot
+     * {@link visibility} names. Published with it: a pass that writes its own words into the visibility
+     * buffer appends its meshlets here.
      *
      * @returns {number}
      */
-    get visibility_triangle() {
-        return this.read(this.#visibility_triangle);
+    get visible_meshlets() {
+        return this.read(this.#visible_meshlets);
     }
 
-    set visibility_triangle(handle) {
-        this.#visibility_triangle = this.publish(handle);
+    set visible_meshlets(handle) {
+        this.#visible_meshlets = this.publish(handle);
     }
 }

package/src/shade/renderer/gbuffer/G_BUFFER_ALBEDO_FORMAT.d.ts

@@ -1,4 +1,6 @@
 /**
+ * The G-buffer's albedo target: `rgb` the albedo sRGB-encoded, as `encode_g_buffer_albedo` writes it and
+ * `decode_g_buffer_albedo` reads it, `a` the ambient occlusion, linear.
  *
  * @type {GPUTextureFormat}
  */

package/src/shade/renderer/gbuffer/G_BUFFER_ALBEDO_FORMAT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"G_BUFFER_ALBEDO_FORMAT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/gbuffer/G_BUFFER_ALBEDO_FORMAT.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,sDAAmD"}
+{"version":3,"file":"G_BUFFER_ALBEDO_FORMAT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/gbuffer/G_BUFFER_ALBEDO_FORMAT.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,sDAAmD"}

package/src/shade/renderer/gbuffer/G_BUFFER_ALBEDO_FORMAT.js

@@ -1,4 +1,6 @@
 /**
+ * The G-buffer's albedo target: `rgb` the albedo sRGB-encoded, as `encode_g_buffer_albedo` writes it and
+ * `decode_g_buffer_albedo` reads it, `a` the ambient occlusion, linear.
  *
  * @type {GPUTextureFormat}
  */

package/src/shade/renderer/gbuffer/G_BUFFER_COLOR_TARGETS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"G_BUFFER_COLOR_TARGETS.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/gbuffer/G_BUFFER_COLOR_TARGETS.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qCAFU,qBAAqB,CAW5B"}
+{"version":3,"file":"G_BUFFER_COLOR_TARGETS.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/gbuffer/G_BUFFER_COLOR_TARGETS.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qCAFU,qBAAqB,CAY5B"}

package/src/shade/renderer/gbuffer/G_BUFFER_COLOR_TARGETS.js

@@ -1,14 +1,17 @@
+import { G_BUFFER_ALBEDO_FORMAT } from "./G_BUFFER_ALBEDO_FORMAT.js";
+
 /**
  * @readonly
  * @type {GPUColorTargetState[]}
  */
 export const G_BUFFER_COLOR_TARGETS = Object.freeze([
-    // metalness, roughness
-    { format: 'rg8unorm' },
-    // octahedral-encoded normal
-    { format:'rgba16uint'},
-    // albedo + AO
+    // metalness, roughness, and the face normal in ba: octahedral, 8 bits per axis
+    // (chunk_encode_g_buffer_face_normal)
     { format: 'rgba8unorm' },
+    // the shading normal: octahedral, 16 bits per axis, packed (chunk_encode_g_buffer_normal)
+    { format: 'r32uint' },
+    // albedo + AO
+    { format: G_BUFFER_ALBEDO_FORMAT },
     // emissive RGB
     { format: 'r32uint' },
 ]);

package/src/shade/renderer/geometry/sdf/shader_sdf_visualize.d.ts

@@ -4,17 +4,19 @@
  * @param {FrameGraph} options.graph
  * @param {GPUViewContext} options.view
  * @param {number} options.input_depth
- * @param {number} options.input_normals
- * @param {number} options.input_viz_mesh
+ * @param {number} options.input_pbr the G-buffer's PBR target, for its face normal
+ * @param {number} options.input_visibility the visibility buffer
+ * @param {number} options.input_visible_meshlets the frame's visible-meshlet table, which resolves it
  * @param settings
  * @returns {number} texture with shadows
  */
-export function graph_draw_sdf_normals({ graph, view, input_depth, input_normals, input_viz_mesh, }: {
+export function graph_draw_sdf_normals({ graph, view, input_depth, input_pbr, input_visibility, input_visible_meshlets, }: {
     graph: FrameGraph;
     view: GPUViewContext;
     input_depth: number;
-    input_normals: number;
-    input_viz_mesh: number;
+    input_pbr: number;
+    input_visibility: number;
+    input_visible_meshlets: number;
 }): number;
 export const shader_sdf_visualize: ImageShader;
 import { ImageShader } from "../../shader/ImageShader.js";

package/src/shade/renderer/geometry/sdf/shader_sdf_visualize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_sdf_visualize.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/shader_sdf_visualize.js"],"names":[],"mappings":"AA4JA;;;;;;;;;;GAUG;AACH;IAR+B,KAAK;IACD,IAAI;IACZ,WAAW,EAA3B,MAAM;IACU,aAAa,EAA7B,MAAM;IACU,cAAc,EAA9B,MAAM;IAEJ,MAAM,CAmGlB;AAvHD,+CASG;4BApIyB,6BAA6B"}
+{"version":3,"file":"shader_sdf_visualize.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/shader_sdf_visualize.js"],"names":[],"mappings":"AAqKA;;;;;;;;;;;GAWG;AACH;IAT+B,KAAK;IACD,IAAI;IACZ,WAAW,EAA3B,MAAM;IACU,SAAS,EAAzB,MAAM;IACU,gBAAgB,EAAhC,MAAM;IACU,sBAAsB,EAAtC,MAAM;IAEJ,MAAM,CAsGlB;AA3HD,+CASG;4BAvIyB,6BAA6B"}