@woosh/meep-engine 3.61.3 → 3.62.0

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

package/src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_instance.d.ts

@@ -3,15 +3,21 @@
  *
  * ```wgsl
  * fn vg_instance_stretch(global: mat4x4<f32>) -> vec2<f32>
+ * fn vg_instance_eye(global: mat4x4<f32>, position: vec3<f32>) -> vec4<f32>
  * fn vg_instance_record(mesh_index: u32, geometry_row: u32, capacity: u32) -> u32
  * fn vg_store(base: u32, field: u32, value: f32)
  * ```
  *
- * `vg_instance_stretch` is the largest and smallest stretch the transform applies to any direction,
- * or zero for a transform that flattens the instance. `vg_instance_record` reserves a record under
+ * `vg_instance_stretch` is the longest and shortest column of the transform's linear part, or zero
+ * for a column of zeros. That is the largest and smallest stretch it applies to any direction when
+ * the columns are orthogonal, a rotation times any scale; a shear stretches beyond its columns and
+ * is not accounted for, as in Nanite. (`mat3_singular_values` accounts for it, at many times the
+ * cost.) `vg_instance_eye` is `position` in the
+ * instance's object space, scaled by w: xyz / w is the eye, and w is the |det| that division takes,
+ * not positive for a transform without an inverse. `vg_instance_record` reserves a record under
  * `capacity`, writes the instance's mesh row and its geometry's root page, lookup and claim width,
  * and returns the record's first word, or {@link VG_INSTANCE_RECORD_NONE} when the records are full.
- * What the instance is cut against (its eye, projection and volume) is the collect's own.
+ * What the instance is cut against (its projection and volume) is the collect's own.
  *
  * Requires the importing shader to declare `instances`, `claim_widths` and `vg_geometries`.
  *

package/src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_instance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_vgeo_cut_instance.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_instance.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,sCAFU,SAAS,CAoFc;0BA7GP,0CAA0C"}
+{"version":3,"file":"chunk_vgeo_cut_instance.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_instance.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,sCAFU,SAAS,CAqFiD;0BApH1C,0CAA0C"}

package/src/shade/renderer/geometry/virtual/runtime/cut/chunk_vgeo_cut_instance.js

@@ -1,4 +1,5 @@
-import { chunk_mat3_singular_values } from "../../../../shader/chunk/geometry/mat3/chunk_mat3_singular_values.js";
+import { chunk_compute_normal_matrix_from_m4 } from "../../../../shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.js";
+import { chunk_mat4_extract_scale } from "../../../../shader/chunk/geometry/mat4/chunk_mat4_extract_scale.js";
 import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
 import { VGEO_GEOMETRY_ROW_OFFSET } from "../layout/VGEO_GEOMETRY_ROW_OFFSET.js";
 import { VGEO_GEOMETRY_ROW_WORDS } from "../layout/VGEO_GEOMETRY_ROW_WORDS.js";
@@ -10,15 +11,21 @@ import { VGEO_INSTANCE_WORDS } from "../layout/VGEO_INSTANCE_WORDS.js";
  *
  * ```wgsl
  * fn vg_instance_stretch(global: mat4x4<f32>) -> vec2<f32>
+ * fn vg_instance_eye(global: mat4x4<f32>, position: vec3<f32>) -> vec4<f32>
  * fn vg_instance_record(mesh_index: u32, geometry_row: u32, capacity: u32) -> u32
  * fn vg_store(base: u32, field: u32, value: f32)
  * ```
  *
- * `vg_instance_stretch` is the largest and smallest stretch the transform applies to any direction,
- * or zero for a transform that flattens the instance. `vg_instance_record` reserves a record under
+ * `vg_instance_stretch` is the longest and shortest column of the transform's linear part, or zero
+ * for a column of zeros. That is the largest and smallest stretch it applies to any direction when
+ * the columns are orthogonal, a rotation times any scale; a shear stretches beyond its columns and
+ * is not accounted for, as in Nanite. (`mat3_singular_values` accounts for it, at many times the
+ * cost.) `vg_instance_eye` is `position` in the
+ * instance's object space, scaled by w: xyz / w is the eye, and w is the |det| that division takes,
+ * not positive for a transform without an inverse. `vg_instance_record` reserves a record under
  * `capacity`, writes the instance's mesh row and its geometry's root page, lookup and claim width,
  * and returns the record's first word, or {@link VG_INSTANCE_RECORD_NONE} when the records are full.
