@woosh/meep-engine 3.61.2 → 3.62.0

package/src/shade/playground/ssr_variance/capture.js

@@ -21,7 +21,7 @@ struct Capture { @location(0) radiance: vec4f, @location(1) mask: vec4f }
     let p = vec2i(coord.xy);
     var output: Capture;
     output.radiance = textureLoad(tSource, p, 0);
-    output.mask = vec4f(select(0.0, 1.0, decode_g_buffer_normal(textureLoad(tNormal, p, 0).xy).y > 0.99));
+    output.mask = vec4f(select(0.0, 1.0, decode_g_buffer_normal(textureLoad(tNormal, p, 0).x).y > 0.99));
     return output;
 }`, [chunk_decode_g_buffer_normal]) }),
     targets: [{ format: 'rgba32float' }, { format: 'rgba32float' }],

package/src/shade/renderer/Renderer.d.ts

@@ -316,13 +316,13 @@ export class Renderer {
      *
      * @returns {GPUTextureContext}
      */
-    get texture_normal_current(): GPUTextureContext;
+    get texture_pbr_current(): GPUTextureContext;
     /**
      * At the size last frame was drawn at, as {@link texture_depth_previous} is.
      *
      * @returns {GPUTextureContext}
      */
-    get texture_normal_previous(): GPUTextureContext;
+    get texture_pbr_previous(): GPUTextureContext;
     /**
      *
      * @param {number} ratio

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}

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];
     }
@@ -1215,6 +1212,37 @@ export class Renderer {
         cmd.finish();
     }
 
+    /**
+     * The inputs of the probe clipmap's fused indirect pass (`shader_probe_clipmap_indirect_lighting`), less the
+     * probes' own bindings, which `GPUProbeClipmapGI.write_sampling_bindings` adds: for the frame's pass and for
+     * the mode's indirect debug views alike. A fresh object each call, as the probes' bindings are written into it.
+     *
+     * @param {object} params
+     * @param {GPUViewContext} params.view_ctx
+     * @param {number} params.depth graph handle
+     * @param {number} params.normal graph handle
+     * @param {number} params.bent_normal graph handle
+     * @param {number} params.albedo_ao graph handle
+     * @param {number} params.pbr graph handle
+     * @param {number} params.environment graph handle
+     * @param {number} params.camera graph handle
+     * @returns {Object}
+     */
+    #probe_clipmap_indirect_inputs({ view_ctx, depth, normal, bent_normal, albedo_ao, pbr, environment, camera }) {
+        return {
+            tDepth: depth,
+            tNormals: normal,
+            tBentNormals: bent_normal,
+            tGBufferAlbedo: albedo_ao,
+            tGBufferPBR: pbr,
+            tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
+            view: view_ctx.uniform_buffer.buffer,
+            camera,
+            tEnvironment: environment,
+            tSplitSum: STATIC_GRAPHICS_ENGINE_ASSETS.split_sum,
+        };
+    }
+
     /**
      * Build and composite deferred indirect lighting, including fused and SSR paths.
      *
@@ -1307,18 +1335,16 @@ export class Renderer {
                             output: [current_color_out],
                             input_depth: gr_texture_depth_current,
                             load_op: "load",
-                            inputs: this.#probe_clipmap_gi.write_sampling_bindings({
-                                tDepth: gr_texture_depth_current,
-                                tNormals: gr_texture_normal,
-                                tBentNormals: bent_normals,
-                                tGBufferAlbedo: gr_texture_material_albedo_ao,
-                                tGBufferPBR: gr_texture_pbr,
-                                tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
-                                view: view_ctx.uniform_buffer.buffer,
+                            inputs: this.#probe_clipmap_gi.write_sampling_bindings(this.#probe_clipmap_indirect_inputs({
+                                view_ctx,
+                                depth: gr_texture_depth_current,
+                                normal: gr_texture_normal,
+                                bent_normal: bent_normals,
+                                albedo_ao: gr_texture_material_albedo_ao,
+                                pbr: gr_texture_pbr,
+                                environment: gr_texture_environment,
                                 camera: gr_buffer_camera_current,
-                                tEnvironment: gr_texture_environment,
-                                tSplitSum: STATIC_GRAPHICS_ENGINE_ASSETS.split_sum,
-                            }),
+                            })),
                         });
                         return current_color_out;
                     }
@@ -1830,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);
@@ -1857,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,
@@ -2116,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 ?? []),
         ];
@@ -2126,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;
@@ -2149,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
             })),
         ];
@@ -2366,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
@@ -2759,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,
@@ -2766,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
@@ -2776,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,
             });
         }
@@ -2807,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
@@ -2820,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");
 
@@ -2871,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);
 
@@ -2897,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),
@@ -2945,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,
@@ -2955,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,
@@ -3100,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
@@ -3266,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,
 
@@ -3339,6 +3355,16 @@ export class Renderer {
                 view: view_ctx,
                 settings: this.probe_clipmap,
                 resolution: resolution_internal.asArray(),
+                indirect: this.#probe_clipmap_indirect_inputs({
+                    view_ctx,
+                    depth: gr_texture_depth_current,
+                    normal: gr_texture_normal,
+                    bent_normal: bent_normals,
+                    albedo_ao: gr_texture_material_albedo_ao,
+                    pbr: gr_texture_pbr,
+                    environment: gr_texture_environment,
+                    camera: gr_buffer_camera_current,
+                }),
             });
         }
 

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"}