@woosh/meep-engine 3.39.0 → 3.40.0

package/src/shade/renderer/rasterize/RasterizationJob.d.ts

@@ -6,8 +6,7 @@ export class RasterizationJob {
     pipeline_type: number;
     /**
      * Side-to-cullMode lookup applied per material bucket. Default {@link CullPolicy.Standard}
-     * matches main-pass culling. Shadow callers set {@link CullPolicy.Reversed} so the back
-     * face of sided geometry is what gets written into the shadow map.
+     * matches main-pass culling, which shadow casters use too.
      * @type {Readonly<Record<number, GPUCullMode>>}
      */
     cull_policy: Readonly<Record<number, GPUCullMode>>;

package/src/shade/renderer/rasterize/RasterizationJob.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RasterizationJob.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/rasterize/RasterizationJob.js"],"names":[],"mappings":";;;;AAcA;IACI,sBAAmD;IAEnD;;;;;OAKG;IACH,aAFU,SAAS,OAAO,MAAM,cAAc,CAAC,CAEb;IAElC;;OAEG;IACH,kCAAW;IACX;;;;OAIG;IACH,0CAAiB;IAEjB;;OAEG;IACH,4BAAa;IAEb;;;OAGG;IACH,UAFU,MAAM,EAAE,CAEV;IAER;;OAEG;IACH,yBAAQ;IAER;;;OAGG;IACH,gBAAyB;IAEzB;;;OAGG;IACH,sBAA+B;CAClC"}
+{"version":3,"file":"RasterizationJob.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/rasterize/RasterizationJob.js"],"names":[],"mappings":";;;;AAcA;IACI,sBAAmD;IAEnD;;;;OAIG;IACH,aAFU,SAAS,OAAO,MAAM,cAAc,CAAC,CAEb;IAElC;;OAEG;IACH,kCAAW;IACX;;;;OAIG;IACH,0CAAiB;IAEjB;;OAEG;IACH,4BAAa;IAEb;;;OAGG;IACH,UAFU,MAAM,EAAE,CAEV;IAER;;OAEG;IACH,yBAAQ;IAER;;;OAGG;IACH,gBAAyB;IAEzB;;;OAGG;IACH,sBAA+B;CAClC"}

package/src/shade/renderer/rasterize/RasterizationJob.js

@@ -17,8 +17,7 @@ export class RasterizationJob {
 
     /**
      * Side-to-cullMode lookup applied per material bucket. Default {@link CullPolicy.Standard}
-     * matches main-pass culling. Shadow callers set {@link CullPolicy.Reversed} so the back
-     * face of sided geometry is what gets written into the shadow map.
+     * matches main-pass culling, which shadow casters use too.
      * @type {Readonly<Record<number, GPUCullMode>>}
      */
     cull_policy = CullPolicy.Standard;

package/src/shade/renderer/rasterize/bucket/construct_primitive_state.d.ts

@@ -16,12 +16,11 @@ export function construct_primitive_state(draw_mode: ShadeDrawMode, side: ShadeD
  *
  *  - `Standard` is the main-pass mapping: a one-sided material renders the face its winding
  *    presents (cull back), `Double` renders both.
- *  - `Reversed` culls the other way, so the *back* face is what gets drawn. This is the
- *    standard "back-face shadow casting" / "front-face culling for shadow casters"
- *    technique — shadow callers select this policy so the surface written into the shadow
- *    map sits behind the lit surface, eliminating self-shadow acne on the lit side and
- *    keeping shadow casting consistent with the user's view of one-sided geometry.
- *    `Double` has no opposite and stays at `none`.
+ *  - `Reversed` culls the other way, so the *back* face is what gets drawn — "back-face
+ *    shadow casting". Shadow casters do not use it: they cull as the main view does, and the
+ *    shared rasterizer slope bias keeps acne off; back faces on top of that bias left a gap of
+ *    a shadow texel or so where a caster meets the ground. `Double` has no opposite and stays
+ *    at `none`.
  */
 export type CullPolicy = Readonly<Record<number, GPUCullMode>>;
 export namespace CullPolicy {

package/src/shade/renderer/rasterize/bucket/construct_primitive_state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"construct_primitive_state.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/construct_primitive_state.js"],"names":[],"mappings":"AA4DA;;;;;;GAMG;AACH,qDALW,aAAa,QACb,aAAa,gBACb,SAAS,OAAO,MAAM,cAAc,CAAC,GACnC,cAAc,CA2B1B;;;;;;;;;;;;;;;;;;yBA5DS,SAAS,OAAO,MAAM,cAAc,CAAC;;;;;;;;;AAe/C;;;;;;;GAOG;AACH,yCAFU,cAAc,aAAa,CAAC,CAKnC;8BAzD2B,iCAAiC;8BACjC,iCAAiC;+BAFhC,uDAAuD"}
+{"version":3,"file":"construct_primitive_state.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/construct_primitive_state.js"],"names":[],"mappings":"AA2DA;;;;;;GAMG;AACH,qDALW,aAAa,QACb,aAAa,gBACb,SAAS,OAAO,MAAM,cAAc,CAAC,GACnC,cAAc,CA2B1B;;;;;;;;;;;;;;;;;yBA5DS,SAAS,OAAO,MAAM,cAAc,CAAC;;;;;;;;;AAe/C;;;;;;;GAOG;AACH,yCAFU,cAAc,aAAa,CAAC,CAKnC;8BAxD2B,iCAAiC;8BACjC,iCAAiC;+BAFhC,uDAAuD"}

