@woosh/meep-engine 3.18.0 → 3.20.0

package/src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_temporal_accumulate.js

@@ -0,0 +1,137 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_rgb_to_luminance } from "../../../shader/chunk/color/chunk_rgb_to_luminance.js";
+import { chunk_decode_g_buffer_normal } from "../../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { chunk_is_finite } from "../../../shader/chunk/math/chunk_is_finite.js";
+import { chunk_decode_g_buffer_roughness } from "../../../shader/chunk/material/chunk_decode_g_buffer_roughness.js";
+import { chunk_project_position_from_depth } from "../../../shader/chunk/camera/chunk_project_position_from_depth.js";
+import { chunk_texel_coordinate_to_uv } from "../../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
+import { chunk_get_view_space_depth } from "../../../shader/chunk/depth/chunk_get_view_space_depth.js";
+import { chunk_is_background } from "../../../shader/chunk/depth/chunk_is_background.js";
+
+/** Linear radiance accumulation. Spatial contrast and single stochastic hits are not motion. */
+export const chunk_ssr_temporal_accumulate = CodeChunk.from(/* language=WGSL */ `
+const SSR_SHORT_BLEND = 0.25;
+const SSR_SHORT_VARIANCE_SCALE = SSR_SHORT_BLEND / (2.0-SSR_SHORT_BLEND);
+
+struct SSRAccumulation {
+    radiance: vec4f,
+    age: f32,
+    short_luma: f32,
+}
+
+fn ssr_temporal_accumulate(current: vec4f, previous: vec4f, previous_age: f32,
+    previous_short_luma: f32, confidence: f32, motion_confidence: f32, st: vec2i, history_uv: vec2f) -> SSRAccumulation {
+    let old_age = clamp(previous_age, 1.0, 128.0);
+    let current_luma = rgb_to_luminance(current.rgb);
+    let previous_luma = rgb_to_luminance(previous.rgb);
+    // Alpha describes uncertainty in the accumulated mean. Recover the estimated
+    // distribution variance before judging whether a new sample is surprising.
+    let previous_variance = max(0.0, previous.w) * old_age;
+    let short_luma = mix(previous_short_luma, current_luma, SSR_SHORT_BLEND);
+    let short_delta = current_luma - previous_short_luma;
+    // Noise statistics need a short window too: long-lived variance would hide a
+    // real transition from a noisy bright reflection to a steady dark surface.
+    let sample_variance = (1.0-SSR_SHORT_BLEND) * (previous_variance + SSR_SHORT_BLEND * short_delta * short_delta);
+    // Compare two means at different time scales, normalized by sampling noise.
+    // The previous implementation compared the mean with ONE noisy sample and
+    // discarded useful history on almost every bright ray hit.
+    let short_sigma = sqrt(max(1e-6, sample_variance * SSR_SHORT_VARIANCE_SCALE));
+    let inconsistency = abs(short_luma - previous_luma) / short_sigma;
+    var reactive = smoothstep(3.0, 6.0, inconsistency);
+
+    // A 5x5 neighbourhood sees beyond the small prefilter. Persistent temporal
+    // uncertainty keeps a chance cluster of misses from clipping a valid mean to
+    // black. Real geometry and coherent lighting changes can still rectify it.
+    let size = vec2i(textureDimensions(tInput));
+    let center_normal = decode_g_buffer_normal(textureLoad(tNormal, st, 0).xy);
+    let center_depth = textureLoad(tDepth, st, 0).r;
+    let center_roughness = decode_g_buffer_roughness(textureLoad(tPBR, st, 0));
+    var first = vec3f(0.0);
+    var second = vec3f(0.0);
+    var count = 0.0;
+    var history_mean = 0.0;
+    var short_mean = 0.0;
+    var noise_sum = 0.0;
+    var history_count = 0.0;
+    let history_st = vec2i(history_uv * vec2f(size));
+    for (var y = -2; y <= 2; y++) {
+        for (var x = -2; x <= 2; x++) {
+            let p = st + vec2i(x,y);
+            if (any(p < vec2i(0)) || any(p >= size)) { continue; }
+            let normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).xy);
+            let depth = textureLoad(tDepth, p, 0).r;
+            if (is_background(depth)) { continue; }
+            let roughness = decode_g_buffer_roughness(textureLoad(tPBR, p, 0));
+            if (!(abs(roughness-center_roughness) <= 0.08)) { continue; }
+            if (dot(normal,center_normal) < 0.9 || abs(depth-center_depth) > max(1e-4, center_depth*0.02)) { continue; }
+            let c = textureLoad(tInput, p, 0).rgb;
+            first += c;
+            second += c*c;
+            count += 1.0;
+            // Compare local short- and long-term means. A moving rough reflection
+            // can change many individually low-SNR pixels coherently. One noisy
+            // pixel cannot establish that, but a matched patch can.
+            let h = history_st + vec2i(x,y);
+            if (any(h < vec2i(0)) || any(h >= size)) { continue; }
+            let old_geometry = textureLoad(tHistoryGeometry,h,0);
+            if (!(dot(old_geometry.xyz,normal) >= 0.9)) { continue; }
+            if (!(abs(old_geometry.w-roughness) <= 0.08)) { continue; }
+            // Device depths belong to different cameras. Validate the old point
+            // against the current surface in world space, as the history gather does.
+            let old_depth = textureLoad(tPreviousDepth,h,0).r;
+            if (is_background(old_depth)) { continue; }
+            let position = project_position_from_depth(texel_coordinate_to_uv(vec2f(p),vec2u(size)),depth,camera_current.view_projection_matrix_inverse);
+            let old_position = project_position_from_depth(texel_coordinate_to_uv(vec2f(h),vec2u(size)),old_depth,camera_previous.view_projection_matrix_inverse);
+            let plane_distance = abs(dot(normal,old_position-position));
+            let tolerance = max(1e-4,0.002*get_view_space_depth(depth,camera_current));
+            if (!(plane_distance <= tolerance)) { continue; }
+            let old = textureLoad(tHistory,h,0);
+            let old_metadata = textureLoad(tHistoryMetadata,h,0);
+            if (!is_finite(old.x) || !is_finite(old.y) || !is_finite(old.z) || !is_finite(old.w)
+                || !is_finite(old_metadata.z) || !is_finite(old_metadata.w)) { continue; }
+            let luma = rgb_to_luminance(c);
+            let d = luma-old_metadata.w;
+            history_mean += rgb_to_luminance(old.rgb);
+            short_mean += mix(old_metadata.w,luma,SSR_SHORT_BLEND);
+            noise_sum += (1.0-SSR_SHORT_BLEND) * (max(0.0,old.w)*clamp(old_metadata.z,1.0,128.0) + SSR_SHORT_BLEND*d*d);
+            history_count += 1.0;
+        }
+    }
+    if (history_count >= 9.0) {
+        // The 3x3 prefilter correlates adjacent samples: use a conservative nine
+        // taps per independent observation instead of claiming 25 independent rays.
+        let sigma = sqrt(max(1e-6,noise_sum*SSR_SHORT_VARIANCE_SCALE*9.0));
+        reactive = max(reactive,smoothstep(3.0,6.0,abs(short_mean-history_mean)/sigma));
+    }
+    // Blend update rates, not history lengths: halfway from 128 to two frames
+    // would still retain ~98% history and barely respond to a detected change.
+    let mature_age = min(128.0, old_age * confidence + 1.0);
+    var age = 1.0 / mix(1.0/mature_age, 0.5, reactive);
+    let mean = first / max(1.0,count);
+    // The carried variance is in luminance units. Expand RGB bounds along the
+    // history color, otherwise saturated blue gets only 7.22% of its RGB sigma
+    // and a normal stochastic miss can erase an already converged reflection.
+    let noise_color = select(vec3f(1.0),previous.rgb/max(previous_luma,1e-6),previous_luma > 1e-6);
+    let deviation = sqrt(max(noise_color*noise_color*previous_variance, second / max(1.0,count) - mean*mean));
+    let gamma = mix(1.5, 4.0, motion_confidence);
+    let clipped = clamp(previous.rgb, max(vec3f(0.0),mean-gamma*deviation), mean+gamma*deviation);
+    // Once history is outside even the noise-expanded box, it is no longer a
+    // well-supported long-term estimate. Do not leave it pinned to a clipped edge.
+    let rectified = any(abs(previous.rgb-clipped) > vec3f(1e-5));
+    if (rectified) { age = min(age, 2.0); }
+    // Confidence can force a much larger current contribution than 1/age.
+    // Carry that actual update rate into the age/variance pair too; otherwise a
+    // half-current blend can claim the uncertainty of a 65-frame accumulation.
+    age = min(age, 1.0 / max(1e-6, 1.0-saturate(confidence)));
+    let weight = min(saturate(confidence), 1.0 - 1.0/age);
+    let color = mix(current.rgb, clipped, weight);
+    var result: SSRAccumulation;
+    // Post-spatial passes receive uncertainty of the mean, rather than the raw
+    // sample distribution or the resolve pass's within-ray variance.
+    result.radiance = vec4f(color, min(65504.0,sample_variance/age));
+    result.age = age;
+    result.short_luma = select(short_luma, rgb_to_luminance(color), rectified);
+    return result;
+}
+`, [chunk_rgb_to_luminance, chunk_decode_g_buffer_normal, chunk_is_finite, chunk_decode_g_buffer_roughness,
+    chunk_project_position_from_depth, chunk_texel_coordinate_to_uv, chunk_get_view_space_depth, chunk_is_background]);

