@woosh/meep-engine 3.61.3 → 3.62.0

package/src/engine/graphics3/shader_picking_gather.js

@@ -1,120 +1,133 @@
-import {
-    VIZ_BUFFER_INVALID_MESH_VALUE
-} from "../../shade/renderer/rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
-import { CodeChunk } from "../../shade/renderer/shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shade/renderer/shader/ComputeShader.js";
-import {
-    ShaderResourceSetDescriptor
-} from "../../shade/renderer/shader/resource/ShaderResourceSetDescriptor.js";
-import { u32 } from "../../shade/renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shade/renderer/shader/type/WebGPUArray.js";
-
-/**
- * Words a query occupies, on the way in and on the way back: a pixel's x and y going in, the mesh
- * row and the depth's bit pattern coming out.
- *
- * @type {number}
- */
-export const PICKING_GATHER_STRIDE_WORDS = 2;
-
-/**
- * The `x` of a query whose point is not on the view at all.
- *
- * A pick names a fraction of the view and a caller is free to ask outside it, so a query carries
- * either a pixel or this. No pixel can collide with it: `maxTextureDimension2D` is nowhere near
- * 2^32 - 1 in any WebGPU profile, so there is no view this is a column of.
- *
- * @type {number}
- */
-export const PICKING_QUERY_OFF_VIEW = 0xFFFFFFFF;
-
-/**
- * @type {number}
- */
-export const PICKING_GATHER_WORKGROUP_SIZE = 64;
-
-const resources = new ShaderResourceSetDescriptor();
-
-// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer
-resources.setImmediate("query_count", u32);
-
-resources.createGroup()
-    // The frame's visibility buffer — the `meshes` row the rasterizer wrote at each pixel — and the
-    // depth it wrote with it. Both are read as *bindings*, which is the whole reason this pass is a
-    // dispatch: see the note on {@link shader_picking_gather}.
-    .addTexture("viz_mesh", "uint")
-    .addTexture("viz_depth", "depth");
-
-resources.createGroup()
-    // x, y per query; `PICKING_QUERY_OFF_VIEW` in x for a query that is off the view
-    .addStorageBuffer("queries", WebGPUArray.u32)
-    // mesh row, then the depth's bits, per query
-    .addStorageBuffer("results", WebGPUArray.u32, true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const PICKING_STRIDE : u32 = ${PICKING_GATHER_STRIDE_WORDS}u;
-const PICKING_OFF_VIEW : u32 = ${PICKING_QUERY_OFF_VIEW}u;
-const PICKING_VIZ_INVALID : u32 = ${VIZ_BUFFER_INVALID_MESH_VALUE}u;
-
-@compute @workgroup_size(${PICKING_GATHER_WORKGROUP_SIZE},1,1)
-fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
-    let index = gid.x;
-
-    /*
-     The dispatch is sized to ceil(query_count / 64) workgroups, so the tail carries up to 63 idle
-     threads. Guarded on the immediate rather than on arrayLength: both buffers come from the
-     transient pool, which matches approximately, so their lengths are pool state rather than the
-     number of queries — a thread past the end would read a previous tenant's pixel and write a row
-     nobody asked for.
-    */
-    if index >= query_count {
-        return;
-    }
-
-    let base = index * PICKING_STRIDE;
-
-    let x = queries[base];
-    let y = queries[base + 1u];
-
-    /*
-     Every slot is written, the off-view ones included. A pooled buffer arrives carrying whatever its
-     last tenant left, and a query off the view has to read back as nothing rather than as that — so
-     the pass defines the whole of its output instead of a clear being encoded ahead of it.
-    */
-    if x == PICKING_OFF_VIEW {
-        results[base] = PICKING_VIZ_INVALID;
-        results[base + 1u] = 0u;
-
-        return;
-    }
-
-    let at = vec2<i32>(i32(x), i32(y));
-
-    results[base] = textureLoad(viz_mesh, at, 0).r;
-    results[base + 1u] = bitcast<u32>(textureLoad(viz_depth, at, 0));
-}
-`);
-
-/**
- * Reads the visibility buffer's mesh row and the frame's depth at a handful of pixels, into a
- * buffer small enough to read back on a click.
- *
- * **A dispatch rather than a copy, twice over.** The obvious shape for this is
- * `copyTextureToBuffer` of a 1x1 region per query, and it is not legal WebGPU for either texture.
- * The visibility buffer is a render attachment the renderer never gave `COPY_SRC` — and should not
- * have to, since the flag is for the whole frame and a pick happens on a click — while a depth
- * format may not be sub-region copied **at all**: "if the format is a depth-or-stencil format [...]
- * the subresource size is equal to size", so the only legal copy of a 1065x1668 depth buffer is all
- * 7 MB of it. Both textures are already `TEXTURE_BINDING`, because the frame shades from them, and
- * `textureLoad` has neither restriction.
- *
- * One thread per query. Nothing is sampled, filtered or interpolated: the answer has to be the row
- * the rasterizer wrote at that exact pixel, which is what makes a pick as precise as the frame.
- */
-export const shader_picking_gather = ComputeShader.from({
-    label: "Picking/Gather",
-    resources,
-    body,
-});
+import {
+    VIZ_BUFFER_INVALID_MESH_VALUE
+} from "../../shade/renderer/rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
+import {
+    chunk_visibility_decode,
+    VISIBLE_MESHLETS_RESOURCE
+} from "../../shade/renderer/rasterize/visibility/chunk_visibility_decode.js";
+import { CodeChunk } from "../../shade/renderer/shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shade/renderer/shader/ComputeShader.js";
+import {
+    ShaderResourceSetDescriptor
+} from "../../shade/renderer/shader/resource/ShaderResourceSetDescriptor.js";
+import { u32 } from "../../shade/renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shade/renderer/shader/type/WebGPUArray.js";
+
+/**
+ * Words a query occupies, on the way in and on the way back: a pixel's x and y going in, the mesh
+ * row and the depth's bit pattern coming out.
+ *
+ * @type {number}
+ */
+export const PICKING_GATHER_STRIDE_WORDS = 2;
+
+/**
+ * The `x` of a query whose point is not on the view at all.
+ *
+ * A pick names a fraction of the view and a caller is free to ask outside it, so a query carries
+ * either a pixel or this. No pixel can collide with it: `maxTextureDimension2D` is nowhere near
+ * 2^32 - 1 in any WebGPU profile, so there is no view this is a column of.
+ *
+ * @type {number}
+ */
+export const PICKING_QUERY_OFF_VIEW = 0xFFFFFFFF;
+
+/**
+ * @type {number}
+ */
+export const PICKING_GATHER_WORKGROUP_SIZE = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("query_count", u32);
+
+resources.createGroup()
+    // The frame's visibility buffer, with the table that resolves each pixel to the `meshes` row it was
+    // drawn for, and the depth written with it. Read as *bindings*, which is the whole reason this pass
+    // is a dispatch: see the note on {@link shader_picking_gather}.
+    .addTexture("visibility", "uint")
+    .add(VISIBLE_MESHLETS_RESOURCE)
+    .addTexture("viz_depth", "depth");
+
+resources.createGroup()
+    // x, y per query; `PICKING_QUERY_OFF_VIEW` in x for a query that is off the view
+    .addStorageBuffer("queries", WebGPUArray.u32)
+    // mesh row, then the depth's bits, per query
+    .addStorageBuffer("results", WebGPUArray.u32, true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const PICKING_STRIDE : u32 = ${PICKING_GATHER_STRIDE_WORDS}u;
+const PICKING_OFF_VIEW : u32 = ${PICKING_QUERY_OFF_VIEW}u;
+const PICKING_VIZ_INVALID : u32 = ${VIZ_BUFFER_INVALID_MESH_VALUE}u;
+
+@compute @workgroup_size(${PICKING_GATHER_WORKGROUP_SIZE},1,1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    let index = gid.x;
+
+    /*
+     The dispatch is sized to ceil(query_count / 64) workgroups, so the tail carries up to 63 idle
+     threads. Guarded on the immediate rather than on arrayLength: both buffers come from the
+     transient pool, which matches approximately, so their lengths are pool state rather than the
+     number of queries — a thread past the end would read a previous tenant's pixel and write a row
+     nobody asked for.
+    */
+    if index >= query_count {
+        return;
+    }
+
+    let base = index * PICKING_STRIDE;
+
+    let x = queries[base];
+    let y = queries[base + 1u];
+
+    /*
+     Every slot is written, the off-view ones included. A pooled buffer arrives carrying whatever its
+     last tenant left, and a query off the view has to read back as nothing rather than as that — so
+     the pass defines the whole of its output instead of a clear being encoded ahead of it.
+    */
+    if x == PICKING_OFF_VIEW {
+        results[base] = PICKING_VIZ_INVALID;
+        results[base + 1u] = 0u;
+
+        return;
+    }
+
+    let at = vec2<i32>(i32(x), i32(y));
+
+    let word = textureLoad(visibility, at, 0).r;
+
+    var row = PICKING_VIZ_INVALID;
+
+    if word != VISIBILITY_NONE {
+        row = visibility_decode(word).mesh;
+    }
+
+    results[base] = row;
+    results[base + 1u] = bitcast<u32>(textureLoad(viz_depth, at, 0));
+}
+`, [chunk_visibility_decode]);
+
+/**
+ * Reads the visibility buffer's mesh row and the frame's depth at a handful of pixels, into a
+ * buffer small enough to read back on a click.
+ *
+ * **A dispatch rather than a copy, twice over.** The obvious shape for this is
+ * `copyTextureToBuffer` of a 1x1 region per query, and it is not legal WebGPU for either texture.
+ * The visibility buffer is a render attachment the renderer never gave `COPY_SRC` — and should not
+ * have to, since the flag is for the whole frame and a pick happens on a click — while a depth
+ * format may not be sub-region copied **at all**: "if the format is a depth-or-stencil format [...]
+ * the subresource size is equal to size", so the only legal copy of a 1065x1668 depth buffer is all
+ * 7 MB of it. Both textures are already `TEXTURE_BINDING`, because the frame shades from them, and
+ * `textureLoad` has neither restriction.
+ *
+ * One thread per query. Nothing is sampled, filtered or interpolated: the answer has to be the row
+ * the rasterizer wrote at that exact pixel, which is what makes a pick as precise as the frame.
+ */
+export const shader_picking_gather = ComputeShader.from({
+    label: "Picking/Gather",
+    resources,
+    body,
+});

