@woosh/meep-engine 3.23.0 → 3.24.0

package/src/shade/renderer/global_illumination/brick4/cpu/brick4_bake_for_scene.js

@@ -9,7 +9,7 @@ import { brick4_to_gpu_structure } from "./brick4_to_gpu_structure.js";
 /**
  * Requires a fairly beefy GPU to run, confirmed to work on RTX 4090.
  * @param {Object} options
- * @param {Scene} options.scene
+ * @param {Scene} options.scene the scene the renderer holds a context for — what is baked
  * @param {Renderer} options.renderer
  * @param {number} [options.cell_size=0.5] desired cell size for the voxel grid
  * @param {number} [options.max_memory_usage_bytes] maximum memory usage in bytes, default is 16MB
@@ -22,8 +22,10 @@ export async function brick4_bake_for_scene({
                                                 max_memory_usage_bytes = 16 * MEGABYTE,
                                             }) {
 
+    const scene_ctx = renderer.scenes.obtain(scene);
+
     const bvh = new StaticSceneBVH();
-    bvh.build(scene);
+    bvh.build(scene_ctx);
 
     let _cell_size = cell_size;
 
@@ -50,8 +52,6 @@ export async function brick4_bake_for_scene({
 
     console.log(brick4);
 
-    const scene_ctx = renderer.scenes.obtain(scene);
-
     const probe_data = await brick4_bake_basic({
         brick4,
         graphics: renderer.graphics,

package/src/shade/renderer/global_illumination/brick4/cpu/brick4_generate_tree_from_scene.d.ts

@@ -2,13 +2,11 @@
  * Generate a "brick" tree, where each node is a 4x4x4 probe volume.
  *
  * @param {Object} options
- * @param {Scene} options.scene
  * @param {StaticSceneBVH} options.bvh
  * @param {number} [options.cell_size] size of the smallest cell in world units
  * @param {number} [options.max_memory_usage_bytes] upper limit of how much total memory the entire tree will take up, including probe data
  */
