@woosh/meep-engine 3.61.2 → 3.62.0

package/src/shade/renderer/geometry/sdf/bundle/model_cache_bundle_read.js

@@ -0,0 +1,140 @@
+import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
+import { MESH_SDF_BRICK_TEXEL_COUNT, MESH_SDF_EMPTY, MESH_SDF_EMPTY_INSIDE } from "../MESH_SDF.js";
+import { MESH_SURFACE_PLANE_BLOCK_WORDS, MESH_SURFACE_PRESENCE_BLOCK_WORDS } from "../surface/MESH_SURFACE_BLOCK.js";
+import { ModelCacheBundle, ModelCacheBundleCache, ModelCacheBundleField } from "./ModelCacheBundle.js";
+import { MODEL_CACHE_BUNDLE_FORMAT_VERSION, MODEL_CACHE_BUNDLE_MAGIC } from "./MODEL_CACHE_BUNDLE.js";
+
+/**
+ * @param {BinaryBuffer} buffer
+ * @param {string} what
+ * @returns {Uint32Array}
+ */
+function read_words(buffer, what) {
+    const length = buffer.readUint32();
+
+    if (4 * length > buffer.data.byteLength - buffer.position) {
+        throw new Error(`model cache bundle: ${what} runs past the end`);
+    }
+
+    const words = new Uint32Array(length);
+
+    buffer.readUint32Array(words, 0, length);
+
+    return words;
+}
+
+/**
+ * A bundle from bytes (`MODEL_CACHE_BUNDLE.js`). Throws on a file of another kind, one that needs a
+ * newer reader, or one whose references or lengths do not hold together.
+ *
+ * @param {Uint8Array} bytes
+ * @returns {ModelCacheBundle}
+ */
+export function model_cache_bundle_read(bytes) {
+    const buffer = new BinaryBuffer();
+
+    buffer.fromArrayBuffer(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+
+    if (buffer.readUint32() !== MODEL_CACHE_BUNDLE_MAGIC) {
+        throw new Error("model cache bundle: not a bundle");
+    }
+
+    buffer.readUint16();
+
+    const needs = buffer.readUint16();
+
+    if (needs > MODEL_CACHE_BUNDLE_FORMAT_VERSION) {
+        throw new Error(`model cache bundle: needs a reader of version ${needs}, this one is ${MODEL_CACHE_BUNDLE_FORMAT_VERSION}`);
+    }
+
+    const bundle = new ModelCacheBundle();
+
+    bundle.voxel_size = buffer.readFloat32();
+    bundle.max_bricks = buffer.readUint32();
+
+    const brick_count = buffer.readUint32();
+    const field_count = buffer.readUint32();
+    const cache_count = buffer.readUint32();
+
+    bundle.bricks = new Uint8Array(brick_count * MESH_SDF_BRICK_TEXEL_COUNT);
+    buffer.readBytes(bundle.bricks, 0, bundle.bricks.length);
+
+    for (let f = 0; f < field_count; f++) {
+        const field = new ModelCacheBundleField();
+
+        for (let i = 0; i < 3; i++) {
+            field.origin[i] = buffer.readFloat32();
+        }
+
+        field.voxel = buffer.readFloat32();
+
+        for (let i = 0; i < 3; i++) {
+            field.bricks[i] = buffer.readUint32();
+        }
+
+        field.level_count = buffer.readUint32();
+        field.two_sided = buffer.readUint32();
+        field.entries = read_words(buffer, "a field's entries");
+        field.numbered = read_words(buffer, "a field's numbering");
+        field.blocks = buffer.readUint32();
+        field.table = read_words(buffer, "a field's table");
+
+        let stored = 0;
+
+        for (let i = 0; i < field.entries.length; i++) {
+            const entry = field.entries[i];
+
+            if (entry === MESH_SDF_EMPTY || entry === MESH_SDF_EMPTY_INSIDE) {
+                continue;
+            }
+
+            if (entry >= brick_count) {
+                throw new Error(`model cache bundle: field ${f} names brick ${entry} of ${brick_count}`);
+            }
+
+            stored++;
+        }
+
+        if (field.numbered.length !== stored || field.numbered.some(entry => entry >= field.entries.length)) {
+            throw new Error(`model cache bundle: field ${f}'s numbering does not name its ${stored} stored bricks`);
+        }
+
+        if (field.table.length !== 0 && field.table.length !== stored) {
+            throw new Error(`model cache bundle: field ${f}'s table holds ${field.table.length} words for ${stored} stored bricks`);
+        }
+
+        bundle.fields.push(field);
+    }
+
+    for (let c = 0; c < cache_count; c++) {
+        const cache = new ModelCacheBundleCache();
+
+        cache.field = buffer.readUint32();
+        cache.texels = buffer.readUint32();
+
+        for (let p = 0; p < 3; p++) {
+            cache.codes[p] = buffer.readUint32();
+        }
+
+        cache.presence = read_words(buffer, "a cache's presence");
+
+        for (let p = 0; p < 3; p++) {
+            cache.planes[p] = read_words(buffer, "a cache's plane");
+        }
+
+        if (cache.field >= field_count) {
+            throw new Error(`model cache bundle: cache ${c} names field ${cache.field} of ${field_count}`);
+        }
+
+        const blocks = cache.texels === 0 ? 0 : bundle.fields[cache.field].blocks;
+
+        if (cache.presence.length !== blocks * MESH_SURFACE_PRESENCE_BLOCK_WORDS
+            || cache.planes.some((words, p) => words.length !== ((cache.texels & (1 << p)) === 0 ? 0 : blocks * MESH_SURFACE_PLANE_BLOCK_WORDS[p]))) {
+            throw new Error(`model cache bundle: cache ${c}'s blocks are not its field's ${blocks}`);
+        }
+
+        bundle.caches.push(cache);
+    }
+
+    return bundle;
+}

package/src/shade/renderer/geometry/sdf/bundle/model_cache_bundle_write.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A bundle as bytes (`MODEL_CACHE_BUNDLE.js`).
+ *
+ * @param {import("./ModelCacheBundle.js").ModelCacheBundle} bundle
+ * @returns {Uint8Array}
+ */
+export function model_cache_bundle_write(bundle: import("./ModelCacheBundle.js").ModelCacheBundle): Uint8Array;
+//# sourceMappingURL=model_cache_bundle_write.d.ts.map

package/src/shade/renderer/geometry/sdf/bundle/model_cache_bundle_write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model_cache_bundle_write.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bundle/model_cache_bundle_write.js"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH,iDAHW,OAAO,uBAAuB,EAAE,gBAAgB,GAC9C,UAAU,CAuDtB"}