package/src/shade/device/mock/SoftwareGPUTexture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUTexture.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUTexture.js"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AACH,yEAFgB,UAAU;IAkEtB;;;;;;OAMG;IACH,6EAFa,kBAAkB,CAI9B;IAnCD;;;;OAIG;IACH,iFAFW,OAAO,EAqBjB;IAzDD;;;;;;OAMG;IACH,uBAEC;IAuCG,WAAuC;IACvC,YAAyC;IACzC,wBAAiE;IAEjE,YAA+B;IAC/B,eAA6C;IAC7C,WAA6B;IAC7B,iBAA8C;IAC9C,mBAAkD;IActD;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,wCAEC;IAED;;;;;;;;;OASG;IACH,8BAUC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,WAAW,CAgBvB;IAED;;;;;;;;;;;;;OAaG;IACH,kEAUC;IAwCD;;;OAGG;IACH,gBAOC;IAGL;;;OAGG;IACH,+BAFU,OAAO,CAEgC;;CANhD;sCAlRqC,4BAA4B"}
+{"version":3,"file":"SoftwareGPUTexture.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUTexture.js"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AACH,yEAFgB,UAAU;IAkEtB;;;;;;OAMG;IACH,6EAFa,kBAAkB,CAI9B;IAnCD;;;;OAIG;IACH,iFAFW,OAAO,EAqBjB;IAzDD;;;;;;OAMG;IACH,uBAEC;IAuCG,WAAuC;IACvC,YAAyC;IACzC,wBAAiE;IAEjE,YAA+B;IAC/B,eAA6C;IAC7C,WAA6B;IAC7B,iBAA8C;IAC9C,mBAAkD;IActD;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,wCAEC;IAED;;;;;;;;;OASG;IACH,8BAUC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,WAAW,CAgBvB;IAED;;;;;;;;;;;;;OAaG;IACH,kEAUC;IAmDD;;;OAGG;IACH,gBAOC;IAGL;;;OAGG;IACH,+BAFU,OAAO,CAEgC;;CANhD;sCA7RqC,4BAA4B"}

package/src/shade/device/mock/SoftwareGPUTexture.js

@@ -266,6 +266,17 @@ export class SoftwareGPUTexture extends SoftwareGPUObjectBase {
                 + ` nor one of its viewFormats (${this.#view_formats.join(', ') || 'none'})`;
         }
 
+        /*
+         The levels a view covers must be levels the texture has: at least one, all of them below its
+         mipLevelCount. An unset count is every level from the base on.
+        */
+        const base_mip_level = descriptor?.baseMipLevel ?? 0;
+        const mip_level_count = descriptor?.mipLevelCount ?? (this.mipLevelCount - base_mip_level);
+
+        if (mip_level_count < 1 || base_mip_level + mip_level_count > this.mipLevelCount) {
+            return `levels ${base_mip_level} to ${base_mip_level + mip_level_count - 1} of '${this.label}', which has ${this.mipLevelCount}`;
+        }
+
         return null;
     }
 

