@3driseai/3drise-viewer 0.1.16 → 0.1.18

package/dist/components/effects/FallingLeavesEffect.js

@@ -0,0 +1,446 @@
+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';
+/**
+ * Leaves drifting past the object, each one integrating the Andersen-Pesavento-Wang falling-plate equations, so they flutter, glide and tumble like real leaves.
+ *
+ * (m + m₁₁)u̇ = (m + m₂₂)ωv − ρΓv − m′g sinθ − F_u · Γ = −½C_T l uv/|V| + ½C_R l²ω · (I + I_a)ω̇ = (m₁₁ − m₂₂)uv − τ
+ */
+// ---------------------------------------------------------------------------
+// Andersen, Pesavento & Wang (JFM 2005): the quasi-steady equations of a rigid
+// plate falling in a vertical plane. In the plate frame (u along the chord, v
+// normal, omega the spin, theta the chord angle):
+//   (m + m11) u' = (m + m22) omega v - Gamma v - m' g sin(theta) - F_u
+//   (m + m22) v' = -(m + m11) omega u + Gamma u - m' g cos(theta) - F_v
+//   (I + Ia) omega' = (m11 - m22) u v - tau
+// m11, m22 and Ia are the added mass and added moment of the surrounding fluid
+// (that anisotropy, m11 != m22, is what makes the plate rotate at all);
+// Gamma = -C_T l uv/|V| + C_R l^2 omega / 2 is the quasi-steady circulation, so
+// the Kutta-Joukowski force rho Gamma x V is the lift; F = (A - B cos 2alpha)|V|(u,v)/2
+// is the drag with its angle-of-attack dependence, and tau the dissipative torque.
+// The dimensionless inertia I* decides the regime: light plates flutter
+// (side-to-side glides with periodic reversals), heavy ones tumble (continuous
+// rotation with a steady sideways drift). Both parameter sets below were checked
+// numerically; the tumble knob is the share of leaves drawn from the tumbling one.
+// ---------------------------------------------------------------------------
+const LEAF_CT = 1.2;
+const LEAF_CR = Math.PI;
+const LEAF_A = 1.4;
+const LEAF_B = 1.0;
+const LEAF_MU1 = 0.2;
+const LEAF_MU2 = 0.2;
+const LEAF_DT = 0.03; // largest stable step of the plate equations
+const LEAF_RATE_F = 10; // plate time units per second, fluttering leaves
+const LEAF_RATE_T = 4; // ... and tumbling ones, so both descend at a similar pace
+const LEAF_SUN = new THREE.Vector3(0.3853, 0.8807, 0.2752);
+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;
+    };
+}
+/** Plate constants for an elliptic cross-section of density ratio rhoS and thickness ratio beta. */
+function plateConsts(rhoS, beta) {
+    const a = 0.5, b = beta * a;
+    return {
+        l: 2 * a,
+        a,
+        m: rhoS * Math.PI * a * b,
+        mp: (rhoS - 1) * Math.PI * a * b,
+        m11: Math.PI * b * b,
+        m22: Math.PI * a * a,
+        Isum: 0.25 * rhoS * Math.PI * a * b * (a * a + b * b) + 0.125 * Math.PI * (a * a - b * b) * (a * a - b * b),
+    };
+}
+function createUniforms() {
+    return {
+        uTime: { value: 0 },
+        uSpeed: { value: 1 },
+        uIntensity: { value: 1 },
+        uOpacity: { value: 1 },
+        uColor: { value: new THREE.Color() },
+        uAutumnColor: { value: new THREE.Color() },
+        uLeafSize: { value: 1.3 },
+        uFallHeight: { value: 3 },
+        uSpread: { value: 2.2 },
+        uTumble: { value: 0.35 },
+        uWind: { value: 0.5 },
+        uBound: { value: 1 },
+        uSun: { value: LEAF_SUN.clone() },
+    };
+}
+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.uAutumnColor.value.set(c.autumnColor);
+    u.uLeafSize.value = c.leafSize;
+    u.uFallHeight.value = c.fallHeight;
+    u.uSpread.value = c.spread;
+    u.uTumble.value = c.tumble;
+    u.uWind.value = c.wind;
+    u.uBound.value = bound;
+}
+const leafVert = /* glsl */ `
+  attribute vec3 aLeaf;     // fade, colour mix, seed
+  varying vec2 vQ;          // -1..1 across the chord, -1..1 from stem to tip
+  varying vec3 vN;
+  varying vec3 vView;
+  varying float vFade;
+  varying float vMix;
+  varying float vSeed;
+  void main(){
+    vQ = position.xy * 2.0;
+    vFade = aLeaf.x;
+    vMix = aLeaf.y;
+    vSeed = aLeaf.z;
+    // instanceMatrix carries the plate's frame: x = chord, y = span, z = normal
+    vec4 world = instanceMatrix * vec4(position, 1.0);
+    vN = normalize(mat3(instanceMatrix) * vec3(0.0, 0.0, 1.0));
+    vec4 mv = modelViewMatrix * world;
+    vView = mv.xyz;
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+const leafFrag = /* glsl */ `
+  uniform vec3 uColor;
+  uniform vec3 uAutumnColor;
+  uniform vec3 uSun;
+  uniform float uIntensity;
+  uniform float uOpacity;
+  varying vec2 vQ;
+  varying vec3 vN;
+  varying vec3 vView;
+  varying float vFade;
+  varying float vMix;
+  varying float vSeed;
+
+  const float TAU = 6.28318530718;
+
+  // half width of the blade at t (0 stem, 1 tip): a lopsided oval with a serrated edge
+  float bladeW(float t, float seed){
+    float s = sin(3.14159265 * pow(clamp(t, 0.0, 1.0), 0.7));
+    float w = pow(s, 0.8) * (1.0 - 0.22 * t);
+    float serr = 1.0 + 0.055 * sin(t * TAU * 6.0 + 0.6 + seed * 3.0);
+    return w * serr * 0.94;
+  }
+
+  void main(){
+    float t = clamp(vQ.y * 0.5 + 0.5, 0.0, 1.0);
+    float x = abs(vQ.x);
+    float w = bladeW((t - 0.08) / 0.92, vSeed);
+    // anti-alias on the outline's own gradient, so the serrations stay clean
+    // wherever the edge runs nearly along the quad's axes
+    float f = x - w;
+    float fw = max(fwidth(f), 1e-4) * 0.8;
+    float ft = max(fwidth(t), 1e-4);
+    float blade = (1.0 - smoothstep(-fw, fw, f)) * smoothstep(0.075 - ft, 0.075 + ft, t);
+    float fs = max(fwidth(x), 1e-4) * 0.8;
+    float stem = (1.0 - smoothstep(-fs, fs, x - 0.032)) * (1.0 - smoothstep(0.02, 0.10, t));
+    float a = max(blade, stem) * vFade;
+    if (a < 0.02) discard;
+
+    // midrib and side veins: the light through them is blocked a little more
+    float rib = 1.0 - smoothstep(0.0, 0.055 + 0.04 * (1.0 - t), x);
+    float vc = fract((t * 5.5 - x * 0.9) * 1.0);
+    float veins = (1.0 - smoothstep(0.0, 0.16, min(vc, 1.0 - vc))) * smoothstep(0.03, 0.4, w - x) * 0.7;
+    float thickness = 0.55 + 0.45 * rib + 0.3 * veins;
+
+    vec3 base = mix(uColor, uAutumnColor, clamp(vMix, 0.0, 1.0));
+    base *= 0.82 + 0.36 * fract(vSeed * 7.3);
+
+    // two-sided lighting: the normal always faces the viewer
+    vec3 n = normalize(vN);
+    vec3 vdir = normalize(-vView);
+    vec3 nv = dot(n, vdir) < 0.0 ? -n : n;
+    float diff = max(dot(nv, uSun), 0.0);
+    // translucency: light coming through the blade from behind, warmer and softer
+    float back = max(dot(-nv, uSun), 0.0);
+    float trans = pow(back, 1.4) / thickness;
+    vec3 warm = mix(base, vec3(1.0, 0.72, 0.26), 0.45) * 1.25;
+    // sky fill from above, a dim warm bounce from the ground, plus a weak sheen
+    vec3 sky = vec3(0.42, 0.5, 0.64) * (0.55 + 0.45 * max(nv.y, 0.0))
+             + vec3(0.2, 0.15, 0.1) * max(-nv.y, 0.0);
+    vec3 h = normalize(uSun + vdir);
+    float sheen = pow(max(dot(nv, h), 0.0), 26.0) * 0.16;
+
+    vec3 col = base * (0.42 * sky + 0.95 * diff) + warm * trans * 0.6 + vec3(sheen);
+    // veins and midrib catch a little more light, the edge a little less
+    col *= 0.9 + 0.28 * rib + 0.16 * veins;
+    col *= mix(0.72, 1.0, smoothstep(0.0, 0.12, w - x));
+    col *= uIntensity;
+    float alpha = a * uOpacity;
+    gl_FragColor = vec4(col * alpha, alpha);
+  }
+`;
+function build(u, c, bound, env) {
+    const n = Math.round(Math.min(Math.max(c.leafCount, 4), 400));
+    const rand = mulberry32(4271);
+    // per-leaf state: plate equations (u, v, omega, theta) and world position
+    const su = new Float64Array(n);
+    const sv = new Float64Array(n);
+    const sw = new Float64Array(n);
+    const st = new Float64Array(n);
+    const px = new Float64Array(n);
+    const py = new Float64Array(n);
+    const pz = new Float64Array(n);
+    const gen = new Int32Array(n);
+    const isT = new Uint8Array(n);
+    const azim = new Float64Array(n);
+    const azOff = new Float64Array(n);
+    const side = new Float64Array(n);
+    const wob = new Float64Array(n * 2); // wobble frequency, phase
+    const cmix = new Float32Array(n);
+    const seed = new Float32Array(n);
+    const pl = [];
+    for (let i = 0; i < n; i++)
+        pl.push(plateConsts(3, 0.125));
+    const fade = new Float32Array(n);
+    const order = [];
+    for (let i = 0; i < n; i++)
+        order.push(i);
+    const depth = new Float32Array(n);
+    const leafData = new Float32Array(n * 3);
+    const geo = new THREE.PlaneGeometry(1, 1);
+    const attr = new THREE.InstancedBufferAttribute(leafData, 3);
+    attr.setUsage(THREE.DynamicDrawUsage);
+    geo.setAttribute('aLeaf', attr);
+    const mat = new THREE.ShaderMaterial({
+        vertexShader: leafVert, fragmentShader: leafFrag, uniforms: u,
+        transparent: true, depthWrite: false, premultipliedAlpha: true,
+        blending: THREE.NormalBlending, side: THREE.DoubleSide,
+    });
+    const mesh = new THREE.InstancedMesh(geo, mat, n);
+    mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+    mesh.frustumCulled = false;
+    const group = new THREE.Group();
+    group.add(mesh);
+    const mtx = new THREE.Matrix4();
+    const chord = new THREE.Vector3();
+    const span = new THREE.Vector3();
+    const norm = new THREE.Vector3();
+    const pos = new THREE.Vector3();
+    const eDir = new THREE.Vector3();
+    const ePerp = new THREE.Vector3();
+    const k = [0, 0, 0, 0];
+    const k2 = [0, 0, 0, 0];
+    /** (Re)start leaf i at the top of the column; deterministic in (i, generation). */
+    const spawn = (i, first) => {
+        const r = mulberry32(i * 7919 + gen[i] * 104729 + 17);
+        const bnd = u.uBound.value;
+        const spread = Math.max(u.uSpread.value, 1.05);
+        const tumbling = r() < u.uTumble.value;
+        isT[i] = tumbling ? 1 : 0;
+        // fluttering plates are light, tumbling ones heavy: two verified parameter sets
+        pl[i] = tumbling ? plateConsts(6, 0.2) : plateConsts(2.4 + r() * 1.0, 0.10 + r() * 0.06);
+        const ring = 1.2 + (spread - 1.2) * Math.sqrt(r());
+        const ang = r() * Math.PI * 2;
+        px[i] = Math.cos(ang) * ring * bnd;
+        pz[i] = Math.sin(ang) * ring * bnd;
+        const top = bnd * u.uFallHeight.value;
+        py[i] = first ? -bnd + (top + bnd) * r() : top * (0.9 + 0.1 * r());
+        // the plane the leaf falls in is kept roughly tangential to the object, so a
+        // gliding tumbler circles it instead of shooting off into the distance
+        side[i] = r() < 0.5 ? -1 : 1;
+        azOff[i] = (r() - 0.5) * 0.7;
+        azim[i] = ang + side[i] * Math.PI * 0.5 + azOff[i];
+        su[i] = (r() - 0.5) * 0.2;
+        sv[i] = 0;
+        sw[i] = tumbling ? (r() < 0.5 ? -1 : 1) * (2 + r()) : (r() - 0.5) * 0.8;
+        st[i] = r() * Math.PI * 2;
+        wob[i * 2] = 0.5 + r() * 0.7;
+        wob[i * 2 + 1] = r() * Math.PI * 2;
+        cmix[i] = r();
+        seed[i] = r();
+        fade[i] = 0;
+    };
+    for (let i = 0; i < n; i++)
+        spawn(i, true);
+    /** One midpoint step of the plate equations for leaf i. */
+    const derivs = (i, uu, vv, ww, th, out) => {
+        const p = pl[i];
+        const V = Math.sqrt(uu * uu + vv * vv) + 1e-9;
+        const cos2a = (uu * uu - vv * vv) / (V * V);
+        const G = -0.5 * LEAF_CT * p.l * (uu * vv) / V + 0.5 * LEAF_CR * p.l * p.l * ww;
+        const cd = 0.5 * p.l * (LEAF_A - LEAF_B * cos2a) * V;
+        const tau = Math.PI * p.a * p.a * p.a * p.a * (LEAF_MU1 * V / p.a + LEAF_MU2 * Math.abs(ww)) * ww;
+        out[0] = ((p.m + p.m22) * ww * vv - G * vv - p.mp * Math.sin(th) - cd * uu) / (p.m + p.m11);
+        out[1] = (-(p.m + p.m11) * ww * uu + G * uu - p.mp * Math.cos(th) - cd * vv) / (p.m + p.m22);
+        out[2] = ((p.m11 - p.m22) * uu * vv - tau) / p.Isum;
+        out[3] = ww;
+    };
+    return {
+        object: group,
+        materials: [mat],
+        apply(c2) { },
+        update(dt, camera) {
+            u.uTime.value += dt * u.uSpeed.value;
+            const t = u.uTime.value;
+            const bnd = u.uBound.value;
+            const width = Math.max(u.uLeafSize.value, 0.01) * 0.16 * bnd; // the plate's chord, in world units
+            const length = width / 0.55;
+            const dtReal = Math.min(dt, 0.1) * Math.max(u.uSpeed.value, 0);
+            // the breeze is one big slow eddy: it gusts and swings round, so leaves
+            // get pushed about instead of being blown out of the scene for good
+            const gustA = t * 0.052 + 0.7 * Math.sin(t * 0.081);
+            const gustM = u.uWind.value * bnd * 0.24 * (0.7 + 0.5 * Math.sin(t * 0.23) + 0.2 * Math.sin(t * 0.41 + 1.1));
+            const gustX = Math.cos(gustA) * gustM;
+            const gustZ = Math.sin(gustA) * gustM;
+            const floorY = -bnd * 0.97;
+            const outR = bnd * (u.uSpread.value + 1.6);
+            const camPos = camera ? camera.position : null;
+            for (let i = 0; i < n; i++) {
+                const rate = isT[i] ? LEAF_RATE_T : LEAF_RATE_F;
+                let tsim = dtReal * rate;
+                const steps = Math.max(1, Math.min(8, Math.ceil(tsim / LEAF_DT)));
+                const h = tsim / steps;
+                let dxp = 0, dyp = 0;
+                for (let s = 0; s < steps; s++) {
+                    derivs(i, su[i], sv[i], sw[i], st[i], k);
+                    const hm = 0.5 * h;
+                    derivs(i, su[i] + hm * k[0], sv[i] + hm * k[1], sw[i] + hm * k[2], st[i] + hm * k[3], k2);
+                    su[i] += h * k2[0];
+                    sv[i] += h * k2[1];
+                    sw[i] += h * k2[2];
+                    st[i] += h * k2[3];
+                    // clamps: the model never needs these, but a bad config must not explode
+                    if (su[i] > 6)
+                        su[i] = 6;
+                    else if (su[i] < -6)
+                        su[i] = -6;
+                    if (sv[i] > 6)
+                        sv[i] = 6;
+                    else if (sv[i] < -6)
+                        sv[i] = -6;
+                    if (sw[i] > 14)
+                        sw[i] = 14;
+                    else if (sw[i] < -14)
+                        sw[i] = -14;
+                    const cs = Math.cos(st[i]), sn = Math.sin(st[i]);
+                    dxp += h * (su[i] * cs - sv[i] * sn);
+                    dyp += h * (su[i] * sn + sv[i] * cs);
+                }
+                if (!isFinite(su[i] + sv[i] + sw[i] + st[i])) {
+                    gen[i]++;
+                    spawn(i, false);
+                }
+                // the falling plane keeps facing around the object, with a slow
+                // wander on top, so the leaves circle it instead of leaving
+                const hAng = Math.atan2(pz[i], px[i]);
+                azim[i] = hAng + side[i] * Math.PI * 0.5 + azOff[i] + 0.25 * Math.sin(t * 0.13 + wob[i * 2 + 1]);
+                const ca = Math.cos(azim[i]), sa = Math.sin(azim[i]);
+                eDir.set(ca, 0, sa);
+                ePerp.set(-sa, 0, ca);
+                px[i] += dxp * width * ca + gustX * dtReal;
+                pz[i] += dxp * width * sa + gustZ * dtReal;
+                py[i] += dyp * width;
+                // the leaf may not pass through the host
+                const rr = Math.sqrt(px[i] * px[i] + py[i] * py[i] + pz[i] * pz[i]);
+                const rmin = bnd * 1.04 + length * 0.35;
+                if (rr < rmin && rr > 1e-5) {
+                    const f = rmin / rr;
+                    px[i] *= f;
+                    py[i] *= f;
+                    pz[i] *= f;
+                    // and slides off it instead of sticking
+                    const nx = px[i] / rmin, ny = py[i] / rmin, nz = pz[i] / rmin;
+                    const slide = dtReal * bnd * 0.35;
+                    px[i] += slide * (-ny) * nx / Math.max(1 - ny * ny, 0.08);
+                    pz[i] += slide * (-ny) * nz / Math.max(1 - ny * ny, 0.08);
+                }
+                const hr = Math.sqrt(px[i] * px[i] + pz[i] * pz[i]);
+                if (py[i] < floorY - bnd * 0.05 || hr > outR) {
+                    gen[i]++;
+                    spawn(i, false);
+                }
+                // fade in at the top, out just above the ground and at the far edge
+                const top = bnd * u.uFallHeight.value;
+                const fIn = Math.min(1, Math.max(0, (top + bnd * 0.05 - py[i]) / (bnd * 0.5)));
+                const fOut = Math.min(1, Math.max(0, (py[i] - floorY) / (bnd * 0.45)));
+                const fSide = 1 - Math.min(1, Math.max(0, (hr - outR * 0.78) / (outR * 0.22)));
+                fade[i] = Math.min(Math.min(fIn, fOut), fSide);
+                depth[i] = camPos ? -((px[i] - camPos.x) * (px[i] - camPos.x) + (py[i] - camPos.y) * (py[i] - camPos.y) + (pz[i] - camPos.z) * (pz[i] - camPos.z)) : -py[i];
+            }
+            // painter's order: furthest first, so the transparent blades layer correctly
+            for (let a = 1; a < n; a++) {
+                const v = order[a];
+                let b = a - 1;
+                while (b >= 0 && depth[order[b]] > depth[v]) {
+                    order[b + 1] = order[b];
+                    b--;
+                }
+                order[b + 1] = v;
+            }
+            for (let j = 0; j < n; j++) {
+                const i = order[j];
+                const ca = Math.cos(azim[i]), sa = Math.sin(azim[i]);
+                const cs = Math.cos(st[i]), sn = Math.sin(st[i]);
+                // chord lies in the falling plane at angle theta; span is the leaf's long axis
+                chord.set(ca * cs, sn, sa * cs);
+                span.set(-sa, 0, ca);
+                // a little out-of-plane wobble: roll about the chord
+                const roll = 0.3 * Math.sin(t * wob[i * 2] + wob[i * 2 + 1]);
+                const cr = Math.cos(roll), sr = Math.sin(roll);
+                norm.copy(chord).cross(span).normalize();
+                span.multiplyScalar(cr).addScaledVector(norm, sr).normalize();
+                norm.copy(chord).cross(span).normalize();
+                pos.set(px[i], py[i], pz[i]).addScaledVector(span, 0.12 * length * Math.sin(t * wob[i * 2] * 0.7 + wob[i * 2 + 1]));
+                mtx.makeBasis(chord.multiplyScalar(width), span.multiplyScalar(length), norm);
+                mtx.setPosition(pos);
+                mesh.setMatrixAt(j, mtx);
+                leafData[j * 3] = fade[i];
+                leafData[j * 3 + 1] = cmix[i];
+                leafData[j * 3 + 2] = seed[i];
+            }
+            mesh.instanceMatrix.needsUpdate = true;
+            attr.needsUpdate = true;
+        },
+        dispose() { geo.dispose(); mat.dispose(); },
+    };
+}
+/** Defaults for every knob, so an older saved config still renders. */
+const DEFAULTS = {
+    intensity: 1,
+    speed: 1,
+    color: '#7f9b3f',
+    opacity: 1,
+    leafCount: 60,
+    leafSize: 1.3,
+    fallHeight: 3,
+    spread: 2.2,
+    tumble: 0.35,
+    wind: 0.5,
+    autumnColor: '#c4631f',
+};
+const FallingLeavesEffect = ({ 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.leafCount]);
+    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 FallingLeavesEffect;

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

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { AnimationOptions, FieldLinesConfig } from '@3driseai/3drise-core';
+import type { ObjectReadyProps } from '../../types/objectReady';
+export interface FieldLinesEffectProps extends ObjectReadyProps {
+    boundingRadius: number;
+    config: FieldLinesConfig;
+    animations?: AnimationOptions[];
+}
+declare const FieldLinesEffect: React.FC<FieldLinesEffectProps>;
+export default FieldLinesEffect;
+//# sourceMappingURL=FieldLinesEffect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FieldLinesEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/FieldLinesEffect.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAGhF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,WAAW,qBAAsB,SAAQ,gBAAgB;IAC3D,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,gBAAgB,CAAC;IACzB,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACnC;AAqND,QAAA,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC,qBAAqB,CA2DrD,CAAC;AACF,eAAe,gBAAgB,CAAC"}