package/src/shade/renderer/geometry/sdf/bundle/model_cache_bundle_write.js

@@ -0,0 +1,76 @@
+import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
+import {
+    MODEL_CACHE_BUNDLE_FORMAT_VERSION,
+    MODEL_CACHE_BUNDLE_MAGIC,
+    MODEL_CACHE_BUNDLE_MIN_READER_VERSION
+} from "./MODEL_CACHE_BUNDLE.js";
+
+/**
+ * @param {BinaryBuffer} buffer
+ * @param {Uint32Array} words
+ */
+function write_words(buffer, words) {
+    buffer.writeUint32(words.length);
+    buffer.writeUint32Array(words, 0, words.length);
+}
+
+/**
+ * A bundle as bytes (`MODEL_CACHE_BUNDLE.js`).
+ *
+ * @param {import("./ModelCacheBundle.js").ModelCacheBundle} bundle
+ * @returns {Uint8Array}
+ */
+export function model_cache_bundle_write(bundle) {
+    const buffer = new BinaryBuffer();
+
+    buffer.writeUint32(MODEL_CACHE_BUNDLE_MAGIC);
+    buffer.writeUint16(MODEL_CACHE_BUNDLE_FORMAT_VERSION);
+    buffer.writeUint16(MODEL_CACHE_BUNDLE_MIN_READER_VERSION);
+    buffer.writeFloat32(bundle.voxel_size);
+    buffer.writeUint32(bundle.max_bricks);
+    buffer.writeUint32(bundle.brick_count);
+    buffer.writeUint32(bundle.fields.length);
+    buffer.writeUint32(bundle.caches.length);
+
+    buffer.writeBytes(bundle.bricks, 0, bundle.bricks.length);
+
+    for (const field of bundle.fields) {
+        for (let i = 0; i < 3; i++) {
+            buffer.writeFloat32(field.origin[i]);
+        }
+
+        buffer.writeFloat32(field.voxel);
+
+        for (let i = 0; i < 3; i++) {
+            buffer.writeUint32(field.bricks[i]);
+        }
+
+        buffer.writeUint32(field.level_count);
+        buffer.writeUint32(field.two_sided);
+
+        write_words(buffer, field.entries);
+        write_words(buffer, field.numbered);
+
+        buffer.writeUint32(field.blocks);
+        write_words(buffer, field.table);
+    }
+
+    for (const cache of bundle.caches) {
+        buffer.writeUint32(cache.field);
+        buffer.writeUint32(cache.texels);
+
+        for (let p = 0; p < 3; p++) {
+            buffer.writeUint32(cache.codes[p]);
+        }
+
+        write_words(buffer, cache.presence);
+
+        for (let p = 0; p < 3; p++) {
+            write_words(buffer, cache.planes[p]);
+        }
+    }
+
+    buffer.trim();
+
+    return new Uint8Array(buffer.data);
+}

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