-export function brick4_generate_tree_from_scene({ scene, bvh, cell_size, max_memory_usage_bytes, }: {
-    scene: Scene;
+export function brick4_generate_tree_from_scene({ bvh, cell_size, max_memory_usage_bytes, }: {
     bvh: StaticSceneBVH;
     cell_size?: number;
     max_memory_usage_bytes?: number;

package/src/shade/renderer/global_illumination/brick4/cpu/brick4_generate_tree_from_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"brick4_generate_tree_from_scene.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/brick4/cpu/brick4_generate_tree_from_scene.js"],"names":[],"mappings":"AAyKA;;;;;;;;GAQG;AACH;IAL0B,KAAK;IACI,GAAG,EAA3B,cAAc;IACG,SAAS,GAA1B,MAAM;IACW,sBAAsB,GAAvC,MAAM;2BAobhB;+BA1lB8B,sCAAsC;uCAS9B,6BAA6B"}
+{"version":3,"file":"brick4_generate_tree_from_scene.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/brick4/cpu/brick4_generate_tree_from_scene.js"],"names":[],"mappings":"AAyKA;;;;;;;GAOG;AACH;IAJmC,GAAG,EAA3B,cAAc;IACG,SAAS,GAA1B,MAAM;IACW,sBAAsB,GAAvC,MAAM;2BAsbhB;+BA3lB8B,sCAAsC;uCAS9B,6BAA6B"}

package/src/shade/renderer/global_illumination/brick4/cpu/brick4_generate_tree_from_scene.js

@@ -171,19 +171,17 @@ function purge_partial_depths(root, expansion_candidates) {
  * Generate a "brick" tree, where each node is a 4x4x4 probe volume.
  *
  * @param {Object} options
- * @param {Scene} options.scene
  * @param {StaticSceneBVH} options.bvh
  * @param {number} [options.cell_size] size of the smallest cell in world units
  * @param {number} [options.max_memory_usage_bytes] upper limit of how much total memory the entire tree will take up, including probe data
  */
 export function brick4_generate_tree_from_scene({
-                                                    scene,
                                                     bvh,
                                                     cell_size = 0.2,
                                                     max_memory_usage_bytes = 30 * MEGABYTE,
                                                 }) {
 
-    assert.defined(scene, 'scene');
+    assert.defined(bvh, 'bvh');
     assert.isNumber(cell_size, 'cell_size');
     assert.greaterThan(cell_size, 0, 'cell_size must be positive');
 
@@ -191,7 +189,10 @@ export function brick4_generate_tree_from_scene({
     // used to produce better dispersion and break ties
     const random = seededRandom(1337);
 
-    const scene_bounds = scene.instances.bounding_box;
+    // the box around everything in the tree: its root's
+    const scene_bounds = new AABB3();
+
+    bvh.instance_bvh.node_get_aabb(bvh.instance_bvh.root, scene_bounds);
 
     // Memory tracking is done from the GPU's perspective
 

package/src/shade/renderer/global_illumination/brick4/gpu/bake/brick4_bake_basic.js

@@ -86,7 +86,7 @@ export async function brick4_bake_basic({
 
         graphics.update();
 
-        r_materials.ensure_scene_materials(scene.scene);
+        r_materials.ensure_scene_materials(scene);
         r_materials.update();
     }
 

package/src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPULightProbeVolumeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.js"],"names":[],"mappings":"AAqBA;;;GAGG;AAEH;IA+GI;;;;OAIG;IACH,sBAHW,eAAe,SACf,eAAe,QAQzB;IAhCD;;;;OAIG;IACH,sBAHW,eAAe,SACf,eAAe,EAgBzB;IAtFD;;;OAGG;IACH,sCAEC;IAdD;;;OAGG;IACH,qCAEC;IAoCD;;;OAGG;IACH,6BAEC;IAYD;;;OAGG;IACH,0CASC;IAyDD;;;OAGG;IACH,gCAFW,MAAM,wEAahB;IAED;;;;;OAKG;IACH,qBAJW,sBAAsB,gBACtB,MAAM,qBACN,MAAM,QA6ChB;IAED,aAgGC;IAED;;;OAGG;IACH,sCAFW,MAAM,QA8ChB;IAED;;;OAGG;IACH,eAFY,MAAM,CAUjB;IAED,gBACC;;CACJ;8BA7XY,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,mCAAmC,EAAE,eAAe;kCAZtC,uCAAuC;uCAFlC,8CAA8C"}
+{"version":3,"file":"GPULightProbeVolumeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.js"],"names":[],"mappings":"AAqBA;;;GAGG;AAEH;IA+GI;;;;OAIG;IACH,sBAHW,eAAe,SACf,eAAe,QAQzB;IAhCD;;;;OAIG;IACH,sBAHW,eAAe,SACf,eAAe,EAgBzB;IAtFD;;;OAGG;IACH,sCAEC;IAdD;;;OAGG;IACH,qCAEC;IAoCD;;;OAGG;IACH,6BAEC;IAYD;;;OAGG;IACH,0CASC;IAyDD;;;OAGG;IACH,gCAFW,MAAM,wEAUhB;IAED;;;;;OAKG;IACH,qBAJW,sBAAsB,gBACtB,MAAM,qBACN,MAAM,QA6ChB;IAED,aAgGC;IAED;;;OAGG;IACH,sCAFW,MAAM,QA8ChB;IAED;;;OAGG;IACH,eAFY,MAAM,CAUjB;IAED,gBACC;;CACJ;8BA1XY,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,mCAAmC,EAAE,eAAe;kCAZtC,uCAAuC;uCAFlC,8CAA8C"}

package/src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.js

@@ -174,9 +174,6 @@ export class GPULightProbeVolumeRenderer {
      * @param {number} resolution
      */
     async generate_locations(resolution = 2) {
-        // this.#scene.light_probe_volume.source.build_grid(this.#scene.scene.instances.bounding_box, new Vector3(resolution, resolution, resolution));
-        // return this.#scene;
-
         await graph_generate_probe_locations({
             scene: this.#scene,
             graphics: this.#graphics,
@@ -261,7 +258,7 @@ export class GPULightProbeVolumeRenderer {
 
         const r_materials = this.#materials;
 
-        r_materials.ensure_scene_materials(this.#scene.scene);
+        r_materials.ensure_scene_materials(this.#scene);
         r_materials.update();
 
         const command_ctx = ShadeGPUCommandContext.create(

package/src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.d.ts

@@ -2,13 +2,18 @@ export function sh3_sample_irradiance_by_direction(result: any, result_offset: a
 /**
  *
  * @param {Object} options
- * @param {Scene} options.scene
+ * @param {GPUSceneContext} options.scene_context the scene's context — its probe volume is what is
+ *        drawn, and its rows are where the markers go
  * @param {boolean} [options.colors_enabled] disable if you don't care about actual encoded SH data
  * @param {number} [options.probe_size]
+ * @param {AABB3} [options.bounds] the scene's bounds, which the automatic probe size is a fraction
+ * of — required when no `probe_size` is given. The renderer's TLAS reads them back
+ * (`GPUInstancesAccelerationStructure.read_scene_bounds`); this function has no device.
  */
-export function lpv_visualise_probes({ scene, colors_enabled, probe_size }: {
-    scene: Scene;
+export function lpv_visualise_probes({ scene_context, colors_enabled, probe_size, bounds }: {
+    scene_context: GPUSceneContext;
     colors_enabled?: boolean;
     probe_size?: number;
+    bounds?: AABB3;
 }): void;
 //# sourceMappingURL=lpv_visualise_probes.d.ts.map

package/src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lpv_visualise_probes.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.js"],"names":[],"mappings":"AAwBA,8LAoDC;AAkKD;;;;;;GAMG;AACH;IAJ0B,KAAK;IACF,cAAc,GAAhC,OAAO;IACU,UAAU,GAA3B,MAAM;SAmEhB"}
+{"version":3,"file":"lpv_visualise_probes.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.js"],"names":[],"mappings":"AA6BA,8LAoDC;AAkKD;;;;;;;;;;GAUG;AACH;IARoC,aAAa;IAEpB,cAAc,GAAhC,OAAO;IACU,UAAU,GAA3B,MAAM;IACU,MAAM;SAiEhC"}

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

@@ -1,5 +1,10 @@
+import { assert } from "../../../../core/assert.js";
 import { float_to_uint8 } from "../../../../core/binary/float_to_uint8.js";
 import {
+
+/**
+ * @typedef {import("../../scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
+ */
     decode_octahedron_to_unit
 } from "../../../../core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js";
 import {
@@ -14,7 +19,7 @@ import { Attribute } from "../../geometry/Attribute.js";
 import { make_octahedron_geometry } from "../../geometry/primitives/make_octahedron_geometry.js";
 import { StandardAttributes } from "../../geometry/StandardAttributes.js";
 import { StandardShadeMaterial } from "../../material/StandardShadeMaterial.js";
-import { Mesh } from "../../scene/Mesh.js";
+import { place_primitive } from "../../scene/rows/place_primitive.js";
 import { ShadeTexture } from "../../texture/ShadeTexture.js";
 import { ShadeTextureFlags } from "../../texture/ShadeTextureFlags.js";
 import { ShadeImage } from "../../texture/source/ShadeImage.js";
@@ -239,22 +244,27 @@ function smooth_normals(geometry) {
 /**
  *
  * @param {Object} options
- * @param {Scene} options.scene
+ * @param {GPUSceneContext} options.scene_context the scene's context — its probe volume is what is
+ *        drawn, and its rows are where the markers go
  * @param {boolean} [options.colors_enabled] disable if you don't care about actual encoded SH data
  * @param {number} [options.probe_size]
+ * @param {AABB3} [options.bounds] the scene's bounds, which the automatic probe size is a fraction
+ * of — required when no `probe_size` is given. The renderer's TLAS reads them back
+ * (`GPUInstancesAccelerationStructure.read_scene_bounds`); this function has no device.
  */
 export function lpv_visualise_probes({
-                                         scene,
+                                         scene_context,
     colors_enabled = true,
-    probe_size= -1
+    probe_size= -1,
+    bounds = null
 }) {
-    const lpv = scene.light_probe_volume;
-
-    const bounds = scene.instances.bounding_box;
+    const lpv = scene_context.scene.light_probe_volume;
 
     let scale;
     if(probe_size <= 0) {
         // auto-scale
+        assert.notNull(bounds, 'bounds: the automatic probe size is a fraction of the scene\'s, and none were given');
+
         scale = Math.min(bounds.width, bounds.height, bounds.depth) * 0.005;
     }else{
         scale = probe_size * 0.5;
@@ -299,13 +309,8 @@ export function lpv_visualise_probes({
         // the scale moved, so the matrix owes an update - a Transform64 recomposes nothing on its own
         transform.updateMatrix();
 
-        scene.instances.add(Mesh.from(
-            geo,
-            material,
-            // the matrix sits at offset 0, so the transform goes straight in as one; Mesh.from
-            // copies the first 16 elements out of it and keeps no reference
-            transform
-        ));
+        // a marker at a row of its own; the placement copies the transform
+        place_primitive(scene_context, geo, material, transform);
 
     }
 }

package/src/shade/renderer/global_illumination/lpv/placement/graph_generate_probe_locations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_generate_probe_locations.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/placement/graph_generate_probe_locations.js"],"names":[],"mappings":"AAqNA;;;;;;GAMG;AACH;IAJoC,KAAK;IACL,QAAQ;IAChB,UAAU,GAA3B,MAAM;kBAsJhB"}
+{"version":3,"file":"graph_generate_probe_locations.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/placement/graph_generate_probe_locations.js"],"names":[],"mappings":"AAsNA;;;;;;GAMG;AACH;IAJoC,KAAK;IACL,QAAQ;IAChB,UAAU,GAA3B,MAAM;kBA6JhB"}

package/src/shade/renderer/global_illumination/lpv/placement/graph_generate_probe_locations.js

@@ -1,5 +1,6 @@
 import { assert } from "../../../../../core/assert.js";
 import { UINT32_MAX } from "../../../../../core/binary/UINT32_MAX.js";
+import { AABB3 } from "../../../../../core/geom/3d/aabb/AABB3.js";
 import Vector3 from "../../../../../core/geom/Vector3.js";
 import { delay } from "../../../../../core/process/delay.js";
 import { FrameGraph } from "../../../../../engine/graphics/render/frame_graph/FrameGraph.js";
@@ -247,7 +248,14 @@ export async function graph_generate_probe_locations({
 
     const data_initial_placement = {};
 
-    const bounds = scene.scene.instances.bounding_box;
+    // the box the GPU built the TLAS under — the union of every drawn row's bounds as the bounds
+    // pass derived them, which is the whole scene whoever placed what
+    const scene_bounds = new Float32Array(6);
+    const has_bounds = await scene.tlas.read_scene_bounds(scene_bounds);
+
+    assert.equal(has_bounds, true, 'the scene has no mesh row to place probes around');
+
+    const bounds = new AABB3(...scene_bounds);
 
     const largest_bounds_dimension = Math.max(bounds.width, bounds.height, bounds.depth);
     bounds.grow(Math.max(largest_bounds_dimension, 1e-5) * 0.05);

package/src/shade/renderer/global_illumination/lpv/placement/software/lpv_generate_probe_locations2.d.ts

@@ -3,12 +3,12 @@
  *
  * Assumes that light probes have a form of visibility check, so we place probes away from geometry to take advantage of that.
  * @param {Object} options
- * @param {Scene} options.scene
+ * @param {GPUSceneContext} options.scene_context the scene's context — its rows are the primitives
  * @param {number} [options.frequency] scene will be quantized to voxels of roughly this size
  * @returns {number[]}
  */
-export function lpv_generate_probe_locations2({ scene, frequency }: {
-    scene: Scene;
+export function lpv_generate_probe_locations2({ scene_context, frequency }: {
+    scene_context: GPUSceneContext;
     frequency?: number;
 }): number[];
 //# sourceMappingURL=lpv_generate_probe_locations2.d.ts.map

package/src/shade/renderer/global_illumination/lpv/placement/software/lpv_generate_probe_locations2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lpv_generate_probe_locations2.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/lpv/placement/software/lpv_generate_probe_locations2.js"],"names":[],"mappings":"AAWA;;;;;;;;GAQG;AACH;IAJ0B,KAAK;IACH,SAAS,GAA1B,MAAM;IACJ,MAAM,EAAE,CAuMpB"}
+{"version":3,"file":"lpv_generate_probe_locations2.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/lpv/placement/software/lpv_generate_probe_locations2.js"],"names":[],"mappings":"AAgBA;;;;;;;;GAQG;AACH;IAJoC,aAAa;IACrB,SAAS,GAA1B,MAAM;IACJ,MAAM,EAAE,CAyMpB"}

package/src/shade/renderer/global_illumination/lpv/placement/software/lpv_generate_probe_locations2.js

@@ -1,5 +1,10 @@
 import { UINT32_MAX } from "../../../../../../core/binary/UINT32_MAX.js";
+import { AABB3 } from "../../../../../../core/geom/3d/aabb/AABB3.js";
 import {
+
+/**
+ * @typedef {import("../../../../scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
+ */
     array_quick_sort_by_comparator
 } from "../../../../../../core/collection/array/array_quick_sort_by_comparator.js";
 import { v3_distance } from "../../../../../../core/geom/vec3/v3_distance.js";
@@ -14,19 +19,21 @@ import { sdf_find_local_maxima } from "./sdf_find_local_maxima.js";
  *
  * Assumes that light probes have a form of visibility check, so we place probes away from geometry to take advantage of that.
  * @param {Object} options
- * @param {Scene} options.scene
+ * @param {GPUSceneContext} options.scene_context the scene's context — its rows are the primitives
  * @param {number} [options.frequency] scene will be quantized to voxels of roughly this size
  * @returns {number[]}
  */
 export function lpv_generate_probe_locations2({
-                                                  scene,
+                                                  scene_context,
                                                   frequency = 0.5
                                               }) {
-
     const bvh = new StaticSceneBVH();
-    bvh.build(scene);
+    bvh.build(scene_context);
+
+    // the box around everything in the tree: its root's
+    const scene_bounds = new AABB3();
 
-    const scene_bounds = scene.instances.bounding_box;
+    bvh.instance_bvh.node_get_aabb(bvh.instance_bvh.root, scene_bounds);
 
     // Ensure the entire scene is within the distance field
     scene_bounds.grow(Math.max(scene_bounds.width, scene_bounds.height, scene_bounds.depth) * 0.04);

package/src/shade/renderer/global_illumination/probe/octahedral/GPUProbeAtlas.js

@@ -239,7 +239,7 @@ export class GPUProbeAtlas {
         ];
 
         const r_materials = graphics.materials_resident;
-        r_materials.ensure_scene_materials(scene.scene);
+        r_materials.ensure_scene_materials(scene);
         r_materials.update();
 
         const random_seed = randomIntegerBetween(this.random, 0, UINT32_MAX);

package/src/shade/renderer/light/GPULightCollection.d.ts

@@ -24,6 +24,15 @@ export class GPULightCollection {
      * @returns {GPUBuffer}
      */
     get buffer_data(): GPUBuffer;
+    /**
+     * The readback service over the light database — what carries a GPU-written row back to the
+     * CPU: a directional shadow map's caster range, measured against one frame's cascades and
+     * applied to the next frame's. Requests are taken any time; the copies are encoded at the tail
+     * of the shadow draw and delivered at the head of {@link update}.
+     *
+     * @returns {import("../buffer/table/GPUDatabaseReadback.js").GPUDatabaseReadback}
+     */
+    get readback(): import("../buffer/table/GPUDatabaseReadback.js").GPUDatabaseReadback;
     /**
      * @returns {GPUSceneShadowmapContext}
      */
@@ -39,6 +48,25 @@ export class GPULightCollection {
      * @param {GraphicsContext} ctx
      */
     update(ctx: GraphicsContext): void;
+    /**
+     * Hold a `transforms` row for every light's entity, and let go of the rows of lights that left.
+     *
+     * Called by the scene context before it flushes its rows, so a light that arrived this frame is
+     * written this frame; runs only when the source's version moved, and a moved light is one of
+     * the things that moves it, so every held row is marked as well — a mark on a row the GPU
+     * composes writes nothing.
+     *
+     * @param {import("../scene/rows/GPUSceneRows.js").GPUSceneRows} rows
+     */
+    sync_rows(rows: import("../scene/rows/GPUSceneRows.js").GPUSceneRows): void;
+    /**
+     * Write every light record's pose from its entity's row — after the hierarchy pass composed it.
+     * Nothing to dispatch while there is no light.
+     *
+     * @param {ShadeGPUCommandContext} cmd_ctx
+     * @param {GPUBuffer} scene_database
+     */
+    refresh_poses(cmd_ctx: ShadeGPUCommandContext, scene_database: GPUBuffer): void;
     destroy(): void;
     #private;
 }
@@ -48,4 +76,5 @@ export type LightCollection = import("./LightCollection.js").LightCollection;
 import { GPUDatabase } from "../buffer/table/GPUDatabase.js";
 import { GPUSceneShadowmapContext } from "../shadow/map/GPUSceneShadowmapContext.js";
 import { GPUTextureContext } from "../texture/GPUTextureContext.js";
+import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
 //# sourceMappingURL=GPULightCollection.d.ts.map

package/src/shade/renderer/light/GPULightCollection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPULightCollection.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/light/GPULightCollection.js"],"names":[],"mappings":"AAmCA;IAwGI;;;;;;OAMG;IACH,sBALW,eAAe,aACf,eAAe,EA8BzB;IAlID;;;OAGG;IACH,6DAEC;IAeD;;OAEG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,6BAEC;IAWD;;OAEG;IACH,+CAEC;IA6BD;;;OAGG;IACH,qCAEC;IAGD,+BAIC;IAwFD;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAsED,gBAIC;;CACJ;8BA1TY,OAAO,uBAAuB,EAAE,eAAe;8BAC/C,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,sBAAsB,EAAE,eAAe;4BAd/B,gCAAgC;yCACnB,2CAA2C;kCAClD,iCAAiC"}
+{"version":3,"file":"GPULightCollection.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/light/GPULightCollection.js"],"names":[],"mappings":"AAyCA;IAgII;;;;;;OAMG;IACH,sBALW,eAAe,aACf,eAAe,EA8BzB;IA1JD;;;OAGG;IACH,6DAEC;IAeD;;OAEG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,6BAEC;IAED;;;;;;;OAOG;IACH,qFAEC;IAWD;;OAEG;IACH,+CAEC;IAyCD;;;OAGG;IACH,qCAEC;IAGD,+BAIC;IAwFD;;;OAGG;IACH,YAFW,eAAe,QA8BzB;IAED;;;;;;;;;OASG;IACH,gBAFW,OAAO,+BAA+B,EAAE,YAAY,QAkC9D;IAED;;;;;;OAMG;IACH,uBAHW,sBAAsB,mCAyBhC;IAwED,gBAQC;;CACJ;8BAvaY,OAAO,uBAAuB,EAAE,eAAe;8BAC/C,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,sBAAsB,EAAE,eAAe;4BApB/B,gCAAgC;yCACnB,2CAA2C;kCAClD,iCAAiC;uCAH5B,wCAAwC"}