reze-engine 0.68.1 → 0.68.2

package/src/shaders/passes/aov.ts

@@ -0,0 +1,187 @@
+import { sceneLightApi } from "../scene-light-api"
+import { lightsApi, MAX_LIGHTS } from "../lights"
+
+/**
+ * The frame, read back as numbers — what an agent (or a test) measures instead
+ * of squinting at a picture.
+ *
+ * A screenshot answers "what does it look like". It cannot answer the questions
+ * a lighting artist actually asks of a render: is her face in the sun's shadow,
+ * which lamp is carrying the key, how many stops over is that highlight, which
+ * pixels are skin. Every one of those is a number the frame already computed
+ * and threw away; these passes keep them.
+ *
+ * TWO ENTRY POINTS over one prelude:
+ *
+ *   pixels — one invocation per texel of the frame just rendered. Reads the id
+ *            attachment, the depth and the linear HDR resolve, rebuilds the
+ *            world point from the depth and a normal from its neighbours, and
+ *            asks the same shadow atlas and lamp records the materials asked.
+ *   probe  — the same light questions at points the caller names (a bone, a
+ *            face), with each lamp's share kept apart.
+ *
+ * The normal is RECONSTRUCTED from depth, not the one the material shaded
+ * with: the frame never stores normals, and storing them for every frame to
+ * serve an occasional readback would be the cost the id attachment's
+ * store-only-when-read rule exists to avoid. On a silhouette edge it is the
+ * flatter of the two neighbours, which is right for every texel that is not
+ * the edge itself.
+ */
+
+/** Floats per texel in the pixels output — see PIXEL_FIELDS. */
+export const AOV_PIXEL_STRIDE = 12
+
+/** What each of a texel's floats is, in order. */
+export const AOV_PIXEL_FIELDS = [
+  "r", "g", "b", // linear HDR, before exposure and the view transform
+  "depth", // distance from the eye, world units; 0 where nothing drew
+  "sunShadow", // 1 lit, 0 in a caster's shadow; -1 where nothing drew
+  "sunFacing", // N·L toward the sun, -1..1 (the toon ramp's input)
+  "lampR", "lampG", "lampB", // every positional lamp's light arriving here
+  "ambR", "ambG", "ambB", // the world's light arriving here
+] as const
+
+/** Floats per probe point before its per-lamp block. */
+export const AOV_PROBE_HEAD = 12
+/** Floats per probe point: the head, then rgb+pad for every lamp slot. */
+export const AOV_PROBE_STRIDE = AOV_PROBE_HEAD + MAX_LIGHTS * 4
+
+// Bindings 0..3 are the scene light API, 4..6 the lamps and their cookies.
+const PRELUDE = /* wgsl */ `
+${sceneLightApi(true, 0, 0)}
+${lightsApi(0, 4, "0xffffffffu", { binding: 5, sampler: "_aovSampler" })}
+@group(0) @binding(6) var _aovSampler: sampler;
+
+/** The sun's cast shadow at p, nudged along n off the surface — the
+ *  materials' rzSunOcclusion, without the facing test (sunFacing carries it). */
+fn aovSunShadow(p: vec3f, n: vec3f) -> f32 {
+  let castAmt = _rzLight.lights[0].direction.w;
+  if (castAmt <= 0.0) { return 1.0; }
+  let a = _rzSunLocate(p + n * 0.08);
+  if (a.w < 0.0) { return 1.0; }
+  return mix(1.0, _rzSunTaps(a), castAmt);
+}
+
+fn aovToSun() -> vec3f { return normalize(-_rzLight.lights[0].direction.xyz); }
+`
+
+export const AOV_PIXELS_WGSL = /* wgsl */ `
+${PRELUDE}
+@group(0) @binding(7) var idTex: texture_multisampled_2d<u32>;
+@group(0) @binding(8) var depthTex: texture_depth_multisampled_2d;
+@group(0) @binding(9) var hdrTex: texture_2d<f32>;
+struct AovU { invViewProj: mat4x4f, eye: vec4f, size: vec4u, }
+@group(0) @binding(10) var<uniform> u: AovU;
+@group(0) @binding(11) var<storage, read_write> outF: array<f32>;
+@group(0) @binding(12) var<storage, read_write> outId: array<u32>;
+
+fn worldAt(c: vec2i, z: f32) -> vec3f {
+  let uv = (vec2f(c) + 0.5) / vec2f(u.size.xy);
+  let h = u.invViewProj * vec4f(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, z, 1.0);
+  return h.xyz / h.w;
+}
+
+fn drawn(c: vec2i) -> bool {
+  if (any(c < vec2i(0)) || any(c >= vec2i(u.size.xy))) { return false; }
+  let id = textureLoad(idTex, c, 0).xy;
+  return id.x != 0u || id.y != 0u;
+}
+
+/** The step from p to the neighbour at c + d (or c - d, negated), whichever is
+ *  nearer in depth: across a silhouette the far neighbour belongs to something
+ *  else, and a normal built from it tilts toward the background. */
+fn tangent(c: vec2i, d: vec2i, p: vec3f) -> vec3f {
+  let a = c + d;
+  let b = c - d;
+  let okA = drawn(a);
+  let okB = drawn(b);
+  var ta = vec3f(0.0);
+  var tb = vec3f(0.0);
+  if (okA) { ta = worldAt(a, textureLoad(depthTex, a, 0)) - p; }
+  if (okB) { tb = p - worldAt(b, textureLoad(depthTex, b, 0)); }
+  if (okA && okB) { return select(tb, ta, dot(ta, ta) <= dot(tb, tb)); }
+  if (okA) { return ta; }
+  return tb;
+}
+
+@compute @workgroup_size(8, 8)
+fn pixels(@builtin(global_invocation_id) gid: vec3u) {
+  if (gid.x >= u.size.x || gid.y >= u.size.y) { return; }
+  let c = vec2i(gid.xy);
+  let i = gid.y * u.size.x + gid.x;
+  let o = i * ${AOV_PIXEL_STRIDE}u;
+  let id = textureLoad(idTex, c, 0).xy;
+  let rgb = textureLoad(hdrTex, c, 0).rgb;
+  // Material in the low half, object in the high — the attachment's own order
+  // (scene-contract: vec2u(material, object)).
+  outId[i] = (id.y << 16u) | (id.x & 0xffffu);
+  outF[o] = rgb.r;
+  outF[o + 1u] = rgb.g;
+  outF[o + 2u] = rgb.b;
+  for (var k = 3u; k < ${AOV_PIXEL_STRIDE}u; k++) { outF[o + k] = 0.0; }
+  if (id.x == 0u && id.y == 0u) {
+    outF[o + 4u] = -1.0;
+    return;
+  }
+  let p = worldAt(c, textureLoad(depthTex, c, 0));
+  var n = cross(tangent(c, vec2i(0, 1), p), tangent(c, vec2i(1, 0), p));
+  let toEye = u.eye.xyz - p;
+  if (dot(n, n) < 1e-12) { n = toEye; }
+  n = normalize(n);
+  // Toward the eye: the side of the surface this texel shows.
+  if (dot(n, toEye) < 0.0) { n = -n; }
+  let lamps = rzLightsDiffuse(p, n);
+  let amb = rzWorldAmbient(n);
+  outF[o + 3u] = length(toEye);
+  outF[o + 4u] = aovSunShadow(p, n);
+  outF[o + 5u] = dot(n, aovToSun());
+  outF[o + 6u] = lamps.r;
+  outF[o + 7u] = lamps.g;
+  outF[o + 8u] = lamps.b;
+  outF[o + 9u] = amb.r;
+  outF[o + 10u] = amb.g;
+  outF[o + 11u] = amb.b;
+}
+`
+
+export const AOV_PROBE_WGSL = /* wgsl */ `
+${PRELUDE}
+struct ProbePoint { p: vec4f, n: vec4f, }
+@group(0) @binding(7) var<storage, read> points: array<ProbePoint>;
+@group(0) @binding(8) var<storage, read_write> outF: array<f32>;
+
+@compute @workgroup_size(1)
+fn probe(@builtin(global_invocation_id) gid: vec3u) {
+  let i = gid.x;
+  if (i >= arrayLength(&points)) { return; }
+  let p = points[i].p.xyz;
+  let n = normalize(points[i].n.xyz);
+  let o = i * ${AOV_PROBE_STRIDE}u;
+  // Colour and strength travel apart in the light uniform (writeSun); the
+  // light arriving is their product.
+  let sun = _rzLight.lights[0].color.rgb * _rzLight.lights[0].color.w;
+  let amb = rzWorldAmbient(n);
+  outF[o] = aovSunShadow(p, n);
+  outF[o + 1u] = dot(n, aovToSun());
+  outF[o + 2u] = sun.r;
+  outF[o + 3u] = sun.g;
+  outF[o + 4u] = sun.b;
+  outF[o + 5u] = amb.r;
+  outF[o + 6u] = amb.g;
+  outF[o + 7u] = amb.b;
+  let count = rzLightCount();
+  outF[o + 8u] = f32(count);
+  // The document's lamps come first (setLights order); the rest are effects'.
+  outF[o + 9u] = f32(_rzLightDocCount());
+  for (var k = 10u; k < ${AOV_PROBE_HEAD}u; k++) { outF[o + k] = 0.0; }
+  for (var l = 0u; l < ${MAX_LIGHTS}u; l++) {
+    var c = vec3f(0.0);
+    if (l < count) { c = _rzLightOne(l, p, n); }
+    let b = o + ${AOV_PROBE_HEAD}u + l * 4u;
+    outF[b] = c.r;
+    outF[b + 1u] = c.g;
+    outF[b + 2u] = c.b;
+    outF[b + 3u] = 0.0;
+  }
+}
+`