@@ -7,6 +7,9 @@
  * fn mesh_sdf_level_bricks(header: MeshSDF, level: u32) -> vec3<u32>
  * fn mesh_sdf_level_offset(header: MeshSDF, level: u32) -> u32   // the level's first entry
  * fn mesh_sdf_level_voxel(header: MeshSDF, level: u32) -> f32
+ * fn mesh_sdf_brick_count(header: MeshSDF) -> u32                // every level's bricks
+ * fn mesh_sdf_numbers(header: MeshSDF) -> u32                    // the first brick's number
+ * fn mesh_sdf_numbered(header: MeshSDF) -> u32                   // the brick numbered 0
  * fn mesh_sdf_brick_of(header: MeshSDF, brick: u32) -> vec4<u32> // level, then x, y, z
  * fn mesh_sdf_brick_corner(header: MeshSDF, brick: vec4<u32>) -> vec3<f32> // texel 0's point
  * fn mesh_sdf_encode(distance: f32, voxel: f32) -> f32           // saturate(d / 2R + 0.5)
@@ -14,6 +17,12 @@
  * fn mesh_sdf_entry_holds_slot(entry: u32) -> bool               // not EMPTY, on either side
  * ```
  *
+ * A geometry's range in the indirection, n being its brick count: its stored count at `indirection - 2`,
+ * its pending word at `indirection - 1` (`MESH_SDF_BAKE.js`), its n entries from `indirection` in the
+ * layout's order, then each brick's number among the bricks given a slot ({@link MESH_SDF_UNNUMBERED}
+ * for one with none) from `mesh_sdf_numbers`, then the bricks by number from `mesh_sdf_numbered`, as
+ * many as the stored count says.
+ *
  * @type {CodeChunk}
  */
 export const chunk_mesh_sdf: CodeChunk;

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_mesh_sdf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/chunk_mesh_sdf.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;GAiBG;AACH,6BAFU,SAAS,CAoFZ;0BA/GmB,oCAAoC"}
+{"version":3,"file":"chunk_mesh_sdf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/chunk_mesh_sdf.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,6BAFU,SAAS,CAiGZ;0BAtImB,oCAAoC"}

package/src/shade/renderer/geometry/sdf/chunk_mesh_sdf.js

@@ -5,6 +5,7 @@ import {
     MESH_SDF_BRICK_VOXELS,
     MESH_SDF_EMPTY,
     MESH_SDF_EMPTY_INSIDE,
+    MESH_SDF_UNNUMBERED,
     MeshSDFState
 } from "./MESH_SDF.js";
 import { MESH_SDF_STRUCT } from "./MESH_SDF_STRUCT.js";
@@ -18,6 +19,9 @@ import { MESH_SDF_STRUCT } from "./MESH_SDF_STRUCT.js";
  * fn mesh_sdf_level_bricks(header: MeshSDF, level: u32) -> vec3<u32>
  * fn mesh_sdf_level_offset(header: MeshSDF, level: u32) -> u32   // the level's first entry
  * fn mesh_sdf_level_voxel(header: MeshSDF, level: u32) -> f32
+ * fn mesh_sdf_brick_count(header: MeshSDF) -> u32                // every level's bricks
+ * fn mesh_sdf_numbers(header: MeshSDF) -> u32                    // the first brick's number
+ * fn mesh_sdf_numbered(header: MeshSDF) -> u32                   // the brick numbered 0
  * fn mesh_sdf_brick_of(header: MeshSDF, brick: u32) -> vec4<u32> // level, then x, y, z
  * fn mesh_sdf_brick_corner(header: MeshSDF, brick: vec4<u32>) -> vec3<f32> // texel 0's point
  * fn mesh_sdf_encode(distance: f32, voxel: f32) -> f32           // saturate(d / 2R + 0.5)
@@ -25,6 +29,12 @@ import { MESH_SDF_STRUCT } from "./MESH_SDF_STRUCT.js";
  * fn mesh_sdf_entry_holds_slot(entry: u32) -> bool               // not EMPTY, on either side
  * ```
  *
