@3driseai/3drise-core 1.0.1

package/dist/three/effects/AuraEffectV.js

@@ -0,0 +1,150 @@
+import * as THREE from 'three';
+const vertexShader = /* glsl */ `
+  varying vec3 vNormal;
+  varying vec3 vViewDir;
+  varying vec3 vWorldNormal;
+
+  void main() {
+    vNormal       = normalize(normalMatrix * normal);
+    vWorldNormal  = normalize((modelMatrix * vec4(normal, 0.0)).xyz);
+    vec4 mv       = modelViewMatrix * vec4(position, 1.0);
+    vViewDir      = normalize(-mv.xyz);
+    gl_Position   = projectionMatrix * mv;
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform float u_time;
+  uniform float uFresnelPower;
+  uniform float uPulseSpeed;
+  uniform float uNoiseAmount;
+  uniform float uOpacity;
+  uniform float uLayerIndex;  // 0..1
+  uniform float uBaseHue;
+  uniform float uIntensity;
+
+  varying vec3 vNormal;
+  varying vec3 vViewDir;
+  varying vec3 vWorldNormal;
+
+  // ── HSV helper ────────────────────────────────────────────────────────────
+  vec3 hsv2rgb(float h, float s, float v) {
+    vec3 rgb = clamp(abs(mod(h*6.0+vec3(0.,4.,2.),6.)-3.)-1.,0.,1.);
+    return v * mix(vec3(1.0), rgb, s);
+  }
+
+  // ── 3D value noise + 4-octave FBM ─────────────────────────────────────────
+  float hash(vec3 p){ return fract(sin(dot(p,vec3(127.1,311.7,74.7)))*43758.5453); }
+  float noise(vec3 p){
+    vec3 i=floor(p); vec3 f=fract(p); f=f*f*(3.-2.*f);
+    return mix(mix(mix(hash(i),         hash(i+vec3(1,0,0)),f.x),
+                   mix(hash(i+vec3(0,1,0)),hash(i+vec3(1,1,0)),f.x),f.y),
+               mix(mix(hash(i+vec3(0,0,1)),hash(i+vec3(1,0,1)),f.x),
+                   mix(hash(i+vec3(0,1,1)),hash(i+vec3(1,1,1)),f.x),f.y),f.z);
+  }
+  float fbm(vec3 p){
+    float v=0., a=0.5;
+    for(int i=0;i<4;i++){ v+=a*noise(p); p=p*2.17+vec3(1.7,9.2,3.7); a*=0.5; }
+    return v;
+  }
+
+  void main() {
+    vec3 viewDir = normalize(vViewDir);
+
+    // ── Fresnel ────────────────────────────────────────────────────────────
+    float ndv     = abs(dot(vNormal, viewDir));
+    float fresnel = pow(1.0 - ndv, uFresnelPower);
+
+    // ── 4-octave FBM noise ─────────────────────────────────────────────────
+    float f = fbm(vWorldNormal * 3.5 + u_time * 0.18);
+
+    // ── Iridescence: hue shifts with view angle AND time ───────────────────
+    float hue     = mod(uBaseHue + ndv * 0.45 - uLayerIndex * 0.15 + u_time * 0.04, 1.0);
+    vec3  iriCol  = hsv2rgb(hue, 0.85, 1.0);
+
+    // ── Electric tendrils: sharp bright streaks where FBM exceeds threshold ─
+    float tendrils = smoothstep(0.60, 0.75, f + uLayerIndex * 0.05);
+
+    // ── Pulse per layer (staggered phase) ──────────────────────────────────
+    float pulse = 0.65 + 0.35 * sin(u_time * uPulseSpeed + uLayerIndex * 2.1);
+
+    // ── Combine ────────────────────────────────────────────────────────────
+    float noiseBlend = (1.0 - uNoiseAmount) + uNoiseAmount * f;
+    float alpha = fresnel * noiseBlend * uOpacity * pulse * (1.0 - uLayerIndex * 0.22) * uIntensity;
+    if (alpha < 0.004) discard;
+
+    vec3 col = iriCol + iriCol * tendrils * 1.8;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+export class AuraEffectV {
+    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 { layerCount, fresnelPower, pulseSpeed, innerColor, noiseAmount, sizeMultiplier, opacity, speed, intensity } = this.config;
+        const c = new THREE.Color(innerColor);
+        const h = { h: 0, s: 0, l: 0 };
+        c.getHSL(h);
+        const baseHue = h.h;
+        const baseR = this.boundingRadius * sizeMultiplier;
+        for (let i = 0; i < layerCount; i++) {
+            const mat = new THREE.ShaderMaterial({
+                vertexShader,
+                fragmentShader,
+                uniforms: {
+                    u_time: { value: 0 },
+                    uFresnelPower: { value: fresnelPower },
+                    uPulseSpeed: { value: pulseSpeed * speed },
+                    uNoiseAmount: { value: noiseAmount },
+                    uOpacity: { value: opacity },
+                    uLayerIndex: { value: layerCount > 1 ? i / (layerCount - 1) : 0 },
+                    uBaseHue: { value: baseHue },
+                    uIntensity: { value: intensity },
+                },
+                transparent: true,
+                depthWrite: false,
+                blending: THREE.AdditiveBlending,
+                side: THREE.BackSide,
+            });
+            this.materials.push(mat);
+            const layerT = layerCount > 1 ? i / (layerCount - 1) : 0;
+            const r = baseR * (1 + layerT * layerT * 0.5);
+            const geo = new THREE.SphereGeometry(r, 40, 40);
+            const mesh = new THREE.Mesh(geo, mat);
+            this.group.add(mesh);
+        }
+    }
+    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/AuroraEffectV.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"AuroraEffectV.d.ts","sourceRoot":"","sources":["../../../src/three/effects/AuroraEffectV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAgDlE,qBAAa,aAAa;IACtB,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,OAAO,CAAM;gBACT,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,cAAc,GAAE,MAAU;IAQhF,OAAO,CAAC,KAAK;IAwCb,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IAMpD,YAAY,CAAC,MAAM,EAAE,YAAY,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI;IAOjE,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAajD"}

package/dist/three/effects/AuroraEffectV.js

@@ -0,0 +1,129 @@
+import * as THREE from 'three';
+const ribbonVert = /* glsl */ `
+  uniform float u_time;
+  uniform float uPhase;
+  uniform float u_speed;
+  uniform float uWaveAmp;
+  varying vec2  vUv;
+
+  void main() {
+    vec3 pos = position;
+    float w1 = sin(pos.y * 2.5 + u_time * u_speed + uPhase)         * uWaveAmp;
+    float w2 = sin(pos.y * 1.2 - u_time * u_speed * 0.7 + uPhase * 1.3) * uWaveAmp * 0.5;
+    float w3 = sin(pos.y * 4.1 + u_time * u_speed * 1.3 + uPhase * 2.1) * uWaveAmp * 0.18;
+    pos.x += w1 + w2 + w3;
+    pos.z += sin(pos.y * 3.0 + u_time * u_speed * 0.5 + uPhase * 0.7) * uWaveAmp * 0.3;
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
+  }
+`;
+const ribbonFrag = /* glsl */ `
+  uniform float u_time;
+  uniform float uHue;
+  uniform float uOpacity;
+  uniform float uIntensity;
+  varying vec2  vUv;
+
+  vec3 hsl2rgb(float h, float s, float l) {
+    vec3 rgb = clamp(abs(mod(h * 6.0 + vec3(0.0, 4.0, 2.0), 6.0) - 3.0) - 1.0, 0.0, 1.0);
+    return l + s * (rgb - 0.5) * (1.0 - abs(2.0 * l - 1.0));
+  }
+
+  void main() {
+    float fade = sin(vUv.y * 3.14159);
+    fade = pow(fade, 0.6);
+
+    float shimmer = 0.55 + 0.45 * sin(vUv.y * 22.0 + u_time * 2.4 + uHue * 9.0);
+
+    float hEdge = smoothstep(0.0, 0.18, vUv.x) * smoothstep(1.0, 0.82, vUv.x);
+
+    float hue = mod(uHue + vUv.y * 0.14 + u_time * 0.022, 1.0);
+    vec3  col = hsl2rgb(hue, 0.92, 0.58 + shimmer * 0.12);
+
+    float alpha = fade * shimmer * hEdge * uOpacity * uIntensity;
+    if (alpha < 0.005) discard;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+export class AuroraEffectV {
+    scene;
+    group;
+    materials = [];
+    config;
+    boundingRadius;
+    ribbons = [];
+    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 { ribbonCount, waveAmplitude, colorShift, arcWidth, opacity, intensity } = this.config;
+        const N = Math.max(3, Math.min(ribbonCount, 10));
+        const r = this.boundingRadius;
+        const w = r * 0.9;
+        const h = r * 2.2;
+        const rad = r * 1.35;
+        const hues = [0.33, 0.38, 0.45, 0.50, 0.57, 0.65, 0.72, 0.78, 0.82, 0.87];
+        this.ribbons = [];
+        for (let i = 0; i < N; i++) {
+            const t = N === 1 ? 0.5 : i / (N - 1);
+            const angle = (t - 0.5) * arcWidth * Math.PI;
+            const hue = (colorShift + hues[i % hues.length]) % 1;
+            const geo = new THREE.PlaneGeometry(w, h, 1, 24);
+            const mat = new THREE.ShaderMaterial({
+                vertexShader: ribbonVert,
+                fragmentShader: ribbonFrag,
+                uniforms: {
+                    u_time: { value: 0 },
+                    uPhase: { value: i * 1.13 + t * Math.PI * 2 },
+                    u_speed: { value: 0.55 + Math.random() * 0.3 },
+                    uWaveAmp: { value: waveAmplitude * r * 0.55 },
+                    uHue: { value: hue },
+                    uOpacity: { value: opacity },
+                    uIntensity: { value: intensity },
+                },
+                transparent: true,
+                depthWrite: false,
+                blending: THREE.AdditiveBlending,
+                side: THREE.DoubleSide,
+            });
+            this.materials.push(mat);
+            this.ribbons.push({ mat });
+            const mesh = new THREE.Mesh(geo, mat);
+            mesh.position.set(Math.sin(angle) * rad, r * 0.55, -Math.cos(angle) * rad);
+            mesh.rotation.y = angle;
+            mesh.rotation.x = 0.08;
+            this.group.add(mesh);
+        }
+    }
+    update(elapsed, delta = 0.016) {
+        const { speed } = this.config;
+        for (const { mat } of this.ribbons)
+            mat.uniforms.u_time.value = elapsed;
+        this.group.rotation.y += delta * speed * 0.06;
+    }
+    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.ribbons = [];
+        this.group.clear();
+        if (removeFromScene && this.group.parent)
+            this.group.parent.remove(this.group);
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"BlackHoleEffectV.d.ts","sourceRoot":"","sources":["../../../src/three/effects/BlackHoleEffectV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AA2GrE,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;gBACX,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,cAAc,GAAE,MAAU;IAQnF,OAAO,CAAC,KAAK;IA2Eb,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,GAAE,MAAc,GAAG,IAAI;IAIrD,YAAY,CAAC,MAAM,EAAE,eAAe,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI;IAOpE,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAYjD"}

package/dist/three/effects/BlackHoleEffectV.js

@@ -0,0 +1,219 @@
+import * as THREE from 'three';
+const diskVert = /* glsl */ `
+  varying vec2 vUv;
+  void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position,1.0); }
+`;
+const diskFrag = /* glsl */ `
+  uniform float u_time;
+  uniform float uRotSpeed;
+  uniform vec3  uDiskColor;
+  uniform float uOpacity;
+  uniform float uIntensity;
+
+  varying vec2 vUv;
+
+  vec3 tempColor(float t) {
+    vec3 outer = uDiskColor * 0.4;
+    vec3 mid   = uDiskColor;
+    vec3 inner = vec3(0.85, 0.95, 1.0) * 2.5;
+    if (t < 0.5) return mix(outer, mid,   t * 2.0);
+    else          return mix(mid,  inner, (t - 0.5) * 2.0);
+  }
+
+  float hash(float n) { return fract(sin(n) * 43758.5453); }
+
+  void main() {
+    vec2  centered = vUv * 2.0 - 1.0;
+    float dist     = length(centered);
+    if (dist > 1.0 || dist < 0.001) discard;
+
+    float angle = atan(centered.y, centered.x);
+
+    float t = 1.0 - dist;
+
+    float spiral = fract(dist * 6.0 - u_time * uRotSpeed + angle / 6.28318);
+    float bands  = pow(spiral, 2.2) * 0.6 + 0.4;
+
+    float bright = pow(t, 0.7) * bands;
+
+    float noise = 0.85 + 0.15 * sin(angle * 7.0 + dist * 18.0 - u_time * 2.5);
+
+    vec3  col   = tempColor(t) * bright * noise;
+    float alpha = bright * noise * uOpacity * uIntensity * smoothstep(0.0, 0.08, dist);
+    if (alpha < 0.005) discard;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const lensFrag = /* glsl */ `
+  uniform float u_time;
+  uniform vec3  uDiskColor;
+  uniform float uOpacity;
+  uniform float uIntensity;
+  varying vec3  vNormal;
+
+  void main() {
+    vec3  viewDir = normalize(cameraPosition - vNormal * 100.0);
+    float ndv     = abs(dot(normalize(vNormal), viewDir));
+    float fresnel = pow(1.0 - ndv, 2.2);
+    float equator = exp(-ndv * ndv * 6.0) * 2.5;
+    float alpha   = (fresnel * 0.4 + equator * 0.6) * uOpacity * uIntensity;
+    if (alpha < 0.005) discard;
+    vec3 col = mix(uDiskColor, vec3(1.0, 0.92, 0.8), fresnel * 0.5);
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const lensVert = /* glsl */ `
+  varying vec3 vNormal;
+  void main() {
+    vNormal = (modelMatrix * vec4(normal, 0.0)).xyz;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const jetVert = /* glsl */ `
+  attribute float aT;
+  attribute float aPhase;
+  uniform float   u_time;
+  uniform float   u_speed;
+  uniform float   uLength;
+  uniform float   uDir;
+  uniform float   uRadius;
+  varying float   vT;
+  void main() {
+    float t  = fract(aT + u_time * u_speed);
+    vT = t;
+    float r  = uRadius * (1.0 - t * 0.85);
+    float a  = aPhase + t * 4.0;
+    float x  = cos(a) * r;
+    float z  = sin(a) * r;
+    float y  = uDir * t * uLength;
+    vec4  mv = modelViewMatrix * vec4(x, y, z, 1.0);
+    gl_PointSize = (1.0 - t) * 6.0 * (200.0 / -mv.z);
+    gl_Position  = projectionMatrix * mv;
+  }
+`;
+const jetFrag = /* glsl */ `
+  uniform vec3  uJetColor;
+  uniform float uOpacity;
+  varying float vT;
+  void main() {
+    vec2  c = gl_PointCoord - 0.5;
+    if (length(c) > 0.5) discard;
+    float g = exp(-dot(c,c) * 6.0);
+    float a = g * uOpacity * (1.0 - vT) * smoothstep(0.0, 0.1, vT);
+    if (a < 0.01) discard;
+    gl_FragColor = vec4(uJetColor, a);
+  }
+`;
+export class BlackHoleEffectV {
+    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 { diskColor, jetEnabled, jetColor, rotationSpeed, tilt, opacity, speed, intensity } = this.config;
+        const r = this.boundingRadius;
+        const tiltRad = (tilt * Math.PI) / 180;
+        this.group.rotation.set(0, 0, tiltRad);
+        const dc = new THREE.Color(diskColor);
+        const dcv = new THREE.Vector3(dc.r, dc.g, dc.b);
+        const diskMat = new THREE.ShaderMaterial({
+            vertexShader: diskVert, fragmentShader: diskFrag,
+            uniforms: {
+                u_time: { value: 0 },
+                uRotSpeed: { value: rotationSpeed },
+                uDiskColor: { value: dcv },
+                uOpacity: { value: opacity },
+                uIntensity: { value: intensity },
+            },
+            transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, side: THREE.DoubleSide,
+        });
+        this.materials.push(diskMat);
+        const lensMat = new THREE.ShaderMaterial({
+            vertexShader: lensVert, fragmentShader: lensFrag,
+            uniforms: {
+                u_time: { value: 0 },
+                uDiskColor: { value: dcv },
+                uOpacity: { value: opacity },
+                uIntensity: { value: intensity },
+            },
+            transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, side: THREE.BackSide,
+        });
+        this.materials.push(lensMat);
+        // Photon sphere lensing rim
+        this.group.add(new THREE.Mesh(new THREE.SphereGeometry(r * 0.55, 48, 48), lensMat));
+        // Accretion disk
+        const diskMesh = new THREE.Mesh(new THREE.RingGeometry(r * 0.38, r * 1.15, 72), diskMat);
+        diskMesh.rotation.set(Math.PI / 2, 0, 0);
+        this.group.add(diskMesh);
+        // Jets
+        if (jetEnabled) {
+            const JN = 80;
+            const jT = new Float32Array(JN);
+            const jPhase = new Float32Array(JN);
+            for (let i = 0; i < JN; i++) {
+                jT[i] = i / JN;
+                jPhase[i] = Math.random() * Math.PI * 2;
+            }
+            const jGeo = new THREE.BufferGeometry();
+            jGeo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(JN * 3), 3));
+            jGeo.setAttribute('aT', new THREE.BufferAttribute(jT, 1));
+            jGeo.setAttribute('aPhase', new THREE.BufferAttribute(jPhase, 1));
+            jGeo.frustumCulled = false;
+            const jc = new THREE.Color(jetColor);
+            const makeJetMat = (dir) => {
+                const m = new THREE.ShaderMaterial({
+                    vertexShader: jetVert, fragmentShader: jetFrag,
+                    uniforms: {
+                        u_time: { value: 0 },
+                        u_speed: { value: speed },
+                        uLength: { value: r * 2.2 },
+                        uDir: { value: dir },
+                        uRadius: { value: r * 0.12 },
+                        uJetColor: { value: new THREE.Vector3(jc.r, jc.g, jc.b) },
+                        uOpacity: { value: opacity * 0.8 },
+                    },
+                    transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+                });
+                return m;
+            };
+            const jetMat1 = makeJetMat(1);
+            const jetMat2 = makeJetMat(-1);
+            this.materials.push(jetMat1);
+            this.materials.push(jetMat2);
+            this.group.add(new THREE.Points(jGeo, jetMat1));
+            this.group.add(new THREE.Points(jGeo, jetMat2));
+        }
+    }
+    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/ConstellationEffectV.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ConstellationEffectV.d.ts","sourceRoot":"","sources":["../../../src/three/effects/ConstellationEffectV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAwFzE,qBAAa,oBAAoB;IAC7B,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,OAAO,CAAQ;IACvB,OAAO,CAAC,OAAO,CAAQ;gBACX,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,mBAAmB,EAAE,cAAc,GAAE,MAAU;IAQvF,OAAO,CAAC,KAAK;IAyEb,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IASpD,YAAY,CAAC,MAAM,EAAE,mBAAmB,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI;IAOxE,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAcjD"}