package/src/shade/renderer/rasterize/bucket/construct_primitive_state.js

@@ -23,12 +23,11 @@ const lut_topology = {
  *
  *  - `Standard` is the main-pass mapping: a one-sided material renders the face its winding
  *    presents (cull back), `Double` renders both.
- *  - `Reversed` culls the other way, so the *back* face is what gets drawn. This is the
- *    standard "back-face shadow casting" / "front-face culling for shadow casters"
- *    technique — shadow callers select this policy so the surface written into the shadow
- *    map sits behind the lit surface, eliminating self-shadow acne on the lit side and
- *    keeping shadow casting consistent with the user's view of one-sided geometry.
- *    `Double` has no opposite and stays at `none`.
+ *  - `Reversed` culls the other way, so the *back* face is what gets drawn — "back-face
+ *    shadow casting". Shadow casters do not use it: they cull as the main view does, and the
+ *    shared rasterizer slope bias keeps acne off; back faces on top of that bias left a gap of
+ *    a shadow texel or so where a caster meets the ground. `Double` has no opposite and stays
+ *    at `none`.
  *
  * @enum {Readonly<Record<number, GPUCullMode>>}
  */

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.d.ts

@@ -128,10 +128,10 @@ export type AVBOITSideChannel = {
         emission: number;
     };
     /**
-     * whether the channel would add nothing this frame;
+     * whether the channel would add nothing for this view;
      * asked before the orchestrator records, and a channel that answers `true` is not asked for
      * anything else in that frame.
      */
-    avboit_is_empty?: () => boolean;
+    avboit_is_empty?: (view: import("../../../view/GPUViewContext.js").GPUViewContext) => boolean;
 };
 //# sourceMappingURL=AVBOITSideChannel.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAC;QACvD,wBAA8B,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QACjG,eAAqB,EAAE,MAAM,CAAC;QAC9B,sBAA4B,EAAE,OAAO,uCAAuC,EAAE,yBAAyB,CAAC;KACrG,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAKtB,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAU9D,MAAM,OAAO"}