- * What the instance is cut against (its eye, projection and volume) is the collect's own.
+ * What the instance is cut against (its projection and volume) is the collect's own.
  *
  * Requires the importing shader to declare `instances`, `claim_widths` and `vg_geometries`.
  *
@@ -36,42 +43,43 @@ fn vg_store(base: u32, field: u32, value: f32) {
 }
 
 fn vg_instance_stretch(global: mat4x4<f32>) -> vec2<f32> {
-    let linear = mat3x3<f32>(global[0].xyz, global[1].xyz, global[2].xyz);
-
-    let stretch = mat3_singular_values(linear);
+    let lengths = mat4_extract_scale(global);
+    let stretch = vec2<f32>(max(lengths.x, max(lengths.y, lengths.z)), min(lengths.x, min(lengths.y, lengths.z)));
 
     /*
-     A singular transform — an instance scaled to zero in some direction. mat4_inverse says so
-     by dividing by a zero determinant, and the NaN that comes back makes **every** comparison
-     in vg_project and the culls fail open, so one zero-scaled instance draws its whole
-     resident set. It covers nothing, so dropping it is also the right picture.
-
-     **The determinant is the test, and sigma_min alone was not.** This guard used to be
-     !(sigma_min > 0) on its own, and the closed form's own doc offered sigma_min as a
-     degeneracy test — true in exact arithmetic, false in f32. An axis-aligned flatten makes
-     MtM exactly diagonal and takes the exact branch, which does return zero. A ROTATED one
-     takes the trigonometric branch, where sigma_min is a difference of nearly equal numbers
-     with an absolute error of about sqrt(eps_f32) * sigma_max — so it came back near 1e-4
-     rather than 0, and thirty-six of forty rotated zero-scale instances passed this line with
-     a NaN eye and a projection scale of 6.2e10 behind it (REVIEW_LEDGER M3, re-review
-     2026-09-12). The determinant does not have that problem: a flattened instance has one
-     exactly-zero column at every rotation, and every term of the expansion carries a factor
-     from it. It is also, exactly, the number mat4_inverse divides by.
-
-     sigma_min is kept beside it because it is not redundant: a matrix that is merely very
-     close to singular has a non-zero determinant and can still report sigma_min as zero, and
-     a ratio of the two would then be an infinity rather than a correction.
-
-     Both written as !(x > 0) rather than x <= 0 so that a NaN — which compares false against
-     everything — is caught rather than passed through.
+     A column of zeros, a scale of zero, answers zero, which the collect drops: the projection
+     divides by the shortest column. Written !(x > 0) rather than x <= 0 so that a NaN, which
+     compares false against everything, is caught rather than passed through.
      */
-    if (!(abs(determinant(linear)) > 0.0) || !(stretch.y > 0.0)) {
+    if (!(stretch.y > 0.0)) {
         return vec2<f32>(0.0);
     }
 
     return stretch;
 }
 
+fn vg_instance_eye(global: mat4x4<f32>, position: vec3<f32>) -> vec4<f32> {
+    /*
+     An affine transform's inverse has adj(L) / det(L) for its linear part, and
+     compute_normal_matrix_from_m4 is adj(L) transposed, with det's sign folded in. So the eye is
+     transpose(normal) * (position - t) / |det|, and |det| = dot(l0, normal[0]) is the number it is
+     divided by. That number is w, for the collect to test before it divides. A test of any other
+     expansion of the determinant can pass where this one is zero: under a flattened parent a
+     rotated child's columns are all non-zero yet dependent, and two expansions then disagree
+     about zero. Even the sign that orients the normal matrix is a second evaluation of this dot,
+     so where the determinant is rounding noise a backend that fuses the two differently can make
+     w negative, which drops the instance.
+
+     A singular transform has no eye. The NaN that dividing by it brings makes **every**
+     comparison in vg_project and the culls fail open, so one zero-scaled instance would draw its
+     whole resident set (REVIEW_LEDGER M3). It covers nothing, so dropping it is also the right
+     picture.
+     */
+    let normal = compute_normal_matrix_from_m4(global);
+
+    return vec4<f32>(transpose(normal) * (position - global[3].xyz), dot(global[0].xyz, normal[0]));
+}
+
 fn vg_instance_record(mesh_index: u32, geometry_row: u32, capacity: u32) -> u32 {
     let slot = atomicAdd(&claim_widths.count, 1u);
 
@@ -108,4 +116,4 @@ fn vg_instance_record(mesh_index: u32, geometry_row: u32, capacity: u32) -> u32
 
     return base;
 }
-`, [chunk_mat3_singular_values]);
+`, [chunk_mat4_extract_scale, chunk_compute_normal_matrix_from_m4]);