package/src/shade/renderer/postprocess/ssr/ssr_reproject_shader.d.ts

@@ -1,11 +1,3 @@
-/**
- * Note: result will be in YCoCg color space
- * @see https://projects.blender.org/blender/blender/src/commit/866ef5b468589587395b1ee7480ea75b4c0fbc26/source/blender/draw/engines/eevee_next/shaders/eevee_film_lib.glsl#L340
- * @see https://github.com/GameTechDev/TAA/blob/39786709cf70a1e0906196c600f6079571a33ceb/MiniEngine/Core/Shaders/TAAResolve.hlsl#L472
- * @type {CodeChunk}
- */
-export const chunk_ssr_history_color_bounding_box_YCoCg: CodeChunk;
 export const ssr_reproject_shader: ImageShader;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ImageShader } from "../../shader/ImageShader.js";
 //# sourceMappingURL=ssr_reproject_shader.d.ts.map

package/src/shade/renderer/postprocess/ssr/ssr_reproject_shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssr_reproject_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/ssr_reproject_shader.js"],"names":[],"mappings":"AAuCA;;;;;GAKG;AACH,yDAFU,SAAS,CA+ElB;AA2ED,+CAGG;0BAjMuB,oCAAoC;4BAClC,6BAA6B"}
+{"version":3,"file":"ssr_reproject_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/ssr_reproject_shader.js"],"names":[],"mappings":"AAqGA,+CAGG;4BAlGyB,6BAA6B"}