package/dist/graph/presets/pool_floor.d.ts

@@ -1,3 +0,0 @@
-import type { ShaderGraph } from "../schema";
-export declare const POOL_FLOOR_GRAPH: ShaderGraph;
-//# sourceMappingURL=pool_floor.d.ts.map

package/dist/graph/presets/pool_floor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pool_floor.d.ts","sourceRoot":"","sources":["../../../src/graph/presets/pool_floor.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,eAAO,MAAM,gBAAgB,EAAE,WA6B9B,CAAA"}

package/dist/graph/presets/pool_floor.js

@@ -1,42 +0,0 @@
-// Pool floor — the tiled bottom seen through water, with caustics on it.
-//
-// The other half of a pool, and the half that does most of the work. A water
-// surface can be tuned for a long time without the shot reading as a pool;
-// putting the focused-light web on the FLOOR is what settles it, because that
-// is the cue a photograph actually carries. It is a floor material, so it is
-// applied to the tile under the water rather than to the water itself.
-//
-// Caustics land between the albedo and the shading deliberately: they are
-// light, so they should still be dimmed by the floor's own shadow rather than
-// glowing through it. That is the difference between water-focused sun and a
-// decal.
-export const POOL_FLOOR_GRAPH = {
-    version: 1,
-    name: "Pool floor",
-    tags: ["stage", "water", "pool"],
-    nodes: [
-        { id: "tex", type: "texture" },
-        { id: "mat", type: "material_diffuse" },
-        { id: "base", type: "mix/multiply", inputs: { fac: 1.0 } },
-        { id: "caust", type: "caustics" },
-        {
-            id: "principled",
-            type: "principled",
-            inputs: { metallic: 0.0, specular_ior_level: 0.4, roughness: 0.45, spec_clamp: 10.0, sheen_weight: 0.0, sheen_tint: 0.0 },
-        },
-    ],
-    links: [
-        { from: { node: "tex", socket: "color" }, to: { node: "base", socket: "a" } },
-        { from: { node: "mat", socket: "color" }, to: { node: "base", socket: "b" } },
-        { from: { node: "base", socket: "color" }, to: { node: "caust", socket: "color" } },
-        { from: { node: "caust", socket: "color" }, to: { node: "principled", socket: "base_color" } },
-    ],
-    output: { node: "principled", socket: "color" },
-    params: [
-        { id: "tint", label: "Light tint", target: { node: "caust", socket: "tint" }, kind: "color", default: [1.0, 1.0, 1.0] },
-        { id: "scale", label: "Caustic scale", target: { node: "caust", socket: "scale" }, kind: "float", min: 0.01, max: 1, default: 0.12 },
-        { id: "speed", label: "Caustic speed", target: { node: "caust", socket: "speed" }, kind: "float", min: 0, max: 1, default: 0.15 },
-        { id: "strength", label: "Caustic strength", target: { node: "caust", socket: "strength" }, kind: "float", min: 0, max: 3, default: 0.6 },
-        { id: "fade", label: "Depth fade", target: { node: "caust", socket: "fade" }, kind: "float", min: 1, max: 200, default: 30 },
-    ],
-};