package/src/shade/device/pipeline/rp_validate_and_rewrite_for_color_attachments.js

@@ -48,7 +48,7 @@ for (const tuple of compatible_tuples) {
  */
 function is_compatible(a, b) {
     // Identical formats are always compatible — including formats with no tuple entry (e.g. the
-    // gbuffer's rgba16uint / r32uint), which the rewrite loop still checks when some OTHER target
+    // gbuffer's r32uint targets), which the rewrite loop still checks when some OTHER target
     // triggered a rewrite. Guard the lookup so an unlisted source is treated as incompatible and
     // reaches the descriptive error below, rather than throwing a raw TypeError.
     if (a === b) {

package/src/shade/playground/contact_shadows/ContactShadowLab.js

@@ -344,7 +344,7 @@ export class ContactShadowLab {
                         step_count: this.march_steps,
                     },
                     gBufferDepth: depth,
-                    gBufferNormal: gbuffer.normal,
+                    gBufferPBR: gbuffer.pbr,
                     camera: view.camera.buffer,
                     tContactShadow: TextureResourceDescriptor.from({
                         resolution: [width, height],
@@ -363,7 +363,7 @@ export class ContactShadowLab {
             contact = graph_contact_shadow_linear({
                 graph,
                 depth,
-                normal: gbuffer.normal,
+                pbr: gbuffer.pbr,
                 camera: view.camera.buffer,
                 resolution,
                 settings,
@@ -372,7 +372,7 @@ export class ContactShadowLab {
 
         const traced = this.reference || this.measuring;
 
-        const reference = traced ? this.#record_reference(graph, view, depth, gbuffer.normal, width, height) : -1;
+        const reference = traced ? this.#record_reference(graph, view, depth, gbuffer.pbr, width, height) : -1;
 
         let flags = 0;
 
@@ -427,7 +427,7 @@ export class ContactShadowLab {
      * One ray per pixel from its G-buffer position toward the sun, through the scene's BVH
      * ({@link shader_contact_lab_reference}): visibility, 1 lit and 0 shadowed.
      */
-    #record_reference(graph, view, depth, normal, width, height) {
+    #record_reference(graph, view, depth, pbr, width, height) {
         const data = {};
         const pass = graph.add('Contact lab / ray-traced reference', data, (data, resources, context) => {
             const scene_ctx = view.scene;
@@ -444,7 +444,7 @@ export class ContactShadowLab {
                 bindings: {
                     settings: { normal_offset: this.reference_normal_offset },
                     gBufferDepth: resources.get(data.depth).obtainView(MIP_0),
-                    gBufferNormal: resources.get(data.normal).obtainView(MIP_0),
+                    gBufferPBR: resources.get(data.pbr).obtainView(MIP_0),
                     camera: view.camera.buffer,
                     view: view.uniform_buffer,
                     tlas: scene_ctx.tlas.buffer,
@@ -463,7 +463,7 @@ export class ContactShadowLab {
         });
 
         data.depth = pass.read(depth);
-        data.normal = pass.read(normal);
+        data.pbr = pass.read(pbr);
         data.output = pass.create('contact lab / reference', TextureResourceDescriptor.from({
             resolution: [width, height],
             format: 'r32float',

package/src/shade/playground/contact_shadows/shader_contact_lab_composite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_contact_lab_composite.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/contact_shadows/shader_contact_lab_composite.js"],"names":[],"mappings":";;;6BA4BU,MAAM;;;;;;;;;oCAgBN,MAAM;;;;;AAwKhB;;;;;;;;;;;;;;;GAeG;AACH,2CAFU,WAAW,CAkBlB;4BArOyB,sCAAsC"}
+{"version":3,"file":"shader_contact_lab_composite.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/contact_shadows/shader_contact_lab_composite.js"],"names":[],"mappings":";;;6BA+BU,MAAM;;;;;;;;;oCAgBN,MAAM;;;;;AAuKhB;;;;;;;;;;;;;;;GAeG;AACH,2CAFU,WAAW,CAkBlB;4BApOyB,sCAAsC"}

package/src/shade/playground/contact_shadows/shader_contact_lab_composite.js

@@ -4,6 +4,9 @@ import { chunk_project_position_from_depth } from "../../renderer/shader/chunk/c
 import { chunk_is_background } from "../../renderer/shader/chunk/depth/chunk_is_background.js";
 import { chunk_mat4_extract_position } from "../../renderer/shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
 import { chunk_decode_g_buffer_normal } from "../../renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import {
+    chunk_decode_g_buffer_face_normal
+} from "../../renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_face_normal.js";
 import { chunk_directional_lights_iteration_mask } from "../../renderer/shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
 import { chunk_get_directional_light_info_by_index } from "../../renderer/shader/chunk/light/io/chunk_get_directional_light_info_by_index.js";
 import { REFLECTED_LIGHT_STRUCT } from "../../renderer/shader/chunk/light/REFLECTED_LIGHT_STRUCT.js";
@@ -123,11 +126,9 @@ fn main(
     let position_ws = project_position_from_depth(uv, texel_depth, camera.view_projection_matrix_inverse);
     let view_direction = normalize(mat4_extract_position(camera.transform) - position_ws);
 
-    let g_buffer_sample_normal = textureLoad(gBufferNormal, i_coord, 0);
-
     let geometry = ${GEOMETRIC_SHADING_INFO_STRUCT.wgsl_ref}(
-        decode_g_buffer_normal(g_buffer_sample_normal.xy),
-        decode_g_buffer_normal(g_buffer_sample_normal.zw),
+        decode_g_buffer_normal(textureLoad(gBufferNormal, i_coord, 0).x),
+        decode_g_buffer_face_normal(textureLoad(gBufferPBR, i_coord, 0)),
         position_ws,
         view_direction,
     );
@@ -201,6 +202,7 @@ fn main(
         chunk_project_position_from_depth,
         chunk_mat4_extract_position,
         chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_read_gBuffer_material,
         chunk_directional_lights_iteration_mask,
         chunk_get_directional_light_info_by_index,

package/src/shade/playground/contact_shadows/shader_contact_lab_reference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_contact_lab_reference.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/contact_shadows/shader_contact_lab_reference.js"],"names":[],"mappings":"AAuGA;;;;;;;;;;;GAWG;AACH,2CAFU,aAAa,CAMpB;8BAxG2B,wCAAwC"}
+{"version":3,"file":"shader_contact_lab_reference.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/contact_shadows/shader_contact_lab_reference.js"],"names":[],"mappings":"AAyGA;;;;;;;;;;;GAWG;AACH,2CAFU,aAAa,CAMpB;8BAxG2B,wCAAwC"}

package/src/shade/playground/contact_shadows/shader_contact_lab_reference.js

@@ -4,7 +4,9 @@ import { INDIRECT_MATERIAL_ARRAY_TYPE } from "../../renderer/material/resident/I
 import { chunk_ray_shaded_query_occluded } from "../../renderer/path_tracer/shader/chunk_ray_shaded_query_occluded.js";
 import { chunk_project_position_from_depth } from "../../renderer/shader/chunk/camera/chunk_project_position_from_depth.js";
 import { chunk_is_background } from "../../renderer/shader/chunk/depth/chunk_is_background.js";
-import { chunk_decode_g_buffer_normal } from "../../renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import {
+    chunk_decode_g_buffer_face_normal
+} from "../../renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_face_normal.js";
 import { chunk_offset_ray } from "../../renderer/shader/chunk/geometry/ray/chunk_offset_ray.js";
 import { RAY_STRUCT } from "../../renderer/shader/chunk/geometry/ray/RAY_STRUCT.js";
 import { chunk_directional_lights_iteration_mask } from "../../renderer/shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
@@ -38,7 +40,7 @@ resources.createGroup()
 
 resources.createGroup()
     .addTexture("gBufferDepth")
-    .addTexture("gBufferNormal", "uint")
+    .addTexture("gBufferPBR")
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
     .addUniform("view", VIEW_UNIFORM_STRUCT)
     .addStorageTexture("tReference", "r32float", "2d", "write-only");
@@ -66,7 +68,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     if (!is_background(depth) && directional_bits != 0u) {
         let uv = texel_coordinate_to_uv(vec2<f32>(id.xy), size);
         let position_ws = project_position_from_depth(uv, depth, camera.view_projection_matrix_inverse);
-        let geometric_normal = decode_g_buffer_normal(textureLoad(gBufferNormal, id.xy, 0).zw);
+        let geometric_normal = decode_g_buffer_face_normal(textureLoad(gBufferPBR, id.xy, 0));
 
         let sun = get_directional_light_info_by_index(&light_data, countTrailingZeros(directional_bits));
 
@@ -93,7 +95,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
         chunk_is_background,
         chunk_texel_coordinate_to_uv,
         chunk_project_position_from_depth,
-        chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_offset_ray,
         chunk_directional_lights_iteration_mask,
         chunk_get_directional_light_info_by_index,

package/src/shade/playground/contact_shadows/shader_contact_shadow_march.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_contact_shadow_march.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/contact_shadows/shader_contact_shadow_march.js"],"names":[],"mappings":"AA6EA;;;;;;;GAOG;AACH,0CAFU,aAAa,CAMpB;8BAjF2B,wCAAwC"}
+{"version":3,"file":"shader_contact_shadow_march.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/contact_shadows/shader_contact_shadow_march.js"],"names":[],"mappings":"AA+EA;;;;;;;GAOG;AACH,0CAFU,aAAa,CAMpB;8BAjF2B,wCAAwC"}

package/src/shade/playground/contact_shadows/shader_contact_shadow_march.js

@@ -3,7 +3,9 @@ import { chunk_ss_trace_pixel_occlusion } from "../../renderer/deferred/chunk_ss
 import { chunk_project_position_from_depth } from "../../renderer/shader/chunk/camera/chunk_project_position_from_depth.js";
 import { chunk_get_view_space_depth } from "../../renderer/shader/chunk/depth/chunk_get_view_space_depth.js";
 import { chunk_is_background } from "../../renderer/shader/chunk/depth/chunk_is_background.js";
-import { chunk_decode_g_buffer_normal } from "../../renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import {
+    chunk_decode_g_buffer_face_normal
+} from "../../renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_face_normal.js";
 import { chunk_texel_coordinate_to_uv } from "../../renderer/shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
 import { CodeChunk } from "../../renderer/shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../renderer/shader/ComputeShader.js";
@@ -23,7 +25,7 @@ resources.setImmediate("settings", SETTINGS);
 
 resources.createGroup()
     .addTexture("gBufferDepth")
-    .addTexture("gBufferNormal", "uint")
+    .addTexture("gBufferPBR")
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
     .addStorageTexture("tContactShadow", "r32float", "2d", "write-only");
 
@@ -47,7 +49,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
 
     let uv = texel_coordinate_to_uv(vec2<f32>(id.xy), size);
     let position_ws = project_position_from_depth(uv, depth, camera.view_projection_matrix_inverse);
-    let geometric_normal = decode_g_buffer_normal(textureLoad(gBufferNormal, id.xy, 0).zw);
+    let geometric_normal = decode_g_buffer_face_normal(textureLoad(gBufferPBR, id.xy, 0));
 
     // the same window as the wavefront pass: an occluder may sit up to 2 × thickness × its distance in front
     let thickness = 2.0 * settings.surface_thickness * get_view_space_depth(depth, camera);
@@ -70,7 +72,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
         chunk_texel_coordinate_to_uv,
         chunk_project_position_from_depth,
         chunk_get_view_space_depth,
-        chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_ss_trace_pixel_occlusion,
     ]
 );

package/src/shade/playground/ssr_reprojection/SpatialFilterProbe.js

@@ -16,7 +16,7 @@ const shader = new ImageShader({
         body:CodeChunk.from(/* language=WGSL */ `
 @fragment fn main(@builtin(position) coord:vec4f) -> @location(0) vec4f {
     let p = vec2i(coord.xy);
-    if (decode_g_buffer_normal(textureLoad(tNormal,p,0).xy).y < 0.99) { return vec4f(-1.0); }
+    if (decode_g_buffer_normal(textureLoad(tNormal,p,0).x).y < 0.99) { return vec4f(-1.0); }
     let a = textureLoad(tBefore,p,0);
     let b = textureLoad(tAfter,p,0);
     let difference = abs(a.rgb-b.rgb);

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