package/src/shade/renderer/postprocess/ssr/ssr_reproject_shader.js

@@ -1,6 +1,4 @@
 import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
-import { chunk_aabb3_normalized_dist } from "../../shader/chunk/geometry/aabb3/chunk_line_aabb3_clipping_distance.js";
-import { chunk_get_std_dev3 } from "../../shader/chunk/math/statistics/chunk_get_std_dev3.js";
 import { chunk_screen_coordinate_to_world } from "../../shader/chunk/camera/chunk_screen_coordinate_to_world.js";
 import { chunk_get_view_space_depth } from "../../shader/chunk/depth/chunk_get_view_space_depth.js";
 import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
@@ -11,13 +9,12 @@ import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourc
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { f32, u32, vec2f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { chunk_color_clip_to_aabb3 } from "../taa/chunk_color_clip_to_aabb3.js";
-import { chunk_taa_decode_color } from "../taa/chunk_taa_decode_color.js";
-import { chunk_taa_encode_color } from "../taa/chunk_taa_encode_color.js";
-import { chunk_taa_velocity_confidence, chunk_taa_velocity_variance_scale } from "../taa/shader_taa.js";
+import { chunk_taa_velocity_confidence } from "../taa/shader_taa.js";
 import { chunk_depth_clip_offset_codec } from "../taa/chunk_depth_clip_offset_codec.js";
 import { chunk_ssr_reprojection } from "./reproject/chunk_ssr_reprojection.js";
 import { chunk_ssr_sample_history } from "./reproject/chunk_ssr_sample_history.js";
+import { chunk_ssr_temporal_accumulate } from "./reproject/chunk_ssr_temporal_accumulate.js";
+import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
 
 const settings = WebGPUStruct.from({ history_validity: f32, reprojection_mode: u32, jitter_delta: vec2f });
 const resources = new ShaderResourceSetDescriptor();
@@ -37,96 +34,10 @@ resources.createGroup()
     .addUniform("camera_current", CAMERA_UNIFORM_STRUCT)
     .addUniform("camera_previous", CAMERA_UNIFORM_STRUCT);
 
-/**
- * Note: result will be in YCoCg color space
- * @see https://projects.blender.org/blender/blender/src/commit/866ef5b468589587395b1ee7480ea75b4c0fbc26/source/blender/draw/engines/eevee_next/shaders/eevee_film_lib.glsl#L340
- * @see https://github.com/GameTechDev/TAA/blob/39786709cf70a1e0906196c600f6079571a33ceb/MiniEngine/Core/Shaders/TAAResolve.hlsl#L472
- * @type {CodeChunk}
- */
-export const chunk_ssr_history_color_bounding_box_YCoCg = CodeChunk.from(
-    //language=WGSL
-    `
-fn ssr_history_color_bounding_box_YCoCg(
-    current_color_texture: texture_2d<f32>,
-    in_current_colour_variance:vec4<f32>,
-    in_screen_st:vec2<i32>,
-    
-    in_variance_gamma: f32,
-   
-    out_min_c: ptr< function, vec3<f32> >,
-    out_max_c: ptr< function, vec3<f32> >,
-) {
-    
-    const offsets = array< vec2<i32>,8>(
-      vec2( -1, -1 ),
-      vec2(  0, -1 ),
-      vec2(  1, -1 ), 
-      
-      vec2( -1,  0 ), 
-      vec2(  1,  0 ), 
-      
-      vec2( -1,  1 ),
-      vec2(  0,  1 ), 
-      vec2(  1,  1 ), 
-   );
-    
-    const iteratorMax = 8;
-    const rcp_divider = 1.f / 9.f;
-
-    // calcluate mean value (mean) and standard deviation (variance)
-
-    var moment1 = in_current_colour_variance.rgb;
-    var moment2 = moment1*moment1;
-    var source_variance = in_current_colour_variance.w;
-    
-    for (var  i = 0; i < iteratorMax; i++ ) {
-        let new_st = clamp(in_screen_st + offsets[i], vec2i(0), vec2i(textureDimensions(current_color_texture)) - 1);
-        
-        let texel = textureLoad( current_color_texture, new_st, 0 );
-        let new_colour = taa_encode_color( texel.rgb );
-        
-        moment1 += new_colour;
-        moment2 += new_colour*new_colour;
-        
-        source_variance += texel.w;
-    }
-    
-    source_variance *= rcp_divider;
-    
-    // get resolve-stage standard deviation
-    let source_std_dev = sqrt(source_variance);
-
-    // Apply perceptual weighting to variance.
-    // Y (Luma) is critical for structural sharpness -> Keep strict (1.0x).
-    // Co/Cg (Chroma) is less noticeable to human perception -> Relax to prevent color flickering/desaturation.
-    // Cg (green) has stronger visual response than Co (orange) to human perception
-    const variance_scale = vec3(1.0, 1.4, 1.2);
-    
-    // Apply the base gamma to the perceptual scale
-    let final_sigma = variance_scale * in_variance_gamma * (1 + source_std_dev);
-    
-    let mean = moment1 * rcp_divider;
-    let std_dev = get_std_dev3(mean, moment2 * rcp_divider );
-    
-    let sigma = std_dev * final_sigma;
-        
-    *out_min_c = mean - sigma;
-    *out_max_c = mean + sigma;
-        
-}
-    `,
-    [
-        chunk_get_std_dev3,
-        chunk_taa_decode_color,
-        chunk_taa_encode_color,
-    ]
-)
-
-
 const body = CodeChunk.from(/* language=WGSL */ `
 struct SSRTemporalOutput {
     @location(0) radiance: vec4f,
-    @location(1) metadata: vec2f,
+    @location(1) metadata: vec4f,
     @location(2) geometry: vec4f,
 }
 
@@ -139,7 +50,7 @@ fn main(@builtin(position) coord: vec4f) -> SSRTemporalOutput {
     let roughness = decode_g_buffer_roughness(textureLoad(tPBR, st, 0));
     var output: SSRTemporalOutput;
     output.radiance = current;
-    output.metadata = metadata;
+    output.metadata = vec4f(metadata, 1.0, rgb_to_luminance(current.rgb));
     output.geometry = vec4f(normal, roughness);
     let depth = textureLoad(tDepth, st, 0).r;
     // A reset must never read history, even when stale textures contain non-finite values.
@@ -153,9 +64,11 @@ fn main(@builtin(position) coord: vec4f) -> SSRTemporalOutput {
     var history: SSRHistorySample;
     var confidence = 0.0;
     var motion_confidence = 1.0;
-    let virtual_eligible = settings.reprojection_mode != 1u && metadata.y >= 0.75 && metadata.x > 0.0 && is_finite(metadata.x) && roughness <= 0.2;
+    var history_uv = vec2f(0.0);
+    let virtual_eligible = settings.reprojection_mode != 1u && metadata.y >= 0.5 && metadata.x > 0.0 && is_finite(metadata.x) && roughness <= 0.2;
     if (virtual_eligible) {
         let uv = ssr_history_uv(virtual_position, camera_previous.view_projection_matrix);
+        history_uv = uv;
         history = ssr_sample_history(uv, position, normal, roughness, metadata, virtual_position, true, plane_tolerance);
         confidence = history.confidence;
     }
@@ -165,37 +78,28 @@ fn main(@builtin(position) coord: vec4f) -> SSRTemporalOutput {
         let surface_confidence = textureLoad(tOcclusion, st, 0).r * motion_confidence;
         if (surface_confidence <= 0.001) { return output; }
         let uv = ssr_surface_history_uv(coord.xy, velocity, settings.jitter_delta, size);
+        history_uv = uv;
         history = ssr_sample_history(uv, position, normal, roughness, metadata, virtual_position, false, plane_tolerance);
         confidence = history.confidence * surface_confidence;
+        confidence *= ssr_surface_parallax_confidence(camera_position,position,metadata.x,camera_previous.view_projection_matrix,size);
         // Surface correspondence alone cannot justify a long history for a smooth finite reflection.
         if (virtual_eligible) { confidence *= 0.25; }
     }
     if (confidence <= 0.001) { return output; }
 
-    let current_color = taa_encode_color(current.rgb);
-    let history_color = taa_encode_color(history.radiance.rgb);
-    var min_c: vec3f;
-    var max_c: vec3f;
-    ssr_history_color_bounding_box_YCoCg(tInput, vec4f(current_color, current.w), st,
-        2.0 * taa_velocity_variance_scale(motion_confidence), &min_c, &max_c);
-    let clipped = color_clip_to_aabb3(history_color, current_color, min_c, max_c);
-    let tension = saturate(aabb3_normalized_dist_from_center(current_color, clipped, min_c, max_c));
-    let blend = 0.05 * mix(0.2, 1.0, tension * tension);
-    // Geometry cannot see motion of the reflected object. Respond to radiance disagreement too.
-    let difference = length(history_color - current_color);
-    let reactive = 1.0 / (1.0 + 16.0 * difference);
-    let weight = ssr_history_weight(current.w, history.radiance.w, blend, confidence * reactive);
-    output.radiance = vec4f(taa_decode_color(mix(current_color, clipped, weight)),
-        mix(current.w, history.radiance.w, weight));
+    let accumulated = ssr_temporal_accumulate(current, history.radiance, history.age,
+        history.short_luma, confidence, motion_confidence, st, history_uv);
+    output.radiance = accumulated.radiance;
+    output.metadata.z = accumulated.age;
+    output.metadata.w = accumulated.short_luma;
     return output;
 }
 `, [chunk_ssr_reprojection, chunk_ssr_sample_history, chunk_screen_coordinate_to_world,
     chunk_get_view_space_depth, chunk_decode_g_buffer_normal, chunk_decode_g_buffer_roughness,
-    chunk_depth_clip_offset_codec, chunk_taa_encode_color, chunk_taa_decode_color,
-    chunk_ssr_history_color_bounding_box_YCoCg, chunk_color_clip_to_aabb3,
-    chunk_aabb3_normalized_dist, chunk_taa_velocity_confidence, chunk_taa_velocity_variance_scale]);
+    chunk_depth_clip_offset_codec, chunk_taa_velocity_confidence,
+    chunk_ssr_temporal_accumulate, chunk_rgb_to_luminance]);
 
 export const ssr_reproject_shader = new ImageShader({
     descriptor: ShaderDescriptor.from({ label: "SSR Reproject", body, resources }),
-    targets: [{ format: "rgba16float" }, { format: "rg32float" }, { format: "rgba16float" }],
+    targets: [{ format: "rgba16float" }, { format: "rgba32float" }, { format: "rgba16float" }],
 });

