@3driseai/3drise-core 1.0.1

package/dist/three/effects/PortalEffectV.js

@@ -0,0 +1,213 @@
+import * as THREE from 'three';
+const discVertShader = /* glsl */ `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const discFragShader = /* glsl */ `
+  uniform float u_time;
+  uniform float uSpiralTurns;
+  uniform float uRotationSpeed;
+  uniform vec3  uInnerColor;
+  uniform vec3  uOuterColor;
+  uniform float uOpacity;
+  uniform float uIntensity;
+
+  varying vec2 vUv;
+
+  float hash(vec2 p){ return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
+
+  void main() {
+    vec2  centered = vUv * 2.0 - 1.0;
+    float dist     = length(centered);
+    if (dist > 1.0) discard;
+
+    float angle = atan(centered.y, centered.x);
+    const float TAU = 6.28318530718;
+    float t     = u_time * uRotationSpeed;
+
+    float s1 = fract(dist * uSpiralTurns        - angle / TAU + t);
+    float s2 = fract(dist * uSpiralTurns * 0.6  + angle / TAU - t * 1.4);
+    float s3 = fract(dist * uSpiralTurns * 2.2  - angle / TAU * 1.5 + t * 2.1);
+
+    float w3    = pow(1.0 - dist, 2.0);
+    float vortex = s1 * 0.45 + s2 * 0.30 * (1.0 - w3) + s3 * 0.60 * w3;
+
+    float rimRing = exp(-pow((dist - 0.92) / 0.04, 2.0)) * 3.0;
+    float rim     = pow(smoothstep(0.85, 1.0, dist), 0.7) * 1.5;
+
+    float core        = exp(-dist * dist * 22.0) * 4.0;
+    float singularity = exp(-dist * dist * 90.0) * 8.0;
+
+    float edgeFade = 1.0 - smoothstep(0.72, 1.0, dist);
+    float noise    = hash(vec2(dist * 8.0 + t * 0.3, angle));
+    float flux     = 0.85 + 0.15 * noise;
+
+    vec3 rimLight = mix(uOuterColor * 2.0, vec3(1.0, 0.9, 0.7), rimRing * 0.5);
+    vec3 col      = mix(rimLight, uInnerColor, vortex * 0.7 + core * 0.3) * flux;
+    col += vec3(1.0, 0.95, 0.85) * (singularity + core * 0.4);
+    col += uOuterColor * rim * 0.8;
+
+    float alpha = (vortex * 0.5 + edgeFade * 0.25 + core * 0.5 + rim * 0.4 + singularity * 0.3)
+                  * uOpacity * uIntensity;
+    if (alpha < 0.008) discard;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const dustVertShader = /* glsl */ `
+  attribute float aAngle;
+  attribute float aRadiusOff;
+  attribute float aHeightOff;
+  attribute float aSpeed;
+  attribute float aPhase;
+
+  uniform float u_time;
+  uniform float uRadius;
+  uniform float uPointSize;
+  uniform float u_speed;
+
+  varying float vAlpha;
+
+  void main() {
+    const float TAU = 6.28318530718;
+
+    float angle = aAngle + u_time * u_speed * aSpeed;
+    float r     = uRadius * (1.0 + aRadiusOff);
+    float y     = uRadius * aHeightOff * sin(angle * 2.3 + aPhase + u_time * 0.7);
+
+    vec3 pos = vec3(cos(angle) * r, y, sin(angle) * r);
+
+    float twinkle = pow(max(0.0, sin(u_time * 1.8 + aPhase)), 6.0);
+    float base    = 0.08 + 0.12 * (0.5 + 0.5 * sin(aPhase + u_time * 0.4));
+    vAlpha        = base + twinkle * 0.7;
+
+    vec4 mv      = modelViewMatrix * vec4(pos, 1.0);
+    gl_PointSize = uPointSize * (0.4 + twinkle * 1.6) * (180.0 / -mv.z);
+    gl_Position  = projectionMatrix * mv;
+  }
+`;
+const dustFragShader = /* glsl */ `
+  uniform vec3  uColor;
+  uniform float uOpacity;
+  varying float vAlpha;
+
+  void main() {
+    vec2  coord = gl_PointCoord - 0.5;
+    float dist  = length(coord);
+    if (dist > 0.5) discard;
+    float glow  = exp(-dist * dist * 9.0);
+    gl_FragColor = vec4(uColor, vAlpha * uOpacity * glow);
+  }
+`;
+export class PortalEffectV {
+    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 { radius, spiralTurns, innerGlowColor, outerGlowColor, rotationSpeed, particleRingEnabled, particleCount, opacity, speed, intensity } = this.config;
+        const r = this.boundingRadius * radius;
+        const ic = new THREE.Color(innerGlowColor);
+        const oc = new THREE.Color(outerGlowColor);
+        const innerColorVec = new THREE.Vector3(ic.r, ic.g, ic.b);
+        const outerColorVec = new THREE.Vector3(oc.r, oc.g, oc.b);
+        const discMat = new THREE.ShaderMaterial({
+            vertexShader: discVertShader,
+            fragmentShader: discFragShader,
+            uniforms: {
+                u_time: { value: 0 },
+                uSpiralTurns: { value: spiralTurns },
+                uRotationSpeed: { value: rotationSpeed * speed },
+                uInnerColor: { value: innerColorVec },
+                uOuterColor: { value: outerColorVec },
+                uOpacity: { value: opacity },
+                uIntensity: { value: intensity },
+            },
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.AdditiveBlending,
+            side: THREE.DoubleSide,
+        });
+        this.materials.push(discMat);
+        const subGroup = new THREE.Group();
+        subGroup.rotation.set(-Math.PI / 2, 0, 0);
+        subGroup.position.set(0, -this.boundingRadius * 0.75, 0);
+        subGroup.add(new THREE.Mesh(new THREE.CircleGeometry(r, 80), discMat));
+        if (particleRingEnabled) {
+            const count = particleCount;
+            const angles = new Float32Array(count);
+            const radOffsets = new Float32Array(count);
+            const heightOffs = new Float32Array(count);
+            const speeds = new Float32Array(count);
+            const phases = new Float32Array(count);
+            for (let i = 0; i < count; i++) {
+                angles[i] = (i / count) * Math.PI * 2 + Math.random() * 0.2;
+                radOffsets[i] = (Math.random() - 0.5) * 0.24;
+                heightOffs[i] = (Math.random() - 0.5) * 0.16;
+                speeds[i] = 0.3 + Math.random() * 1.4;
+                phases[i] = Math.random() * Math.PI * 2;
+            }
+            const dustGeo = new THREE.BufferGeometry();
+            dustGeo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(count * 3), 3));
+            dustGeo.setAttribute('aAngle', new THREE.BufferAttribute(angles, 1));
+            dustGeo.setAttribute('aRadiusOff', new THREE.BufferAttribute(radOffsets, 1));
+            dustGeo.setAttribute('aHeightOff', new THREE.BufferAttribute(heightOffs, 1));
+            dustGeo.setAttribute('aSpeed', new THREE.BufferAttribute(speeds, 1));
+            dustGeo.setAttribute('aPhase', new THREE.BufferAttribute(phases, 1));
+            const dustCol = new THREE.Color(innerGlowColor).lerp(new THREE.Color('#ffffff'), 0.75);
+            const dustColVec = new THREE.Vector3(dustCol.r, dustCol.g, dustCol.b);
+            const dustMat = new THREE.ShaderMaterial({
+                vertexShader: dustVertShader,
+                fragmentShader: dustFragShader,
+                uniforms: {
+                    u_time: { value: 0 },
+                    uRadius: { value: r },
+                    uPointSize: { value: 5 * intensity },
+                    u_speed: { value: speed * 0.5 },
+                    uColor: { value: dustColVec },
+                    uOpacity: { value: opacity * 0.6 },
+                },
+                transparent: true,
+                depthWrite: false,
+                blending: THREE.AdditiveBlending,
+            });
+            this.materials.push(dustMat);
+            subGroup.add(new THREE.Points(dustGeo, dustMat));
+        }
+        this.group.add(subGroup);
+    }
+    update(elapsed, _delta = 0.016) {
+        for (const mat of this.materials)
+            mat.uniforms.u_time.value = elapsed;
+    }
+    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/ShockwaveEffectV.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ShockwaveEffectV.d.ts","sourceRoot":"","sources":["../../../src/three/effects/ShockwaveEffectV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAwErE,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,UAAU,CAAM;IACxB,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,SAAS,CAAM;gBACX,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,cAAc,GAAE,MAAU;IAQnF,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,KAAK;IAuDb,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IAuBpD,YAAY,CAAC,MAAM,EAAE,eAAe,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI;IAOpE,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAejD"}