package/src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_collect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_vgeo_cut_collect.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_collect.js"],"names":[],"mappings":"AA6NA,oDAIG;8BA3N2B,qCAAqC"}
+{"version":3,"file":"shader_vgeo_cut_collect.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_collect.js"],"names":[],"mappings":"AA4NA,oDAIG;8BA1N2B,qCAAqC"}

package/src/shade/renderer/geometry/virtual/runtime/cut/shader_vgeo_cut_collect.js

@@ -6,7 +6,6 @@ import { COLLECTION_U32_STRUCT_READ } from "../../../../gpu_primitive/COLLECTION
 import { COLLECTION_U32_STRUCT_WRITE } from "../../../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
 import { ComputeShader } from "../../../../shader/ComputeShader.js";
 import { GEOMETRY_METADATA_STRUCT } from "../../../GEOMETRY_METADATA_STRUCT.js";
-import { chunk_mat4_inverse } from "../../../../shader/chunk/geometry/mat4/chunk_mat4_inverse.js";
 import { chunk_scene_database_access } from "../../../../scene/chunk_scene_database_access.js";
 import { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { VGEO_CUT_STAT } from "../layout/VGEO_CUT_STAT.js";
@@ -131,19 +130,25 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
     /*
      In perspective, error and distance are both object-space, so a **uniform** scale cancels out of
      r_e * k / d exactly and needs no term at all. A non-uniform one does not, and the correction is
-     the ratio of the largest stretch this transform applies to any direction to the smallest —
-     which is the ratio of its singular values, not of its column lengths. A shear has unit columns
-     and stretches space without bound, so column lengths report 1 and under-refine, which is the
-     direction a conservative correction is not allowed to fail in.
+     the ratio of the longest column to the shortest. Those are the transform's largest and smallest
+     stretch exactly when the columns are orthogonal, a rotation times any scale. A shear stretches
+     space beyond its columns, so a sheared instance under-refines: accepted, as Nanite accepts it,
+     for a correction that costs three lengths.
 
      An orthographic view has no distance for a scale to cancel against: an object-space error
-     becomes world units by the largest stretch, and the correction is sigma_max alone. The weight
-     picks between them without a branch, and at w = 1 the expression is today's x / y exactly.
+     becomes world units by the largest stretch, and the correction is the longest column alone. The
+     weight picks between them without a branch, and at w = 1 the expression is x / y exactly.
      */
     let stretch = vg_instance_stretch(node.global);
 
-    // a transform that flattens the instance, which vg_instance_stretch answers with zero
-    if (!(stretch.y > 0.0)) {
+    // the camera's position in this instance's object space, out of the camera's own world transform
+    let eye = vg_instance_eye(node.global, camera.transform[3].xyz);
+
+    /*
+     A transform that flattens the instance, which vg_instance_stretch answers with zero, or that
+     has no inverse to take the eye through: eye.w is the very determinant the eye is divided by.
+     */
+    if (!(stretch.y > 0.0) || !(eye.w > 0.0)) {
         atomicAdd(
             &feedback[params.stats_base + ${VGEO_CUT_STAT.INSTANCES_DROPPED}u], 1u
         );
@@ -167,11 +172,6 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
         return;
     }
 
-    let to_object = mat4_inverse(node.global);
-
-    // the camera's position in this instance's object space, out of the camera's own world transform
-    let eye = to_object * vec4<f32>(camera.transform[3].xyz, 1.0);
-
     vg_store(base, ${VGEO_INSTANCE_OFFSET.EYE}u, eye.x / eye.w);
     vg_store(base, ${VGEO_INSTANCE_OFFSET.EYE + 1}u, eye.y / eye.w);
     vg_store(base, ${VGEO_INSTANCE_OFFSET.EYE + 2}u, eye.z / eye.w);
@@ -216,7 +216,6 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
 `, [
     chunk_scene_database_access,
     chunk_vgeo_cut_instance,
-    chunk_mat4_inverse,
 ]);
 
 export const shader_vgeo_cut_collect = ComputeShader.from({

package/src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_debug_draw.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_brick4_debug_draw.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_debug_draw.js"],"names":[],"mappings":"AAoEA,mDAUE;4BAtE0B,mCAAmC"}
+{"version":3,"file":"shader_brick4_debug_draw.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_debug_draw.js"],"names":[],"mappings":"AAwEA,mDAUE;4BAvE0B,mCAAmC"}

package/src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_debug_draw.js

@@ -5,6 +5,9 @@ import {
 } from "../../../../shader/chunk/camera/chunk_project_position_from_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 { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
 import { ImageShader } from "../../../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -17,6 +20,7 @@ const resources = new ShaderResourceSetDescriptor();
 resources.createGroup()
     .addTexture("tDepth")
     .addTexture("tNormals", "uint")
+    .addTexture("tPBR")
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
 
 resources.createGroup()
@@ -45,10 +49,9 @@ fn main(
     
     let view_direction = normalize(camera_position_ws - position_ws);
     
-    let g_buffer_sample_normal = textureLoad(tNormals, 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(tNormals, i_coord, 0).x);
+    let geometric_normal = decode_g_buffer_face_normal(textureLoad(tPBR, i_coord, 0));
     
     let c = brick4_sample(
         position_ws,
@@ -62,6 +65,7 @@ fn main(
         chunk_project_position_from_depth,
         chunk_mat4_extract_position,
         chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_brick4_sample,
     ]
 );

package/src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_diffuse.js

@@ -60,7 +60,7 @@ fn main(
     
     let g_buffer_sample_normal = textureLoad(tBentNormals, i_coord, 0);
     
-    let bent_normal = decode_g_buffer_normal(g_buffer_sample_normal.xy);
+    let bent_normal = decode_g_buffer_normal(g_buffer_sample_normal.x);
     
     let node = brick4_node_by_position(position_ws);
     

package/src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_indirect_lighting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_brick4_indirect_lighting.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_indirect_lighting.js"],"names":[],"mappings":"AA0MA,0DAwBE;4BA3M0B,mCAAmC"}
+{"version":3,"file":"shader_brick4_indirect_lighting.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_indirect_lighting.js"],"names":[],"mappings":"AA4MA,0DAwBE;4BA5M0B,mCAAmC"}

package/src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_indirect_lighting.js

@@ -10,6 +10,7 @@ import {
 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_compute_indirect_specular } from "../../../../shader/chunk/material/chunk_compute_indirect_specular.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";
@@ -70,7 +71,7 @@ fn main(
     let g_buffer_sample_normal = textureLoad(tGBufferNormals, i_coord, 0);
     let g_buffer_bent_normal = textureLoad(tBentNormals, i_coord, 0);
 
-    let albedo = albedo_ao_sample.rgb;
+    let albedo = decode_g_buffer_albedo(albedo_ao_sample.rgb);
     let occlusion = albedo_ao_sample.a;
 
     let f_metalness = decode_g_buffer_metalness(texel_pbr);
@@ -83,8 +84,8 @@ fn main(
     let material_specularF0 = metalness_to_specular_color(f_metalness, albedo);
     let material_specularF90 = 1.0;
 
-    let shading_normal = decode_g_buffer_normal(g_buffer_sample_normal.xy);
-    let bent_normal = decode_g_buffer_normal(g_buffer_bent_normal.xy);
+    let shading_normal = decode_g_buffer_normal(g_buffer_sample_normal.x);
+    let bent_normal = decode_g_buffer_normal(g_buffer_bent_normal.x);
 
     let position_ws = project_position_from_depth(uv, texel_depth, camera.view_projection_matrix_inverse);
     let camera_position_ws = mat4_extract_position(camera.transform);
@@ -181,6 +182,7 @@ fn main(
         chunk_project_position_from_depth,
         chunk_mat4_extract_position,
         chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_albedo,
         chunk_decode_g_buffer_metalness,
         chunk_decode_g_buffer_roughness,
         chunk_metalness_to_specular_color,

package/src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_specular.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_brick4_specular.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_specular.js"],"names":[],"mappings":"AAwEA,iDAaE;4BA3E0B,mCAAmC"}
+{"version":3,"file":"shader_brick4_specular.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_specular.js"],"names":[],"mappings":"AAsEA,iDAaE;4BAzE0B,mCAAmC"}

package/src/shade/renderer/global_illumination/brick4/gpu/draw/shader_brick4_specular.js

@@ -48,10 +48,8 @@ fn main(
     
     let view_direction = normalize(camera_position_ws - position_ws);
     
-    let g_buffer_sample_normal = textureLoad(tNormals, 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(tNormals, i_coord, 0).x);
     
     let roughness = decode_g_buffer_roughness(textureLoad(tPBR, i_coord, 0));
     

package/src/shade/renderer/global_illumination/ibl/shader_diffuse_IBL.js

@@ -23,7 +23,7 @@ fn main(
 ) -> @location(0) vec4<f32> {
     let coord_i = vec2u(coord.xy);
 
-    let bent_normal_encoded = textureLoad(tBentNormals, coord_i, 0).rg;
+    let bent_normal_encoded = textureLoad(tBentNormals, coord_i, 0).x;
 
     let bent_normal = decode_g_buffer_normal(bent_normal_encoded);
 

package/src/shade/renderer/global_illumination/ibl/shader_specular_IBL.js

@@ -35,12 +35,12 @@ fn main(
     
     let roughness = decode_g_buffer_roughness(texel_pbr);
     
-    let bent_normal_encoded = textureLoad(tBentNormals, coord_i, 0).rg;
+    let bent_normal_encoded = textureLoad(tBentNormals, coord_i, 0).x;
     
     let bent_normal = decode_g_buffer_normal(bent_normal_encoded);
     
     let shading_normal = decode_g_buffer_normal(
-        textureLoad(tNormals, coord_i, 0).rg
+        textureLoad(tNormals, coord_i, 0).x
     );
     
     let texel_depth = textureLoad(tDepth,

package/src/shade/renderer/global_illumination/lpv/shader_diffuse_LPV.js

@@ -42,7 +42,7 @@ fn main(
     
     let coord_i = vec2u(coord.xy);
     
-    let bent_normal_encoded = textureLoad(tBentNormals, coord_i, 0).rg;
+    let bent_normal_encoded = textureLoad(tBentNormals, coord_i, 0).x;
     
     let bent_normal = decode_g_buffer_normal(bent_normal_encoded);
     

package/src/shade/renderer/global_illumination/probe_clipmap/brick/GPUBrickClipmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUBrickClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/GPUBrickClipmap.js"],"names":[],"mappings":"AA6FA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;GAGG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAyJI;;;;;;;;OAQG;IACH;QAN2B,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QAGU,UAAU,EAA1B,MAAM;OAgGhB;IA/PD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IA+OX;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;;OAIG;IACH,wBAEC;IAED;;;;;;;OAOG;IACH,mCAQC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,sBAFW,UAAU,MAAM,CAAC,QAiB3B;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAMnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAb+B,KAAK,EAAzB,UAAU;QACM,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,MAAM,EAAtB,MAAM;QAC4B,SAAS,EAA3C,UAAU,aAAa,CAAC;QACiB,gBAAgB,GAAzD,UAAU,mBAAmB,CAAC;QACA,KAAK,EAAnC,eAAe,GAAC,IAAI;QACH,MAAM,GAAvB,MAAM;QAEJ,MAAM,CA6GlB;IAgWD,gBAcC;;CACJ;mCAx8BY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU;8BACpF,OAAO,mCAAmC,EAAE,eAAe;;;;;;;WA+C1D,UAAU;;;;WACV,MAAM;;;;;;UACN,MAAM;;;;;aAGN,MAAM;;;;sBAEN,MAAM;;;;;mBAEN,MAAM;;;;gBACN,MAAM;mBACN,MAAM;;;;;;;;;;WAGN,eAAe;;;;;;aAEf,eAAe;;;+BAON,UAAU,QAAE,oBAAoB,KAAG,IAAI;;;;;;;;;iCAUvC,UAAU,QAAE,oBAAoB,KAAG,IAAI;;+BA1G/B,0CAA0C"}
+{"version":3,"file":"GPUBrickClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/GPUBrickClipmap.js"],"names":[],"mappings":"AA6FA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;GAGG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAkKI;;;;;;;;OAQG;IACH;QAN2B,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QAGU,UAAU,EAA1B,MAAM;OAgGhB;IAxQD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAwPX;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;;OAIG;IACH,wBAEC;IAED;;;;;;;OAOG;IACH,mCAQC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,sBAFW,UAAU,MAAM,CAAC,QAiB3B;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAMnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAb+B,KAAK,EAAzB,UAAU;QACM,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,MAAM,EAAtB,MAAM;QAC4B,SAAS,EAA3C,UAAU,aAAa,CAAC;QACiB,gBAAgB,GAAzD,UAAU,mBAAmB,CAAC;QACA,KAAK,EAAnC,eAAe,GAAC,IAAI;QACH,MAAM,GAAvB,MAAM;QAEJ,MAAM,CAiHlB;IAgWD,gBAcC;;CACJ;mCAr9BY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU;8BACpF,OAAO,mCAAmC,EAAE,eAAe;;;;;;;WA+C1D,UAAU;;;;WACV,MAAM;;;;;;UACN,MAAM;;;;;aAGN,MAAM;;;;sBAEN,MAAM;;;;;mBAEN,MAAM;;;;gBACN,MAAM;mBACN,MAAM;;;;;;;;;;WAGN,eAAe;;;;;;aAEf,eAAe;;;+BAON,UAAU,QAAE,oBAAoB,KAAG,IAAI;;;;;;;;;iCAUvC,UAAU,QAAE,oBAAoB,KAAG,IAAI;;+BA1G/B,0CAA0C"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/GPUBrickClipmap.js

@@ -260,6 +260,15 @@ export class GPUBrickClipmap {
     #starved = 0;
     #grow_pending = false;
 
+    /** Frames recorded. */
+    #frame = 0;
+
+    /**
+     * The frame the capacity last grew in. A reading recorded before it asked for what that growth gave, so
+     * only a count that moved in a frame at or after it grows the capacity again.
+     */
+    #grown_frame = -1;
+
     #destroyed = false;
 
     /** The frame's scroll boxes: the smallest cell and the cascade, then the size and the first thread. */
@@ -551,6 +560,7 @@ export class GPUBrickClipmap {
         if (this.#grow_pending) {
             this.#grow_pending = false;
             this.#grow();
+            this.#grown_frame = this.#frame;
         }
 
         this.#place(x, y, z);
@@ -621,6 +631,8 @@ export class GPUBrickClipmap {
         store.make_side_effect();
 
         // a starved take grows the capacity, from a later frame
+        const read_frame = this.#frame;
+
         graph_read_buffer({ graph, buffer: store_data.state, offset: 4 * BRICK_STATE_STARVED, size: 4 })
             .then(reference => {
                 try {
@@ -628,7 +640,7 @@ export class GPUBrickClipmap {
 
                     if (!this.#destroyed && starved !== this.#starved) {
                         this.#starved = starved;
-                        this.#grow_pending = true;
+                        this.#grow_pending ||= read_frame >= this.#grown_frame;
                     }
                 } finally {
                     reference.release();
@@ -647,6 +659,7 @@ export class GPUBrickClipmap {
         }
 
         this.#fresh = false;
+        this.#frame++;
 
         return context.state;
     }

package/src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUProbeClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js"],"names":[],"mappings":"AA0HA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH;IAqRI;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAjB2B,aAAa,EAA7B,MAAM;QAEU,UAAU,EAA1B,MAAM;QAKU,OAAO,EAAvB,MAAM;QACU,mBAAmB,EAAnC,MAAM;QAEU,gBAAgB,EAAhC,MAAM;QACW,cAAc,EAA/B,OAAO;QAES,KAAK,EAArB,MAAM;QACU,QAAQ,EAAxB,MAAM;OAmHhB;IAxZD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,kBAHU,MAAM,CAGR;IAER;;;;OAIG;IACH,8BAHU,MAAM,CAGI;IAEpB;;;;OAIG;IACH,2BAHU,MAAM,CAGC;IAEjB;;;;;OAKG;IACH,yBAHU,OAAO,CAGF;IAEf;;;;OAIG;IACH,gBAHU,MAAM,CAGV;IA2WN;;;;;;;;OAQG;IACH,4CAUC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;OAKG;IACH,uBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,sBAEC;IAGD;;;OAGG;IACH,0BAEC;IAED;;;;;OAKG;IACH,wBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED;;;;;;;OAOG;IACH,SAJW,MAAM,KACN,MAAM,KACN,MAAM,QAkChB;IAED;;;;;;;;OAQG;IACH,sBAFW,eAAe,QA+BzB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH;QAzB+B,KAAK,EAAzB,UAAU;QACiB,KAAK,EAAhC,iBAAiB;QACD,eAAe,EAA/B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,cAAc,EAA9B,MAAM;QACyD,aAAa,EAA5E,OAAO,6BAA6B,EAAE,eAAe;QAErC,MAAM,EAAtB,MAAM;QAE+D,KAAK,EAA1E,OAAO,mCAAmC,EAAE,eAAe;QAEP,QAAQ,EAA5D;YAAC,cAAc,qBAA0B;SAAC;QAEzB,kBAAkB,EAAnC,OAAO;QAEU,cAAc,EAA/B,OAAO;QAEiC,QAAQ,EAAhD;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC;QAEL,YAAY,EAArC,eAAe;QACU,eAAe,EAAxC,eAAe;QACC,QAAQ,EAAxB,MAAM;aAuOhB;IA6gBD,gBAcC;;CACJ;mCA18CY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU;gCACpF,OAAO,8BAA8B,EAAE,uBAAuB,GAAC,OAAO,2BAA2B,EAAE,oBAAoB"}
+{"version":3,"file":"GPUProbeClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js"],"names":[],"mappings":"AA0HA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH;IA2RI;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAjB2B,aAAa,EAA7B,MAAM;QAEU,UAAU,EAA1B,MAAM;QAKU,OAAO,EAAvB,MAAM;QACU,mBAAmB,EAAnC,MAAM;QAEU,gBAAgB,EAAhC,MAAM;QACW,cAAc,EAA/B,OAAO;QAES,KAAK,EAArB,MAAM;QACU,QAAQ,EAAxB,MAAM;OAmHhB;IA9ZD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,kBAHU,MAAM,CAGR;IAER;;;;OAIG;IACH,8BAHU,MAAM,CAGI;IAEpB;;;;OAIG;IACH,2BAHU,MAAM,CAGC;IAEjB;;;;;OAKG;IACH,yBAHU,OAAO,CAGF;IAEf;;;;OAIG;IACH,gBAHU,MAAM,CAGV;IAiXN;;;;;;;;OAQG;IACH,4CAUC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;OAKG;IACH,uBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,sBAEC;IAGD;;;OAGG;IACH,0BAEC;IAED;;;;;OAKG;IACH,wBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED;;;;;;;OAOG;IACH,SAJW,MAAM,KACN,MAAM,KACN,MAAM,QAkChB;IAED;;;;;;;;OAQG;IACH,sBAFW,eAAe,QA+BzB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH;QAzB+B,KAAK,EAAzB,UAAU;QACiB,KAAK,EAAhC,iBAAiB;QACD,eAAe,EAA/B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,cAAc,EAA9B,MAAM;QACyD,aAAa,EAA5E,OAAO,6BAA6B,EAAE,eAAe;QAErC,MAAM,EAAtB,MAAM;QAE+D,KAAK,EAA1E,OAAO,mCAAmC,EAAE,eAAe;QAEP,QAAQ,EAA5D;YAAC,cAAc,qBAA0B;SAAC;QAEzB,kBAAkB,EAAnC,OAAO;QAEU,cAAc,EAA/B,OAAO;QAEiC,QAAQ,EAAhD;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC;QAEL,YAAY,EAArC,eAAe;QACU,eAAe,EAAxC,eAAe;QACC,QAAQ,EAAxB,MAAM;aA0OhB;IA6gBD,gBAcC;;CACJ;mCAn9CY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU;gCACpF,OAAO,8BAA8B,EAAE,uBAAuB,GAAC,OAAO,2BAA2B,EAAE,oBAAoB"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js

@@ -382,6 +382,12 @@ export class GPUProbeClipmap {
     #starved = 0;
     #grow_pending = false;
 
+    /**
+     * The frame the capacity last grew in. A reading recorded before it asked for what that growth gave, so
+     * only a count that moved in a frame at or after it grows the capacity again.
+     */
+    #grown_frame = -1;
+
     /** Frames recorded: the clock the records keep. */
     #frame = 0;
 
@@ -834,6 +840,7 @@ export class GPUProbeClipmap {
         if (this.#grow_pending) {
             this.#grow_pending = false;
             this.#grow();
+            this.#grown_frame = this.#frame;
         }
 
         const trace_capacity = Math.floor(ray_budget / rays_per_probe);
@@ -1018,6 +1025,8 @@ export class GPUProbeClipmap {
         update.make_side_effect();
 
         // an admission the free list could not serve grows the capacity, from a later frame
+        const read_frame = this.#frame;
+
         graph_read_buffer({ graph, buffer: update_data.counters, offset: 4 * PROBE_COUNTER_STARVED, size: 4 })
             .then(reference => {
                 try {
@@ -1025,7 +1034,7 @@ export class GPUProbeClipmap {
 
                     if (!this.#destroyed && starved !== this.#starved) {
                         this.#starved = starved;
-                        this.#grow_pending = true;
+                        this.#grow_pending ||= read_frame >= this.#grown_frame;
                     }
                 } finally {
                     reference.release();

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_diffuse.js

@@ -49,8 +49,8 @@ fn main(
     let view_direction = normalize(mat4_extract_position(camera.transform) - position);
 
     // the surface's own normal picks, as want chose by it; the bent normal resolves, as IBL's does
-    let normal = decode_g_buffer_normal(textureLoad(tNormals, i_coord, 0).xy);
-    let bent_normal = decode_g_buffer_normal(textureLoad(tBentNormals, i_coord, 0).xy);
+    let normal = decode_g_buffer_normal(textureLoad(tNormals, i_coord, 0).x);
+    let bent_normal = decode_g_buffer_normal(textureLoad(tBentNormals, i_coord, 0).x);
 
     let noise = stbn_sample_vec2(vec3<u32>(i_coord, view.frame_index));
     let probes = probe_clipmap_sample_sh(position, normal, view_direction, noise);

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_indirect_lighting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_indirect_lighting.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_indirect_lighting.js"],"names":[],"mappings":"AAyIA;;;;;;;;;;;;;GAaG;AACH,qDAFU,WAAW,CA0BlB;4BA1JyB,gCAAgC"}
+{"version":3,"file":"shader_probe_clipmap_indirect_lighting.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_indirect_lighting.js"],"names":[],"mappings":"AA2IA;;;;;;;;;;;;;GAaG;AACH,qDAFU,WAAW,CA0BlB;4BA3JyB,gCAAgC"}