package/src/shade/renderer/scene/Mesh.js

@@ -4,7 +4,7 @@ import { aabb3_from_v3_array_transformed } from "../../../core/geom/3d/aabb/aabb
 import { aabb3_matrix4_project } from "../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
 import { sphere_matrix4_transform } from "../../../core/geom/3d/sphere/sphere_matrix4_transform.js";
 import { epsilonEquals } from "../../../core/math/epsilonEquals.js";
-import { optional_equality } from "../../descriptor/util/optional_equality.js";
+import { optional_equality } from "../../../core/model/object/optional_equality.js";
 import { StandardAttributes } from "../geometry/StandardAttributes.js";
 import { Node3D } from "./Node3D.js";
 

package/src/shade/renderer/texture/ShadeTexture.js

@@ -1,6 +1,6 @@
 import { assert } from "../../../core/assert.js";
 import { combine_hash } from "../../../core/collection/array/combine_hash.js";
-import { optional_hash } from "../../descriptor/util/optional_hash.js";
+import { optional_hash } from "../../../core/model/object/optional_hash.js";
 import { ShadeTextureFlags } from "./ShadeTextureFlags.js";
 import { TextureFilterType } from "./TextureFilterType.js";
 import { TextureWrapType } from "./TextureWrapType.js";

package/src/shade/renderer/texture/source/texel_data_from_ktx2.d.ts

