@woosh/meep-engine 3.64.1 → 3.67.0

package/src/shade/renderer/postprocess/eye/shader_autoexposure_adapt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_autoexposure_adapt.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/eye/shader_autoexposure_adapt.js"],"names":[],"mappings":"AASA,sDAsBE;AA+FF,sDAIG;6BAjI0B,mCAAmC;8BAElC,+BAA+B"}
+{"version":3,"file":"shader_autoexposure_adapt.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/eye/shader_autoexposure_adapt.js"],"names":[],"mappings":"AASA,sDAsBE;AAkGF,sDAIG;6BApI0B,mCAAmC;8BAElC,+BAA+B"}

package/src/shade/renderer/postprocess/eye/shader_autoexposure_adapt.js

@@ -41,6 +41,7 @@ resources.createGroup()
     .addUniform("previous", F32_CONTAINER_STRUCT)
     .addStorageBuffer("adapted", F32_CONTAINER_STRUCT, true)
     .addStorageBuffer("out_multiplier", F32_CONTAINER_STRUCT, true)
+    .addStorageBuffer("out_adaptation", F32_CONTAINER_STRUCT, true)
 ;
 
 
@@ -64,6 +65,7 @@ fn main(){
     */
     if (!(goal.value > 0.0)) {
         adapted.value = previous.value;
+        out_adaptation.value = previous.value;
 
         out_multiplier.value = (MIDDLE_GREY / current_linear) * exp2(settings.compensation);
 
@@ -113,7 +115,8 @@ fn main(){
     // convert back to linear space
     let new_linear = exp2(new_ev);
     adapted.value = new_linear;
-    
+    out_adaptation.value = new_linear;
+
     // apply final transforms
 
     let shifted = MIDDLE_GREY / adapted.value;

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_add_per_object_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js"],"names":[],"mappings":"AAkRA;;;;GAIG;AACH,+DAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAhB4B,KAAK;IACT,aAAa,EAA1B,MAAM;IACO,kBAAkB,EAA/B,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,mBAAmB,EAAhC,MAAM;IACO,4BAA4B,EAAzC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACQ,eAAe,EAA7B,OAAO;IAGQ,UAAU,EAAzB,MAAM,EAAE;IACa,IAAI;IACvB,MAAM,CA8ElB;8BAhXY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"graph_add_per_object_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js"],"names":[],"mappings":"AA8QA;;;;GAIG;AACH,+DAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAhB4B,KAAK;IACT,aAAa,EAA1B,MAAM;IACO,kBAAkB,EAA/B,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,mBAAmB,EAAhC,MAAM;IACO,4BAA4B,EAAzC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACQ,eAAe,EAA7B,OAAO;IAGQ,UAAU,EAAzB,MAAM,EAAE;IACa,IAAI;IACvB,MAAM,CA+DlB;8BA9VY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js

@@ -1,6 +1,4 @@
 import { assert } from "../../../../core/assert.js";
-import { m4_invert } from "../../../../core/geom/3d/mat4/m4_invert.js";
-import { m4_multiply } from "../../../../core/geom/3d/mat4/m4_multiply.js";
 import { mat4x4f, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
 import { U32_CONTAINER_STRUCT } from "../../shader/type/U32_CONTAINER_STRUCT.js";
@@ -33,6 +31,7 @@ import { ImageShader } from "../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
 import { construct_pixel_reprojection_matrix } from "./construct_pixel_reprojection_matrix.js";
+import { view_velocity_matrices } from "./view_velocity_matrices.js";
 import {
     construct_reprojection_matrix_rotation_only,
 } from "./construct_reprojection_matrix.js";
@@ -266,9 +265,6 @@ const shader = new ImageShader({
     }]
 });
 
-const scratch_unjit_view_proj_curr_f64 = new Float64Array(16);
-const scratch_unjit_view_proj_prev_f64 = new Float64Array(16);
-const scratch_unjit_inv_view_proj_curr_f64 = new Float64Array(16);
 const scratch_unjit_view_proj_prev_f32 = new Float32Array(16);
 const scratch_unjit_inv_view_proj_curr_f32 = new Float32Array(16);
 
@@ -359,24 +355,9 @@ export function graph_add_per_object_velocity({
     const current_camera = view.camera.camera;
     const previous_camera = view.gpu_previous_camera_state.camera;
 
-    // Un-jittered current-frame inverse view-projection (for
-    // unprojecting depth → world without folding in jitter shift).
-    m4_multiply(
-        scratch_unjit_view_proj_curr_f64,
-        current_camera.projection_matrix,
-        current_camera.view_matrix
-    );
-    m4_invert(scratch_unjit_inv_view_proj_curr_f64, scratch_unjit_view_proj_curr_f64);
-
-    // Un-jittered previous-frame view-projection.
-    m4_multiply(
-        scratch_unjit_view_proj_prev_f64,
-        previous_camera.projection_matrix,
-        previous_camera.view_matrix
-    );
-
-    scratch_unjit_inv_view_proj_curr_f32.set(scratch_unjit_inv_view_proj_curr_f64);
-    scratch_unjit_view_proj_prev_f32.set(scratch_unjit_view_proj_prev_f64);
+    // Un-jittered: this frame's inverse view-projection (depth → world without the jitter's shift)
+    // and last frame's view-projection.
+    view_velocity_matrices(view, scratch_unjit_inv_view_proj_curr_f32, scratch_unjit_view_proj_prev_f32);
 
     // Background rotation-only reprojection (pixel space).
     const reprojection_matrix_64 = new Float64Array(16);

package/src/shade/renderer/postprocess/velocity/view_velocity_matrices.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The two matrices a pass needs to say how far a pixel's surface moved on screen: this frame's inverse
+ * view-projection, to take a pixel and its depth to the world, and last frame's view-projection, to take
+ * where that point was back to the screen. Both are free of the sub-pixel jitter, as the velocity buffer
+ * is: a still surface has no velocity however the frame is jittered.
+ *
+ * @param {GPUViewContext} view
+ * @param {Float32Array} inverse_view_projection receives this frame's, 16 elements
+ * @param {Float32Array} view_projection_previous receives last frame's, 16 elements
+ */
+export function view_velocity_matrices(view: GPUViewContext, inverse_view_projection: Float32Array, view_projection_previous: Float32Array): void;
+//# sourceMappingURL=view_velocity_matrices.d.ts.map

package/src/shade/renderer/postprocess/velocity/view_velocity_matrices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view_velocity_matrices.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/view_velocity_matrices.js"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,sFAHW,YAAY,4BACZ,YAAY,QActB"}

package/src/shade/renderer/postprocess/velocity/view_velocity_matrices.js

@@ -0,0 +1,29 @@
+import { m4_invert } from "../../../../core/geom/3d/mat4/m4_invert.js";
+import { m4_multiply } from "../../../../core/geom/3d/mat4/m4_multiply.js";
+
+const scratch_view_projection = new Float64Array(16);
+const scratch_inverse = new Float64Array(16);
+
+/**
+ * The two matrices a pass needs to say how far a pixel's surface moved on screen: this frame's inverse
+ * view-projection, to take a pixel and its depth to the world, and last frame's view-projection, to take
+ * where that point was back to the screen. Both are free of the sub-pixel jitter, as the velocity buffer
+ * is: a still surface has no velocity however the frame is jittered.
+ *
+ * @param {GPUViewContext} view
+ * @param {Float32Array} inverse_view_projection receives this frame's, 16 elements
+ * @param {Float32Array} view_projection_previous receives last frame's, 16 elements
+ */
+export function view_velocity_matrices(view, inverse_view_projection, view_projection_previous) {
+    const current = view.camera.camera;
+    const previous = view.gpu_previous_camera_state.camera;
+
+    m4_multiply(scratch_view_projection, current.projection_matrix, current.view_matrix);
+    m4_invert(scratch_inverse, scratch_view_projection);
+
+    inverse_view_projection.set(scratch_inverse);
+
+    m4_multiply(scratch_view_projection, previous.projection_matrix, previous.view_matrix);
+
+    view_projection_previous.set(scratch_view_projection);
+}

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AA4DA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAuDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAiJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CA4M7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IA3B+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAGC,eAAe,GAAzC,eAAe;IAGsF,MAAM,EAA3G,OAAO,iEAAiE,EAAE,iBAAiB;IAGlE,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CAsTlB;+BAz9B8B,qBAAqB;gCAIpB,6CAA6C"}
+{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AA4DA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAuDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAiJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CA4M7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IA3B+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAGC,eAAe,GAAzC,eAAe;IAGsF,MAAM,EAA3G,OAAO,iEAAiE,EAAE,iBAAiB;IAGlE,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CA4UlB;+BA/+B8B,qBAAqB;gCAIpB,6CAA6C"}

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js

@@ -867,6 +867,28 @@ export function graph_rasterize_meshes_transparent_avboit({
         label: `${view_ctx.label}/AVBOIT-double`,
     });
 
+    // The meshes' fragments pick the probes around them, which no pixel of the G-buffer asked for: their meshlets
+    // ask, for the frame after. A bucket of no material lists none.
+    if (material_count_front > 0) {
+        probes.graph_want_meshlets({
+            graph,
+            scene: scene_ctx,
+            camera: gr_camera,
+            meshlet_collection: prep_front.meshlet_collection,
+            meshlet_iterator_command: prep_front.meshlet_iterator_command,
+        });
+    }
+
+    if (material_count_double > 0) {
+        probes.graph_want_meshlets({
+            graph,
+            scene: scene_ctx,
+            camera: gr_camera,
+            meshlet_collection: prep_double.meshlet_collection,
+            meshlet_iterator_command: prep_double.meshlet_iterator_command,
+        });
+    }
+
     // Occupancy and warp
     // ======
 

package/src/shade/renderer/scene/GPUSceneContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AA4EA;;;;;;;;;GASG;AACH;IAEI;;;;;;;OAOG;IACH,iCAFW,eAAe,QASzB;IA4KD;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAyCf;IAtND;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAOD;;;;;OAKG;IACH,yBAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA2ID;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,+CAEC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CA4DrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;;;OAKG;IACH,gEAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA6BD;;;;;OAKG;IACH,cAsEC;IAED;;;;;OAKG;IACH,YAFW,eAAe,QAyBzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAUD;;;;;;;;;;;OAWG;IACH,oBAHW,UAAU,GACR,MAAM,CAQlB;IAoCD;;;;;;;OAOG;IACH,gBAuBC;IAwCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAl3BY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;yBACzE,OAAO,2DAA2D,EAAE,UAAU;+BA5B5D,iDAAiD;sBAM1D,YAAY;oCAFE,uCAAuC;6BAC9C,yBAAyB;uBAH/B,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAMrC,wCAAwC;0CAlBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;+BAInD,2CAA2C;qCADrC,qDAAqD;oCAItD,qCAAqC;4BAC7C,gCAAgC;uCASrB,iDAAiD;6BAQ3D,wBAAwB;wCADb,mCAAmC;uCAlBpC,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AA4EA;;;;;;;;;GASG;AACH;IAEI;;;;;;;OAOG;IACH,iCAFW,eAAe,QASzB;IA4KD;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAyCf;IAtND;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAOD;;;;;OAKG;IACH,yBAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA2ID;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,+CAEC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CA4DrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;;;OAKG;IACH,gEAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA6BD;;;;;OAKG;IACH,cAsEC;IAED;;;;;OAKG;IACH,YAFW,eAAe,QA4BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAUD;;;;;;;;;;;OAWG;IACH,oBAHW,UAAU,GACR,MAAM,CAQlB;IAoCD;;;;;;;OAOG;IACH,gBAuBC;IAwCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAr3BY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;yBACzE,OAAO,2DAA2D,EAAE,UAAU;+BA5B5D,iDAAiD;sBAM1D,YAAY;oCAFE,uCAAuC;6BAC9C,yBAAyB;uBAH/B,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAMrC,wCAAwC;0CAlBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;+BAInD,2CAA2C;qCADrC,qDAAqD;oCAItD,qCAAqC;4BAC7C,gCAAgC;uCASrB,iDAAiD;6BAQ3D,wBAAwB;wCADb,mCAAmC;uCAlBpC,wCAAwC"}

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

@@ -723,6 +723,9 @@ export class GPUSceneContext {
         this.#light_probe_volume.update();
         this.#lights.update(ctx);
         this.#volumetrics.update(ctx, 0);
+
+        // what the frame before read is this frame's history; producers write after this
+        this.#wind.advance_frame();
         this.#wind.update();
 
         // Per-frame animation database flush — picks up any new clips,

package/src/shade/renderer/scene/GRASS_SURFACE_PARAMS_STRUCT.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The `lattice_bits` of a surface whose densest species has `density` blades a square metre, on surfels
+ * `finest_spacing` apart: the least whole number of doublings of a surfel's side that reaches the density.
+ *
+ * @param {number} density blades a square metre, above zero
+ * @param {number} finest_spacing metres
+ * @returns {number}
+ */
+export function grass_surface_lattice_bits(density: number, finest_spacing: number): number;
+/**
+ * What grows on a grass surface, taken over every species its members grow: a record of the scene
+ * database's `grass_surface_params` table, at the surface's own `transforms` row. A row nothing has written
+ * reads as zeros, a surface on which nothing grows.
+ *
+ * - `lattice_bits`: the surface's blade lattice has `2^lattice_bits` points along a side of a finest
+ *   surfel's square, the fewest that make the lattice as dense as the densest species.
+ * - `density`: the densest species' blades in a square metre.
+ * - `blade_length`, `blade_length_min`: the longest and the shortest species' blade, metres.
+ * - `blade_width_min`: the narrowest species' blade, metres.
+ * - `cover`: the greatest product of a species' density and its blade's width, a metre of blade a square
+ *   metre of ground.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_SURFACE_PARAMS_STRUCT: WebGPUStruct;
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=GRASS_SURFACE_PARAMS_STRUCT.d.ts.map

package/src/shade/renderer/scene/GRASS_SURFACE_PARAMS_STRUCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GRASS_SURFACE_PARAMS_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GRASS_SURFACE_PARAMS_STRUCT.js"],"names":[],"mappings":"AA2BA;;;;;;;GAOG;AACH,oDAJW,MAAM,kBACN,MAAM,GACJ,MAAM,CAIlB;AAlCD;;;;;;;;;;;;;;GAcG;AACH,0CAFU,YAAY,CASU;6BAxBH,gCAAgC"}

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

@@ -0,0 +1,38 @@
+import { f32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+
+/**
+ * What grows on a grass surface, taken over every species its members grow: a record of the scene
+ * database's `grass_surface_params` table, at the surface's own `transforms` row. A row nothing has written
+ * reads as zeros, a surface on which nothing grows.
+ *
+ * - `lattice_bits`: the surface's blade lattice has `2^lattice_bits` points along a side of a finest
+ *   surfel's square, the fewest that make the lattice as dense as the densest species.
+ * - `density`: the densest species' blades in a square metre.
+ * - `blade_length`, `blade_length_min`: the longest and the shortest species' blade, metres.
+ * - `blade_width_min`: the narrowest species' blade, metres.
+ * - `cover`: the greatest product of a species' density and its blade's width, a metre of blade a square
+ *   metre of ground.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_SURFACE_PARAMS_STRUCT = WebGPUStruct.from({
+    lattice_bits: u32,
+    density: f32,
+    blade_length: f32,
+    blade_length_min: f32,
+    blade_width_min: f32,
+    cover: f32,
+}, "GrassSurfaceParams").pack();
+
+/**
+ * The `lattice_bits` of a surface whose densest species has `density` blades a square metre, on surfels
+ * `finest_spacing` apart: the least whole number of doublings of a surfel's side that reaches the density.
+ *
+ * @param {number} density blades a square metre, above zero
+ * @param {number} finest_spacing metres
+ * @returns {number}
+ */
+export function grass_surface_lattice_bits(density, finest_spacing) {
+    return Math.max(0, Math.ceil(Math.log2(finest_spacing * Math.sqrt(density)) - 1e-9));
+}

package/src/shade/renderer/scene/MESH_GROUND_COVER_STRUCT.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A mesh row's membership of a grass surface: which surface it is ground of, what a column of that
+ * surface traces to find it, and what grows on it.
+ *
+ * A record of the scene database's `mesh_ground_covers` table, which shares the `meshes` table's index
+ * space: a row's ground cover is at the row's own index.
+ *
+ * **`flags` says what holds.** A row nothing has written, and a row on a page the table has never
+ * allocated, both read as a record of zeros, so zero flags is "not ground of any surface" and the other
+ * fields are read only when {@link MESH_GROUND_COVER_FLAG_MEMBER} is set.
+ */
+export const MESH_GROUND_COVER_STRUCT: WebGPUStruct;
+/**
+ * The row is a member of the surface its record names. Its faces are ground of that surface: they
+ * hold surfels, and they hide the ground of other members under them.
+ *
+ * @type {number}
+ */
+export const MESH_GROUND_COVER_FLAG_MEMBER: number;
+/**
+ * Something grows on the member, and its record's `species` holds. A member without it only hides
+ * ground.
+ *
+ * @type {number}
+ */
+export const MESH_GROUND_COVER_FLAG_GROWS: number;
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=MESH_GROUND_COVER_STRUCT.d.ts.map

package/src/shade/renderer/scene/MESH_GROUND_COVER_STRUCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MESH_GROUND_COVER_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/MESH_GROUND_COVER_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,oDA2B6B;AAE7B;;;;;GAKG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;;;;GAKG;AACH,2CAFU,MAAM,CAE8B;6BAxDjB,gCAAgC"}

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

@@ -0,0 +1,58 @@
+import { f32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+
+/**
+ * A mesh row's membership of a grass surface: which surface it is ground of, what a column of that
+ * surface traces to find it, and what grows on it.
+ *
+ * A record of the scene database's `mesh_ground_covers` table, which shares the `meshes` table's index
+ * space: a row's ground cover is at the row's own index.
+ *
+ * **`flags` says what holds.** A row nothing has written, and a row on a page the table has never
+ * allocated, both read as a record of zeros, so zero flags is "not ground of any surface" and the other
+ * fields are read only when {@link MESH_GROUND_COVER_FLAG_MEMBER} is set.
+ */
+export const MESH_GROUND_COVER_STRUCT = WebGPUStruct.from({
+    /**
+     * {@link MESH_GROUND_COVER_FLAG_MEMBER}, {@link MESH_GROUND_COVER_FLAG_GROWS}.
+     */
+    flags: u32,
+
+    /**
+     * The `transforms` row of the grass surface the mesh is a member of: the surface's frame.
+     */
+    surface: u32,
+
+    /**
+     * The geometry a column traces for this member. The mesh's own, or a stand-in's for a geometry
+     * that cannot be ray traced itself.
+     */
+    geometry: u32,
+
+    /**
+     * Index of the species that grows on the member. Read only when
+     * {@link MESH_GROUND_COVER_FLAG_GROWS} is set.
+     */
+    species: u32,
+
+    /**
+     * Scale on the member's painted density, 0 to 1.
+     */
+    density: f32,
+}, "MeshGroundCover").pack();
+
+/**
+ * The row is a member of the surface its record names. Its faces are ground of that surface: they
+ * hold surfels, and they hide the ground of other members under them.
+ *
+ * @type {number}
+ */
+export const MESH_GROUND_COVER_FLAG_MEMBER = 1;
+
+/**
+ * Something grows on the member, and its record's `species` holds. A member without it only hides
+ * ground.
+ *
+ * @type {number}
+ */
+export const MESH_GROUND_COVER_FLAG_GROWS = 2;

package/src/shade/renderer/scene/SCENE_DATABASE_SPEC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SCENE_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SCENE_DATABASE_SPEC.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,wDAYG;sCA1BmC,0CAA0C"}
+{"version":3,"file":"SCENE_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SCENE_DATABASE_SPEC.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,wDAkBG;sCAlCmC,0CAA0C"}

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

@@ -1,4 +1,6 @@
 import { GPUDatabaseDefinition } from "../buffer/table/GPUDatabaseDefinition.js";
+import { GRASS_SURFACE_PARAMS_STRUCT } from "./GRASS_SURFACE_PARAMS_STRUCT.js";
+import { MESH_GROUND_COVER_STRUCT } from "./MESH_GROUND_COVER_STRUCT.js";
 import { MESH_INSTANCE_METADATA_STRUCT } from "./MESH_INSTANCE_METADATA_STRUCT.js";
 import { MESH_OUTLINE_STRUCT } from "./MESH_OUTLINE_STRUCT.js";
 import { NODE3D_STRUCT } from "./NODE3D_STRUCT.js";
@@ -24,6 +26,12 @@ export const SCENE_DATABASE_SPEC = GPUDatabaseDefinition.from({
     // which outline specs a mesh row is drawn with, at the row's own index; written by OutlineSystem
     // when a row's specs change, read by the outline classify pass
     mesh_outlines: MESH_OUTLINE_STRUCT,
+    // which grass surface a mesh row is ground of, at the row's own index; written by GrassSurfaceSystem
+    // when a membership changes, read by the grass surface bake and by the blades that stand on it
+    mesh_ground_covers: MESH_GROUND_COVER_STRUCT,
+    // what grows on a grass surface, at the surface's own row; written by GrassSurfaceSystem, read by
+    // the passes that count and make its blades
+    grass_surface_params: GRASS_SURFACE_PARAMS_STRUCT,
 });
 
 SCENE_DATABASE_SPEC.add_link({ table: 'water_bodies', field: 'node', target_database: SCENE_DATABASE_SPEC,

package/src/shade/renderer/shader/chunk/color/conversion/chunk_CRM_REC709_AP1.d.ts

@@ -9,6 +9,12 @@ export const M3_REC709_TO_AP1: Float64Array;
  * @type {Float64Array}
  */
 export const M3_AP1_TO_REC709: Float64Array;
+/**
+ * AP1's contribution of each channel to Y, the row Unreal calls `AP1_RGB2Y`: the shader's `AP1_LUMINANCE`, for code that
+ * measures AP1 luma on the CPU.
+ * @type {Float64Array}
+ */
+export const AP1_LUMINANCE: Float64Array;
 /**
  * - `CRM_FROM_REC709_TO_AP1` and `CRM_FROM_AP1_TO_REC709`: {@link M3_REC709_TO_AP1} and its inverse.
  * - `AP1_LUMINANCE`: AP1's contribution of each channel to Y, the row Unreal calls `AP1_RGB2Y`.

package/src/shade/renderer/shader/chunk/color/conversion/chunk_CRM_REC709_AP1.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_CRM_REC709_AP1.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/conversion/chunk_CRM_REC709_AP1.js"],"names":[],"mappings":"AAqBA;;;;GAIG;AACH,+BAFU,YAAY,CAE8B;AAIpD;;;GAGG;AACH,+BAFU,YAAY,CAE8B;AAYpD;;;;;;;GAOG;AACH,mCAFU,SAAS,CASjB;0BAzDwB,gCAAgC"}
+{"version":3,"file":"chunk_CRM_REC709_AP1.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/conversion/chunk_CRM_REC709_AP1.js"],"names":[],"mappings":"AAqBA;;;;GAIG;AACH,+BAFU,YAAY,CAE8B;AAIpD;;;GAGG;AACH,+BAFU,YAAY,CAE8B;AAGpD;;;;GAIG;AACH,4BAFU,YAAY,CAEoE;AAW1F;;;;;;;GAOG;AACH,mCAFU,SAAS,CASjB;0BAhEwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/color/conversion/chunk_CRM_REC709_AP1.js

@@ -35,6 +35,13 @@ m3_multiply(M3_REC709_TO_AP1, XYZ_TO_AP1, M3_REC709_TO_AP1);
 export const M3_AP1_TO_REC709 = new Float64Array(9);
 m3_invert(M3_AP1_TO_REC709, M3_REC709_TO_AP1);
 
+/**
+ * AP1's contribution of each channel to Y, the row Unreal calls `AP1_RGB2Y`: the shader's `AP1_LUMINANCE`, for code that
+ * measures AP1 luma on the CPU.
+ * @type {Float64Array}
+ */
+export const AP1_LUMINANCE = Float64Array.of(AP1_TO_XYZ[3], AP1_TO_XYZ[4], AP1_TO_XYZ[5]);
+
 /**
  * @param {Float64Array} m row-major
  * @returns {string} a WGSL `mat3x3<f32>` constructor, column by column

package/src/shade/renderer/shader/chunk/color/grade/chunk_color_grade.d.ts

@@ -1,10 +1,10 @@
 /**
  * `color_grade(scene, grade, keys)`: exposed scene-linear Rec.709 through a {@link ColorGrade}, white balance, then
- * primaries, then hue curves, to Rec.709 again, not negative. `grade` is the grade's {@link COLOR_GRADE_STRUCT} and
- * `keys` the curves' keyframes. See `ColorGrade` for what each stage does.
+ * primaries, then saturation against luma, then hue curves, to Rec.709 again, not negative. `grade` is the grade's
+ * {@link COLOR_GRADE_STRUCT} and `keys` the curves' keyframes. See `ColorGrade` for what each stage does.
  *
- * Also defines each stage on its own: `color_grade_primaries(ap1, grade)` and
- * `color_grade_hue_curves(color, counts, keys)`.
+ * Also defines each stage on its own: `color_grade_primaries(ap1, grade)`,
+ * `color_grade_luma_saturation(ap1, counts, keys, first)` and `color_grade_hue_curves(color, counts, keys)`.
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/shader/chunk/color/grade/chunk_color_grade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_color_grade.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/grade/chunk_color_grade.js"],"names":[],"mappings":"AASA;;;;;;;;;GASG;AACH,gCAFU,SAAS,CA0HjB;0BAxIwB,gCAAgC"}
+{"version":3,"file":"chunk_color_grade.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/grade/chunk_color_grade.js"],"names":[],"mappings":"AASA;;;;;;;;;GASG;AACH,gCAFU,SAAS,CA2MjB;0BAzNwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/color/grade/chunk_color_grade.js

@@ -9,11 +9,11 @@ import { chunk_oklab_to_linear_srgb } from "../oklab/chunk_oklab_to_linear_srgb.
 
 /**
  * `color_grade(scene, grade, keys)`: exposed scene-linear Rec.709 through a {@link ColorGrade}, white balance, then
- * primaries, then hue curves, to Rec.709 again, not negative. `grade` is the grade's {@link COLOR_GRADE_STRUCT} and
- * `keys` the curves' keyframes. See `ColorGrade` for what each stage does.
+ * primaries, then saturation against luma, then hue curves, to Rec.709 again, not negative. `grade` is the grade's
+ * {@link COLOR_GRADE_STRUCT} and `keys` the curves' keyframes. See `ColorGrade` for what each stage does.
  *
- * Also defines each stage on its own: `color_grade_primaries(ap1, grade)` and
- * `color_grade_hue_curves(color, counts, keys)`.
+ * Also defines each stage on its own: `color_grade_primaries(ap1, grade)`,
+ * `color_grade_luma_saturation(ap1, counts, keys, first)` and `color_grade_hue_curves(color, counts, keys)`.
  *
  * @type {CodeChunk}
  */
@@ -65,6 +65,78 @@ fn color_grade_primaries(ap1: vec3<f32>, grade: ${COLOR_GRADE_STRUCT.wgsl_ref})
     return shadows * weight_shadows + midtones * weight_midtones + highlights * weight_highlights;
 }
 
+// each AP1 channel drawn away from the luma by its factor, read at the luma's stops from middle grey: the all-channel
+// curve times the channel's own; counts are the red, green, blue and all-channel curves' keys, in that order, starting
+// at key 'first'
+fn color_grade_luma_saturation(
+    ap1: vec3<f32>,
+    counts: vec4<u32>,
+    keys: ptr<storage, array<${ANIMATION_CURVE_KEYFRAME_STRUCT.wgsl_ref}>, read>,
+    first: u32,
+) -> vec3<f32> {
+    let luma = dot(ap1, AP1_LUMINANCE);
+
+    // a colour with no luma has no tonal place to read the curves at, and nothing to saturate
+    if (all(counts == vec4<u32>(0u)) || luma <= 0.0) {
+        return ap1;
+    }
+
+    let stops = log2(luma / 0.18);
+
+    var saturation = vec3<f32>(1.0);
+
+    if (counts.x > 0u) {
+        saturation.x = animation_curve_evaluate_keys(keys, first, counts.x, stops);
+    }
+    if (counts.y > 0u) {
+        saturation.y = animation_curve_evaluate_keys(keys, first + counts.x, counts.y, stops);
+    }
+    if (counts.z > 0u) {
+        saturation.z = animation_curve_evaluate_keys(keys, first + counts.x + counts.y, counts.z, stops);
+    }
+    if (counts.w > 0u) {
+        saturation *= animation_curve_evaluate_keys(keys, first + counts.x + counts.y + counts.z, counts.w, stops);
+    }
+
+    return max(vec3<f32>(0.0), mix(vec3<f32>(luma), ap1, saturation));
+}
+
+// each AP1 channel multiplied by its gain, and every channel by 2^exposure, read at the luma's stops from middle grey;
+// counts are the red, green and blue gain curves' keys and the exposure curve's, in that order, starting at key 'first'
+fn color_grade_luma_gain(
+    ap1: vec3<f32>,
+    counts: vec4<u32>,
+    keys: ptr<storage, array<${ANIMATION_CURVE_KEYFRAME_STRUCT.wgsl_ref}>, read>,
+    first: u32,
+) -> vec3<f32> {
+    let luma = dot(ap1, AP1_LUMINANCE);
+
+    // a colour with no luma has no tonal place to read the curves at
+    if (all(counts == vec4<u32>(0u)) || luma <= 0.0) {
+        return ap1;
+    }
+
+    let stops = log2(luma / 0.18);
+
+    var gain = vec3<f32>(1.0);
+    var exposure = 0.0;
+
+    if (counts.x > 0u) {
+        gain.x = animation_curve_evaluate_keys(keys, first, counts.x, stops);
+    }
+    if (counts.y > 0u) {
+        gain.y = animation_curve_evaluate_keys(keys, first + counts.x, counts.y, stops);
+    }
+    if (counts.z > 0u) {
+        gain.z = animation_curve_evaluate_keys(keys, first + counts.x + counts.y, counts.z, stops);
+    }
+    if (counts.w > 0u) {
+        exposure = animation_curve_evaluate_keys(keys, first + counts.x + counts.y + counts.z, counts.w, stops);
+    }
+
+    return max(vec3<f32>(0.0), ap1 * gain * exp2(exposure));
+}
+
 // hue shift, chroma scale and lightness against OkLCh hue; counts.xyz are the three curves' keys, in that order
 fn color_grade_hue_curves(
     color: vec3<f32>,
@@ -123,7 +195,16 @@ fn color_grade(
 ) -> vec3<f32> {
     let white_balance = mat3x3<f32>(grade.white_balance_c0.xyz, grade.white_balance_c1.xyz, grade.white_balance_c2.xyz);
 
-    let ap1 = color_grade_primaries(CRM_FROM_REC709_TO_AP1 * (white_balance * scene), grade);
+    let primaries = color_grade_primaries(CRM_FROM_REC709_TO_AP1 * (white_balance * scene), grade);
+
+    // the luma curves' keys follow the hue curves': saturation's, then gain's
+    let counts = grade.curve_counts;
+    let saturation_counts = grade.luma_curve_counts;
+    let hue_keys = counts.x + counts.y + counts.z;
+    let saturation_keys = saturation_counts.x + saturation_counts.y + saturation_counts.z + saturation_counts.w;
+
+    let gained = color_grade_luma_gain(primaries, grade.luma_gain_counts, keys, hue_keys + saturation_keys);
+    let ap1 = color_grade_luma_saturation(gained, saturation_counts, keys, hue_keys);
 
     let graded = max(CRM_FROM_AP1_TO_REC709 * ap1, vec3<f32>(0.0));
 

package/src/shade/renderer/shader/chunk/color/tonemap/purkinje/chunk_apply_purkinje_shift.d.ts

@@ -0,0 +1,65 @@
+/**
+ * How much of the eye's response is the rods', at an adaptation: 1 at and below {@link PURKINJE_MESOPIC_MIN_NITS}, 0 at
+ * and above {@link PURKINJE_MESOPIC_MAX_NITS}, linear in log luminance in between. The share `apply_purkinje_shift`
+ * blends by, for code that needs it on the CPU.
+ *
+ * @param {number} adaptation_luminance cd/m²
+ * @returns {number} 0 to 1
+ */
+export function purkinje_rod_share(adaptation_luminance: number): number;
+/**
+ * Rec.709 photopic luminance weights: what the cones see of a linear Rec.709 colour.
+ * @type {ReadonlyArray<number>}
+ */
+export const PURKINJE_REC709_PHOTOPIC: ReadonlyArray<number>;
+/**
+ * Rec.709 scotopic luminance weights: what the rods see of a linear Rec.709 colour. They sum to 1, so a grey has the
+ * same scotopic luminance as photopic.
+ * @type {ReadonlyArray<number>}
+ */
+export const PURKINJE_REC709_SCOTOPIC: ReadonlyArray<number>;
+/**
+ * "Rod blue": the colour the scotopic signal is carried by. Artistic: (0.3, 0.5, 0.9) mimics the sensation of the
+ * rods' 507 nm peak.
+ * @type {ReadonlyArray<number>}
+ */
+export const PURKINJE_NIGHT_TINT: ReadonlyArray<number>;
+/**
+ * CIE 191's mesopic range, cd/m²: rods alone below the lower bound (scotopic), cones alone above the upper (photopic).
+ */
+export const PURKINJE_MESOPIC_MIN_NITS: 0.005;
+export const PURKINJE_MESOPIC_MAX_NITS: 5;
+/**
+ * Purkinje shift.
+ * Human vision system shifts color perception away from red in night-time conditions.
+ *
+ * ```wgsl
+ * fn apply_purkinje_shift(color_rec709: vec3<f32>, adaptation_luminance: f32) -> vec3<f32>
+ * fn purkinje_rod_share(adaptation_luminance: f32) -> f32
+ * ```
+ *
+ * `color_rec709` is scene-linear Rec.709; `adaptation_luminance` is the luminance the eye is adapted to, cd/m². Above
+ * 5 cd/m² the colour is returned as it is; below 0.005 cd/m² it is the rod response alone, its scotopic luminance
+ * carried by a blue tint; in between the two blend linearly in log luminance, by `purkinje_rod_share`. The shift is
+ * linear in the colour, so it gives the same result ahead of the exposure as after it.
+ *
+ * The constants are the module's exports ({@link PURKINJE_REC709_SCOTOPIC} and the rest), and
+ * {@link purkinje_rod_share} is the share on the CPU.
+ *
+ * NOTE: this should go before the tonemapper.
+ *
+ * Notes on deriving it from the rod and cone responses: PURKINJE_PHYSICAL_DERIVATION_NOTES.md, beside this file.
+ *
+ * @see J. Patry, "Real-Time Samurai Cinema: Lighting, Atmosphere, and Tonemapping in Ghost of Tsushima", Advances in
+ *      Real-Time Rendering in Games, SIGGRAPH 2021 — the primary reference.
+ *      https://www.advances.realtimerendering.com/s2021/jpatry_advances2021/index.html
+ * @see A. G. Kirk, J. F. O'Brien, "Perceptually based tone mapping for low-light conditions", ACM TOG 30(4), 2011.
+ *      https://www2.eecs.berkeley.edu/Pubs/TechRpts/2011/EECS-2011-91.pdf
+ * @see D. Cao, J. Pokorny, V. C. Smith, A. J. Zele, "Rod contributions to color perception: linear with rod
+ *      contrast", Vision Research 48(26), 2008.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_apply_purkinje_shift: CodeChunk;
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_apply_purkinje_shift.d.ts.map

package/src/shade/renderer/shader/chunk/color/tonemap/purkinje/chunk_apply_purkinje_shift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_apply_purkinje_shift.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/color/tonemap/purkinje/chunk_apply_purkinje_shift.js"],"names":[],"mappings":"AAiCA;;;;;;;GAOG;AACH,yDAHW,MAAM,GACJ,MAAM,CAQlB;AA7CD;;;GAGG;AACH,uCAFU,cAAc,MAAM,CAAC,CAEiD;AAEhF;;;;GAIG;AACH,uCAFU,cAAc,MAAM,CAAC,CAEiD;AAEhF;;;;GAIG;AACH,kCAFU,cAAc,MAAM,CAAC,CAEmC;AAElE;;GAEG;AACH,8CAA+C;AAC/C,0CAA2C;AAwC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,yCAFU,SAAS,CAwCjB;0BAvIwB,mCAAmC"}