@3driseai/3drise-viewer 0.1.16 → 0.1.18

package/dist/components/effects/DandelionSeedsEffect.js

@@ -0,0 +1,510 @@
+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';
+/**
+ * Dandelion seeds let go of the head one by one and drift away: a high-drag pappus gives them a slow terminal fall, and curl-noise wind with updrafts carries them. Use for meadow, summer, wish, gentle scenes.
+ *
+ * dv/dt = (u_wind + u_turb + lift·ŷ − v_settle·ŷ − v)/τ · u = ∇×A (divergence-free) · potential flow around the head · pappus aligns with −v_rel
+ */
+// ---------------------------------------------------------------------------
+// A dandelion seed is a tiny achene under a pappus - an umbrella of ~100 fine
+// filaments. The pappus has an enormous drag-to-mass ratio (it even holds a
+// separated vortex ring above itself), so the seed reaches its terminal speed
+// in a fraction of a second and then simply goes where the air goes:
+//     dv/dt = (u_air - v_settle * yhat - v) / tau,   tau ~ 0.3 s
+// The air is a mean wind plus a divergence-free swirl (the analytic curl of a
+// trig vector potential, so gusts rotate and never compress) plus a slow
+// updraft. Around the head the mean wind follows the potential flow past a
+// sphere, u = U(1 + a^3/2r^3) - 3a^3/2r^5 (U.r) r, which is exactly tangent at
+// the surface - so seeds slide around the head instead of into it.
+// Drag also aligns the pappus with the relative airflow, so each seed hangs
+// its achene downwind-down and tips as gusts hit it. Seeds are pulled loose
+// one at a time (sooner in stronger wind), fade out far downwind, and are
+// replaced on the same spot on the head.
+// ---------------------------------------------------------------------------
+const vert = /* glsl */ `
+  // position = (s along the part, side of the ribbon, filament angle)
+  attribute float aPart;      // 0 pappus filament, 1 beak, 2 achene
+  attribute vec4 aSeedA;      // hub position xyz, alpha w
+  attribute vec4 aSeedB;      // pappus axis xyz, roll w
+  attribute vec2 aVar;        // per-seed size factor, per-seed shape hash
+  uniform float uSeedSize;
+  uniform float uBound;
+  uniform float uViewH;
+  varying float vAcross;
+  varying float vFade;
+  varying float vPart;
+  varying float vAlpha;
+
+  void main(){
+    vec3 C = aSeedA.xyz;
+    vec3 A = normalize(aSeedB.xyz + vec3(0.0, 1e-5, 0.0));
+    vec3 ref = abs(A.y) < 0.9 ? vec3(0.0, 1.0, 0.0) : vec3(1.0, 0.0, 0.0);
+    vec3 e1 = normalize(cross(A, ref));
+    vec3 e2 = cross(A, e1);
+    float phi = position.z + aSeedB.w;
+    vec3 d = cos(phi) * e1 + sin(phi) * e2;
+
+    float R = 0.16 * uSeedSize * uBound * aVar.x;   // pappus radius
+    float s = position.x;
+    vec3 P;
+    vec3 T;
+    float hw;
+    float fade;
+    if (aPart < 0.5){
+      // one bristle: a nearly straight ray from the hub on a cone of half-angle
+      // th, with a little gravity sag, so the pappus reads as a starburst whose
+      // spread of angles gives the shallow dome
+      float h = fract(sin((position.z + aVar.y * 7.3) * 31.7182) * 43758.5453);
+      float th = 0.72 + 0.62 * h;
+      float len = R / max(sin(th), 0.45) * (0.82 + 0.3 * h);
+      float sag = 0.14 * s * s;
+      P = C + len * (s * sin(th) * d + (s * cos(th) - sag) * A);
+      T = normalize(sin(th) * d + (cos(th) - 0.28 * s) * A);
+      hw = R * (0.013 + 0.013 * s);              // feathery toward the tip
+      fade = (1.0 - 0.35 * s) * (1.0 - smoothstep(0.7, 1.0, s) * 0.8);
+    } else if (aPart < 1.5){
+      // the beak: a thin stalk hanging from the hub down the axis
+      P = C - A * (1.45 * R * s);
+      T = A;
+      hw = R * 0.011;
+      fade = 0.55;
+    } else {
+      // the achene: a small spindle at the bottom of the beak
+      float t0 = 1.45 * R;
+      P = C - A * (t0 + 0.55 * R * s);
+      T = A;
+      hw = R * 0.05 * sin(3.14159 * (0.12 + 0.82 * s));
+      fade = 1.0;
+    }
+
+    vec4 mv = modelViewMatrix * vec4(P, 1.0);
+    float pxPerUnit = projectionMatrix[1][1] * uViewH / max(-mv.z, 0.05);
+    float minHW = 0.8 / max(pxPerUnit, 1e-4);   // keep every ribbon ~1.6 px wide
+    float w = max(hw, minHW);
+    // give back in alpha what a widened ribbon gains in area
+    vAlpha = aSeedA.w * clamp(hw / max(minHW, 1e-6), 0.4, 1.0);
+    vec3 vd = normalize(cameraPosition - P);
+    vec3 off = cross(T, vd);
+    float ol = length(off);
+    off = ol > 1e-5 ? off / ol : e1;
+    P += off * (position.y * w);
+
+    vAcross = position.y;
+    vFade = fade;
+    vPart = aPart;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(P, 1.0);
+  }
+`;
+const frag = /* glsl */ `
+  uniform vec3 uColor;
+  uniform vec3 uStemColor;
+  uniform float uIntensity;
+  uniform float uOpacity;
+  varying float vAcross;
+  varying float vFade;
+  varying float vPart;
+  varying float vAlpha;
+
+  void main(){
+    // soft across the ribbon: a parabolic profile, so no hard edges anywhere
+    float a = vAlpha * vFade * (1.0 - vAcross * vAcross) * uOpacity;
+    if (a < 0.003) discard;
+    vec3 col = vPart < 0.5 ? uColor : uStemColor * (vPart > 1.5 ? 1.0 : 0.62);
+    gl_FragColor = vec4(col * uIntensity, a * (vPart < 0.5 ? 0.45 : 0.9));
+  }
+`;
+function mulberry32(seed) {
+    return () => {
+        seed |= 0;
+        seed = (seed + 0x6d2b79f5) | 0;
+        let r = Math.imul(seed ^ (seed >>> 15), 1 | seed);
+        r = (r + Math.imul(r ^ (r >>> 7), 61 | r)) ^ r;
+        return ((r ^ (r >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** deterministic 0..1 value for seed i on its cycle c */
+function hash2(i, c) {
+    let h = Math.imul(i + 1, 374761393) ^ Math.imul(c + 1, 668265263);
+    h = Math.imul(h ^ (h >>> 13), 1274126177);
+    return ((h ^ (h >>> 16)) >>> 0) / 4294967296;
+}
+/** the ribbon template: 32 pappus filaments, the beak and the achene */
+function buildTemplate() {
+    const F = 32;
+    const NODE = 4;
+    const data = [];
+    const part = [];
+    const index = [];
+    let base = 0;
+    const strip = (nodes, phi, p) => {
+        for (let k = 0; k < nodes; k++) {
+            const s = k / (nodes - 1);
+            data.push(s, -1, phi);
+            part.push(p);
+            data.push(s, 1, phi);
+            part.push(p);
+        }
+        for (let k = 0; k < nodes - 1; k++) {
+            const a = base + k * 2;
+            index.push(a, a + 1, a + 2, a + 1, a + 3, a + 2);
+        }
+        base += nodes * 2;
+    };
+    for (let f = 0; f < F; f++) {
+        const j = (((f * 2654435761) >>> 0) / 4294967296 - 0.5) * 0.55;
+        strip(NODE, ((f + j) / F) * Math.PI * 2, 0);
+    }
+    strip(3, 0, 1);
+    strip(4, 0, 2);
+    const geo = new THREE.InstancedBufferGeometry();
+    geo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(data), 3));
+    geo.setAttribute('aPart', new THREE.BufferAttribute(new Float32Array(part), 1));
+    geo.setIndex(index);
+    return geo;
+}
+function createUniforms() {
+    return {
+        uTime: { value: 0 },
+        uSpeed: { value: 1 },
+        uIntensity: { value: 1 },
+        uOpacity: { value: 1 },
+        uColor: { value: new THREE.Color() },
+        uStemColor: { value: new THREE.Color() },
+        uWindSpeed: { value: 0.55 },
+        uWindDirection: { value: 20 },
+        uTurbulence: { value: 0.8 },
+        uSeedSize: { value: 1 },
+        uLift: { value: 1 },
+        uBound: { value: 1 },
+        uViewH: { value: 800 },
+    };
+}
+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.uStemColor.value.set(c.stemColor);
+    u.uWindSpeed.value = c.windSpeed;
+    u.uWindDirection.value = c.windDirection;
+    u.uTurbulence.value = c.turbulence;
+    u.uSeedSize.value = c.seedSize;
+    u.uLift.value = c.lift;
+    u.uBound.value = bound;
+}
+function build(u, c, bound, env) {
+    const n = Math.round(Math.min(Math.max(c.seedCount, 10), 260));
+    const hasHost = !!(env && env.hasHost);
+    const b = bound;
+    const SIM_DT = 1 / 30;
+    const TAU_V = 0.32; // velocity relaxation time of a pappus, seconds
+    const SETTLE = 0.12; // terminal settling speed, in bound units per second
+    const FADE_R = 6.5; // seeds fade out beyond this radius
+    const LIFE = 22; // ... or after this long in the air
+    const rand = mulberry32(90210);
+    const slot = new Float32Array(n * 3); // attachment direction on the head
+    const pos = new Float32Array(n * 3);
+    const vel = new Float32Array(n * 3);
+    const axis = new Float32Array(n * 3);
+    const timer = new Float32Array(n);
+    const wait = new Float32Array(n);
+    const cycle = new Int32Array(n);
+    const mode = new Int32Array(n); // 0 attached, 1 flying, 2 fading
+    const roll = new Float32Array(n);
+    const spin = new Float32Array(n);
+    const varr = new Float32Array(n * 2); // size factor, shape hash
+    const settleF = new Float32Array(n); // per-seed terminal fall speed
+    const tilt = new Float32Array(n * 3); // small permanent tilt of the pappus
+    const seedA = new Float32Array(n * 4);
+    const seedB = new Float32Array(n * 4);
+    const air = new Float32Array(3);
+    // attachment slots: a Fibonacci spiral over the upper hemisphere of the head
+    const GOLD = Math.PI * (3 - Math.sqrt(5));
+    for (let i = 0; i < n; i++) {
+        const t = (i + 0.5) / n;
+        const y = -0.12 + 1.1 * t; // upper hemisphere, a little below the equator
+        const r = Math.sqrt(Math.max(1 - y * y, 0.02));
+        const a = i * GOLD;
+        slot[i * 3] = r * Math.cos(a);
+        slot[i * 3 + 1] = y;
+        slot[i * 3 + 2] = r * Math.sin(a);
+        axis[i * 3] = slot[i * 3];
+        axis[i * 3 + 1] = slot[i * 3 + 1];
+        axis[i * 3 + 2] = slot[i * 3 + 2];
+        cycle[i] = 0;
+        mode[i] = 0;
+        // staggered: every seed is already part way through its wait
+        wait[i] = 4 + 11 * hash2(i, 0);
+        timer[i] = wait[i] * rand();
+        roll[i] = rand() * Math.PI * 2;
+        varr[i * 2] = 0.78 + 0.44 * rand();
+        varr[i * 2 + 1] = rand();
+        // real pappi differ in drag, so seeds sink at slightly different rates
+        settleF[i] = SETTLE * b * (0.72 + 0.6 * rand());
+        // and none is perfectly symmetric: each flies with a small fixed lean
+        const ta = rand() * Math.PI * 2, tm = 0.07 + 0.2 * rand();
+        tilt[i * 3] = Math.cos(ta) * tm;
+        tilt[i * 3 + 1] = 0;
+        tilt[i * 3 + 2] = Math.sin(ta) * tm;
+        spin[i] = (0.1 + 0.25 * rand()) * (rand() < 0.5 ? -1 : 1);
+        seedA[i * 4 + 3] = 0;
+    }
+    const geo = buildTemplate();
+    const aAttr = new THREE.InstancedBufferAttribute(seedA, 4);
+    const bAttr = new THREE.InstancedBufferAttribute(seedB, 4);
+    aAttr.setUsage(THREE.DynamicDrawUsage);
+    bAttr.setUsage(THREE.DynamicDrawUsage);
+    geo.setAttribute('aSeedA', aAttr);
+    geo.setAttribute('aSeedB', bAttr);
+    geo.setAttribute('aVar', new THREE.InstancedBufferAttribute(varr, 2));
+    geo.instanceCount = n;
+    const mat = new THREE.ShaderMaterial({
+        vertexShader: vert, fragmentShader: frag, uniforms: u,
+        transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+        side: THREE.DoubleSide,
+    });
+    const mesh = new THREE.Mesh(geo, mat);
+    mesh.frustumCulled = false;
+    const vp = new THREE.Vector2();
+    mesh.onBeforeRender = (renderer) => {
+        renderer.getDrawingBufferSize(vp);
+        u.uViewH.value = vp.y * 0.5;
+    };
+    const group = new THREE.Group();
+    group.add(mesh);
+    let simTime = 0;
+    let acc = 0;
+    /** air velocity at (x,y,z): mean wind around the head + curl gusts + updraft */
+    function airAt(x, y, z, t) {
+        const ws = Math.max(u.uWindSpeed.value, 0) * b;
+        const ang = (u.uWindDirection.value * Math.PI) / 180;
+        let wx = Math.cos(ang) * ws;
+        let wz = Math.sin(ang) * ws;
+        let wy = 0;
+        if (hasHost) {
+            // potential flow past a sphere: tangent at the surface, uniform far away
+            const aH = 1.12 * b;
+            const r2 = x * x + y * y + z * z;
+            const r = Math.sqrt(r2) + 1e-5;
+            if (r < 8 * aH) {
+                const rr = Math.max(r, aH);
+                const k = (aH * aH * aH) / (2 * rr * rr * rr);
+                const dotp = (wx * x + wz * z) / (rr * rr);
+                const px = wx * (1 + k) - 3 * k * dotp * x;
+                const py = -3 * k * dotp * y;
+                const pz = wz * (1 + k) - 3 * k * dotp * z;
+                wx = px;
+                wy = py;
+                wz = pz;
+            }
+        }
+        // Divergence-free gusts: the analytic curl of a trig vector potential,
+        // sampled in coordinates carried along by the mean wind (Taylor's frozen
+        // turbulence). Advecting the pattern matters: a gust field pinned to
+        // space would have fixed stagnation points that collect seeds.
+        const ax0 = x - Math.cos(ang) * ws * t;
+        const az0 = z - Math.sin(ang) * ws * t;
+        const g = Math.max(u.uTurbulence.value, 0) * (0.4 * ws + 0.05 * b);
+        const k1 = 0.62 / b;
+        const p1 = 0.21 * t, p2 = 0.17 * t + 2.1, p3 = 0.13 * t + 4.7;
+        wx += g * (Math.sin(k1 * az0 + p1) + 0.6 * Math.cos(k1 * y * 1.3 + p3));
+        wy += g * (0.7 * Math.sin(k1 * ax0 + p2) + 0.7 * Math.cos(k1 * az0 * 1.2 + p1));
+        wz += g * (0.6 * Math.sin(k1 * y + p3) + Math.cos(k1 * ax0 * 1.1 + p2));
+        // slow, wide thermals, also carried along with the wind
+        const lift = Math.max(u.uLift.value, 0) * SETTLE * b;
+        wy += lift * (1.0 + 0.9 * Math.sin(0.42 * ax0 / b + 0.15 * t) * Math.cos(0.36 * az0 / b - 0.11 * t));
+        air[0] = wx;
+        air[1] = wy;
+        air[2] = wz;
+    }
+    function hubRadius() {
+        return b + 1.45 * 0.16 * Math.max(u.uSeedSize.value, 0.1) * b;
+    }
+    function respawn(i) {
+        cycle[i]++;
+        mode[i] = 0;
+        timer[i] = 0;
+        wait[i] = 4 + 11 * hash2(i, cycle[i]);
+        roll[i] = hash2(i, cycle[i] + 7919) * Math.PI * 2;
+    }
+    function step(h) {
+        const t = simTime;
+        const hubR = hubRadius();
+        const ws = Math.max(u.uWindSpeed.value, 0);
+        const fadeR = FADE_R * b;
+        for (let i = 0; i < n; i++) {
+            const i3 = i * 3, i4 = i * 4;
+            roll[i] += h * spin[i];
+            timer[i] += h;
+            if (mode[i] === 0) {
+                // still on the head: sit on the slot, fade in, and wait for a gust
+                const sx = slot[i3], sy = slot[i3 + 1], sz = slot[i3 + 2];
+                pos[i3] = sx * hubR;
+                pos[i3 + 1] = sy * hubR;
+                pos[i3 + 2] = sz * hubR;
+                axis[i3] = sx;
+                axis[i3 + 1] = sy;
+                axis[i3 + 2] = sz;
+                seedA[i4 + 3] = Math.min(timer[i] / 1.6, 1);
+                // stronger wind pulls seeds loose sooner
+                if (timer[i] > wait[i] * (0.45 / Math.max(ws, 0.06))) {
+                    mode[i] = 1;
+                    timer[i] = 0;
+                    airAt(pos[i3], pos[i3 + 1], pos[i3 + 2], t);
+                    vel[i3] = air[0] * 0.2;
+                    vel[i3 + 1] = air[1] * 0.2;
+                    vel[i3 + 2] = air[2] * 0.2;
+                }
+                continue;
+            }
+            let x = pos[i3], y = pos[i3 + 1], z = pos[i3 + 2];
+            airAt(x, y, z, t);
+            // relax toward the air's velocity minus the slow terminal fall
+            const tx = air[0], ty = air[1] - settleF[i], tz = air[2];
+            const k = Math.min(h / TAU_V, 1);
+            let vx = vel[i3] + (tx - vel[i3]) * k;
+            let vy = vel[i3 + 1] + (ty - vel[i3 + 1]) * k;
+            let vz = vel[i3 + 2] + (tz - vel[i3 + 2]) * k;
+            x += vx * h;
+            y += vy * h;
+            z += vz * h;
+            // the head is solid: slide around it
+            if (hasHost) {
+                const d = Math.sqrt(x * x + y * y + z * z);
+                const lim = hubR * 0.99;
+                if (d < lim && d > 1e-5) {
+                    const f = lim / d;
+                    x *= f;
+                    y *= f;
+                    z *= f;
+                    const vr = (vx * x + vy * y + vz * z) / (lim * lim);
+                    vx -= vr * x;
+                    vy -= vr * y;
+                    vz -= vr * z;
+                }
+            }
+            vel[i3] = vx;
+            vel[i3 + 1] = vy;
+            vel[i3 + 2] = vz;
+            pos[i3] = x;
+            pos[i3 + 1] = y;
+            pos[i3 + 2] = z;
+            // drag turns the pappus into the relative airflow (achene downwind-down)
+            const rx = air[0] - vx, ry = air[1] - vy, rz = air[2] - vz;
+            let ax = rx + tilt[i3] * settleF[i] * 4, ay = ry + settleF[i] * 0.6, az = rz + tilt[i3 + 2] * settleF[i] * 4;
+            const am = Math.sqrt(ax * ax + ay * ay + az * az);
+            if (am < 1e-4) {
+                ax = 0;
+                ay = 1;
+                az = 0;
+            }
+            else {
+                ax /= am;
+                ay /= am;
+                az /= am;
+            }
+            const ka = Math.min(h / 0.35, 1);
+            let nx = axis[i3] + (ax - axis[i3]) * ka;
+            let ny = axis[i3 + 1] + (ay - axis[i3 + 1]) * ka;
+            let nz = axis[i3 + 2] + (az - axis[i3 + 2]) * ka;
+            const nm = Math.sqrt(nx * nx + ny * ny + nz * nz) + 1e-6;
+            axis[i3] = nx / nm;
+            axis[i3 + 1] = ny / nm;
+            axis[i3 + 2] = nz / nm;
+            const dist = Math.sqrt(x * x + y * y + z * z);
+            if (mode[i] === 1) {
+                seedA[i4 + 3] = 1;
+                if (dist > fadeR || timer[i] > LIFE) {
+                    mode[i] = 2;
+                    timer[i] = 0;
+                }
+            }
+            else {
+                const f = 1 - timer[i] / 1.4;
+                seedA[i4 + 3] = Math.max(f, 0);
+                if (f <= 0)
+                    respawn(i);
+            }
+        }
+    }
+    function writeInstances() {
+        for (let i = 0; i < n; i++) {
+            const i3 = i * 3, i4 = i * 4;
+            seedA[i4] = pos[i3];
+            seedA[i4 + 1] = pos[i3 + 1];
+            seedA[i4 + 2] = pos[i3 + 2];
+            seedB[i4] = axis[i3];
+            seedB[i4 + 1] = axis[i3 + 1];
+            seedB[i4 + 2] = axis[i3 + 2];
+            seedB[i4 + 3] = roll[i];
+        }
+        aAttr.needsUpdate = true;
+        bAttr.needsUpdate = true;
+    }
+    step(0);
+    writeInstances();
+    return {
+        object: group,
+        materials: [mat],
+        apply(c2) { },
+        update(dt, camera) {
+            const h = Math.min(Math.max(dt, 0), 0.1) * Math.max(u.uSpeed.value, 0);
+            u.uTime.value += h;
+            acc += h;
+            let guard = 0;
+            while (acc >= SIM_DT && guard < 6) {
+                step(SIM_DT);
+                simTime += SIM_DT;
+                acc -= SIM_DT;
+                guard++;
+            }
+            if (guard >= 6)
+                acc = 0;
+            writeInstances();
+        },
+        dispose() { geo.dispose(); mat.dispose(); },
+    };
+}
+/** Defaults for every knob, so an older saved config still renders. */
+const DEFAULTS = {
+    intensity: 1,
+    speed: 1,
+    color: '#ffeccf',
+    opacity: 1,
+    seedCount: 90,
+    windSpeed: 0.55,
+    windDirection: 20,
+    turbulence: 0.8,
+    seedSize: 1,
+    lift: 1,
+    stemColor: '#d8b183',
+};
+const DandelionSeedsEffect = ({ 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, cfg.seedCount]);
+    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 DandelionSeedsEffect;

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

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { AnimationOptions, FallingLeavesConfig } from '@3driseai/3drise-core';
+import type { ObjectReadyProps } from '../../types/objectReady';
+export interface FallingLeavesEffectProps extends ObjectReadyProps {
+    boundingRadius: number;
+    config: FallingLeavesConfig;
+    animations?: AnimationOptions[];
+    /** True when the effect is attached to an object, so it can react to the host. */
+    hasHost?: boolean;
+}
+declare const FallingLeavesEffect: React.FC<FallingLeavesEffectProps>;
+export default FallingLeavesEffect;
+//# sourceMappingURL=FallingLeavesEffect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FallingLeavesEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/FallingLeavesEffect.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsD,MAAM,OAAO,CAAC;AAG3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAGnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,WAAW,wBAAyB,SAAQ,gBAAgB;IAC9D,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAChC,kFAAkF;IAClF,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAwZD,QAAA,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC,wBAAwB,CA+B3D,CAAC;AAEF,eAAe,mBAAmB,CAAC"}