@3driseai/3drise-viewer 0.1.16 → 0.1.17

package/dist/components/effects/PlanetaryRingsEffect.js

@@ -0,0 +1,458 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { useFrame } from '@react-three/fiber';
+import { applyGenerativeAnimations } from '../../utils/handleGenerativeEffectsAnimations.js';
+import { useObjectReady } from '../../hooks/useObjectReady.js';
+/**
+ * A Saturn-like ring system: Keplerian shear shapes icy clumps, resonant moons open gaps and spiral density waves, and the planet casts a soft shadow. Use for planets, sci-fi, space scenes.
+ *
+ * Ω ∝ r^−3/2 · gaps at r = r_moon (q/p)^(2/3) · wave phase m(θ−θ_moon) − kΔr² · I/F = ϖ₀P(α)μ₀/4(μ+μ₀)·(1−e^(−τ(1/μ+1/μ₀)))
+ */
+const NOISE3 = /* glsl */ `
+  float hash13(vec3 p3){
+    p3 = fract(p3 * 0.1031);
+    p3 += dot(p3, p3.zyx + 31.32);
+    return fract((p3.x + p3.y) * p3.z);
+  }
+  float vnoise(vec3 p){
+    vec3 i = floor(p);
+    vec3 f = fract(p);
+    f = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);
+    float n000 = hash13(i);
+    float n100 = hash13(i + vec3(1.0, 0.0, 0.0));
+    float n010 = hash13(i + vec3(0.0, 1.0, 0.0));
+    float n110 = hash13(i + vec3(1.0, 1.0, 0.0));
+    float n001 = hash13(i + vec3(0.0, 0.0, 1.0));
+    float n101 = hash13(i + vec3(1.0, 0.0, 1.0));
+    float n011 = hash13(i + vec3(0.0, 1.0, 1.0));
+    float n111 = hash13(i + vec3(1.0, 1.0, 1.0));
+    return mix(mix(mix(n000, n100, f.x), mix(n010, n110, f.x), f.y),
+               mix(mix(n001, n101, f.x), mix(n011, n111, f.x), f.y), f.z);
+  }
+  // low-frequency fBm; the rotation between octaves hides the lattice
+  const mat3 FBM_ROT = mat3(0.00, 0.80, 0.60, -0.80, 0.36, -0.48, -0.60, -0.48, 0.64);
+  float fbm3(vec3 p, int octaves){
+    float a = 0.5, s = 0.0;
+    for (int i = 0; i < 5; i++){
+      if (i >= octaves) break;
+      s += a * vnoise(p);
+      p = FBM_ROT * p * 2.02;
+      a *= 0.5;
+    }
+    return s;
+  }
+`;
+// ---------------------------------------------------------------------------
+// A ring system is a differentially rotating disc of icy particles.
+//  * Kepler: Omega(r) = Omega_in (r_in / r)^(3/2). Neighbouring orbits shear
+//    past each other, so any clump is drawn out into a trailing streak. The
+//    clump texture is advected by a two-phase flow map (two copies of the same
+//    noise, each restarted half a cycle apart and cross-faded) so the pattern
+//    shears the way the gas does but never winds up.
+//  * Resonances: a moon at r_m forces the ring where the orbital periods are
+//    commensurate, r = r_m (q/p)^(2/3). Strong resonances clear gaps (2:1 with
+//    a Mimas-like moon = the Cassini division); the rest launch spiral density
+//    waves whose wavenumber grows linearly with distance from resonance, so
+//    the phase goes as m(theta - theta_moon) - k dr^2: a tight wave train that
+//    damps out within a few tens of wavelengths.
+//  * Light: a ring is an optically thin-to-thick slab. Single scattering gives
+//    I/F = w0 P(alpha) mu0 / (4 (mu + mu0)) (1 - exp(-tau (1/mu + 1/mu0)))
+//    on the lit side, and the transmitted form on the unlit side, where the
+//    dense B ring goes dark and only the thin parts glow. P(alpha) mixes a
+//    backscattering Lambert-sphere phase for the big particles with a
+//    Henyey-Greenstein lobe (g = 0.72) for the dust, which is why dusty
+//    ringlets and spokes blaze when the rings are lit from behind.
+// ---------------------------------------------------------------------------
+const ringCommon = /* glsl */ `
+  uniform float uTime;
+  uniform float uBound;
+  uniform float uInnerRadius;
+  uniform float uOuterRadius;
+  uniform float uMoons;
+  const float PI = 3.14159265359;
+  const float OMEGA_IN = 0.13;
+
+  float ringR(float x){ return (uInnerRadius + x * (uOuterRadius - uInnerRadius)) * uBound; }
+  float kepler(float r){ return OMEGA_IN * pow(max(uInnerRadius * uBound, 1e-4) / max(r, 1e-4), 1.5); }
+
+  // moon 0: Mimas-like, its 2:1 resonance is the Cassini division at x = 0.56
+  // moon 1: Janus-like, its 7:6 resonance truncates the A ring at x = 0.945
+  // moon 2: Pan, inside the Encke gap at x = 0.825
+  float moonRadius(int idx){
+    if (idx == 0) return ringR(0.56) / pow(0.5, 0.66666667);
+    if (idx == 1) return ringR(0.945) / pow(6.0 / 7.0, 0.66666667);
+    return ringR(0.825);
+  }
+  float moonPhase(int idx){
+    float r = moonRadius(idx);
+    return kepler(r) * uTime + float(idx) * 2.1;
+  }
+`;
+const ringVert = /* glsl */ `
+  uniform float uOuterRadius;
+  uniform float uBound;
+  varying vec3 vLocal;
+  varying vec3 vWorld;
+  varying vec3 vNormal;
+  varying vec3 vCenter;
+  void main(){
+    vec3 p = vec3(position.x, 0.0, -position.y) * uOuterRadius * uBound * 1.06;
+    vLocal = p;
+    vec4 wp = modelMatrix * vec4(p, 1.0);
+    vWorld = wp.xyz;
+    vNormal = normalize(mat3(modelMatrix) * vec3(0.0, 1.0, 0.0));
+    vCenter = (modelMatrix * vec4(0.0, 0.0, 0.0, 1.0)).xyz;
+    gl_Position = projectionMatrix * viewMatrix * wp;
+  }
+`;
+const ringFrag = /* glsl */ `
+  uniform vec3 uColor;
+  uniform vec3 uGapColor;
+  uniform vec3 uDustColor;
+  uniform float uIntensity;
+  uniform float uOpacity;
+  uniform float uSpokes;
+  uniform float uForwardScatter;
+  uniform float uSunAngle;
+  uniform float uSunElevation;
+  uniform float uHasHost;
+  ${ringCommon}
+  ${NOISE3}
+  varying vec3 vLocal;
+  varying vec3 vWorld;
+  varying vec3 vNormal;
+  varying vec3 vCenter;
+
+  float edgeAt(float x, float e, float w){ return smoothstep(e - w, e + w, x); }
+  float bandAt(float x, float a, float b, float w){ return edgeAt(x, a, w) * (1.0 - edgeAt(x, b, w)); }
+
+  // clumpy ring texture, sampled on the ring embedded in 3D so it wraps in angle
+  float clumps(float th, float r, float cyc, float lod){
+    float ka = 13.0, kr = 22.0;
+    vec3 q = vec3(cos(th), sin(th), 0.0) * (r / uBound) * ka + vec3(0.0, 0.0, r / uBound * kr + cyc * 13.7);
+    float n = vnoise(q) * 0.62 + vnoise(q * 2.3 + 11.0) * 0.38;
+    return mix(0.5, n, 1.0 - smoothstep(0.35, 1.0, lod));
+  }
+
+  void main(){
+    float r = length(vLocal.xz);
+    float th = atan(vLocal.z, vLocal.x);
+    float rin = uInnerRadius * uBound;
+    float rout = uOuterRadius * uBound;
+    float span = max(rout - rin, 1e-4);
+    float x = (r - rin) / span;
+    if (x < -0.05 || x > 1.05) discard;
+    float aa = fwidth(r) / span;
+    float w = max(aa, 0.0012);
+
+    float m1 = step(0.5, uMoons);
+    float m2 = step(1.5, uMoons);
+    float m3 = step(2.5, uMoons);
+
+    // ---- radial optical depth profile ------------------------------------
+    float tau = 0.0;
+    float dusty = 0.0;
+    // C ring: thin, dusty, with a few ringlets
+    float cR = bandAt(x, 0.005, 0.2, w * 2.0);
+    tau += cR * (0.16 + 0.07 * sin(x * 120.0));
+    dusty += cR * 0.75;
+    // B ring: the dense one, brightest in its middle
+    float bOut = mix(0.62, 0.56, m1);
+    float bR = bandAt(x, 0.2, bOut, w);
+    tau += bR * (1.5 + 1.1 * smoothstep(0.2, 0.36, x) - 0.75 * smoothstep(0.42, bOut, x));
+    // A ring
+    float aIn = mix(0.62, 0.645, m1);
+    float aOut = mix(1.0, 0.945, m2);
+    float aR = bandAt(x, aIn, aOut, w);
+    tau += aR * (0.85 - 0.3 * smoothstep(aIn, aOut, x));
+    // Cassini division: not empty, a few faint ringlets of darker material
+    float cass = bandAt(x, 0.56, 0.645, w) * m1;
+    tau += cass * (0.06 + 0.07 * smoothstep(0.55, 0.75, sin(x * 210.0)));
+    dusty += cass * 0.4;
+    // Encke gap with Pan inside, and the narrow dusty F ring
+    float encke = exp(-pow((x - 0.825) / 0.0085, 2.0)) * m3;
+    tau *= 1.0 - 0.94 * encke;
+    dusty += encke * 0.6;
+    float fRing = exp(-pow((x - 0.995) / 0.005, 2.0)) * m2;
+    tau += fRing * 0.3;
+    dusty += fRing * 0.9;
+    if (m2 < 0.5) tau *= 1.0 - smoothstep(0.95, 1.0, x);
+
+    // ---- spiral density waves from the resonances ------------------------
+    float wave = 0.0;
+    for (int k = 0; k < 2; k++){
+      if (float(k) + 0.5 > uMoons) break;
+      float rm = moonRadius(k);
+      float thm = moonPhase(k);
+      for (int m = 2; m <= 7; m++){
+        float fm = float(m);
+        float rres = rm * pow((fm - 1.0) / fm, 0.66666667);
+        float dr = r - rres;
+        if (dr < 0.0 || dr > 0.3 * uBound) continue;
+        float lam = 0.08 * uBound;
+        float dpsi = 2.0 * 6.2831853 * dr / (lam * lam);
+        float psi = fm * (th - thm) - 6.2831853 * dr * dr / (lam * lam);
+        float amp = smoothstep(0.0, 0.25 * lam, dr) * exp(-dr / (0.22 * uBound)) / fm;
+        amp *= 1.0 - smoothstep(0.2, 0.7, fwidth(r) * dpsi / 6.2831853);
+        wave += amp * sin(psi);
+      }
+    }
+    tau *= 1.0 + 0.85 * wave;
+
+    // ringlets: axisymmetric fine structure, faded out when a pixel spans several
+    float rl = 0.0;
+    float rlLod = fwidth(x);
+    for (int i = 0; i < 4; i++){
+      float f = 42.0 * pow(1.9, float(i));
+      float amp = 0.3 / pow(1.7, float(i));
+      rl += amp * sin(x * f + float(i) * 2.3) * (1.0 - smoothstep(0.12, 0.45, rlLod * f / 6.2831853));
+    }
+    tau *= 1.0 + 0.55 * rl;
+
+    // ---- clumps advected by the Keplerian shear (two-phase flow map) -----
+    float om = kepler(r);
+    float T = 9.0;
+    float u = uTime / T;
+    float kA = floor(u), kB = floor(u + 0.5);
+    float eA = (u - kA) * T, eB = (u + 0.5 - kB) * T;
+    float wA = 1.0 - abs(2.0 * (u - kA) - 1.0);
+    float lod = fwidth(r) / uBound * 22.0;
+    float nA = clumps(th - om * eA, r, kA, lod);
+    float nB = clumps(th - om * eB, r, kB, lod);
+    float n = mix(nB, nA, wA);
+    tau *= 0.72 + 0.6 * n;
+
+    // ---- spokes: dust lifted above the ring, turning with the planet ------
+    float spoke = 0.0;
+    if (uSpokes > 0.002){
+      float sa = th - kepler(ringR(0.4)) * uTime;
+      float sn = vnoise(vec3(cos(sa) * 5.5, sin(sa) * 5.5, uTime * 0.02 + 4.0));
+      spoke = smoothstep(0.55, 0.78, sn) * bandAt(x, 0.21, 0.55, 0.06);
+      spoke *= 0.45 + 0.55 * vnoise(vec3(cos(sa) * 16.0, sin(sa) * 16.0, x * 2.0));
+      spoke *= uSpokes;
+      tau += spoke * 0.1;
+      dusty += spoke * 0.8;
+    }
+    tau = max(tau, 0.0);
+    if (tau < 0.002) discard;
+    dusty = clamp(dusty, 0.0, 1.0);
+
+    // ---- illumination ----------------------------------------------------
+    float el = radians(uSunElevation), az = radians(uSunAngle);
+    vec3 S = vec3(cos(el) * cos(az), sin(el), cos(el) * sin(az));
+    vec3 N = normalize(vNormal);
+    vec3 P = vWorld - vCenter;
+    vec3 V = normalize(cameraPosition - vWorld);
+    float sN = dot(S, N), vN = dot(V, N);
+    float mu0 = max(abs(sN), 0.03);
+    float mu = max(abs(vN), 0.03);
+    float cosA = clamp(dot(S, V), -1.0, 1.0);
+    float alpha = acos(cosA);
+    // Lambert-sphere phase for the big particles + an opposition surge
+    float pMac = (8.0 / (3.0 * PI)) * (sin(alpha) + (PI - alpha) * cosA) + 0.55 * exp(-alpha / 0.1);
+    // Henyey-Greenstein lobe for the dust (forward scattering)
+    float g = 0.72;
+    float cs = -cosA;
+    float hg = (1.0 - g * g) / pow(max(1.0 + g * g - 2.0 * g * cs, 1e-3), 1.5);
+    float fd = clamp(uForwardScatter * (0.25 + 0.75 * dusty), 0.0, 1.0);
+    float phase = mix(pMac, hg, fd);
+
+    // planet shadow: does the ray from here toward the sun hit the planet?
+    float shadow = 1.0;
+    if (uHasHost > 0.5){
+      float b = dot(P, S);
+      float d = sqrt(max(dot(P, P) - b * b, 0.0));
+      shadow = mix(1.0, smoothstep(uBound * 0.94, uBound * 1.14, d), step(b, 0.0));
+    }
+
+    float w0 = 0.62;
+    float I;
+    if (sN * vN > 0.0){
+      I = w0 * phase * mu0 / (4.0 * (mu + mu0)) * (1.0 - exp(-tau * (1.0 / mu + 1.0 / mu0)));
+    } else {
+      float dm = mu0 - mu;
+      float sgn = dm >= 0.0 ? 1.0 : -1.0;
+      float dd = max(abs(dm), 0.03) * sgn;
+      I = w0 * phase * mu0 / (4.0 * dd) * (exp(-tau / mu0) - exp(-tau / mu));
+    }
+    // self-gravity wakes: the clumps are elongated and shade each other, so the
+    // same optical depth still shows texture where the ring is saturated
+    I = max(I, 0.0) * shadow * (0.86 + 0.28 * n);
+    // spokes are dark against the bright lit side and bright against a dark one
+    I *= 1.0 - 0.6 * spoke * (1.0 - fd);
+
+    float a = (1.0 - exp(-tau / mu)) * uOpacity;
+    vec3 ice = mix(uGapColor, uColor, smoothstep(0.1, 0.7, tau));
+    vec3 col = I * mix(ice, uDustColor, fd * 0.45) * 10.0 * uIntensity;
+    // the outermost edge of the drawn disc fades so the quad never shows
+    a *= 1.0 - smoothstep(1.0, 1.045, x);
+    col *= 1.0 - smoothstep(1.0, 1.045, x);
+    if (a < 0.003) discard;
+    gl_FragColor = vec4(col * a, a);
+  }
+`;
+// Tiny moonlets: shepherds riding in the gaps they keep open.
+const moonVert = /* glsl */ `
+  attribute vec3 aMoon;   // index, phase offset, size
+  uniform float uSunAngle;
+  uniform float uSunElevation;
+  uniform float uHasHost;
+  ${ringCommon}
+  varying float vLit;
+  void main(){
+    int idx = int(aMoon.x + 0.5);
+    float rm = moonRadius(idx);
+    float ph = moonPhase(idx) + aMoon.y;
+    vec3 p = vec3(cos(ph) * rm, 0.0, sin(ph) * rm);
+    vec4 wp = modelMatrix * vec4(p, 1.0);
+    vec3 P = wp.xyz - (modelMatrix * vec4(0.0, 0.0, 0.0, 1.0)).xyz;
+    float el = radians(uSunElevation), az = radians(uSunAngle);
+    vec3 S = vec3(cos(el) * cos(az), sin(el), cos(el) * sin(az));
+    vec3 V = normalize(cameraPosition - wp.xyz);
+    float b = dot(P, S);
+    float d = sqrt(max(dot(P, P) - b * b, 0.0));
+    float shadow = uHasHost > 0.5 ? mix(1.0, smoothstep(uBound * 0.94, uBound * 1.14, d), step(b, 0.0)) : 1.0;
+    vLit = (0.12 + 0.88 * clamp(0.5 + 0.5 * dot(S, V), 0.0, 1.0)) * shadow * step(float(idx) + 0.5, uMoons);
+    vec4 mv = viewMatrix * wp;
+    gl_PointSize = aMoon.z * uBound * (26.0 / max(-mv.z, 0.05));
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+const moonFrag = /* glsl */ `
+  uniform vec3 uColor;
+  uniform float uIntensity;
+  uniform float uOpacity;
+  varying float vLit;
+  void main(){
+    float d = length(gl_PointCoord - 0.5) * 2.0;
+    if (d > 1.0 || vLit < 0.01) discard;
+    float core = smoothstep(1.0, 0.45, d);
+    float a = core * vLit * uOpacity;
+    if (a < 0.004) discard;
+    gl_FragColor = vec4(uColor * a * (0.7 + 0.5 * uIntensity), a);
+  }
+`;
+function createUniforms() {
+    return {
+        uTime: { value: 0 },
+        uSpeed: { value: 1 },
+        uIntensity: { value: 1 },
+        uOpacity: { value: 1 },
+        uColor: { value: new THREE.Color('#e9dcc2') },
+        uGapColor: { value: new THREE.Color('#8fa2b6') },
+        uDustColor: { value: new THREE.Color('#ffd3a1') },
+        uInnerRadius: { value: 1.35 },
+        uOuterRadius: { value: 2.6 },
+        uMoons: { value: 3 },
+        uSpokes: { value: 0.45 },
+        uForwardScatter: { value: 0.35 },
+        uSunAngle: { value: 45 },
+        uSunElevation: { value: 24 },
+        uBound: { value: 1 },
+        uHasHost: { value: 1 },
+    };
+}
+function applyConfig(u, c, bound, env) {
+    u.uSpeed.value = c.speed;
+    u.uIntensity.value = c.intensity;
+    u.uOpacity.value = c.opacity;
+    u.uColor.value.set(c.color);
+    u.uGapColor.value.set(c.gapColor);
+    u.uDustColor.value.set(c.dustColor);
+    u.uInnerRadius.value = c.innerRadius;
+    u.uOuterRadius.value = Math.max(c.outerRadius, c.innerRadius + 0.05);
+    u.uMoons.value = c.moons;
+    u.uSpokes.value = c.spokes;
+    u.uForwardScatter.value = c.forwardScatter;
+    u.uSunAngle.value = c.sunAngle;
+    u.uSunElevation.value = c.sunElevation;
+    u.uBound.value = bound;
+    u.uHasHost.value = env && env.hasHost ? 1 : 0;
+}
+function build(u, c, bound, env) {
+    const ringMat = new THREE.ShaderMaterial({
+        vertexShader: ringVert, fragmentShader: ringFrag, uniforms: u, side: THREE.DoubleSide,
+        transparent: true, depthWrite: false, blending: THREE.NormalBlending, premultipliedAlpha: true,
+    });
+    const moonMat = new THREE.ShaderMaterial({
+        vertexShader: moonVert, fragmentShader: moonFrag, uniforms: u,
+        transparent: true, depthWrite: false, blending: THREE.NormalBlending, premultipliedAlpha: true,
+    });
+    const quad = new THREE.PlaneGeometry(2, 2);
+    const moonGeo = new THREE.BufferGeometry();
+    moonGeo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(9), 3));
+    moonGeo.setAttribute('aMoon', new THREE.BufferAttribute(new Float32Array([
+        0, 0, 2.2,
+        1, 1.7, 1.7,
+        2, 0.4, 1.2,
+    ]), 3));
+    const ring = new THREE.Mesh(quad, ringMat);
+    const moons = new THREE.Points(moonGeo, moonMat);
+    ring.frustumCulled = false;
+    moons.frustumCulled = false;
+    ring.renderOrder = 0;
+    moons.renderOrder = 1;
+    const disc = new THREE.Group();
+    disc.add(ring, moons);
+    const group = new THREE.Group();
+    group.add(disc);
+    return {
+        object: group,
+        materials: [ringMat, moonMat],
+        apply(c2) {
+            disc.rotation.set((c2.tilt * Math.PI) / 180, 0, (c2.tilt * Math.PI) / 180 * 0.35);
+        },
+        update(dt, camera) {
+            u.uTime.value += dt * u.uSpeed.value;
+        },
+        dispose() {
+            quad.dispose();
+            moonGeo.dispose();
+            ringMat.dispose();
+            moonMat.dispose();
+        },
+    };
+}
+/** Defaults for every knob, so an older saved config still renders. */
+const DEFAULTS = {
+    intensity: 1,
+    speed: 1,
+    color: '#e9dcc2',
+    opacity: 1,
+    innerRadius: 1.35,
+    outerRadius: 2.6,
+    tilt: 17,
+    moons: 3,
+    spokes: 0.45,
+    forwardScatter: 0.35,
+    sunAngle: 45,
+    sunElevation: 24,
+    gapColor: '#8fa2b6',
+    dustColor: '#ffd3a1',
+};
+const PlanetaryRingsEffect = ({ boundingRadius, config, animations, hasHost = false, onObjectReady, onObjectDispose }) => {
+    const rootRef = useRef(null);
+    const animCache = useRef({});
+    useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
+    // a standalone effect gets boundingRadius 1
+    const b = boundingRadius > 0 ? boundingRadius : 1;
+    const cfg = useMemo(() => ({ ...DEFAULTS, ...config }), [config]);
+    const env = useMemo(() => ({ hasHost: hasHost }), [hasHost]);
+    // uniforms outlive the objects, so keyframe animations survive a rebuild
+    const uniforms = useMemo(() => createUniforms(), []);
+    // rebuilt only when the host size or a structural knob changes
+    const instance = useMemo(() => build(uniforms, { ...DEFAULTS, ...config }, b, env), [uniforms, b, env]);
+    useEffect(() => () => instance.dispose(), [instance]);
+    useLayoutEffect(() => {
+        applyConfig(uniforms, cfg, b, env);
+        instance.apply(cfg);
+    }, [instance, uniforms, cfg, b, env]);
+    useFrame((state, delta) => {
+        instance.update(Math.min(delta, 0.1), state.camera);
+        if (animations?.length)
+            applyGenerativeAnimations(instance.materials, animations, animCache.current, Date.now(), false);
+    });
+    return (_jsx("group", { ref: rootRef, children: _jsx("primitive", { object: instance.object }) }));
+};
+export default PlanetaryRingsEffect;

package/dist/components/effects/PortalEffect.d.ts

@@ -1,7 +1,7 @@
-import React from "react";
-import type { PortalConfig, AnimationOptions } from "@3driseai/3drise-core";
+import React from 'react';
+import type { AnimationOptions, PortalConfig } from '@3driseai/3drise-core';
 import type { ObjectReadyProps } from '../../types/objectReady';
-interface PortalEffectProps extends ObjectReadyProps {
+export interface PortalEffectProps extends ObjectReadyProps {
     boundingRadius: number;
     config: PortalConfig;
     animations?: AnimationOptions[];

package/dist/components/effects/PortalEffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PortalEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/PortalEffect.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE5E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,UAAU,iBAAkB,SAAQ,gBAAgB;IAChD,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACnC;AAgHD,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CA6E7C,CAAC;AACF,eAAe,YAAY,CAAC"}
+{"version":3,"file":"PortalEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/PortalEffect.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsD,MAAM,OAAO,CAAC;AAG3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG5E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,WAAW,iBAAkB,SAAQ,gBAAgB;IACvD,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACnC;AAsND,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAyE7C,CAAC;AAEF,eAAe,YAAY,CAAC"}