+ * A geometry's range in the indirection, n being its brick count: its stored count at `indirection - 2`,
+ * its pending word at `indirection - 1` (`MESH_SDF_BAKE.js`), its n entries from `indirection` in the
+ * layout's order, then each brick's number among the bricks given a slot ({@link MESH_SDF_UNNUMBERED}
+ * for one with none) from `mesh_sdf_numbers`, then the bricks by number from `mesh_sdf_numbered`, as
+ * many as the stored count says.
+ *
  * @type {CodeChunk}
  */
 export const chunk_mesh_sdf = CodeChunk.from(
@@ -35,6 +45,7 @@ const MESH_SDF_BRICK_TEXELS = ${MESH_SDF_BRICK_TEXELS}u;
 const MESH_SDF_BAND_VOXELS = ${MESH_SDF_BAND_VOXELS}.0;
 const MESH_SDF_EMPTY = ${MESH_SDF_EMPTY}u;
 const MESH_SDF_EMPTY_INSIDE = ${MESH_SDF_EMPTY_INSIDE}u;
+const MESH_SDF_UNNUMBERED = ${MESH_SDF_UNNUMBERED}u;
 const MESH_SDF_STATE_NONE = ${MeshSDFState.None}u;
 const MESH_SDF_STATE_BAKING = ${MeshSDFState.Baking}u;
 const MESH_SDF_STATE_RESIDENT = ${MeshSDFState.Resident}u;
@@ -63,6 +74,18 @@ fn mesh_sdf_level_voxel(header: ${MESH_SDF_STRUCT.wgsl_ref}, level: u32) -> f32
     return header.voxel * f32(1u << level);
 }
 
