@3driseai/3drise-core 1.0.1

package/dist/three/effects/ForcefieldEffectV.js

@@ -0,0 +1,150 @@
+import * as THREE from 'three';
+const shieldVert = /* glsl */ `
+  varying vec3 vNormal;
+  varying vec3 vWorldPos;
+  varying vec2 vUv;
+  void main() {
+    vNormal   = normalize(normalMatrix * normal);
+    vWorldPos = (modelMatrix * vec4(position, 1.0)).xyz;
+    vUv       = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const shieldFrag = /* glsl */ `
+  uniform float u_time;
+  uniform float uHexSize;
+  uniform vec3  uShieldColor;
+  uniform vec3  uRimColor;
+  uniform float uOpacity;
+  uniform float uIntensity;
+
+  uniform vec3  uHitPos[3];
+  uniform float uHitTime[3];
+
+  varying vec3 vNormal;
+  varying vec3 vWorldPos;
+  varying vec2 vUv;
+
+  vec2 hexCoord(vec2 p) {
+    const float SQRT3 = 1.7320508;
+    vec2 r = vec2(1.0, SQRT3);
+    vec2 h = r * 0.5;
+    vec2 a = mod(p,       r) - h;
+    vec2 b = mod(p + h,   r) - h;
+    return dot(a, a) < dot(b, b) ? a : b;
+  }
+
+  float hexEdge(vec2 p, float size) {
+    vec2 hc = hexCoord(p / size);
+    float d = length(hc);
+    return 1.0 - smoothstep(size * 0.38, size * 0.46, d);
+  }
+
+  void main() {
+    vec3  n   = normalize(vNormal);
+    float phi  = atan(n.z, n.x);
+    float theta = acos(clamp(n.y, -1.0, 1.0));
+    vec2  suv  = vec2(phi / 6.28318, theta / 3.14159);
+
+    float edge = hexEdge(suv, uHexSize);
+
+    vec3  viewDir = normalize(cameraPosition - vWorldPos);
+    float fresnel = pow(1.0 - abs(dot(n, viewDir)), 2.5);
+
+    float ripple = 0.0;
+    for (int k = 0; k < 3; k++) {
+      float age  = u_time - uHitTime[k];
+      if (age < 0.0 || age > 2.0) continue;
+      float dist = distance(vWorldPos, uHitPos[k]);
+      float wave = sin(dist * 14.0 - age * 9.0) * exp(-dist * 2.5) * exp(-age * 1.4);
+      ripple    += wave * 0.7;
+    }
+
+    vec3  col   = mix(uShieldColor, uRimColor, fresnel * 0.6 + edge * 0.4);
+    float alpha = (edge * 0.55 + fresnel * 0.3 + max(0.0, ripple) * 0.45 + 0.04)
+                  * uOpacity * uIntensity;
+    if (alpha < 0.005) discard;
+    gl_FragColor = vec4(col + uRimColor * ripple * 0.3, alpha);
+  }
+`;
+export class ForcefieldEffectV {
+    scene;
+    group;
+    materials = [];
+    config;
+    boundingRadius;
+    hitSlot = 0;
+    nextHit = 0;
+    constructor(scene, config, boundingRadius = 1) {
+        this.scene = scene;
+        this.config = config;
+        this.boundingRadius = boundingRadius;
+        this.group = new THREE.Group();
+        scene.add(this.group);
+        this.build();
+    }
+    build() {
+        const { hexSize, shieldColor, rimColor, opacity, intensity } = this.config;
+        const sc = new THREE.Color(shieldColor);
+        const rc = new THREE.Color(rimColor);
+        const mat = new THREE.ShaderMaterial({
+            vertexShader: shieldVert,
+            fragmentShader: shieldFrag,
+            uniforms: {
+                u_time: { value: 0 },
+                uHexSize: { value: hexSize },
+                uShieldColor: { value: new THREE.Vector3(sc.r, sc.g, sc.b) },
+                uRimColor: { value: new THREE.Vector3(rc.r, rc.g, rc.b) },
+                uOpacity: { value: opacity },
+                uIntensity: { value: intensity },
+                uHitPos: { value: [new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3()] },
+                uHitTime: { value: [-99, -99, -99] },
+            },
+            transparent: true,
+            depthWrite: false,
+            side: THREE.FrontSide,
+            blending: THREE.AdditiveBlending,
+        });
+        this.materials.push(mat);
+        this.group.add(new THREE.Mesh(new THREE.SphereGeometry(this.boundingRadius * 1.15, 64, 64), mat));
+    }
+    update(elapsed, delta = 0.016) {
+        const mat = this.materials[0];
+        if (!mat)
+            return;
+        mat.uniforms.u_time.value = elapsed;
+        const { rippleEnabled, speed } = this.config;
+        if (rippleEnabled) {
+            this.nextHit -= delta;
+            if (this.nextHit <= 0) {
+                this.nextHit = 1.4 / speed + Math.random() * 0.8;
+                const phi = Math.random() * Math.PI * 2;
+                const theta = Math.acos(2 * Math.random() - 1);
+                const r = this.boundingRadius * 1.15;
+                const slot = this.hitSlot % 3;
+                mat.uniforms.uHitPos.value[slot].set(Math.sin(theta) * Math.cos(phi) * r, Math.cos(theta) * r, Math.sin(theta) * Math.sin(phi) * r);
+                mat.uniforms.uHitTime.value[slot] = elapsed;
+                this.hitSlot++;
+            }
+        }
+    }
+    updateConfig(config, boundingRadius) {
+        this.config = config;
+        if (boundingRadius !== undefined)
+            this.boundingRadius = boundingRadius;
+        this.dispose(false);
+        this.build();
+    }
+    dispose(removeFromScene = true) {
+        this.group.traverse(child => {
+            const c = child;
+            if (c.geometry)
+                c.geometry.dispose();
+        });
+        this.materials.forEach(m => m.dispose());
+        this.materials = [];
+        this.group.clear();
+        if (removeFromScene && this.group.parent)
+            this.group.parent.remove(this.group);
+    }
+}

package/dist/three/effects/HologramEffectV.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+import type { HologramConfig } from "../../types/generativeEffects";
+export declare class HologramEffectV {
+    private scene;
+    private group;
+    private materials;
+    private config;
+    private boundingRadius;
+    constructor(scene: THREE.Scene, config: HologramConfig, boundingRadius?: number);
+    private build;
+    update(elapsed: number, _delta?: number): void;
+    updateConfig(config: HologramConfig, boundingRadius?: number): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=HologramEffectV.d.ts.map

package/dist/three/effects/HologramEffectV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HologramEffectV.d.ts","sourceRoot":"","sources":["../../../src/three/effects/HologramEffectV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAwEpE,qBAAa,eAAe;IACxB,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,cAAc,CAAC;gBACX,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,cAAc,GAAE,MAAU;IAQlF,OAAO,CAAC,KAAK;IAqCb,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,GAAE,MAAc,GAAG,IAAI;IAYrD,YAAY,CAAC,MAAM,EAAE,cAAc,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI;IAOnE,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAYjD"}

package/dist/three/effects/HologramEffectV.js

@@ -0,0 +1,154 @@
+import * as THREE from 'three';
+const vertexShader = /* glsl */ `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform float u_time;
+  uniform float uScanSpeed;
+  uniform float uScanlineCount;
+  uniform vec3  uColor;
+  uniform float uOpacity;
+  uniform float uFlickerAmount;
+  uniform float uGridEnabled;
+  uniform float uGlitchOffset;
+  uniform float uAberration;
+  uniform float uPlaneY;
+  uniform float uIntensity;
+
+  varying vec2 vUv;
+
+  float hash(float n){ return fract(sin(n) * 43758.5453); }
+  float hash2(vec2 p){ return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
+
+  float scanSample(vec2 uv, float t) {
+    return step(0.45, fract(uv.y * uScanlineCount + t * uScanSpeed));
+  }
+
+  void main() {
+    vec2 uv = vUv;
+    float t  = u_time;
+
+    float blockY  = floor(uv.y * 8.0);
+    float glitchT = hash(blockY + floor(t * 12.0));
+    float doGlitch= step(0.94, glitchT);
+    uv.x += doGlitch * (hash(blockY * 3.1 + t * 4.0) - 0.5) * uGlitchOffset;
+    uv.x  = fract(uv.x);
+
+    float aberr = uAberration * (1.0 + 0.4 * sin(t * 3.0));
+    float r_val = scanSample(uv + vec2( aberr, 0.0), t);
+    float g_val = scanSample(uv,                     t);
+    float b_val = scanSample(uv - vec2( aberr, 0.0), t);
+    vec3  scanRGB = vec3(r_val, g_val, b_val);
+
+    float fringe = sin(uv.y * 60.0 + t * 4.0) * sin(uv.x * 40.0 - t * 2.0) * 0.5 + 0.5;
+    fringe = pow(fringe, 3.0) * 0.35;
+
+    float grid = 0.0;
+    if (uGridEnabled > 0.5) {
+      float gx = step(0.93, fract(uv.x * 14.0));
+      float gy = step(0.93, fract(uv.y * 14.0));
+      grid = max(gx, gy) * 0.5;
+    }
+
+    float assembleT  = mod(t * 0.3, 2.5);
+    float assembled  = smoothstep(assembleT - 0.4, assembleT, uPlaneY * 0.5 + 0.5);
+    float stableT    = smoothstep(0.0, 1.2, assembleT);
+    float assembleA  = mix(assembled, 1.0, stableT);
+
+    float flicker = 1.0 - uFlickerAmount * step(0.93, hash(floor(t * 18.0)));
+
+    vec3  hologramColor = uColor * scanRGB;
+    float scanBright    = (r_val + g_val + b_val) / 3.0;
+    float intensity     = (scanBright * 0.65 + fringe + grid) * flicker * assembleA * uIntensity;
+    if (intensity < 0.015) discard;
+
+    gl_FragColor = vec4(hologramColor + uColor * fringe, intensity * uOpacity);
+  }
+`;
+export class HologramEffectV {
+    scene;
+    group;
+    materials = [];
+    config;
+    boundingRadius;
+    constructor(scene, config, boundingRadius = 1) {
+        this.scene = scene;
+        this.config = config;
+        this.boundingRadius = boundingRadius;
+        this.group = new THREE.Group();
+        scene.add(this.group);
+        this.build();
+    }
+    build() {
+        const { scanlineCount, scanSpeed, scanColor, gridEnabled, flickerAmount, opacity, speed, intensity } = this.config;
+        const c = new THREE.Color(scanColor);
+        const colorVec = new THREE.Vector3(c.r, c.g, c.b);
+        const planeSize = this.boundingRadius * 2.3;
+        const stepY = (this.boundingRadius * 2.5) / Math.max(scanlineCount - 1, 1);
+        for (let i = 0; i < scanlineCount; i++) {
+            const planeY = (i / Math.max(scanlineCount - 1, 1)) * 2 - 1;
+            const mat = new THREE.ShaderMaterial({
+                vertexShader,
+                fragmentShader,
+                uniforms: {
+                    u_time: { value: 0 },
+                    uScanSpeed: { value: scanSpeed * speed },
+                    uScanlineCount: { value: 5.0 + i * 0.3 },
+                    uColor: { value: colorVec },
+                    uOpacity: { value: opacity * intensity },
+                    uFlickerAmount: { value: flickerAmount },
+                    uGridEnabled: { value: gridEnabled ? 1.0 : 0.0 },
+                    uGlitchOffset: { value: 0 },
+                    uAberration: { value: 0.012 },
+                    uPlaneY: { value: planeY },
+                    uIntensity: { value: intensity },
+                },
+                transparent: true,
+                depthWrite: false,
+                blending: THREE.AdditiveBlending,
+                side: THREE.DoubleSide,
+            });
+            this.materials.push(mat);
+            const y = -this.boundingRadius * 1.25 + i * stepY;
+            const mesh = new THREE.Mesh(new THREE.PlaneGeometry(planeSize, planeSize, 2, 2), mat);
+            mesh.position.set(0, y, 0);
+            mesh.rotation.set(-Math.PI / 2, 0, 0);
+            this.group.add(mesh);
+        }
+    }
+    update(elapsed, _delta = 0.016) {
+        const { glitchEnabled } = this.config;
+        this.materials.forEach((mat, i) => {
+            mat.uniforms.u_time.value = elapsed + i * 0.04;
+            if (glitchEnabled && Math.random() > 0.985) {
+                mat.uniforms.uGlitchOffset.value = (Math.random() - 0.5) * 0.06;
+            }
+            else {
+                mat.uniforms.uGlitchOffset.value *= 0.80;
+            }
+        });
+    }
+    updateConfig(config, boundingRadius) {
+        this.config = config;
+        if (boundingRadius !== undefined)
+            this.boundingRadius = boundingRadius;
+        this.dispose(false);
+        this.build();
+    }
+    dispose(removeFromScene = true) {
+        this.group.traverse(child => {
+            const c = child;
+            if (c.geometry)
+                c.geometry.dispose();
+        });
+        this.materials.forEach(m => m.dispose());
+        this.materials = [];
+        this.group.clear();
+        if (removeFromScene && this.group.parent)
+            this.group.parent.remove(this.group);
+    }
+}

package/dist/three/effects/IceCrystalsEffectV.d.ts

@@ -0,0 +1,21 @@
+import * as THREE from 'three';
+import type { IceCrystalsConfig } from "../../types/generativeEffects";
+export declare class IceCrystalsEffectV {
+    private scene;
+    private group;
+    private materials;
+    private config;
+    private boundingRadius;
+    private spikeMesh;
+    private spikeMat;
+    private frostMat;
+    private pulseMats;
+    private timeRef;
+    private N;
+    constructor(scene: THREE.Scene, config: IceCrystalsConfig, boundingRadius?: number);
+    private build;
+    update(_elapsed: number, delta?: number): void;
+    updateConfig(config: IceCrystalsConfig, boundingRadius?: number): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=IceCrystalsEffectV.d.ts.map

package/dist/three/effects/IceCrystalsEffectV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IceCrystalsEffectV.d.ts","sourceRoot":"","sources":["../../../src/three/effects/IceCrystalsEffectV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AA6DvE,qBAAa,kBAAkB;IAC3B,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,cAAc,CAAC;IACvB,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,CAAC,CAAM;gBACH,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,cAAc,GAAE,MAAU;IAQrF,OAAO,CAAC,KAAK;IAwFb,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IAsBrD,YAAY,CAAC,MAAM,EAAE,iBAAiB,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI;IAOtE,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAgBjD"}

package/dist/three/effects/IceCrystalsEffectV.js

@@ -0,0 +1,214 @@
+import * as THREE from 'three';
+const spikeVert = /* glsl */ `
+  varying vec3 vNormal;
+  varying vec3 vWorldPos;
+  void main() {
+    vNormal   = normalize(normalMatrix * normal);
+    vWorldPos = (modelMatrix * vec4(position, 1.0)).xyz;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const spikeFrag = /* glsl */ `
+  uniform vec3  uIceColor;
+  uniform float uOpacity;
+  uniform float uIntensity;
+  varying vec3  vNormal;
+  varying vec3  vWorldPos;
+
+  void main() {
+    vec3 viewDir  = normalize(cameraPosition - vWorldPos);
+    vec3 n        = normalize(vNormal);
+
+    vec3 h        = normalize(viewDir + vec3(0.6, 1.0, 0.4));
+    float spec    = pow(max(dot(n, h), 0.0), 38.0) * 2.5;
+
+    float fresnel = pow(1.0 - abs(dot(n, viewDir)), 2.0);
+
+    float shade   = 0.5 + 0.5 * abs(dot(n, normalize(vec3(1.0, 2.0, 0.5))));
+
+    vec3  col   = uIceColor * shade + vec3(spec) + vec3(0.6, 0.9, 1.0) * fresnel * 0.5;
+    float alpha = (shade * 0.5 + fresnel * 0.35 + spec * 0.15) * uOpacity * uIntensity;
+    gl_FragColor = vec4(col, clamp(alpha, 0.0, 1.0));
+  }
+`;
+const frostVert = /* glsl */ `
+  attribute float aBaseY;
+  attribute float aSize;
+  attribute vec2  aXZ;
+  uniform float   u_time;
+  uniform float   uRange;
+  varying float   vA;
+  void main() {
+    float y  = mod(aBaseY - u_time * 0.35, uRange) - uRange * 0.5;
+    vec3  pos = vec3(aXZ.x, y, aXZ.y);
+    vA = 0.4 + 0.6 * smoothstep(-uRange * 0.5, -uRange * 0.3, y)
+             * smoothstep(uRange * 0.5, uRange * 0.3, y);
+    vec4 mv = modelViewMatrix * vec4(pos, 1.0);
+    gl_PointSize = aSize * (180.0 / -mv.z);
+    gl_Position  = projectionMatrix * mv;
+  }
+`;
+const frostFrag = /* glsl */ `
+  uniform float uOpacity;
+  varying float vA;
+  void main() {
+    vec2  c = gl_PointCoord - 0.5;
+    if (length(c) > 0.5) discard;
+    float g = exp(-dot(c, c) * 6.0);
+    gl_FragColor = vec4(0.85, 0.95, 1.0, g * vA * uOpacity);
+  }
+`;
+export class IceCrystalsEffectV {
+    scene;
+    group;
+    materials = [];
+    config;
+    boundingRadius;
+    spikeMesh = null;
+    spikeMat = null;
+    frostMat = null;
+    pulseMats = [];
+    timeRef = 0;
+    N = 30;
+    constructor(scene, config, boundingRadius = 1) {
+        this.scene = scene;
+        this.config = config;
+        this.boundingRadius = boundingRadius;
+        this.group = new THREE.Group();
+        scene.add(this.group);
+        this.build();
+    }
+    build() {
+        const { spikeCount, spikeLength, frostEnabled, iceColor, opacity, intensity } = this.config;
+        const r = this.boundingRadius;
+        const N = Math.max(10, Math.min(spikeCount, 60));
+        this.N = N;
+        const ic = new THREE.Color(iceColor);
+        const spikeLen = r * spikeLength * 0.55;
+        const spikeBase = r * 0.055 * intensity;
+        const spikeGeo = new THREE.ConeGeometry(spikeBase, spikeLen, 5);
+        spikeGeo.translate(0, spikeLen / 2, 0);
+        const sMat = new THREE.ShaderMaterial({
+            vertexShader: spikeVert,
+            fragmentShader: spikeFrag,
+            uniforms: {
+                uIceColor: { value: new THREE.Vector3(ic.r, ic.g, ic.b) },
+                uOpacity: { value: opacity },
+                uIntensity: { value: intensity },
+            },
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.AdditiveBlending,
+            side: THREE.DoubleSide,
+        });
+        this.spikeMat = sMat;
+        this.materials.push(sMat);
+        const mesh = new THREE.InstancedMesh(spikeGeo, sMat, N);
+        mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+        this.spikeMesh = mesh;
+        const tmpPos = new THREE.Vector3();
+        const tmpQuat = new THREE.Quaternion();
+        const tmpMat = new THREE.Matrix4();
+        const UP = new THREE.Vector3(0, 1, 0);
+        const goldenAngle = Math.PI * (3 - Math.sqrt(5));
+        for (let i = 0; i < N; i++) {
+            const y = 1 - (i / (N - 1)) * 2;
+            const rad = Math.sqrt(1 - y * y) * r;
+            const phi = i * goldenAngle;
+            tmpPos.set(Math.cos(phi) * rad, y * r, Math.sin(phi) * rad);
+            const dir = tmpPos.clone().normalize();
+            tmpQuat.setFromUnitVectors(UP, dir);
+            const scaleY = 0.6 + Math.random() * 0.8;
+            tmpMat.compose(tmpPos, tmpQuat, new THREE.Vector3(1, scaleY, 1));
+            mesh.setMatrixAt(i, tmpMat);
+        }
+        mesh.instanceMatrix.needsUpdate = true;
+        this.group.add(mesh);
+        // Store base matrices for pulse animation
+        this.pulseMats = Array.from({ length: N }, (_, i) => {
+            const m = new THREE.Matrix4();
+            mesh.getMatrixAt(i, m);
+            return m.clone();
+        });
+        // Frost particles
+        if (frostEnabled) {
+            const FN = 180;
+            const range = r * 2.5;
+            const fBaseY = new Float32Array(FN);
+            const fSize = new Float32Array(FN);
+            const fXZ = new Float32Array(FN * 2);
+            for (let i = 0; i < FN; i++) {
+                fBaseY[i] = Math.random() * range;
+                fSize[i] = 1.5 + Math.random() * 3.0;
+                const a = Math.random() * Math.PI * 2;
+                const fr = (0.9 + Math.random() * 0.8) * r;
+                fXZ[i * 2] = Math.cos(a) * fr;
+                fXZ[i * 2 + 1] = Math.sin(a) * fr;
+            }
+            const fGeo = new THREE.BufferGeometry();
+            fGeo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(FN * 3), 3));
+            fGeo.setAttribute('aBaseY', new THREE.BufferAttribute(fBaseY, 1));
+            fGeo.setAttribute('aSize', new THREE.BufferAttribute(fSize, 1));
+            fGeo.setAttribute('aXZ', new THREE.BufferAttribute(fXZ, 2));
+            fGeo.frustumCulled = false;
+            const fMat = new THREE.ShaderMaterial({
+                vertexShader: frostVert,
+                fragmentShader: frostFrag,
+                uniforms: {
+                    u_time: { value: 0 },
+                    uRange: { value: range },
+                    uOpacity: { value: opacity * 0.55 },
+                },
+                transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+            });
+            this.frostMat = fMat;
+            this.materials.push(fMat);
+            this.group.add(new THREE.Points(fGeo, fMat));
+        }
+    }
+    update(_elapsed, delta = 0.016) {
+        this.timeRef += delta;
+        const t = this.timeRef;
+        const { pulseSpeed } = this.config;
+        if (this.frostMat)
+            this.frostMat.uniforms.u_time.value = t;
+        if (this.spikeMesh) {
+            const tmpMat = new THREE.Matrix4();
+            const tmpPos = new THREE.Vector3();
+            const tmpQuat = new THREE.Quaternion();
+            const tmpScale = new THREE.Vector3();
+            for (let i = 0; i < this.N; i++) {
+                const base = this.pulseMats[i];
+                base.decompose(tmpPos, tmpQuat, tmpScale);
+                const pulse = 0.88 + 0.12 * Math.sin(t * pulseSpeed * 1.8 + i * 0.47);
+                tmpScale.y = pulse;
+                tmpMat.compose(tmpPos, tmpQuat, tmpScale);
+                this.spikeMesh.setMatrixAt(i, tmpMat);
+            }
+            this.spikeMesh.instanceMatrix.needsUpdate = true;
+        }
+    }
+    updateConfig(config, boundingRadius) {
+        this.config = config;
+        if (boundingRadius !== undefined)
+            this.boundingRadius = boundingRadius;
+        this.dispose(false);
+        this.build();
+    }
+    dispose(removeFromScene = true) {
+        this.group.traverse(child => {
+            const c = child;
+            if (c.geometry)
+                c.geometry.dispose();
+        });
+        this.materials.forEach(m => m.dispose());
+        this.materials = [];
+        this.spikeMesh = null;
+        this.spikeMat = null;
+        this.frostMat = null;
+        this.pulseMats = [];
+        this.group.clear();
+        if (removeFromScene && this.group.parent)
+            this.group.parent.remove(this.group);
+    }
+}