package/dist/three/effects/ShockwaveEffectV.js

@@ -0,0 +1,195 @@
+import * as THREE from 'three';
+const vertexShader = /* glsl */ `
+  uniform float uProgress;
+  uniform float uExpansionScale;
+
+  void main() {
+    vec3 pos = position;
+    float expansion = 1.0 + uProgress * uExpansionScale;
+    pos.x *= expansion;
+    pos.y *= expansion;
+
+    float angle = atan(pos.y, pos.x);
+    float warp = sin(angle * 8.0 + uProgress * 18.0) * 0.018 * (1.0 - uProgress);
+    pos.z += warp;
+
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform float uProgress;
+  uniform vec3  uColor;
+  uniform vec3  uRimColor;
+  uniform float uOpacity;
+  uniform float u_time;
+
+  float hash(float n){ return fract(sin(n) * 43758.5453); }
+
+  void main() {
+    float fade   = 1.0 - uProgress;
+
+    float corona = exp(-uProgress * 6.0) * 2.5;
+
+    float shimmer = 0.75 + 0.25 * hash(uProgress * 40.0 + u_time * 7.0);
+
+    float rim     = pow(max(0.0, 1.0 - uProgress), 4.0);
+
+    vec3 rimBoosted = mix(uRimColor, vec3(1.4, 1.4, 1.6), corona * 0.5);
+    vec3 finalColor  = mix(uColor, rimBoosted, rim + corona * 0.4);
+    finalColor      += rimBoosted * corona * 0.6;
+
+    float alpha = fade * uOpacity * shimmer;
+    if (alpha < 0.005) discard;
+
+    gl_FragColor = vec4(finalColor, alpha);
+  }
+`;
+const flashFrag = /* glsl */ `
+  uniform float uProgress;
+  uniform vec3  uColor;
+  uniform float uOpacity;
+
+  varying vec2 vUv;
+
+  void main() {
+    vec2 c = vUv * 2.0 - 1.0;
+    float dist = length(c);
+    if (dist > 1.0) discard;
+    float fade = exp(-uProgress * 12.0);
+    float radial = 1.0 - smoothstep(0.4, 1.0, dist);
+    float alpha = fade * radial * uOpacity * 0.9;
+    if (alpha < 0.005) discard;
+    gl_FragColor = vec4(uColor * 2.0, alpha);
+  }
+`;
+const flashVert = /* glsl */ `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+export class ShockwaveEffectV {
+    scene;
+    group;
+    materials = [];
+    config;
+    boundingRadius;
+    ringStates = [];
+    ringMats = [];
+    flashMats = [];
+    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();
+    }
+    makeRingStates(count, interval) {
+        return Array.from({ length: count }, (_, i) => ({
+            progress: 0,
+            cooldown: (i / Math.max(count, 1)) * interval,
+        }));
+    }
+    build() {
+        const { ringCount, expansionRadius, thickness, intervalSeconds, color, rimColor, opacity, intensity } = this.config;
+        const r = this.boundingRadius;
+        const cc = new THREE.Color(color);
+        const rc = new THREE.Color(rimColor);
+        const colorVec = new THREE.Vector3(cc.r, cc.g, cc.b);
+        const rimColorVec = new THREE.Vector3(rc.r, rc.g, rc.b);
+        this.ringStates = this.makeRingStates(ringCount, intervalSeconds);
+        this.ringMats = [];
+        this.flashMats = [];
+        for (let i = 0; i < ringCount; i++) {
+            const mat = new THREE.ShaderMaterial({
+                vertexShader,
+                fragmentShader,
+                uniforms: {
+                    uProgress: { value: 0 },
+                    uExpansionScale: { value: (expansionRadius - 1) * intensity },
+                    uColor: { value: colorVec },
+                    uRimColor: { value: rimColorVec },
+                    uOpacity: { value: opacity },
+                    u_time: { value: 0 },
+                },
+                transparent: true,
+                depthWrite: false,
+                blending: THREE.AdditiveBlending,
+                side: THREE.DoubleSide,
+            });
+            this.ringMats.push(mat);
+            this.materials.push(mat);
+            const fMat = new THREE.ShaderMaterial({
+                vertexShader: flashVert,
+                fragmentShader: flashFrag,
+                uniforms: {
+                    uProgress: { value: 0 },
+                    uColor: { value: colorVec },
+                    uOpacity: { value: opacity },
+                },
+                transparent: true,
+                depthWrite: false,
+                blending: THREE.AdditiveBlending,
+                side: THREE.DoubleSide,
+            });
+            this.flashMats.push(fMat);
+            this.materials.push(fMat);
+            const subGroup = new THREE.Group();
+            const ringMesh = new THREE.Mesh(new THREE.TorusGeometry(r, thickness * intensity, 10, 80), mat);
+            ringMesh.rotation.set(-Math.PI / 2, 0, 0);
+            subGroup.add(ringMesh);
+            const flashR = r * 1.05;
+            const flashMesh = new THREE.Mesh(new THREE.CircleGeometry(flashR, 48), fMat);
+            flashMesh.rotation.set(-Math.PI / 2, 0, 0);
+            subGroup.add(flashMesh);
+            this.group.add(subGroup);
+        }
+    }
+    update(elapsed, delta = 0.016) {
+        const { intervalSeconds, speed } = this.config;
+        for (let i = 0; i < this.ringMats.length; i++) {
+            const state_ = this.ringStates[i];
+            const mat = this.ringMats[i];
+            const fMat = this.flashMats[i];
+            mat.uniforms.u_time.value = elapsed;
+            if (state_.cooldown > 0) {
+                state_.cooldown -= delta;
+                mat.uniforms.uProgress.value = 1;
+                fMat.uniforms.uProgress.value = 1;
+                continue;
+            }
+            state_.progress += delta * speed;
+            const p = Math.min(state_.progress, 1);
+            mat.uniforms.uProgress.value = p;
+            fMat.uniforms.uProgress.value = p;
+            if (state_.progress >= 1) {
+                state_.progress = 0;
+                state_.cooldown = intervalSeconds / speed;
+            }
+        }
+    }
+    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.ringMats = [];
+        this.flashMats = [];
+        this.ringStates = [];
+        this.group.clear();
+        if (removeFromScene && this.group.parent)
+            this.group.parent.remove(this.group);
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"SmokePlumeEffectV.d.ts","sourceRoot":"","sources":["../../../src/three/effects/SmokePlumeEffectV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAkEtE,qBAAa,iBAAiB;IAC1B,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,gBAAgB,EAAE,cAAc,GAAE,MAAU;IAQpF,OAAO,CAAC,KAAK;IAiDb,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,GAAE,MAAc,GAAG,IAAI;IAIrD,YAAY,CAAC,MAAM,EAAE,gBAAgB,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI;IAOrE,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAYjD"}

package/dist/three/effects/SmokePlumeEffectV.js

@@ -0,0 +1,152 @@
+import * as THREE from 'three';
+const smokeVert = /* glsl */ `
+  attribute float aT;
+  attribute vec2  aBase;
+  attribute float aPhase;
+  attribute float aRotOff;
+  attribute float aSize;
+
+  uniform float u_time;
+  uniform float u_speed;
+  uniform float uHeight;
+  uniform float uSpread;
+  uniform float uTurb;
+  uniform float uSizeScale;
+
+  varying float vLife;
+  varying float vAlpha;
+
+  void main() {
+    float life = fract(aT + u_time * u_speed * 0.22);
+    vLife = life;
+
+    float expand  = 1.0 + life * 2.5;
+    float x = aBase.x * expand * uSpread;
+    float z = aBase.y * expand * uSpread;
+
+    float t1 = sin(life * 4.2 + aPhase)               * uTurb * uSpread * life * 0.9;
+    float t2 = sin(life * 7.1 + aPhase * 1.7 + 1.3)   * uTurb * uSpread * life * 0.4;
+    float t3 = cos(life * 3.5 - aPhase * 0.8)          * uTurb * uSpread * life * 0.3;
+    x += t1 + t2;
+    z += t3 + t2 * 0.5;
+
+    float y = life * uHeight - uHeight * 0.45;
+
+    float growFade = smoothstep(0.0, 0.15, life) * smoothstep(1.0, 0.6, life);
+    float sz = aSize * uSizeScale * growFade;
+
+    vAlpha = growFade * growFade;
+
+    vec4 mv = modelViewMatrix * vec4(x, y, z, 1.0);
+    gl_PointSize = sz * (200.0 / -mv.z);
+    gl_Position  = projectionMatrix * mv;
+  }
+`;
+const smokeFrag = /* glsl */ `
+  uniform vec3  uSmokeColor;
+  uniform float uOpacity;
+  varying float vLife;
+  varying float vAlpha;
+
+  void main() {
+    if (vAlpha < 0.01) discard;
+
+    vec2  c = gl_PointCoord - 0.5;
+    float d = length(c);
+    if (d > 0.5) discard;
+
+    float g = exp(-d * d * 3.8);
+
+    float darkening = 1.0 - vLife * 0.45;
+    vec3  col = uSmokeColor * darkening;
+
+    gl_FragColor = vec4(col, g * vAlpha * uOpacity);
+  }
+`;
+export class SmokePlumeEffectV {
+    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 { particleCount, height, spread, smokeColor, turbulence, opacity, speed, intensity } = this.config;
+        const h = this.boundingRadius * height;
+        const s = this.boundingRadius * spread;
+        const N = Math.max(40, particleCount);
+        const aT = new Float32Array(N);
+        const aBase = new Float32Array(N * 2);
+        const aPhase = new Float32Array(N);
+        const aRotOff = new Float32Array(N);
+        const aSize = new Float32Array(N);
+        for (let i = 0; i < N; i++) {
+            aT[i] = i / N;
+            const r = Math.pow(Math.random(), 0.6) * s;
+            const a = Math.random() * Math.PI * 2;
+            aBase[i * 2] = Math.cos(a) * r;
+            aBase[i * 2 + 1] = Math.sin(a) * r;
+            aPhase[i] = Math.random() * Math.PI * 2;
+            aRotOff[i] = Math.random() * Math.PI * 2;
+            aSize[i] = 35 + Math.random() * 45;
+        }
+        const g = new THREE.BufferGeometry();
+        g.setAttribute('position', new THREE.BufferAttribute(new Float32Array(N * 3), 3));
+        g.setAttribute('aT', new THREE.BufferAttribute(aT, 1));
+        g.setAttribute('aBase', new THREE.BufferAttribute(aBase, 2));
+        g.setAttribute('aPhase', new THREE.BufferAttribute(aPhase, 1));
+        g.setAttribute('aRotOff', new THREE.BufferAttribute(aRotOff, 1));
+        g.setAttribute('aSize', new THREE.BufferAttribute(aSize, 1));
+        g.frustumCulled = false;
+        const sc = new THREE.Color(smokeColor);
+        const m = new THREE.ShaderMaterial({
+            vertexShader: smokeVert,
+            fragmentShader: smokeFrag,
+            uniforms: {
+                u_time: { value: 0 },
+                u_speed: { value: speed },
+                uHeight: { value: h },
+                uSpread: { value: s },
+                uTurb: { value: turbulence },
+                uSizeScale: { value: intensity },
+                uSmokeColor: { value: new THREE.Vector3(sc.r, sc.g, sc.b) },
+                uOpacity: { value: opacity },
+            },
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.NormalBlending,
+        });
+        this.materials.push(m);
+        this.group.add(new THREE.Points(g, m));
+    }
+    update(elapsed, _delta = 0.016) {
+        for (const mat of this.materials)
+            mat.uniforms.u_time.value = elapsed;
+    }
+    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/SmokeRingEffectV.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"SmokeRingEffectV.d.ts","sourceRoot":"","sources":["../../../src/three/effects/SmokeRingEffectV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AA6DrE,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,UAAU,CAAM;gBACZ,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,cAAc,GAAE,MAAU;IAQnF,OAAO,CAAC,KAAK;IAiDb,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IA6BpD,YAAY,CAAC,MAAM,EAAE,eAAe,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI;IAOpE,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAajD"}