@woosh/meep-engine 3.47.0 → 3.50.0

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

@@ -1,220 +1,153 @@
 import { assert } from "../../../../core/assert.js";
 import { array_compute_max } from "../../../../core/collection/array/array_compute_max.js";
-import { download_texture_data } from "../../texture/download_texture_data.js";
-import { GPUTextureContext } from "../../texture/GPUTextureContext.js";
+import { GPUTileAtlas3D } from "../../texture/atlas/GPUTileAtlas3D.js";
 import { SFD_BUILD_WORKGROUP_SIZE } from "./SFD_BUILD_WORKGROUP_SIZE.js";
 import { shader_build_sdf } from "./shader_build_sdf.js";
 
 /**
  * @typedef {import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
  * @typedef {import("../GPUGeometryManager.js").GPUGeometryManager} GPUGeometryManager
+ * @typedef {import("../bvh/GPUGeometryBVHManager.js").GPUGeometryBVHManager} GPUGeometryBVHManager
  */
 
-
-const INITIAL_CAPACITY = 16;
-
-const CAPACITY_GROW_STEP = 16;
-const CAPACITY_GROW_FRACTION = 1.2;
-
 /**
  * X*X*X voxels allocated in the atlas to represent SDF for an object
  * @type {number}
  */
 const DEFAULT_MESH_RESOLUTION = 50;
 
+/**
+ * Tiles across x and y to start with: the atlas grows a layer of 16 slots at a time along z, 16 being
+ * what the manager started with and its smallest growth step before it moved onto the atlas. Under
+ * a `maxTextureDimension3D` of 2048, z is full at 40 layers (640 slots, 320 MB of `r32float`), and
+ * the atlas then widens to 8×4 with 21 layers, moving every tile; a slot keeps its index.
+ * @type {number}
+ */
+const ATLAS_SLOTS_X = 4;
+
+/**
+ * @type {number}
+ */
+const ATLAS_SLOTS_Y = 4;
+
+/**
+ * Per-geometry signed distance fields, one {@link DEFAULT_MESH_RESOLUTION}³ `r32float` tile each, in
+ * a {@link GPUTileAtlas3D}.
+ *
+ * **A slot is its geometry's id.** The build shader reads `blas_lookup[slot]` and every reader
+ * addresses a geometry's tile by that id, so slots are claimed in order and never freed: the
+ * atlas's n-th allocation is slot n.
+ *
+ * **No border.** Every reader loads texels with `textureLoad` and clamps the far neighbour of its
+ * trilinear tap to the tile's last texel (`sdf_texture_region_sample_linear_uv`), and the texture
+ * is bound `unfilterable-float`, so no read leaves its tile. A skirt would be dead texels, and the
+ * atlas's skirt is a wrap besides — the far side of a mesh is not the continuation of its near side.
+ */
 export class GPUGeometrySDFManager {
 
     /**
-     * @type {GPUDevice}
+     * @type {GPUTileAtlas3D}
      */
-    #device;
+    #atlas;
 
     /**
-     * Individual SDF textures are written here
-     * @type {GPUTextureContext}
+     * The atlas's grid in tiles, as the shaders take it; refreshed on read.
+     * @type {number[]}
      */
-    #texture;
+    #atlas_resolution_in_tiles = [0, 0, 0];
 
     /**
      *
-     * @return {GPUTextureContext}
+     * @param {GPUDevice} device
      */
-    get texture() {
-        return this.#texture;
+    constructor(device) {
+        assert.defined(device, 'device');
+
+        this.#atlas = new GPUTileAtlas3D({
+            device,
+            format: "r32float",
+            // a cube: the build and every reader take one resolution for all three axes
+            content_size: [DEFAULT_MESH_RESOLUTION, DEFAULT_MESH_RESOLUTION, DEFAULT_MESH_RESOLUTION],
+            border: 0,
+            slots_x: ATLAS_SLOTS_X,
+            slots_y: ATLAS_SLOTS_Y,
+            capacity: ATLAS_SLOTS_X * ATLAS_SLOTS_Y,
+            // loaded by the readers, stored into by shader_build_sdf
+            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING,
+            label: "GPUGeometrySDFManager/atlas",
+        });
     }
 
     /**
-     * Resolution in SDF texels for a single geometry
-     * @type {number}
+     * Allocate slots through {@link ensureCapacity} and {@link build_slots}, never on the atlas
+     * directly: a slot handed out of order would no longer be its geometry's id.
+     * @return {GPUTileAtlas3D}
      */