package/dist/graph/presets/water.d.ts

@@ -1,3 +0,0 @@
-import type { ShaderGraph } from "../schema";
-export declare const WATER_GRAPH: ShaderGraph;
-//# sourceMappingURL=water.d.ts.map

package/dist/graph/presets/water.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"water.d.ts","sourceRoot":"","sources":["../../../src/graph/presets/water.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,eAAO,MAAM,WAAW,EAAE,WAgBzB,CAAA"}

package/dist/graph/presets/water.js

@@ -1,31 +0,0 @@
-// Water — a planar reflection, rippled, seen through Fresnel.
-//
-// Put a stage's water materials in a style group carrying this graph and the
-// pool starts reflecting. The reflection itself is the engine's mirror pass,
-// which this is the only graph to read; everything else here is the shaping
-// that keeps it from reading as a mirror laid flat in the floor.
-//
-// The exposed params are the ones worth a slider while judging a shot. Scale
-// and speed are the ripple; a real pool's surface is slow and broad, so both
-// defaults sit low. Tint is the water's own colour — a game rip carries that
-// in its material, and the converter hands it straight over.
-//
-// How see-through the water is belongs to the MATERIAL's alpha, not to this
-// graph, which is where every other group's coverage comes from too.
-export const WATER_GRAPH = {
-    version: 1,
-    name: "Water",
-    tags: ["water", "stage"],
-    nodes: [{ id: "water", type: "water" }],
-    links: [],
-    output: { node: "water", socket: "color" },
-    params: [
-        { id: "tint", label: "Tint", target: { node: "water", socket: "tint" }, kind: "color", default: [0.04, 0.62, 0.66] },
-        { id: "scale", label: "Ripple scale", target: { node: "water", socket: "scale" }, kind: "float", min: 0.01, max: 1, default: 0.18 },
-        { id: "speed", label: "Ripple speed", target: { node: "water", socket: "speed" }, kind: "float", min: 0, max: 1, default: 0.12 },
-        { id: "strength", label: "Ripple depth", target: { node: "water", socket: "strength" }, kind: "float", min: 0, max: 2, default: 0.7 },
-        { id: "blur", label: "Reflection blur", target: { node: "water", socket: "blur" }, kind: "float", min: 0, max: 1, default: 0.25 },
-        { id: "mirroring", label: "Mirroring", target: { node: "water", socket: "mirroring" }, kind: "float", min: 0, max: 1, default: 0.20 },
-        { id: "sparkle", label: "Sparkle", target: { node: "water", socket: "sparkle" }, kind: "float", min: 0, max: 4, default: 1.0 },
-    ],
-};

