@woosh/meep-engine 3.64.0 → 3.65.0

package/src/shade/playground/grass_surfaces/main.js

@@ -0,0 +1,593 @@
+import { Color } from "../../../core/color/Color.js";
+import { BoxShape3D } from "../../../core/geom/3d/shape/BoxShape3D.js";
+import { SphereShape3D } from "../../../core/geom/3d/shape/SphereShape3D.js";
+import Quaternion from "../../../core/geom/Quaternion.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { DEG_TO_RAD } from "../../../core/math/DEG_TO_RAD.js";
+import { Entity } from "../../../engine/ecs/Entity.js";
+import { EntityComponentDataset } from "../../../engine/ecs/EntityComponentDataset.js";
+import { EntityManager } from "../../../engine/ecs/EntityManager.js";
+import { t64_announce_change } from "../../../engine/ecs/transform/t64_announce_change.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import { GrassSpecies } from "../../../engine/graphics/ecs/grass/GrassSpecies.js";
+import { GrassSurface } from "../../../engine/graphics/ecs/grass/GrassSurface.js";
+import { GroundCover } from "../../../engine/graphics/ecs/grass/GroundCover.js";
+import { Light } from "../../../engine/graphics/ecs/light/Light.js";
+import { LightType } from "../../../engine/graphics/ecs/light/LightType.js";
+import { ShadedGeometry } from "../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
+import { GPUFluidSystem } from "../../../engine/graphics3/GPUFluidSystem.js";
+import { GraphicsEngine } from "../../../engine/graphics3/GraphicsEngine.js";
+import { GrassSurfaceSystem } from "../../../engine/graphics3/GrassSurfaceSystem.js";
+import { GroundCoverSystem } from "../../../engine/graphics3/GroundCoverSystem.js";
+import { LightSystem } from "../../../engine/graphics3/LightSystem.js";
+import { ShadedGeometrySystem } from "../../../engine/graphics3/ShadedGeometrySystem.js";
+import { Collider } from "../../../engine/physics/ecs/Collider.js";
+import { RigidBody } from "../../../engine/physics/ecs/RigidBody.js";
+import { FluidEffectorsComponent } from "../../../engine/physics/fluid/ecs/FluidEffectorsComponent.js";
+import { FluidEffectorsSystem } from "../../../engine/physics/fluid/ecs/FluidEffectorsSystem.js";
+import { FluidObstacle } from "../../../engine/physics/fluid/ecs/FluidObstacle.js";
+import { GPUFluidComponent } from "../../../engine/physics/fluid/ecs/GPUFluidComponent.js";
+import { GlobalFluidEffector } from "../../../engine/physics/fluid/effector/GlobalFluidEffector.js";
+import { OrbitalCameraController } from "../../renderer/camera/orbital/OrbitalCameraController.js";
+import { create_frame_loop } from "../../renderer/create_frame_loop.js";
+import { MeshletGeometry } from "../../renderer/geometry/MeshletGeometry.js";
+import { MeshoptClusterizer } from "../../renderer/geometry/meshlet/build/meshoptimizer/meshopt_clusterizer.js";
+import { meshlet_geometry_build_from_geometry } from "../../renderer/geometry/meshlet_geometry_build_from_geometry.js";
+import { make_box_geometry } from "../../renderer/geometry/primitives/make_box_geometry.js";
+import { make_plane_geometry } from "../../renderer/geometry/primitives/make_plane_geometry.js";
+import { make_uv_sphere_geometry } from "../../renderer/geometry/primitives/make_uv_sphere_geometry.js";
+import { ShadeDrawSide } from "../../renderer/material/ShadeDrawSide.js";
+import { StandardShadeMaterial } from "../../renderer/material/StandardShadeMaterial.js";
+import { TransparencyMode } from "../../renderer/material/TransparencyMode.js";
+import { row_of_entity } from "../../renderer/scene/rows/GPUSceneRows.js";
+import { Scene } from "../../renderer/scene/Scene.js";
+import { read_grass_surfaces } from "./read_grass_surfaces.js";
+
+/**
+ * Grass surfaces on a small set, laid out so that every way a column can meet ground is in view and has a
+ * known answer.
+ *
+ * **The field** is one surface of four members: two 16 m sheets that meet along x = 0, a boulder sunk
+ * through the first, and a hill standing 3 m over the second with a cave under it. A slab hangs over part
+ * of the first sheet and is no member. **The platform** is another surface, two sheets and a crate, that
+ * circles and turns as one.
+ *
+ * **The wind** is the scene's: a steady wind with a gust on it, and a fluid about the field that the
+ * boulder and the hill stand in, so the grass in their lee is in their wake. `globalThis.weather` is the
+ * wind's effector.
+ *
+ * **The roller** is a ball that rolls round a ring on the field's first sheet, an obstacle in the air and
+ * no member of the field: the grass under it is pressed down and stands back up behind it.
+ * `globalThis.__roller_still` holds it where it is.
+ *
+ * `globalThis.world` names every entity and says where each piece is, and `globalThis.read_grass()` reads
+ * the surfaces' pool off the device, so a check can hold what was baked against what was built.
+ *
+ * Serve the workspace with `npm run dev --workspace @woosh/meep-engine` and open
+ * `/src/shade/playground/grass_surfaces/index.html`.
+ */
+
+const CAMERA = {
+    position: new Vector3(-4, 7, 22),
+    target: new Vector3(2, 1, 0),
+    fov_degrees: 50,
+};
+
+/**
+ * Where the pieces are, in metres. Boxes are `[low, high]`.
+ */
+const LAYOUT = {
+    sheet_a: [[-16, 0, -8], [0, 0, 8]],
+    sheet_b: [[0, 0, -8], [16, 0, 8]],
+    boulder: [[-8, -1, 2], [-5, 2, 5]],
+    hill: [[4, 3, -4], [12, 7, 4]],
+    slab: [[-14, 4, -7], [-10, 4.5, -3]],
+    roller: {
+        // the ring it rolls round, on the ground
+        centre: [-3, 0, -3.5],
+        ring: 3,
+        radius: 0.6,
+        // how far its lowest point is under the ground
+        sunk: 0.05,
+        // seconds a lap
+        period: 14,
+    },
+    platform: {
+        centre: [0, 6, -22],
+        radius: 6,
+        // seconds a lap
+        period: 20,
+        // the platform's own frame
+        sheet_a: [[-6, 0, -3], [0, 0, 3]],
+        sheet_b: [[0, 0, -3], [6, 0, 3]],
+        crate: [[1, -0.5, -1], [3, 1, 1]],
+    },
+};
+
+const element = id => document.getElementById(id);
+
+const view_size = () => [Math.max(1, window.innerWidth), Math.max(1, window.innerHeight)];
+
+/**
+ * @param {number[]} position
+ * @param {Quaternion} [rotation]
+ * @returns {Transform64}
+ */
+function placed(position, rotation = new Quaternion()) {
+    const transform = new Transform64();
+
+    transform.setTranslation(position[0], position[1], position[2]);
+    transform.setRotation(rotation.x, rotation.y, rotation.z, rotation.w);
+    transform.updateMatrix();
+
+    return transform;
+}
+
+/**
+ * @param {object} geometry
+ * @returns {MeshletGeometry}
+ */
+function meshlets(geometry) {
+    const built = new MeshletGeometry();
+
+    meshlet_geometry_build_from_geometry(geometry, built);
+
+    return built;
+}
+
+/**
+ * @param {Color} diffuse
+ * @returns {StandardShadeMaterial}
+ */
+function material(diffuse) {
+    const result = new StandardShadeMaterial();
+
+    result.diffuse_color.copy(diffuse);
+    result.roughness_factor = 0.85;
+    result.metallic_factor = 0;
+    result.transparency_mode = TransparencyMode.Opaque;
+    result.draw_side = ShadeDrawSide.Double;
+
+    return result;
+}
+
+/**
+ * @param {MeshletGeometry} geometry
+ * @param {StandardShadeMaterial} material_instance
+ * @returns {ShadedGeometry}
+ */
+function shaded(geometry, material_instance) {
+    const component = new ShadedGeometry();
+
+    component.geometry = geometry;
+    component.material = material_instance;
+
+    return component;
+}
+
+const centre_of = box => [0, 1, 2].map(axis => (box[0][axis] + box[1][axis]) / 2);
+const extent_of = box => [0, 1, 2].map(axis => box[1][axis] - box[0][axis]);
+
+// a plane is made in its own xy; a quarter turn about x lays it flat, facing up
+const FLAT = Quaternion.fromAxisAngle(Vector3.right, -Math.PI / 2);
+
+/**
+ * @param {EntityComponentDataset} dataset
+ */
+function build_world(dataset) {
+    const earth = material(new Color(0.30, 0.26, 0.20, 1));
+    const rock = material(new Color(0.45, 0.45, 0.47, 1));
+    const wood = material(new Color(0.50, 0.38, 0.24, 1));
+    const concrete = material(new Color(0.6, 0.6, 0.6, 1));
+
+    const species = GrassSpecies.from({ blade_length: 0.4, blade_width: 0.015, density: 300 });
+
+    /** What stands in the wind: a box as large as the piece. */
+    const windbreak = box => {
+        const collider = new Collider();
+        const extent = extent_of(box);
+
+        collider.shape = BoxShape3D.from(extent[0] / 2, extent[1] / 2, extent[2] / 2);
+
+        return collider;
+    };
+
+    const sheet = box => shaded(meshlets(make_plane_geometry(extent_of(box)[0], extent_of(box)[2])), earth);
+    const block = (box, material_instance) => shaded(meshlets(make_box_geometry(...extent_of(box))), material_instance);
+
+    const world = { species, field: {}, platform: {} };
+
+    // ---- the field ----
+
+    world.field.surface = new Entity()
+        .add(new Transform64())
+        .add(new GrassSurface())
+        .build(dataset);
+
+    const field_cover = grows => GroundCover.from({ surface: world.field.surface, species: grows ? species : null });
+
+    world.field.sheet_a = new Entity()
+        .add(placed(centre_of(LAYOUT.sheet_a), FLAT))
+        .add(sheet(LAYOUT.sheet_a))
+        .add(field_cover(true))
+        .build(dataset);
+
+    world.field.sheet_b = new Entity()
+        .add(placed(centre_of(LAYOUT.sheet_b), FLAT))
+        .add(sheet(LAYOUT.sheet_b))
+        .add(field_cover(true))
+        .build(dataset);
+
+    // sunk through the first sheet: nothing grows on it, and nothing through it
+    world.field.boulder = new Entity()
+        .add(placed(centre_of(LAYOUT.boulder)))
+        .add(block(LAYOUT.boulder, rock))
+        .add(field_cover(false))
+        .add(new FluidObstacle())
+        .add(windbreak(LAYOUT.boulder))
+        .add(new RigidBody())
+        .build(dataset);
+
+    // standing over the second sheet: grass on its top, and on the cave's floor under it
+    world.field.hill = new Entity()
+        .add(placed(centre_of(LAYOUT.hill)))
+        .add(block(LAYOUT.hill, earth))
+        .add(field_cover(true))
+        .add(new FluidObstacle())
+        .add(windbreak(LAYOUT.hill))
+        .add(new RigidBody())
+        .build(dataset);
+
+    // over the first sheet, and no member: the field's columns pass it by
+    world.field.slab = new Entity()
+        .add(placed(centre_of(LAYOUT.slab)))
+        .add(block(LAYOUT.slab, concrete))
+        .build(dataset);
+
+    // ---- the roller ----
+
+    const roller = LAYOUT.roller;
+
+    const roller_transform = new Transform64();
+    const roller_body = new RigidBody();
+
+    const roller_collider = new Collider();
+
+    roller_collider.shape = SphereShape3D.from(roller.radius);
+
+    world.field.roller = new Entity()
+        .add(roller_transform)
+        .add(shaded(meshlets(make_uv_sphere_geometry(roller.radius, 32, 16)), wood))
+        .add(new FluidObstacle())
+        .add(roller_collider)
+        .add(roller_body)
+        .build(dataset);
+
+    const roll = new Quaternion();
+    const roll_axis = new Vector3();
+
+    /**
+     * Put the roller where it is at a time, moving and turning as a ball that rolls there does.
+     *
+     * @param {number} time seconds
+     */
+    world.field.roll = time => {
+        const rate = 2 * Math.PI / roller.period;
+        const angle = rate * time;
+
+        const out_x = Math.cos(angle);
+        const out_z = Math.sin(angle);
+
+        // along the ring
+        const speed = rate * roller.ring;
+        const way_x = -out_z;
+        const way_z = out_x;
+
+        // it rolls about the axis across its way, a turn for every circumference of ground
+        roll_axis.set(way_z, 0, -way_x);
+        roll.fromAxisAngle(roll_axis, speed * time / roller.radius);
+
+        roller_transform.setTranslation(roller.centre[0] + roller.ring * out_x, roller.radius - roller.sunk, roller.centre[2] + roller.ring * out_z);
+        roller_transform.setRotation(roll.x, roll.y, roll.z, roll.w);
+        roller_transform.updateMatrix();
+
+        roller_body.linearVelocity[0] = speed * way_x;
+        roller_body.linearVelocity[2] = speed * way_z;
+
+        roller_body.angularVelocity[0] = roll_axis.x * speed / roller.radius;
+        roller_body.angularVelocity[2] = roll_axis.z * speed / roller.radius;
+
+        t64_announce_change(dataset, world.field.roller);
+    };
+
+    world.field.roll(0);
+
+    // ---- the platform ----
+
+    const platform = LAYOUT.platform;
+
+    const platform_transform = new Transform64();
+
+    world.platform.surface = new Entity()
+        .add(platform_transform)
+        .add(new GrassSurface())
+        .build(dataset);
+
+    const platform_cover = grows => GroundCover.from({ surface: world.platform.surface, species: grows ? species : null });
+
+    /** @type {{entity: number, transform: Transform64, local: number[], flat: boolean}[]} */
+    const riders = [];
+
+    const ride = (name, box, component, grows, flat) => {
+        const transform = new Transform64();
+
+        const entity = new Entity()
+            .add(transform)
+            .add(component)
+            .add(platform_cover(grows))
+            .build(dataset);
+
+        world.platform[name] = entity;
+
+        riders.push({ entity, transform, local: centre_of(box), flat });
+    };
+
+    ride("sheet_a", platform.sheet_a, sheet(platform.sheet_a), true, true);
+    ride("sheet_b", platform.sheet_b, sheet(platform.sheet_b), true, true);
+    ride("crate", platform.crate, block(platform.crate, wood), false, false);
+
+    const turn = new Quaternion();
+    const rider_rotation = new Quaternion();
+    const offset = new Vector3();
+
+    /**
+     * Put the platform, and everything that rides it, where it is at a time.
+     *
+     * @param {number} time seconds
+     */
+    world.platform.pose = time => {
+        const angle = 2 * Math.PI * time / platform.period;
+
+        const x = platform.centre[0] + platform.radius * Math.cos(angle);
+        const y = platform.centre[1] + Math.sin(angle * 3);
+        const z = platform.centre[2] + platform.radius * Math.sin(angle);
+
+        // it turns as it goes, twice a lap
+        turn.fromAxisAngle(Vector3.up, angle * 2);
+
+        platform_transform.setTranslation(x, y, z);
+        platform_transform.setRotation(turn.x, turn.y, turn.z, turn.w);
+        platform_transform.updateMatrix();
+
+        t64_announce_change(dataset, world.platform.surface);
+
+        for (const rider of riders) {
+            offset.set(rider.local[0], rider.local[1], rider.local[2]);
+            offset.applyQuaternion(turn);
+
+            if (rider.flat) {
+                rider_rotation.multiplyQuaternions(turn, FLAT);
+            } else {
+                rider_rotation.copy(turn);
+            }
+
+            rider.transform.setTranslation(x + offset.x, y + offset.y, z + offset.z);
+            rider.transform.setRotation(rider_rotation.x, rider_rotation.y, rider_rotation.z, rider_rotation.w);
+            rider.transform.updateMatrix();
+
+            t64_announce_change(dataset, rider.entity);
+        }
+    };
+
+    world.platform.pose(0);
+
+    // ---- the wind ----
+
+    const weather = new GlobalFluidEffector();
+
+    weather.wind = [4, 0, 1.5];
+    weather.drag = 0.5;
+    weather.gust = 1.5;
+    weather.gust_period = 4;
+
+    const effectors = new FluidEffectorsComponent();
+
+    effectors.addEffector(weather);
+
+    world.weather = weather;
+
+    new Entity()
+        .add(effectors)
+        .build(dataset);
+
+    // the air about the field: half-metre cells for 16 m each way and 8 m up and down, and two coarser shells
+    const air = new GPUFluidComponent();
+
+    air.resolution = [64, 32, 64];
+    air.cell_size = 0.5;
+    air.cascade_count = 3;
+
+    world.air = new Entity()
+        .add(placed([0, 4, 0]))
+        .add(air)
+        .build(dataset);
+
+    // ---- light ----
+
+    const sun = new Light();
+
+    sun.type.set(LightType.DIRECTION);
+    sun.color.setRGB(1, 0.97, 0.92);
+    sun.intensity.set(2.5);
+    sun.castShadow.set(true);
+
+    const rotation = new Quaternion();
+
+    rotation.fromUnitVectors(Vector3.forward, new Vector3(-0.4, -1, -0.6).normalize());
+    rotation.normalize();
+
+    new Entity()
+        .add(placed([0, 20, 0], rotation))
+        .add(sun)
+        .build(dataset);
+
+    // the rows the device knows the pieces by
+    world.rows = {};
+
+    for (const group of ["field", "platform"]) {
+        world.rows[group] = {};
+
+        for (const [name, entity] of Object.entries(world[group])) {
+            if (typeof entity === "number") {
+                world.rows[group][name] = row_of_entity(entity);
+            }
+        }
+    }
+
+    return world;
+}
+
+function show_message(text) {
+    const message = element("message");
+
+    message.textContent = text;
+    message.style.display = "grid";
+}
+
+async function main() {
+    await MeshoptClusterizer.ready;
+
+    const graphics = new GraphicsEngine();
+    const scene = new Scene();
+
+    element("viewport").appendChild(graphics.viewport.el);
+
+    const [width, height] = view_size();
+
+    graphics.viewport.size.set(width, height);
+
+    const dataset = new EntityComponentDataset();
+    const entities = new EntityManager();
+
+    const grass = new GrassSurfaceSystem(graphics, scene);
+
+    entities.addSystem(new ShadedGeometrySystem(graphics, scene));
+    entities.addSystem(new LightSystem(graphics, scene));
+    entities.addSystem(new FluidEffectorsSystem());
+    entities.addSystem(new GPUFluidSystem(graphics, scene));
+    entities.addSystem(grass);
+    entities.addSystem(new GroundCoverSystem());
+    entities.attachDataset(dataset);
+
+    await new Promise((resolve, reject) => entities.startup(resolve, reject));
+
+    const world = build_world(dataset);
+
+    const camera = graphics.camera.camera;
+
+    camera.near = 0.05;
+    camera.far = 500;
+    camera.fov = CAMERA.fov_degrees * DEG_TO_RAD;
+
+    const controller = new OrbitalCameraController(camera, document.body);
+
+    controller.look(CAMERA.position, CAMERA.target);
+
+    document.body.focus();
+
+    Object.assign(globalThis, { graphics, scene, dataset, entities, grass, world, camera, controller, LAYOUT, weather: world.weather });
+
+    graphics.on.contextFailed.add(failure => show_message("There will be no rendering.\n\n" + failure.message));
+
+    try {
+        await graphics.start();
+    } catch (e) {
+        console.error(e);
+
+        return;
+    }
+
+    const renderer = graphics.renderer;
+
+    renderer.feature_automatic_exposure_enabled = false;
+    renderer.exposure_compensation = 0;
+
+    globalThis.renderer = renderer;
+
+    renderer.graphics.device.lost?.then(info => show_message("The GPU device was lost.\n\n" + (info?.message ?? "")));
+
+    /**
+     * The surfaces' pool, read off the device.
+     *
+     * @param {boolean} [with_surfels]
+     */
+    globalThis.read_grass = (with_surfels = false) => read_grass_surfaces(renderer.graphics.device, grass.surfaces, with_surfels);
+
+    let frames = 0;
+    let time = 0;
+
+    // `__platform_still` holds the platform where it is, `__roller_still` the roller
+    globalThis.__platform_still = false;
+    globalThis.__roller_still = false;
+
+    let roller_time = 0;
+
+    /**
+     * One frame: the platform, the camera, every system's update, the render.
+     *
+     * @param {number} time_delta seconds
+     */
+    function step(time_delta) {
+        const [w, h] = view_size();
+
+        if (w !== graphics.viewport.size.x || h !== graphics.viewport.size.y) {
+            graphics.viewport.size.set(w, h);
+        }
+
+        if (!globalThis.__platform_still) {
+            time += Math.min(time_delta, 0.05);
+
+            world.platform.pose(time);
+        }
+
+        if (!globalThis.__roller_still) {
+            roller_time += Math.min(time_delta, 0.05);
+
+            world.field.roll(roller_time);
+        }
+
+        controller.update();
+
+        entities.update(Math.min(time_delta, 0.05));
+
+        graphics.render(time_delta);
+
+        frames++;
+
+        globalThis.__frames = frames;
+        globalThis.__time = time;
+    }
+
+    // `__paused` hands the frames to whoever drives `step`, such as a timing probe
+    globalThis.step = step;
+    globalThis.__paused = false;
+
+    const status = element("status");
+
+    create_frame_loop(time_delta => {
+        if (!globalThis.__paused) {
+            step(time_delta);
+        }
+
+        if (frames % 30 === 0 && grass.surfaces !== null) {
+            status.textContent = `surfaces ${grass.surfaces.surface_count}   slots ${grass.surfaces.slot_capacity}`;
+        }
+    });
+
+    globalThis.bench_ready = true;
+}
+
+main().catch(e => {
+    console.error(e);
+    show_message(String(e?.stack ?? e));
+});