@@ -21,12 +21,12 @@
  * @param {ArrayBuffer|Uint8Array} bytes the whole file
  * @param {TextureFormat|TextureFormat[]} [transcode_target] what a Basis payload should become — see
  * {@link ktx2_read}, which owns the rules
- * @returns {ShadeTexelData}
+ * @returns {Promise<ShadeTexelData>}
  * @throws {Error} everything {@link ktx2_read} throws, a partial mip chain, and an array or cube map
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function texel_data_from_ktx2(bytes: ArrayBuffer | Uint8Array, transcode_target?: TextureFormat | TextureFormat[]): ShadeTexelData;
+export function texel_data_from_ktx2(bytes: ArrayBuffer | Uint8Array, transcode_target?: TextureFormat | TextureFormat[]): Promise<ShadeTexelData>;
 import { ShadeTexelData } from "./ShadeTexelData.js";
 //# sourceMappingURL=texel_data_from_ktx2.d.ts.map

package/src/shade/renderer/texture/source/texel_data_from_ktx2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texel_data_from_ktx2.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/source/texel_data_from_ktx2.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4CATW,WAAW,GAAC,UAAU,qBACtB,gBAAc,eAAe,GAE3B,cAAc,CAqB1B;+BA9C8B,qBAAqB"}
+{"version":3,"file":"texel_data_from_ktx2.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/source/texel_data_from_ktx2.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4CATW,WAAW,GAAC,UAAU,qBACtB,gBAAc,eAAe,GAE3B,QAAQ,cAAc,CAAC,CAqBnC;+BA9C8B,qBAAqB"}