package/dist/physics/autofit.d.ts

@@ -1,147 +0,0 @@
-import { type Rigidbody } from "./types";
-import type { Skinning } from "../model";
-/**
- * Supplementary colliders fitted to the mesh a PMX rigid body fails to cover.
- *
- * PMX body proxies are bodies of revolution — 下半身 is a capsule lying
- * transversely across the hips, so its cross-section is a circle. A pelvis seen
- * from the side is not a circle, and across every rig measured the butt sits
- * 0.18–0.71 units OUTSIDE that capsule while the front is flush or inside. That
- * gap is where a skirt goes through a character: the cloth is resting correctly
- * on the collider it was given, and the collider stops half a unit short of the
- * skin.
- *
- * A rest offset cannot close it (see RigidBodyStore.restOffset) — it is one
- * scalar on a radially symmetric shape, and the error is asymmetric. Measured
- * on 托特's run cycle, the offset that clears the butt is 0.5, which is simply
- * the size of the missing geometry, and at that value the skirt stands off the
- * front and hips by the same 0.5.
- *
- * So fit the missing piece instead: take each bone-following body's own skinned
- * vertices, find the ones that escape its shape in a concentrated lobe, and fit
- * a capsule to that lobe. That is the fix riggers apply by hand, derived from
- * the mesh rather than guessed.
- *
- * Measured on 托特's run cycle, counting butt vertices swallowed by a cloth
- * body: 32.4 per frame with nothing, 30.9 with a 0.02 rest offset, 12.4 with
- * this pass, 10.4 with both.
- */
-export interface AutoFitOptions {
-    /** A vertex counts as protruding past this much (model units). Below it the
-     *  mesh is within authoring tolerance of the proxy and needs no help. */
-    minProtrusion?: number;
-    /**
-     * Ignore vertices further out than this multiple of the source shape's
-     * RADIUS (its smallest characteristic dimension).
-     *
-     * A coarse first cut at keeping hair and loose clothing out — anything
-     * standing further off the proxy than the proxy is wide is not skin. The
-     * discriminator that actually does the work is minConcentration.
-     */
-    maxProtrusionRatio?: number;
-    /** Fewer protruding vertices than this and it is a spike, not a region. */
-    minVertices?: number;
-    /**
-     * Per-axis quantile the fitted lobe's extent is clipped to, each end. A
-     * handful of stray vertices (a weight-painting slip, a seam) would otherwise
-     * stretch the capsule far past the surface everyone can see.
-     */
-    quantile?: number;
-    /** Skip the fit unless the capsule actually reaches this far past what is
-     *  already covered — otherwise it adds solver rows for nothing. */
-    minGain?: number;
-    /** How tightly the kept lobe's outward directions must agree, 0–1. A loose
-     *  sanity check; the real discriminator is minConcentration. */
-    minDirectionality?: number;
-    /** Vertices outside the dominant lobe, by this cosine, are not part of the
-     *  feature being fitted. */
-    lobeCos?: number;
-    /**
-     * How much deeper the fitted lobe must be than protrusion typically is on
-     * this body, averaged over the vertices that protrude at all.
-     *
-     * This is the guard that separates "the proxy is missing a lobe" from "the
-     * proxy is not a proxy for this mesh at all". A pelvis escapes its capsule by
-     * 0.53 at the back and 0.14 at the front, so the back lobe stands well clear
-     * of the average. Hair escapes the skull by a similar depth in every
-     * direction, so its deepest lobe is no deeper than typical and the ratio sits
-     * near 1. See the note at the meanProtrusion computation for what this
-     * deliberately refuses to fit.
-     *
-     * Without it the pass fits the hairstyle — measured on 托特, 頭 reports
-     * 3653 of 4669 vertices outside its capsule, and the fitted shape was a crate
-     * around the whole head. No threshold on depth or vertex count tells those
-     * two cases apart; concentration does.
-     */
-    minConcentration?: number;
-    /**
-     * How many capsules may be fitted to one body, each against what the previous
-     * ones already cover.
-     *
-     * One capsule inscribed in a lobe does not fill it — on 托特's butt a single
-     * fit removed 58% of the clipping and left the rest at the edges the capsule
-     * could not reach. Each further pass re-measures protrusion against the
-     * original shape UNION everything fitted so far, so it lands on whatever is
-     * still exposed instead of re-fitting the same bulge.
-     */
-    maxShapesPerBody?: number;
-    /**
-     * Quantile of the lobe's perpendicular spread used as the capsule radius.
-     *
-     * The clip-versus-float dial, and the one to reach for if a result looks
-     * wrong. Lower hugs the body: less standoff in idle, more clipping left. 1.0
-     * encloses the lobe entirely, which is what produced a visibly hovering
-     * skirt on 托特.
-     */
-    radiusQuantile?: number;
-    /**
-     * Fit only the deepest part of each lobe: points at least this fraction of
-     * the lobe's own maximum protrusion.
-     *
-     * A lobe tapers to nothing at its edges, and a capsule sized to span the
-     * whole thing has to be fat enough to reach the edges too. Fitting the deep
-     * core keeps each capsule small and lets a later pass handle the shallows
-     * with its own, which is both tighter and closer to what the surface is
-     * actually doing.
-     */
-    lobeDepthFraction?: number;
-}
-/** What the pass decided for one source body — surfaced so a rig can be
- *  inspected rather than silently rebuilt underneath its author. */
-export interface AutoFitResult {
-    /** Index of the body in the input array that this supplements. */
-    sourceIndex: number;
-    sourceName: string;
-    /** Vertices dominated by that body's bone, and how many were outside it. */
-    vertexCount: number;
-    protrudingCount: number;
-    /** Furthest any kept vertex sat outside the source shape. */
-    maxProtrusion: number;
-    /** How far the fitted capsule reaches past what was already covered. */
-    gain: number;
-    /** Length of the kept lobe's mean outward direction, 0–1. */
-    directionality: number;
-    /** Lobe depth over the body's average protrusion. See minConcentration. */
-    concentration: number;
-    /**
-     * Furthest the capsule's newly exposed surface sits from the skin it was
-     * fitted to — the amount cloth resting on it will stand off the body at the
-     * worst point, and the number to watch if a result looks puffy. Only the part
-     * reaching outside the source shape is measured; the rest is buried.
-     */
-    overshoot: number;
-    body: Rigidbody;
-}
-/**
- * Fit supplementary colliders for every bone-following body whose own mesh
- * escapes it.
- *
- * `vertices` is the model's interleaved vertex buffer (stride 8, position
- * first) and `skinning` its joints/weights — both in PMX bind pose, the same
- * space as `shapePosition` / `shapeRotation`, so nothing has to be skinned.
- *
- * Returns one entry per body it chose to supplement; the caller appends
- * `.body` to the rigid body list before constructing RezePhysics.
- */
-export declare function fitSupplementaryColliders(rigidbodies: Rigidbody[], vertices: Float32Array, skinning: Skinning, options?: AutoFitOptions): AutoFitResult[];
-//# sourceMappingURL=autofit.d.ts.map

package/dist/physics/autofit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"autofit.d.ts","sourceRoot":"","sources":["../../src/physics/autofit.ts"],"names":[],"mappings":"AACA,OAAO,EAAiC,KAAK,SAAS,EAAE,MAAM,SAAS,CAAA;AACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,cAAc;IAC7B;6EACyE;IACzE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;OAOG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,2EAA2E;IAC3E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;uEACmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;oEACgE;IAChE,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B;gCAC4B;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;;;;;;;;;;;;;OAgBG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;;;;;OASG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB;;;;;;;;;OASG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AA2BD;oEACoE;AACpE,MAAM,WAAW,aAAa;IAC5B,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;IAClB,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAA;IACnB,eAAe,EAAE,MAAM,CAAA;IACvB,6DAA6D;IAC7D,aAAa,EAAE,MAAM,CAAA;IACrB,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAA;IACZ,6DAA6D;IAC7D,cAAc,EAAE,MAAM,CAAA;IACtB,2EAA2E;IAC3E,aAAa,EAAE,MAAM,CAAA;IACrB;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,SAAS,CAAA;CAChB;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,SAAS,EAAE,EACxB,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,cAAmB,GAC3B,aAAa,EAAE,CA4CjB"}