package/src/shade/playground/grass_surfaces/read_grass_surfaces.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Read the grass surfaces' pool off the device: its counters, every slot that is not free, and on request
+ * the surfels the slots hold. A playground's inspection tool; nothing in a frame calls it.
+ *
+ * @param {GPUDevice} device
+ * @param {import("../../renderer/grass/surface/GPUGrassSurfaces.js").GPUGrassSurfaces} surfaces
+ * @param {boolean} [with_surfels] also read the atlas, and give every slot its `surfels`
+ * @returns {Promise<{capacity: number, free_count: number, starved: number, baked: number, removed: number, listed: number, slots: (GrassSlotReading & {surfels?: GrassSurfelReading[]})[]}>}
+ *          `removed` is the records taken out of the directory since the pool was made, `listed` the records it holds
+ */
+export function read_grass_surfaces(device: GPUDevice, surfaces: import("../../renderer/grass/surface/GPUGrassSurfaces.js").GPUGrassSurfaces, with_surfels?: boolean): Promise<{
+    capacity: number;
+    free_count: number;
+    starved: number;
+    baked: number;
+    removed: number;
+    listed: number;
+    slots: (GrassSlotReading & {
+        surfels?: GrassSurfelReading[];
+    })[];
+}>;
+export type GrassSlotReading = {
+    slot: number;
+    /**
+     * the surface's `transforms` row
+     */
+    surface: number;
+    level: number;
+    layer: number;
+    /**
+     * `[x, z]`, in tiles of the level
+     */
+    tile: number[];
+    /**
+     * `GRASS_SLOT_STATE_*`
+     */
+    state: number;
+    wanted_frame: number;
+    layer_count: number;
+    surfel_count: number;
+};
+export type GrassSurfelReading = {
+    /**
+     * column along the tile's x, `[0, GRASS_TILE_COLUMNS)`
+     */
+    x: number;
+    /**
+     * column along the tile's z
+     */
+    z: number;
+    /**
+     * along the frame's up axis
+     */
+    height: number;
+    /**
+     * the member's `meshes` row
+     */
+    member: number;
+    clear_height: number;
+    density: number;
+};
+//# sourceMappingURL=read_grass_surfaces.d.ts.map

package/src/shade/playground/grass_surfaces/read_grass_surfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read_grass_surfaces.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/grass_surfaces/read_grass_surfaces.js"],"names":[],"mappings":"AAqEA;;;;;;;;;GASG;AACH,iEALW,OAAO,kDAAkD,EAAE,gBAAgB,iBAC3E,OAAO,GACL,QAAQ;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,gBAAgB,GAAG;QAAC,OAAO,CAAC,EAAE,kBAAkB,EAAE,CAAA;KAAC,CAAC,EAAE,CAAA;CAAC,CAAC,CA+G5L;;UAtKa,MAAM;;;;aACN,MAAM;WACN,MAAM;WACN,MAAM;;;;UACN,MAAM,EAAE;;;;WACR,MAAM;kBACN,MAAM;iBACN,MAAM;kBACN,MAAM;;;;;;OAKN,MAAM;;;;OACN,MAAM;;;;YACN,MAAM;;;;YACN,MAAM;kBACN,MAAM;aACN,MAAM"}