-    #slot_resolution = DEFAULT_MESH_RESOLUTION;
+    get atlas() {
+        return this.#atlas;
+    }
 
     /**
-     *
-     * @return {number}
+     * Individual SDF textures are written here. Replaced when the atlas grows, so take a view after
+     * {@link build_slots}, never across it.
+     * @return {import("../../texture/GPUTextureContext.js").GPUTextureContext}
      */
-    get tile_resolution() {
-        return this.#slot_resolution;
+    get texture() {
+        return this.#atlas.texture;
     }
 
     /**
-     *
-     * @type {number[]}
+     * Resolution in SDF texels for a single geometry along each axis — the tile is a cube — which is
+     * also the stride between tiles: the atlas holds them with no border.
+     * @return {number}
      */
-    #atlas_resolution_in_tiles = [0, 0, 0];
-
-    get atlas_resolution_in_tiles() {
-        return this.#atlas_resolution_in_tiles;
+    get tile_resolution() {
+        return DEFAULT_MESH_RESOLUTION;
     }
 
     /**
-     *
-     * @return {number}
+     * Tiles along x, y and z — x and y are what `tile_atlas_slot_origin` takes to place a slot. Read it
+     * after {@link build_slots}: when the atlas widens, x or y changes and every tile moves.
+     * @return {number[]}
      */
-    computeMaxSlotsPerDimension() {
-        const max_texture_dimension3d = this.#device.limits.maxTextureDimension3D;
+    get atlas_resolution_in_tiles() {
+        const atlas = this.#atlas;
+        const out = this.#atlas_resolution_in_tiles;
 
-        return Math.floor(max_texture_dimension3d / this.#slot_resolution);
+        out[0] = atlas.slots_x;
+        out[1] = atlas.slots_y;
+        out[2] = atlas.slots_z;
+
+        return out;
     }
 
     /**
-     *
+     * Slots the texture holds now.
      * @return {number}
      */
-    computeMaxCapacity() {
-        const dimension = this.computeMaxSlotsPerDimension();
-
-
-        const slice_area = dimension * dimension;
-
-        const maxBufferSize = this.#device.limits.maxBufferSize;
-        const slot_resolution = this.#slot_resolution;
-
-        const TEXEL_SIZE = Float32Array.BYTES_PER_ELEMENT;
-        const SLOT_TEXEL_COUNT = slot_resolution * slot_resolution * slot_resolution;
-
-        const SLOT_BYTE_SIZE = slice_area * SLOT_TEXEL_COUNT * TEXEL_SIZE;
-
-        if (SLOT_BYTE_SIZE > maxBufferSize) {
-            throw new Error(`Slot size ${SLOT_BYTE_SIZE} > max buffer size ${maxBufferSize}, can't fit a single slot in GPU memory`);
-        }
-
-        const slice_limit = Math.floor(maxBufferSize / SLOT_BYTE_SIZE);
-
-        if (dimension > slice_limit) {
-            // can't exploit 3-rd dimension limit
-            // NOTE: why? Not sure exactly, but that's how it works in Chrome today 09/12/2024 - storage texture size is limited by buffer limit as well
-            return slice_area * slice_limit;
-        }
-
-        return slice_area * dimension;
+    get capacity() {
+        return this.#atlas.capacity;
     }
 
     /**
+     * Claim every slot below `min_capacity`, growing the atlas as it fills.
      *
      * @param {number} min_capacity
      */
     ensureCapacity(min_capacity) {
         assert.isNonNegativeInteger(min_capacity, 'min_capacity');
 
+        const atlas = this.#atlas;
 
-        const current_capacity = this.capacity;
+        while (atlas.live_count < min_capacity) {
+            const slot = atlas.allocate();
 
-        if (min_capacity <= current_capacity) {
-            // all good
-            return;
+            assert.equal(slot, atlas.live_count - 1, `slot ${slot} came out of order; a geometry SDF slot is its geometry's id, so the atlas must hand them out in sequence`);
         }
-
-        const capacity_limit = this.computeMaxCapacity();
-
-        // this is natural next step based on current capacity
-        const growth_target = Math.min(
-            capacity_limit,
-            Math.max(
-                current_capacity + CAPACITY_GROW_STEP,
-                Math.floor(current_capacity * CAPACITY_GROW_FRACTION)
-            )
-        );
-
-        let target = Math.max(
-            growth_target,
-            min_capacity
-        );
-
-        if (target > capacity_limit) {
-            console.warn(`target(=${target}) > limit(=${capacity_limit}), limiting size to ${capacity_limit}`);
-
-            target = capacity_limit;
-        }
-
-        this.allocate(target);
-    }
-
-    get capacity() {
-        return this.#atlas_resolution_in_tiles[0] * this.#atlas_resolution_in_tiles[1] * this.#atlas_resolution_in_tiles[2];
-    }
-
-    /**
-     *
-     * @param {number} capacity in slots
-     */
-    allocate(capacity) {
-        assert.isNonNegativeInteger(capacity, 'capacity');
-
-        const capacity_limit = this.computeMaxCapacity();
-
-        if (capacity > capacity_limit) {
-            throw new Error(`Over capacity limit ${capacity} > ${capacity_limit}`);
-        }
-
-        // always allocate a full max row, and the other dimensions as needed
-        const dimension_limit = this.computeMaxSlotsPerDimension();
-
-        const slot_resolution = this.#slot_resolution;
-
-        const sx = Math.min(dimension_limit, capacity);
-        const sy = Math.min(dimension_limit, Math.ceil(capacity / dimension_limit));
-        const sz = Math.ceil(capacity / (dimension_limit * dimension_limit));
-
-        this.#atlas_resolution_in_tiles = [sx, sy, sz];
-
-        this.#texture.resize(
-            sx * slot_resolution,
-            sy * slot_resolution,
-            sz * slot_resolution,
-            true,
-        );
-    }
-
-    /**
-     *
-     * @param {GPUDevice} device
-     */
-    constructor(device) {
-        this.#device = device;
-
-        this.#texture = new GPUTextureContext(device);
-
-        const td = this.#texture.descriptor;
-
-        td.format = "r32float"
-        td.dimension = "3d";
-
-        td.usage |= GPUTextureUsage.STORAGE_BINDING; // required to be able to write SDF from compute shader, which is how we build the SDF
-        td.usage |= GPUTextureUsage.COPY_SRC; // Needed for resizing while preserving data
-        td.usage |= GPUTextureUsage.COPY_DST; // Needed for resizing while preserving data
-
-        td.mipLevelCount = 1;
-
-        this.allocate(INITIAL_CAPACITY);
-
-
-        // DEBUG
-        globalThis.sdf = this;
     }
 
     destroy() {
-        this.#texture.destroy();
+        this.#atlas.destroy();
     }
 
 
@@ -234,13 +167,15 @@ export class GPUGeometrySDFManager {
             return;
         }
 
-        // ensure that atlas is large enough
+        // claim every slot before the first dispatch: a grow replaces the texture, and submits its
+        // copy ahead of the command stream the dispatches are recorded into
         const max_slot = array_compute_max(slot_indices);
         this.ensureCapacity(max_slot + 1);
 
         // TODO spread work over multiple frames
 
-        const slot_resolution = this.#slot_resolution;
+        const slot_resolution = this.tile_resolution;
+        const atlas_resolution_in_slots = this.atlas_resolution_in_tiles;
 
         for (let i = 0; i < slot_indices.length; i++) {
             const slot_index = slot_indices[i];
@@ -248,7 +183,7 @@ export class GPUGeometrySDFManager {
             const buffer_settings = {
                 slot_index,
                 slot_resolution,
-                atlas_resolution_in_slots: this.#atlas_resolution_in_tiles,
+                atlas_resolution_in_slots,
             };
 
 
@@ -269,7 +204,10 @@ export class GPUGeometrySDFManager {
                     blas_lookup: blas.buffer_metadata,
                     blas_data: blas.buffer_data,
                     geometries: geometries.buffer_metadata,
-                    output_texture: this.#texture.obtainView(),
+                    // the triangles the query reads, through their meshlets
+                    meshlet_metadata: geometries.meshlets.buffer_metadata,
+                    meshlet_data: geometries.meshlets.buffer_data,
+                    output_texture: this.#atlas.texture.obtainView(),
                 },
                 group_count_x: wgx,
                 group_count_y: wgy,
@@ -280,47 +218,12 @@ export class GPUGeometrySDFManager {
     }
 
     /**
-     *
-     * @param {number} slot_index
-     * @return {number[]}
-     */
-    index_to_slot(slot_index) {
-
-        // the linear→3D mapping is defined by the atlas TILE grid (see allocate(): sx/sy/sz
-        // tiles per axis, matching the WGSL sdf_slot_index_to_texture_offset), not by the
-        // per-tile texel resolution — dividing by #slot_resolution addresses the wrong tile
-        // as soon as the grid width differs from it (true for any multi-row atlas)
-        const [sx, sy] = this.#atlas_resolution_in_tiles;
-        const slice_size = sx * sy;
-
-        const x = slot_index % sx;
-        const z = Math.floor(slot_index / slice_size);
-        const y = Math.floor((slot_index - z * slice_size) / sx);
-
-        return [x, y, z];
-    }
-
-    /**
-     * Downloads raw data for a given slot
-     * NOTE: this is mainly for debug, because of limitations in WebGPU API slot resolution must be 64 for it to work properly
+     * Downloads raw data for a given slot. Mainly for debugging.
      * @param {number} slot
      * @return {Promise<Float32Array>}
      */
     async download_slot(slot) {
-        const r = this.#slot_resolution;
-
-        const slot_coordinate = this.index_to_slot(slot);
-
-        return download_texture_data({
-            device: this.#device,
-            source: this.#texture.gpu_texture,
-            origin: [
-                slot_coordinate[0] * r,
-                slot_coordinate[1] * r,
-                slot_coordinate[2] * r
-            ],
-            copySize: [r, r, r]
-        });
+        const atlas = this.#atlas;
+        return /** @type {Promise<Float32Array>} */ (atlas.texture.download_region(atlas.slot_origin(slot, [0, 0, 0]), atlas.tile_size));
     }
 }
-

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

@@ -1 +1 @@
-{"version":3,"file":"shader_build_sdf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/shader_build_sdf.js"],"names":[],"mappings":"AAiIA,6CAA8D;8BAzHhC,+BAA+B"}
+{"version":3,"file":"shader_build_sdf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/shader_build_sdf.js"],"names":[],"mappings":"AA6HA,6CAA8D;8BArHhC,+BAA+B"}

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

@@ -1,130 +1,126 @@
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { BVH2_NODE_STRUCT } from "../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
-import { BVH_TRAVERSAL_STACK_SIZE } from "../../shader/chunk/bvh/BVH_TRAVERSAL_STACK_SIZE.js";
-import { AABB3_STRUCT } from "../../shader/chunk/geometry/aabb3/AABB3_STRUCT.js";
-import { chunk_array_to_aabb3 } from "../../shader/chunk/geometry/aabb3/chunk_array_to_aabb3.js";
-import { F32_MAX_DEFINITION } from "../../shader/chunk/math/F32_MAX_DEFINITION.js";
-import { SURFACE_POINT_3D } from "../../shader/chunk/sdf/SURFACE_POINT_3D.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
-import { GEOMETRY_METADATA_STRUCT } from "../GEOMETRY_METADATA_STRUCT.js";
-import { chunk_blas_query_sdf } from "./chunk_blas_query_sdf.js";
-import { chunk_sdf_slot_index_to_texture_offset } from "./chunk_sdf_slot_index_to_texture_offset.js";
-import { SDF_BUILD_SETTINGS_STRUCT } from "./SDF_BUILD_SETTINGS_STRUCT.js";
-import { SFD_BUILD_WORKGROUP_SIZE } from "./SFD_BUILD_WORKGROUP_SIZE.js";
-
-const resources = new ShaderResourceSetDescriptor();
-
-// per-dispatch, 32 bytes, read-only: immediate data rather than a uniform buffer
-resources.setImmediate("settings", SDF_BUILD_SETTINGS_STRUCT);
-
-resources.createGroup()
-    .addStorageBuffer("blas_lookup", WebGPUArray.u32)
-    .addStorageBuffer("blas_data", WebGPUArray.from(BVH2_NODE_STRUCT))
-    .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
-
-resources.createGroup()
-    .addStorageTexture("output_texture", "r32float", "3d");
-
-/**
- * To support non-maniforld (open) meshes, we wrap negative distances after a number of voxels
- * @type {number}
- */
-const NEGATIVE_WRAP_DISTANCE = 4;
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-
-@compute @workgroup_size(${SFD_BUILD_WORKGROUP_SIZE.join(',')})
-fn main(
-    @builtin(global_invocation_id) global_id : vec3<u32>,
-){
-    let slot_resolution = settings.slot_resolution;
-    
-    if(any(global_id >= vec3(slot_resolution))){
-        // outside of the slot
-        return;
-    }
-    
-    let slot_index = settings.slot_index;
-    
-    let slice_size = slot_resolution * slot_resolution;
-    
-    let slot_offset_z = slot_index / slice_size;
-    
-    let index_in_slice = slot_index - slot_offset_z*slice_size;
-    
-    let slot_offset_y = index_in_slice / slot_resolution;
-    let slot_offset_x = slot_index % slot_resolution;
-    
-    let texel_offset = sdf_slot_index_to_texture_offset(slot_index, settings.atlas_resolution_in_slots) * slot_resolution;
-    
-    let texel_coordinate = texel_offset + global_id;
-    
-    let slot_resolution_v3f32 = vec3(f32(slot_resolution));
-    
-    // 0.5 is to move to the center of voxel
-    let local_uv = (vec3<f32>(global_id) + 0.5) / slot_resolution_v3f32;
-    
-    // get AABB from geometry's BVH
-    let blas_address = blas_lookup[slot_index];
-    
-    let bounds = array_to_aabb3(blas_data[blas_address].bounds);
-    let tight_bounds_span = (bounds.max - bounds.min);
-    
-    // figure out extents of a single sdf texel
-    let texel_size = tight_bounds_span / (slot_resolution_v3f32);
-    
-    // expand bounds by 1 texel to prevent clipping
-    let expanded_bounds = ${AABB3_STRUCT.wgsl_ref}(
-        bounds.min - texel_size*0.5,
-        bounds.max + texel_size*0.5
-    );
-    
-    let extended_bounds_span = (expanded_bounds.max - expanded_bounds.min);
-    
-    let sample_point = expanded_bounds.min + extended_bounds_span * local_uv;
-    
-    var traversal_stack:array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>;
-    
-    var contact_point: ${SURFACE_POINT_3D.wgsl_ref};
-                
-    // note that distances are normalized to UV space, so no value will be greater than +/- sqrt(2)
-    var sdf_distance = blas_query_sdf(sample_point, slot_index, &contact_point, &traversal_stack, 0u);
-    
-    let voxel_size = extended_bounds_span / slot_resolution_v3f32;
-    
-    // convert distance to voxels
-    let voxel_path = ( (sample_point - contact_point.position) / voxel_size );
-    
-    let voxel_distance = length(voxel_path);
-    
-    if(sdf_distance < 0 && voxel_distance > ${NEGATIVE_WRAP_DISTANCE}){
-        let voxel_compensation = max(0.0, voxel_distance - ${NEGATIVE_WRAP_DISTANCE});
-        sdf_distance = sdf_distance + voxel_compensation * length(voxel_size) * 2.0;
-    }
-        
-    textureStore(
-        output_texture,
-        texel_coordinate,            
-        vec4(sdf_distance,0,0,0)
-    );
-}
-`, [
-        AABB3_STRUCT.declaration_chunk,
-        chunk_sdf_slot_index_to_texture_offset,
-        F32_MAX_DEFINITION,
-        chunk_array_to_aabb3,
-        chunk_blas_query_sdf,
-    ]);
-
-const descriptor = ShaderDescriptor.from({
-    label: "Geometry SDF/ build",
-    resources,
-    body
-});
-
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { BVH2_NODE_STRUCT } from "../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
+import { BVH_TRAVERSAL_STACK_SIZE } from "../../shader/chunk/bvh/BVH_TRAVERSAL_STACK_SIZE.js";
+import { AABB3_STRUCT } from "../../shader/chunk/geometry/aabb3/AABB3_STRUCT.js";
+import { chunk_array_to_aabb3 } from "../../shader/chunk/geometry/aabb3/chunk_array_to_aabb3.js";
+import { F32_MAX_DEFINITION } from "../../shader/chunk/math/F32_MAX_DEFINITION.js";
+import { SURFACE_POINT_3D } from "../../shader/chunk/sdf/SURFACE_POINT_3D.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { chunk_tile_atlas_slot_origin } from "../../texture/atlas/chunk_tile_atlas_slot_origin.js";
+import { GEOMETRY_METADATA_STRUCT } from "../GEOMETRY_METADATA_STRUCT.js";
+import { chunk_blas_query_sdf } from "./chunk_blas_query_sdf.js";
+import { SDF_BUILD_SETTINGS_STRUCT } from "./SDF_BUILD_SETTINGS_STRUCT.js";
+import { SFD_BUILD_WORKGROUP_SIZE } from "./SFD_BUILD_WORKGROUP_SIZE.js";
+import { GEOMETRY_ATTRIBUTE_DATA_RESOURCE } from "../GEOMETRY_ATTRIBUTE_DATA_RESOURCE.js";
+import { MESHLET_METADATA_RESOURCE } from "../meshlet/MESHLET_METADATA_RESOURCE.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, 32 bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("settings", SDF_BUILD_SETTINGS_STRUCT);
+
+resources.createGroup()
+    .addStorageBuffer("blas_lookup", WebGPUArray.u32)
+    .addStorageBuffer("blas_data", WebGPUArray.from(BVH2_NODE_STRUCT))
+    .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
+    .add(MESHLET_METADATA_RESOURCE)
+    .add(GEOMETRY_ATTRIBUTE_DATA_RESOURCE)
+
+resources.createGroup()
+    .addStorageTexture("output_texture", "r32float", "3d");
+
+/**
+ * To support non-maniforld (open) meshes, we wrap negative distances after a number of voxels
+ * @type {number}
+ */
+const NEGATIVE_WRAP_DISTANCE = 4;
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+
+@compute @workgroup_size(${SFD_BUILD_WORKGROUP_SIZE.join(',')})
+fn main(
+    @builtin(global_invocation_id) global_id : vec3<u32>,
+){
+    let slot_resolution = settings.slot_resolution;
+    
+    if(any(global_id >= vec3(slot_resolution))){
+        // outside of the slot
+        return;
+    }
+    
+    let slot_index = settings.slot_index;
+
+    // the slot's corner in the atlas: its grid cell, a whole tile per cell (no border)
+    let texel_offset = tile_atlas_slot_origin(slot_index, settings.atlas_resolution_in_slots.xy, vec3(slot_resolution));
+    
+    let texel_coordinate = texel_offset + global_id;
+    
+    let slot_resolution_v3f32 = vec3(f32(slot_resolution));
+    
+    // 0.5 is to move to the center of voxel
+    let local_uv = (vec3<f32>(global_id) + 0.5) / slot_resolution_v3f32;
+    
+    // get AABB from geometry's BVH
+    let blas_address = blas_lookup[slot_index];
+    
+    let bounds = array_to_aabb3(blas_data[blas_address].bounds);
+    let tight_bounds_span = (bounds.max - bounds.min);
+    
+    // figure out extents of a single sdf texel
+    let texel_size = tight_bounds_span / (slot_resolution_v3f32);
+    
+    // expand bounds by 1 texel to prevent clipping
+    let expanded_bounds = ${AABB3_STRUCT.wgsl_ref}(
+        bounds.min - texel_size*0.5,
+        bounds.max + texel_size*0.5
+    );
+    
+    let extended_bounds_span = (expanded_bounds.max - expanded_bounds.min);
+    
+    let sample_point = expanded_bounds.min + extended_bounds_span * local_uv;
+    
+    var traversal_stack:array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>;
+    
+    var contact_point: ${SURFACE_POINT_3D.wgsl_ref};
+                
+    // note that distances are normalized to UV space, so no value will be greater than +/- sqrt(2)
+    var sdf_distance = blas_query_sdf(sample_point, slot_index, &contact_point, &traversal_stack, 0u);
+    
+    let voxel_size = extended_bounds_span / slot_resolution_v3f32;
+    
+    // convert distance to voxels
+    let voxel_path = ( (sample_point - contact_point.position) / voxel_size );
+    
+    let voxel_distance = length(voxel_path);
+    
+    if(sdf_distance < 0 && voxel_distance > ${NEGATIVE_WRAP_DISTANCE}){
+        let voxel_compensation = max(0.0, voxel_distance - ${NEGATIVE_WRAP_DISTANCE});
+        sdf_distance = sdf_distance + voxel_compensation * length(voxel_size) * 2.0;
+    }
+        
+    textureStore(
+        output_texture,
+        texel_coordinate,            
+        vec4(sdf_distance,0,0,0)
+    );
+}
+`, [
+        AABB3_STRUCT.declaration_chunk,
+        chunk_tile_atlas_slot_origin,
+        F32_MAX_DEFINITION,
+        chunk_array_to_aabb3,
+        chunk_blas_query_sdf,
+    ]);
+
+const descriptor = ShaderDescriptor.from({
+    label: "Geometry SDF/ build",
+    resources,
+    body
+});
+
 export const shader_build_sdf = new ComputeShader(descriptor);

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

@@ -74,7 +74,7 @@ fn main(
 //    
 //        let sdf_uv = (vec3(vec2(vec2f(coord_i)/SLICE_ZOOM), settings.slice * f32(settings.sdf_tile_resolution - 1u)) + 0.5) / f32(settings.sdf_tile_resolution);
 //   
-//        let offset = sdf_slot_index_to_texture_offset(geometry_id, settings.sdf_atlas_resolution) * settings.sdf_tile_resolution;
+//        let offset = tile_atlas_slot_origin(geometry_id, settings.sdf_atlas_resolution.xy, vec3(settings.sdf_tile_resolution));
 //        let geometry_distance = sdf_texture_region_sample_linear_uv(texture_sdf,  offset,  vec3(settings.sdf_tile_resolution), sdf_uv);
 //        return vec4(select(vec3(geometry_distance*scale, 0.0, 0.0), vec3(0.0, 0.0, geometry_distance*scale), geometry_distance >= 0), 1.0);
 ////        return vec4(vec3( geometry_distance ), 1.0);