package/dist/three/effects/LightningEffectV.d.ts

@@ -0,0 +1,27 @@
+import * as THREE from 'three';
+import type { LightningConfig } from "../../types/generativeEffects";
+export declare class LightningEffectV {
+    private scene;
+    private group;
+    private materials;
+    private config;
+    private boundingRadius;
+    private bolts;
+    private lineMat;
+    private glowMats;
+    private coreCol;
+    private glowCol;
+    private depth;
+    private N;
+    private sr;
+    constructor(scene: THREE.Scene, config: LightningConfig, boundingRadius?: number);
+    private boltEndpoints;
+    private makeGeos;
+    private refreshColors;
+    private rebuildShape;
+    private build;
+    update(_elapsed: number, delta?: number): void;
+    updateConfig(config: LightningConfig, boundingRadius?: number): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=LightningEffectV.d.ts.map

package/dist/three/effects/LightningEffectV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightningEffectV.d.ts","sourceRoot":"","sources":["../../../src/three/effects/LightningEffectV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAiDrE,qBAAa,gBAAgB;IACzB,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,cAAc,CAAC;IACvB,OAAO,CAAC,KAAK,CAAM;IACnB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,CAAC,CAAM;IACf,OAAO,CAAC,EAAE,CAAK;gBACH,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,cAAc,GAAE,MAAU;IAQnF,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,QAAQ;IAgBhB,OAAO,CAAC,aAAa;IAwBrB,OAAO,CAAC,YAAY;IAiBpB,OAAO,CAAC,KAAK;IA+Cb,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IAkDrD,YAAY,CAAC,MAAM,EAAE,eAAe,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI;IAOpE,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAejD"}