+fn mesh_sdf_brick_count(header: ${MESH_SDF_STRUCT.wgsl_ref}) -> u32 {
+    return mesh_sdf_level_offset(header, header.level_count) - header.indirection;
+}
+
+fn mesh_sdf_numbers(header: ${MESH_SDF_STRUCT.wgsl_ref}) -> u32 {
+    return header.indirection + mesh_sdf_brick_count(header);
+}
+
+fn mesh_sdf_numbered(header: ${MESH_SDF_STRUCT.wgsl_ref}) -> u32 {
+    return header.indirection + 2u * mesh_sdf_brick_count(header);
+}
+
 fn mesh_sdf_brick_of(header: ${MESH_SDF_STRUCT.wgsl_ref}, brick: u32) -> vec4<u32> {
     var rest = brick;
     var level = 0u;

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

@@ -0,0 +1,13 @@
+/**
+ * A texel's term of its brick's content key (`MESH_SDF_BRICK_KEY.js`): the key is the sum of its
+ * texels' terms. The WGSL twin of `mesh_sdf_brick_key`.
+ *
+ * ```wgsl
+ * fn mesh_sdf_brick_key_term(texel: u32, byte: u32) -> u32   // texel x + 8y + 64z
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_brick_key: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mesh_sdf_brick_key.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mesh_sdf_brick_key.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/chunk_mesh_sdf_brick_key.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,uCAFU,SAAS,CAUZ;0BArBmB,oCAAoC"}

package/src/shade/renderer/geometry/sdf/chunk_mesh_sdf_brick_key.js

@@ -0,0 +1,23 @@
+import { chunk_hash_lowbias32 } from "../../shader/chunk/random/chunk_hash_lowbias32.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { MESH_SDF_BRICK_KEY_SEED } from "./MESH_SDF_BRICK_KEY.js";
+
+/**
+ * A texel's term of its brick's content key (`MESH_SDF_BRICK_KEY.js`): the key is the sum of its
+ * texels' terms. The WGSL twin of `mesh_sdf_brick_key`.
+ *
+ * ```wgsl
+ * fn mesh_sdf_brick_key_term(texel: u32, byte: u32) -> u32   // texel x + 8y + 64z
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_brick_key = CodeChunk.from(
+    //language=WGSL
+    `
+fn mesh_sdf_brick_key_term(texel: u32, byte: u32) -> u32 {
+    return hash_lowbias32(((texel << 8u) | byte) ^ 0x${MESH_SDF_BRICK_KEY_SEED.toString(16)}u);
+}
+`, [
+        chunk_hash_lowbias32,
+    ]);

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

package/src/shade/renderer/geometry/sdf/shader_sdf_visualize.js

@@ -15,11 +15,17 @@ import { BVH2_NODE_STRUCT } from "../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
 import { BVH_STRUCT } from "../../shader/chunk/bvh/BVH_STRUCT.js";
 import { chunk_project_position_from_depth } from "../../shader/chunk/camera/chunk_project_position_from_depth.js";
 import { chunk_hash_u32_to_v4f32 } from "../../shader/chunk/color/chunk_hash_u32_to_v4f32.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 { chunk_camera_ray_from_uv } from "../../shader/chunk/geometry/ray/chunk_camera_ray_from_uv.js";
 import { RAY_STRUCT } from "../../shader/chunk/geometry/ray/RAY_STRUCT.js";
 import { chunk_sdf_query_distance } from "../../shader/chunk/sdf/chunk_sdf_query_distance.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import {
+    chunk_visibility_decode,
+    VISIBLE_MESHLETS_RESOURCE
+} from "../../rasterize/visibility/chunk_visibility_decode.js";
 import { ImageShader } from "../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
@@ -40,8 +46,9 @@ resources.createGroup()
     .add(MESH_SDF_ATLAS_RESOURCE)
     .add(MESH_SDF_SAMPLER_RESOURCE)
     .addTexture("gBufferDepth")
-    .addTexture("gBufferNormals", "uint")
-    .addTexture("vizBufferMesh", "uint")
+    .addTexture("gBufferPBR")
+    .addTexture("visibility", "uint")
+    .add(VISIBLE_MESHLETS_RESOURCE)
 
 resources.createGroup()
     .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
@@ -84,9 +91,10 @@ fn main(
         return vec4(0.33);
     }
     
-    let geometric_normal = decode_g_buffer_normal(textureLoad(gBufferNormals, coord_i, 0).zw);
+    let geometric_normal = decode_g_buffer_face_normal(textureLoad(gBufferPBR, coord_i, 0));
     
-    let mesh_id = textureLoad(vizBufferMesh, coord_i, 0).x;
+    // a surface is here: the depth is not the background's
+    let mesh_id = visibility_decode(textureLoad(visibility, coord_i, 0).x).mesh;
     
     let position_ws = project_position_from_depth(uv, depth, camera.view_projection_matrix_inverse);
 
@@ -135,7 +143,8 @@ fn main(
         RAY_STRUCT.declaration_chunk,
         chunk_camera_ray_from_uv,
         chunk_project_position_from_depth,
-        chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
+        chunk_visibility_decode,
         chunk_ray_query_sdf_raycast,
         chunk_mesh_sdf_query_distance,
         chunk_hash_u32_to_v4f32
@@ -160,8 +169,9 @@ export const shader_sdf_visualize = new ImageShader({
  * @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
  */
@@ -169,8 +179,9 @@ export function graph_draw_sdf_normals({
                                            graph,
                                            view,
                                            input_depth,
-                                           input_normals,
-                                           input_viz_mesh,
+                                           input_pbr,
+                                           input_visibility,
+                                           input_visible_meshlets,
                                        }) {
 
 
@@ -199,7 +210,7 @@ export function graph_draw_sdf_normals({
         /**
          * @type {GPUTextureContext}
          */
-        const normals = resources.get(data.normals);
+        const pbr = resources.get(data.pbr);
         /**
          * @type {GPUTextureContext}
          */
@@ -207,7 +218,7 @@ export function graph_draw_sdf_normals({
         /**
          * @type {GPUTextureContext}
          */
-        const viz_mesh = resources.get(data.viz_mesh);
+        const visibility = resources.get(data.visibility);
 
         const buffer_settings = {
             slice: pingpong(current_time_in_seconds() / 5, 1),
@@ -224,8 +235,9 @@ export function graph_draw_sdf_normals({
             bindings: sdf.write_bindings({
                 settings: buffer_settings,
                 gBufferDepth: depth.obtainView(),
-                gBufferNormals: normals.obtainView(),
-                vizBufferMesh: viz_mesh.obtainView(),
+                gBufferPBR: pbr.obtainView(),
+                visibility: visibility.obtainView(),
+                visible_meshlets: resources.get(data.visible_meshlets),
                 geometries: geometries.buffer_metadata,
                 scene_database: view.scene.scene_database_buffer,
                 tlas: view.scene.tlas.buffer,
@@ -252,8 +264,9 @@ export function graph_draw_sdf_normals({
     const pass_builder = graph.add("SDF Debug", pass_data, execute);
 
     pass_data.depth = pass_builder.read(input_depth);
-    pass_data.normals = pass_builder.read(input_normals);
-    pass_data.viz_mesh = pass_builder.read(input_viz_mesh);
+    pass_data.pbr = pass_builder.read(input_pbr);
+    pass_data.visibility = pass_builder.read(input_visibility);
+    pass_data.visible_meshlets = pass_builder.read(input_visible_meshlets);
 
     pass_data.output = pass_builder.create('sdf', TextureResourceDescriptor.from({
         format: "rgba8unorm",