+{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAC;QACvD,wBAA8B,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QACjG,eAAqB,EAAE,MAAM,CAAC;QAC9B,sBAA4B,EAAE,OAAO,uCAAuC,EAAE,yBAAyB,CAAC;KACrG,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAKtB,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAU9D,CAAC,IAAI,EAAE,OAAO,iCAAiC,EAAE,cAAc,KAAK,OAAO"}

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

@@ -86,7 +86,7 @@
  *     (`chunk_volumetrics_irradiance_sh`), for a channel whose fragments are lit: the renderer's
  *     indirect lighting, whichever mode it runs, and the scene's lights, shadowed and attenuated by
  *     the fog, written by the pass that lights the fog.
- * @property {() => boolean} [avboit_is_empty] whether the channel would add nothing this frame;
+ * @property {(view: import("../../../view/GPUViewContext.js").GPUViewContext) => boolean} [avboit_is_empty] whether the channel would add nothing for this view;
  *     asked before the orchestrator records, and a channel that answers `true` is not asked for
  *     anything else in that frame.
  */

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":"AAKA;;;;;GAKG;AACH,wDAOG;sCAlBmC,0CAA0C"}
+{"version":3,"file":"SCENE_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SCENE_DATABASE_SPEC.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,wDASG;sCAtBmC,0CAA0C"}

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

@@ -2,6 +2,8 @@ import { GPUDatabaseDefinition } from "../buffer/table/GPUDatabaseDefinition.js"
 import { MESH_INSTANCE_METADATA_STRUCT } from "./MESH_INSTANCE_METADATA_STRUCT.js";
 import { NODE3D_STRUCT } from "./NODE3D_STRUCT.js";
 import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "../volumetrics/PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
+import { WATER_BODY_STRUCT } from "../water/medium/WATER_BODIES_STRUCT.js";
+import { WATER_WAVE_RECORD_STRUCT } from "../water/surface/WATER_WAVE_RECORD_STRUCT.js";
 
 /**
  * Schema for the scene's GPU-resident records — meshes and the
@@ -16,8 +18,17 @@ export const SCENE_DATABASE_SPEC = GPUDatabaseDefinition.from({
     // GPUSceneVolumetrics whenever their version moves; read by the froxel volumetrics and by the
     // ray passes through chunk_participating_media_volumes_iterate
     participating_media_volumes: PARTICIPATING_MEDIA_VOLUME_STRUCT,
+    water_bodies: WATER_BODY_STRUCT,
+    water_waves: WATER_WAVE_RECORD_STRUCT,
 });
 
+SCENE_DATABASE_SPEC.add_link({ table: 'water_bodies', field: 'node', target_database: SCENE_DATABASE_SPEC,
+    target_table: 'transforms', nullable: false, owning: false });
+SCENE_DATABASE_SPEC.add_link({ table: 'water_bodies', field: 'wave', target_database: SCENE_DATABASE_SPEC,
+    target_table: 'water_waves', nullable: true, owning: true });
+SCENE_DATABASE_SPEC.add_link({ table: 'water_waves', field: 'node', target_database: SCENE_DATABASE_SPEC,
+    target_table: 'transforms', nullable: false, owning: false });
+
 // A mesh's transform. A mesh row and its transforms row are the same row — the entity's, one on —
 // so this word always names its own index, and it is declared as the link it is.
 SCENE_DATABASE_SPEC.add_link({

package/src/shade/renderer/shader/chunk/atmosphere/phase/jd/build_lut_fog_parameters_jendersie_deon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_lut_fog_parameters_jendersie_deon.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/atmosphere/phase/jd/build_lut_fog_parameters_jendersie_deon.js"],"names":[],"mappings":"AAeA;;;;;;;;;GASG;AACH,qEAPW,MAAM,iBACN,MAAM,iBACN,MAAM,GACJ,YAAY,CAoDxB;6BArE4B,wCAAwC"}
+{"version":3,"file":"build_lut_fog_parameters_jendersie_deon.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/atmosphere/phase/jd/build_lut_fog_parameters_jendersie_deon.js"],"names":[],"mappings":"AAcA;;;;;;;;;GASG;AACH,qEAPW,MAAM,iBACN,MAAM,iBACN,MAAM,GACJ,YAAY,CAoDxB;6BArE4B,wCAAwC"}

package/src/shade/renderer/shader/chunk/atmosphere/phase/jd/build_lut_fog_parameters_jendersie_deon.js

@@ -1,5 +1,4 @@
 import { assert } from "../../../../../../../core/assert.js";
-import { to_half_float_uint16 } from "../../../../../../../core/binary/to_half_float_uint16.js";
 import { BinaryDataType } from "../../../../../../../core/binary/type/BinaryDataType.js";
 import { ColorSpace } from "../../../../../texture/ColorSpace.js";
 import { ShadeTexture } from "../../../../../texture/ShadeTexture.js";
@@ -33,7 +32,7 @@ export function build_lut_fog_parameters_jendersie_deon(
     const log_d_min = Math.log(min_diameter);
     const log_range = Math.log(max_diameter) - log_d_min;
 
-    const u16 = new Uint16Array(resolution * 4);
+    const f16 = new Float16Array(resolution * 4);
 
     const sample = [];
     for (let i = 0; i < resolution; i++) {
@@ -49,7 +48,7 @@ export function build_lut_fog_parameters_jendersie_deon(
         );
 
         for (let j = 0; j < 4; j++) {
-            u16[i * 4 + j] = to_half_float_uint16(sample[j]);
+            f16[i * 4 + j] = sample[j];
         }
 
         assert.greaterThanOrEqual(sample[3],0, "w_D must not be negative");
@@ -57,7 +56,7 @@ export function build_lut_fog_parameters_jendersie_deon(
     }
 
     const image = ShadeImage.fromArrayBuffer(
-        u16.buffer,
+        f16.buffer,
         4,
         BinaryDataType.Float16,
         resolution, 1, 1,
@@ -71,4 +70,4 @@ export function build_lut_fog_parameters_jendersie_deon(
     texture.dimensions = 1;
 
     return texture;
-}
+}

package/src/shade/renderer/shader/chunk/brdf/dfg/generate_dfg_texture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate_dfg_texture.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/brdf/dfg/generate_dfg_texture.js"],"names":[],"mappings":"AA8EA;;;;;GAKG;AACH;IAHoC,QAAQ;IAChB,UAAU,GAA3B,MAAM;SA2BhB"}
+{"version":3,"file":"generate_dfg_texture.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/brdf/dfg/generate_dfg_texture.js"],"names":[],"mappings":"AA0EA;;;;;GAKG;AACH;IAHoC,QAAQ;IAChB,UAAU,GAA3B,MAAM;SA2BhB"}

package/src/shade/renderer/shader/chunk/brdf/dfg/generate_dfg_texture.js

@@ -1,6 +1,5 @@
 import { BinaryBuffer } from "../../../../../../core/binary/BinaryBuffer.js";
 import { downloadAsFile } from "../../../../../../core/binary/downloadAsFile.js";
-import { to_half_float_uint16 } from "../../../../../../core/binary/to_half_float_uint16.js";
 import { BinaryDataType } from "../../../../../../core/binary/type/BinaryDataType.js";
 import { FrameGraph } from "../../../../../../engine/graphics/render/frame_graph/FrameGraph.js";
 import { ShadeGPUCommandContext } from "../../../../../device/ShadeGPUCommandContext.js";
@@ -40,10 +39,7 @@ function graph_download_texture({
             const texture_data = await texture.download();
 
             // encode to f16
-            const f16_data = new Uint16Array(texture.width * texture.height * 2);
-            for (let i = 0; i < texture_data.length; i++) {
-                f16_data[i] = to_half_float_uint16(texture_data[i]);
-            }
+            const f16_data = new Float16Array(texture_data);
 
 
             const image = ShadeImage.fromArrayBuffer(

package/src/shade/renderer/shader/chunk/screen_space/chunk_screen_importance.d.ts

@@ -0,0 +1,30 @@
+/**
+ * How far in from each edge of the screen the importance falls off, as a fraction of the screen's
+ * height (the horizontal falloff is the same distance in pixels).
+ * @type {number}
+ */
+export const SCREEN_IMPORTANCE_BORDER_FRACTION: number;
+/**
+ * Steps a pixel's importance is quantized to when it is summed with atomics: a pixel of full
+ * importance adds this much.
+ * @type {number}
+ */
+export const SCREEN_IMPORTANCE_STEPS: number;
+/**
+ * How much a pixel matters by where it is on screen: 1 over most of it, falling to 0 at the edges —
+ * the automatic exposure's metering mask, after
+ * https://www.unrealengine.com/en-US/tech-blog/how-epic-games-is-handling-auto-exposure-in-4-25 —
+ * shared by every pass that weighs pixels by their place on screen.
+ *
+ * - `screen_importance(uv, vertical_aspect, border_fraction)` — the mask, in [0, 1]; `vertical_aspect`
+ *   is the screen's height over its width, `border_fraction` the falloff's width
+ * - `screen_importance_weight(uv, vertical_aspect)` — the mask at
+ *   {@link SCREEN_IMPORTANCE_BORDER_FRACTION} as an integer for an atomic sum:
+ *   {@link SCREEN_IMPORTANCE_STEPS} at full importance, and never below 1, so that a pixel at the very
+ *   edge still counts
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_screen_importance: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_screen_importance.d.ts.map

package/src/shade/renderer/shader/chunk/screen_space/chunk_screen_importance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_screen_importance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_screen_importance.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,gDAFU,MAAM,CAEsC;AAEtD;;;;GAIG;AACH,sCAFU,MAAM,CAE0B;AAE1C;;;;;;;;;;;;;;GAcG;AACH,sCAFU,SAAS,CAwBjB;0BArDwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/screen_space/chunk_screen_importance.js

@@ -0,0 +1,54 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * How far in from each edge of the screen the importance falls off, as a fraction of the screen's
+ * height (the horizontal falloff is the same distance in pixels).
+ * @type {number}
+ */
+export const SCREEN_IMPORTANCE_BORDER_FRACTION = 0.13;
+
+/**
+ * Steps a pixel's importance is quantized to when it is summed with atomics: a pixel of full
+ * importance adds this much.
+ * @type {number}
+ */
+export const SCREEN_IMPORTANCE_STEPS = 64;
+
+/**
+ * How much a pixel matters by where it is on screen: 1 over most of it, falling to 0 at the edges —
+ * the automatic exposure's metering mask, after
+ * https://www.unrealengine.com/en-US/tech-blog/how-epic-games-is-handling-auto-exposure-in-4-25 —
+ * shared by every pass that weighs pixels by their place on screen.
+ *
+ * - `screen_importance(uv, vertical_aspect, border_fraction)` — the mask, in [0, 1]; `vertical_aspect`
+ *   is the screen's height over its width, `border_fraction` the falloff's width
+ * - `screen_importance_weight(uv, vertical_aspect)` — the mask at
+ *   {@link SCREEN_IMPORTANCE_BORDER_FRACTION} as an integer for an atomic sum:
+ *   {@link SCREEN_IMPORTANCE_STEPS} at full importance, and never below 1, so that a pixel at the very
+ *   edge still counts
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_screen_importance = CodeChunk.from(
+    //language=WGSL
+    `
+fn screen_importance(
+    uv: vec2<f32>,
+    vertical_aspect: f32,
+    border_fraction: f32
+) -> f32{
+
+    let fov = border_fraction * vec2(vertical_aspect, 1.0);
+
+    let border   = smoothstep(vec2(0.0, 0.0), fov, uv) * (1.0 - smoothstep(vec2(1.0, 1.0) - fov, vec2(1.0, 1.0), uv));
+
+    return border.x * border.y;
+}
+
+fn screen_importance_weight(uv: vec2<f32>, vertical_aspect: f32) -> u32 {
+    let importance = screen_importance(uv, vertical_aspect, ${SCREEN_IMPORTANCE_BORDER_FRACTION});
+
+    return max(1u, u32(importance * ${SCREEN_IMPORTANCE_STEPS}));
+}
+    `
+);

package/src/shade/renderer/shader/type/serde/read_gpu_typed_buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read_gpu_typed_buffer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/type/serde/read_gpu_typed_buffer.js"],"names":[],"mappings":"AAuGA;;;;GAIG;AACH,6CAHW,YAAY,yBAqDtB;AAwBD;;;;;;GAMG;AACH,8DALW,WAAW,eACX,MAAM,UACN,MAAM,GACJ,EAAE,CAsBd;6BAjN4B,4CAA4C"}
+{"version":3,"file":"read_gpu_typed_buffer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/type/serde/read_gpu_typed_buffer.js"],"names":[],"mappings":"AAwGA;;;;GAIG;AACH,6CAHW,YAAY,yBAqDtB;AAwBD;;;;;;GAMG;AACH,8DALW,WAAW,eACX,MAAM,UACN,MAAM,GACJ,EAAE,CAsBd;6BAlN4B,4CAA4C"}

package/src/shade/renderer/shader/type/serde/read_gpu_typed_buffer.js

@@ -79,11 +79,12 @@ function read_multiple_f32(buffer, count) {
  *
  * @param {BinaryBuffer} buffer
  * @param {number} count
- * @returns {Uint32Array}
+ * @returns {Int32Array}
  */
 function read_multiple_i32(buffer, count) {
 
-    const r = new Uint32Array(count);
+    // signed storage, or every negative component reads back as its u32 bit pattern
+    const r = new Int32Array(count);
     buffer.readInt32Array(r, 0, count);
     return r;
 }

package/src/shade/renderer/shadow/map/DIRECTIONAL_SHADOWMAP_STRUCT.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A directional light's shadow map: a row of the light database's `shadow_directional` table,
+ * which the light's `shadow_id` names. It says where the map is, which is one of two things:
+ *
+ * - **cascades** — a range over the `shadow_cascade` table, one row per cascade, nearest first, with
+ *   `virtual_map` naming nothing;
+ * - **a virtual shadow map** — `virtual_map` names its row of the `shadow_virtual` table, and the
+ *   cascade range is empty.
+ *
+ * Neither the range nor the link owns its rows: the shadow context claims a map's rows when it
+ * builds the map and gives them back when it evicts it, while the record itself sits in a slot that
+ * is reassigned densely as maps come and go. A record written without `virtual_map` leaves it
+ * naming nothing, which is how a cascaded map's record is written.
+ *
+ * @type {WebGPUStruct}
+ */
+export const DIRECTIONAL_SHADOWMAP_STRUCT: WebGPUStruct;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=DIRECTIONAL_SHADOWMAP_STRUCT.d.ts.map

package/src/shade/renderer/shadow/map/DIRECTIONAL_SHADOWMAP_STRUCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DIRECTIONAL_SHADOWMAP_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/DIRECTIONAL_SHADOWMAP_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,2CAFU,YAAY,CASY;6BAzBL,mCAAmC"}

package/src/shade/renderer/shadow/map/DIRECTIONAL_SHADOWMAP_STRUCT.js

@@ -0,0 +1,27 @@
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * A directional light's shadow map: a row of the light database's `shadow_directional` table,
+ * which the light's `shadow_id` names. It says where the map is, which is one of two things:
+ *
+ * - **cascades** — a range over the `shadow_cascade` table, one row per cascade, nearest first, with
+ *   `virtual_map` naming nothing;
+ * - **a virtual shadow map** — `virtual_map` names its row of the `shadow_virtual` table, and the
+ *   cascade range is empty.
+ *
+ * Neither the range nor the link owns its rows: the shadow context claims a map's rows when it
+ * builds the map and gives them back when it evicts it, while the record itself sits in a slot that
+ * is reassigned densely as maps come and go. A record written without `virtual_map` leaves it
+ * naming nothing, which is how a cascaded map's record is written.
+ *
+ * @type {WebGPUStruct}
+ */
+export const DIRECTIONAL_SHADOWMAP_STRUCT = WebGPUStruct.from({
+    /** row of the map's nearest cascade in `shadow_cascade` */
+    first_cascade: u32,
+    /** how many cascades follow it, the nearest included */
+    cascade_count: u32,
+    /** the map's row in `shadow_virtual`, or NULL for a cascaded map */
+    virtual_map: u32,
+}, "DirectionalShadowmap").pack();

package/src/shade/renderer/shadow/map/DirectionalLightShadowmap.d.ts

@@ -66,6 +66,7 @@ export class DirectionalLightShadowmap extends Shadowmap {
     make_record(): {
         first_cascade: number;
         cascade_count: number;
+        virtual_map: number;
     };
     /**
      * The CPU's half of cascade `index`'s `shadow_cascade` row: where it is in the atlas, and the

package/src/shade/renderer/shadow/map/DirectionalLightShadowmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DirectionalLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/DirectionalLightShadowmap.js"],"names":[],"mappings":"AAwGA;IAsEI;;OAEG;IACH,2BAFW,MAAM,EAiBhB;IAvFD;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;;OAKG;IACH,eAFU,MAAM,CAEF;IAEd;;;;OAIG;IACH,QAFU,YAAY,CAEf;IAEP;;;;;;OAMG;IACH,eAFU,MAAM,CAEG;IAEnB;;;;;;;OAOG;IACH,cAFU,YAAY,CAET;IASb;;;;OAIG;IACH,oBAFU,OAAO,CAEU;IAE3B;;;;;;OAMG;IACH,iBAFU;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,YAAY,EAAE,YAAY,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAC,CAEjF;IAsBhB,+CA0QC;IAED;;;MAKC;IAED;;;;;;;OAOG;IACH,2BAJW,MAAM,UACN;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,UAAU,EAAE,UAAU,MAAM,CAAC,CAAA;KAAC,GAC9C;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,UAAU,EAAE,UAAU,MAAM,CAAC,CAAA;KAAC,CAiB5D;;CAEJ;0BArdyB,gBAAgB"}
+{"version":3,"file":"DirectionalLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/DirectionalLightShadowmap.js"],"names":[],"mappings":"AAyGA;IAsEI;;OAEG;IACH,2BAFW,MAAM,EAiBhB;IAvFD;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;;OAKG;IACH,eAFU,MAAM,CAEF;IAEd;;;;OAIG;IACH,QAFU,YAAY,CAEf;IAEP;;;;;;OAMG;IACH,eAFU,MAAM,CAEG;IAEnB;;;;;;;OAOG;IACH,cAFU,YAAY,CAET;IASb;;;;OAIG;IACH,oBAFU,OAAO,CAEU;IAE3B;;;;;;OAMG;IACH,iBAFU;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,YAAY,EAAE,YAAY,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAC,CAEjF;IAsBhB,+CA0QC;IAED;;;;MAQC;IAED;;;;;;;OAOG;IACH,2BAJW,MAAM,UACN;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,UAAU,EAAE,UAAU,MAAM,CAAC,CAAA;KAAC,GAC9C;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,UAAU,EAAE,UAAU,MAAM,CAAC,CAAA;KAAC,CAiB5D;;CAEJ;0BAxdyB,gBAAgB"}

package/src/shade/renderer/shadow/map/DirectionalLightShadowmap.js

@@ -20,6 +20,7 @@ import { inverseLerp } from "../../../../core/math/inverseLerp.js";
 import {
     quaternion_invert_orientation
 } from "../../../../engine/graphics/ecs/camera/quaternion_invert_orientation.js";
+import { GPU_DATABASE_NULL } from "../../buffer/table/GPU_DATABASE_NULL.js";
 import { CSM_CASCADE_STRUCT, CSM_CASTER_RANGE_UNKNOWN } from "./csm/CSM_CASCADE_STRUCT.js";
 import { SHADOWMAP_CSM_CASCADE_BLEND_FRACTION } from "./csm/SHADOWMAP_CSM_CASCADE_BLEND_FRACTION.js";
 import { SHADOWMAP_CSM_CASTER_RANGE_MARGIN_FRACTION } from "./csm/SHADOWMAP_CSM_CASTER_RANGE_MARGIN_FRACTION.js";
@@ -464,6 +465,9 @@ export class DirectionalLightShadowmap extends Shadowmap {
         return {
             first_cascade: this.first_cascade,
             cascade_count: this.cascade_count,
+            // said outright: the slot may have held a virtual map's record a moment ago, and a write
+            // that leaves a field out keeps what the row had
+            virtual_map: GPU_DATABASE_NULL,
         };
     }
 

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.d.ts

@@ -50,6 +50,43 @@ export class GPUSceneShadowmapContext {
      * @type {boolean}
      */
     use_tetrahedron_point_shadows: boolean;
+    /**
+     * Gives directional lights virtual shadow maps instead of cascades. The renderer pushes this
+     * from its `feature_virtual_shadow_maps` flag before each light update, alongside
+     * {@link enabled}; a flip is picked up in {@link process_lights}, which rebuilds every
+     * directional map of the other kind on the same pass, as it does for the point-light generator.
+     * @type {boolean}
+     */
+    use_virtual_shadow_maps: boolean;
+    /**
+     * The renderer pushes this from {@link Renderer.shadow_virtual_page_budget} every frame. Pages a
+     * frame wants beyond it wait, best first, for the next.
+     *
+     * @param {number} v pages per frame; zero draws none and leaves every page as it is
+     */
+    set virtual_page_budget(v: number);
+    /**
+     * @returns {number} pages per frame, across the scene's virtual shadow maps
+     */
+    get virtual_page_budget(): number;
+    /**
+     * Added to the level every point of a virtual shadow map selects; positive is coarser. Pushed by
+     * the renderer every frame and written into each map's record, so a change takes effect on the
+     * next frame's demand and sampling alike.
+     * @type {number}
+     */
+    virtual_lod_bias: number;
+    /**
+     * Pushed from {@link Renderer.shadow_virtual_first_texel_size}. A change rebuilds every virtual
+     * shadow map in {@link process_lights}: every page of the clipmap changes size.
+     *
+     * @param {number} v metres, positive
+     */
+    set virtual_first_texel_size(v: number);
+    /**
+     * @returns {number}
+     */
+    get virtual_first_texel_size(): number;
     /**
      * The renderer pushes this from {@link Renderer.shadow_cascade_count} before each light update,
      * alongside {@link enabled}. A change is picked up in {@link process_lights}: every directional
@@ -100,6 +137,22 @@ export class GPUSceneShadowmapContext {
      * @returns {number}
      */
     get cascade_table(): number;
+    /**
+     * Record this frame's virtual shadow map feedback — the casters that moved, the pages they made
+     * stale, the pages the view's pixels ask for — into the frame's `Shading` graph once the main
+     * view's depth exists, and read it back for the maps' next frames. Does nothing in a scene
+     * without virtual shadow maps. See {@link graph_vsm_feedback}.
+     *
+     * @param {Object} options
+     * @param {FrameGraph} options.graph
+     * @param {import("../../view/GPUViewContext.js").GPUViewContext} options.view the main view
+     * @param {number} options.depth graph handle of the main view's depth
+     */
+    graph_virtual_feedback({ graph, view, depth }: {
+        graph: FrameGraph;
+        view: import("../../view/GPUViewContext.js").GPUViewContext;
+        depth: number;
+    }): void;
     /**
      *
      * @param {Light} light
@@ -227,5 +280,6 @@ export type GPURecordWriter = import("../../buffer/table/serde/generate_record_w
 import { MaxRectanglesPacker } from "../../../../core/geom/packing/max-rect/MaxRectanglesPacker.js";
 import { GPUTextureContext } from "../../texture/GPUTextureContext.js";
 import { ViewManager } from "../../view/ViewManager.js";
+import { FrameGraph } from "../../../../engine/graphics/render/frame_graph/FrameGraph.js";
 import AABB2 from "../../../../core/geom/2d/aabb/AABB2.js";
 //# sourceMappingURL=GPUSceneShadowmapContext.d.ts.map

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AAsGA;;GAEG;AACH;IAsQI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EAiE5B;IA5UD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsCpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IAetC;;;;;;;;OAQG;IACH,6BAIC;IApBD;;OAEG;IACH,4BAEC;IA0CD;;;;OAIG;IACH,6BAIC;IAhBD;;OAEG;IACH,4BAEC;IAwED;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAoGD;;;;;OAKG;IACH,4BAMC;IA2LD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QAoE3B;IAsGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QAwFhC;IAsbD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAiQnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,KAAK,CAWjB;IAED,gBAiBC;;CACJ;qCA1nDY,OAAO,2CAA2C,EAAE,sBAAsB;8BAC1E,OAAO,0BAA0B,EAAE,eAAe;qBAClD,OAAO,wBAAwB,EAAE,MAAM;iCACvC,OAAO,mCAAmC,EAAE,kBAAkB;oBAC9D,OAAO,4BAA4B,EAAE,KAAK;8BAC1C,OAAO,gCAAgC,EAAE,eAAe;wBACxD,OAAO,gBAAgB,EAAE,SAAS;8BAClC,OAAO,oDAAoD,EAAE,eAAe;oCAtErD,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;kBAtBrC,wCAAwC"}
+{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AAkJA;;GAEG;AACH;IAoWI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EAiE5B;IA1aD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsCpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IAEtC;;;;;;OAMG;IACH,yBAFU,OAAO,CAEe;IAehC;;;;;OAKG;IACH,mCAIC;IAjBD;;OAEG;IACH,kCAEC;IAcD;;;;;OAKG;IACH,kBAFU,MAAM,CAEK;IAerB;;;;;OAKG;IACH,wCAKC;IAlBD;;OAEG;IACH,uCAEC;IA4BD;;;;;;;;OAQG;IACH,6BAIC;IApBD;;OAEG;IACH,4BAEC;IA0CD;;;;OAIG;IACH,6BAIC;IAhBD;;OAEG;IACH,4BAEC;IAkGD;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAoGD;;;;;OAKG;IACH,4BAMC;IA2MD;;;;;;;;;;OAUG;IACH;QAJ+B,KAAK,EAAzB,UAAU;QACqD,IAAI,EAAnE,OAAO,8BAA8B,EAAE,cAAc;QACrC,KAAK,EAArB,MAAM;aAuChB;IA0LD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QAuG3B;IA2GD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QA0FhC;IA2bD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAqTnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,KAAK,CAWjB;IAED,gBAsBC;;CACJ;qCA/lEY,OAAO,2CAA2C,EAAE,sBAAsB;8BAC1E,OAAO,0BAA0B,EAAE,eAAe;qBAClD,OAAO,wBAAwB,EAAE,MAAM;iCACvC,OAAO,mCAAmC,EAAE,kBAAkB;oBAC9D,OAAO,4BAA4B,EAAE,KAAK;8BAC1C,OAAO,gCAAgC,EAAE,eAAe;wBACxD,OAAO,gBAAgB,EAAE,SAAS;8BAClC,OAAO,oDAAoD,EAAE,eAAe;oCA7ErD,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;2BApB5B,8DAA8D;kBAFvE,wCAAwC"}