package/src/shade/renderer/texture/source/texel_data_from_ktx2.js

@@ -24,14 +24,14 @@ import { ShadeTexelData } from "./ShadeTexelData.js";
  * @param {ArrayBuffer|Uint8Array} bytes the whole file
  * @param {TextureFormat|TextureFormat[]} [transcode_target] what a Basis payload should become — see
  * {@link ktx2_read}, which owns the rules
- * @returns {ShadeTexelData}
+ * @returns {Promise<ShadeTexelData>}
  * @throws {Error} everything {@link ktx2_read} throws, a partial mip chain, and an array or cube map
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function texel_data_from_ktx2(bytes, transcode_target = undefined) {
-    const payload = ktx2_read(bytes, transcode_target);
+export async function texel_data_from_ktx2(bytes, transcode_target = undefined) {
+    const payload = await ktx2_read(bytes, transcode_target);
 
     if (payload.layers > 1 || payload.faces > 1) {
         throw new Error(

package/src/shade/renderer/particles/shaders/chunk_particle_curve_animation.d.ts

@@ -1,19 +0,0 @@
-/**
- * Production implementation of the VM `CURVE` opcode's `particle_vm_sample_curve(handle, t)`, backed
- * by the engine's existing AnimationCurve GPU path — no reinvention. It reads the curve header from
- * the `animation_curves` GPUDatabase table by handle and evaluates it with the same
- * `animation_curve_evaluate` cubic-Hermite chunk the skeletal animation system uses.
- *
- * This is the "reuse meep's AnimationCurve" + "GPUDatabase where relevant" integration: an effect
- * author registers a curve via `GPUAnimationManager.register_curve(curve)` (or `add_curve`), gets a
- * handle, references it from a `curve` node, and the simulation samples it on the GPU.
- *
- * The simulate shader that includes this chunk must also bind `particle_curve_database :
- * array<u32>` to `GPUAnimationManager.database.buffer` (in place of the no-op
- * {@link ./chunk_particle_curve_disabled.js} provider used when no effect uses curves).
- *
- * @type {CodeChunk}
- */
-export const chunk_particle_curve_animation: CodeChunk;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_particle_curve_animation.d.ts.map

package/src/shade/renderer/particles/shaders/chunk_particle_curve_animation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_particle_curve_animation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_curve_animation.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;GAeG;AACH,6CAFU,SAAS,CAS0C;0BA3BnC,oCAAoC"}

package/src/shade/renderer/particles/shaders/chunk_particle_curve_animation.js

@@ -1,30 +0,0 @@
-import { ANIMATION_DATABASE_SPEC } from "../../animation/ANIMATION_DATABASE_SPEC.js";
-import { chunk_animation_curve_evaluate } from "../../animation/chunk_animation_curve_evaluate.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-
-const CURVE_TABLE = ANIMATION_DATABASE_SPEC.get("animation_curves");
-
-/**
- * Production implementation of the VM `CURVE` opcode's `particle_vm_sample_curve(handle, t)`, backed
- * by the engine's existing AnimationCurve GPU path — no reinvention. It reads the curve header from
- * the `animation_curves` GPUDatabase table by handle and evaluates it with the same
- * `animation_curve_evaluate` cubic-Hermite chunk the skeletal animation system uses.
- *
- * This is the "reuse meep's AnimationCurve" + "GPUDatabase where relevant" integration: an effect
- * author registers a curve via `GPUAnimationManager.register_curve(curve)` (or `add_curve`), gets a
- * handle, references it from a `curve` node, and the simulation samples it on the GPU.
- *
- * The simulate shader that includes this chunk must also bind `particle_curve_database :
- * array<u32>` to `GPUAnimationManager.database.buffer` (in place of the no-op
- * {@link ./chunk_particle_curve_disabled.js} provider used when no effect uses curves).
- *
- * @type {CodeChunk}
- */
-export const chunk_particle_curve_animation = CodeChunk.from(
-    /* language=wgsl */
-    `
-fn particle_vm_sample_curve(handle : u32, t : f32) -> f32 {
-    let header = ${CURVE_TABLE.marshalling_method_read}(&particle_curve_database, handle);
-    return animation_curve_evaluate(t, &particle_curve_database, header);
-}
-`, [CURVE_TABLE.chunk_read, chunk_animation_curve_evaluate]);

package/src/shade/renderer/particles/shaders/chunk_particle_curve_disabled.d.ts

@@ -1,11 +0,0 @@
-/**
- * Default curve provider: no curves bound, `CURVE` opcodes evaluate to 0. The production feature
- * swaps this for an animation-database-backed provider
- * ({@link ./chunk_particle_curve_animation.js}). Kept separate so an effect that uses no curves
- * compiles without any animation bindings.
- *
- * @type {CodeChunk}
- */
-export const chunk_particle_curve_disabled: CodeChunk;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_particle_curve_disabled.d.ts.map

package/src/shade/renderer/particles/shaders/chunk_particle_curve_disabled.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_particle_curve_disabled.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_curve_disabled.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,4CAFU,SAAS,CAIhB;0BAZuB,oCAAoC"}

package/src/shade/renderer/particles/shaders/chunk_particle_curve_disabled.js

@@ -1,13 +0,0 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-
-/**
- * Default curve provider: no curves bound, `CURVE` opcodes evaluate to 0. The production feature
- * swaps this for an animation-database-backed provider
- * ({@link ./chunk_particle_curve_animation.js}). Kept separate so an effect that uses no curves
- * compiles without any animation bindings.
- *
- * @type {CodeChunk}
- */
-export const chunk_particle_curve_disabled = CodeChunk.from(/* wgsl */ `
-fn particle_vm_sample_curve(handle : u32, t : f32) -> f32 { return 0.0; }
-`);

package/src/shade/renderer/particles/shaders/chunk_particle_emitter_warmup.d.ts

@@ -1,20 +0,0 @@
-/**
- * How many seconds of simulation this frame's newborns of an emitter owe before they may be shown,
- * as the tick pass left it this frame.
- *
- * Zero on all but one frame of an emitter's life. The tick writes the emitter's `prewarm` here on
- * the row's first tick and zero on every tick after, so a newborn asks this rather than asking the
- * record's `prewarm` directly: the record says how long the emitter wants pre-warming *for*, and
- * only the tick knows *whether this is that frame* — it is the generation comparison, and by the
- * time the emit pass runs the tick has already made the two generations agree.
- *
- * Read off the `emitter_state` table of the same database the emitter record came from
- * ({@link ../data/PARTICLE_EMITTER_STATE.js}), through the table's single-field reader, exactly as
- * {@link ./chunk_particle_emitter_age.js} reads the age beside it — one binding for both, and no
- * second copy of the row layout here to drift from the table's.
- *
- * @type {CodeChunk}
- */
-export const chunk_particle_emitter_warmup: CodeChunk;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_particle_emitter_warmup.d.ts.map

package/src/shade/renderer/particles/shaders/chunk_particle_emitter_warmup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_particle_emitter_warmup.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_emitter_warmup.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,4CAFU,SAAS,CAMgD;0BAxBzC,oCAAoC"}

package/src/shade/renderer/particles/shaders/chunk_particle_emitter_world_sphere.d.ts

@@ -1,14 +0,0 @@
-/**
- * An emitter's bounds sphere in world space: the centre through the node's matrix, the radius
- * scaled by the largest axis scale the matrix carries.
- *
- * The axes are read as transformed unit vectors rather than as matrix columns — the same numbers,
- * in a form the WGSL emulator also evaluates. Shared by the tick pass (frustum culling of spawning)
- * and the AVBOIT occupancy pass (which depth slices the emitter's particles can reach), so both
- * test the same sphere.
- *
- * @type {CodeChunk}
- */
-export const chunk_particle_emitter_world_sphere: CodeChunk;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_particle_emitter_world_sphere.d.ts.map

package/src/shade/renderer/particles/shaders/chunk_particle_emitter_world_sphere.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_particle_emitter_world_sphere.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_emitter_world_sphere.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,kDAFU,SAAS,CAUU;0BAtBH,oCAAoC"}

package/src/shade/renderer/particles/shaders/shader_particle_reclaim.d.ts

@@ -1,50 +0,0 @@
-/**
- * Return to the free list the slots the emit pass's pre-warm killed.
- *
- * A newborn of a pre-warming emitter runs its UPDATE program forward before it is shown
- * ({@link ./chunk_particle_emit_step.js}), and one whose life runs out during that never belongs on
- * the alive list. Its slot has to go back to the free list, and this pass is where that happens.
- *
- * ## Why it is a pass of its own
- *
- * Because emit is the one pass that POPS the free list, and a push racing a pop on an array stack
- * hands one slot to two particles.
- *
- * The pop is `old = atomicSub(DEAD, 1)` followed by a read of `dead[old - 1]`; a push would be
- * `d = atomicAdd(DEAD, 1)` followed by a write to `dead[d]`. Order one thread's `atomicSub` before
- * another's `atomicAdd` and the two name the same index, with nothing between the atomic and the
- * plain access to order them. If the write lands first, the popper takes the pushed slot AND leaves
- * it on the stack under a count that now includes it — so the next popper takes it again, and two
- * live particles share one record. That is precisely the failure the build-indirect pass warns about
- * for a different reason, and it is why the emit pass writes to `dead` nowhere: even its
- * pool-exhaustion path only ever puts the counter back.
- *
- * Between two dispatches there is no such race. This pass only pushes; nothing in it pops.
- *
- * ## Where the slots are between the two
- *
- * At the far end of `alive_out`, growing down from `capacity`, counted by
- * {@link PARTICLE_COUNTER.STILLBORN}. A region of a buffer emit already binds, rather than a list of
- * its own: emit binds exactly the eight storage buffers a compute stage gets by default, and a ninth
- * for a list that is empty on all but a handful of frames is not what the ninth is for.
- *
- * The park cannot collide with the alive list growing up from zero. Every entry in either is a
- * distinct pool slot and a parked one is by definition not alive, so the two lengths sum to at most
- * the `capacity` entries between them.
- *
- * ## Sizing
- *
- * A bounded launch with a grid-stride loop, the shape the wide interpreter uses and for the same
- * reason: the length it walks is a GPU-side count. Nothing about it is sized from the host, and the
- * dispatch costs one atomic load and an exit on the frames — nearly all of them — where nothing was
- * parked.
- *
- * @type {ComputeShader}
- */
-/** Workgroups this pass dispatches. Constant: the launch does not depend on how many slots were parked. */
-export const PARTICLE_RECLAIM_WORKGROUP_COUNT: number;
-export const shader_particle_reclaim: ComputeShader;
-export { PARTICLE_RECLAIM_WORKGROUP_SIZE };
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { PARTICLE_RECLAIM_WORKGROUP_SIZE } from "../ParticleConstants.js";
-//# sourceMappingURL=shader_particle_reclaim.d.ts.map

package/src/shade/renderer/particles/shaders/shader_particle_reclaim.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader_particle_reclaim.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_reclaim.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,2GAA2G;AAC3G,sDAAyG;AAWzG,oDAqBG;;8BAnF2B,+BAA+B;gDAGW,yBAAyB"}

package/src/shade/renderer/postprocess/ssr/reproject/shader_ffx_denoiser_reflections_reproject.d.ts

@@ -1,17 +0,0 @@
-/**
- * An unfinished translation of the FidelityFX reflection denoiser's reprojection pass.
- *
- * Not yet a shader, and not yet valid WGSL: the body still carries HLSL spellings the port has not
- * reached (`FfxFloat16x4`, `FfxInt32x2`, `FFX_GROUP_MEMORY_BARRIER`), and `main` is an empty stub
- * with no `@compute` and no `@workgroup_size`. It was a `ComputeShader` here until the workgroup
- * size started being read out of the WGSL, which is a question this source cannot answer; it stays
- * a chunk until someone finishes the port and writes the entry point.
- *
- * The bindings it will want are one texture, `tRadiance`.
- *
- * @see https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/1bbe66e7ea0d358e84af4471a90aa9c35b583de0/sdk/include/FidelityFX/gpu/denoiser/ffx_denoiser_reflections_reproject.h
- * @type {CodeChunk}
- */
-export const chunk_ffx_denoiser_reflections_reproject: CodeChunk;
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=shader_ffx_denoiser_reflections_reproject.d.ts.map

package/src/shade/renderer/postprocess/ssr/reproject/shader_ffx_denoiser_reflections_reproject.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader_ffx_denoiser_reflections_reproject.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/reproject/shader_ffx_denoiser_reflections_reproject.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,uDAFU,SAAS,CAubjB;0BArcwB,uCAAuC"}