@3driseai/3drise-core 1.0.1

package/dist/three/effects/NeuralNetworkEffectV.js

@@ -0,0 +1,211 @@
+import * as THREE from 'three';
+const pulseVert = /* glsl */ `
+  attribute float aBright;
+  uniform float   uSize;
+  varying float   vB;
+  void main() {
+    vB = aBright;
+    if (vB < 0.01) { gl_PointSize = 0.0; gl_Position = vec4(0); return; }
+    vec4 mv = modelViewMatrix * vec4(position, 1.0);
+    gl_PointSize = uSize * vB * (200.0 / -mv.z);
+    gl_Position  = projectionMatrix * mv;
+  }
+`;
+const pulseFrag = /* glsl */ `
+  uniform vec3  uColor;
+  uniform float uOpacity;
+  varying float vB;
+  void main() {
+    if (vB < 0.01) discard;
+    vec2  c = gl_PointCoord - 0.5;
+    if (length(c) > 0.5) discard;
+    float g = exp(-dot(c, c) * 5.5);
+    gl_FragColor = vec4(uColor, g * vB * uOpacity);
+  }
+`;
+const MAX_PULSES = 4;
+export class NeuralNetworkEffectV {
+    scene;
+    group;
+    materials = [];
+    config;
+    boundingRadius;
+    orbitAngles = new Float32Array(0);
+    pulses = [];
+    nextPulse = 0;
+    effectScene = null;
+    tmpMat = new THREE.Matrix4();
+    tmpQuat = new THREE.Quaternion();
+    tmpVec = new THREE.Vector3();
+    N = 20;
+    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 { nodeCount, nodeColor, pulseColor, opacity, intensity } = this.config;
+        const r = this.boundingRadius * 1.35;
+        const N = Math.max(8, Math.min(nodeCount, 40));
+        this.N = N;
+        const basePos = [];
+        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;
+            basePos.push(new THREE.Vector3(Math.cos(phi) * rad, y * r, Math.sin(phi) * rad));
+        }
+        const orbitAxes = Array.from({ length: N }, () => new THREE.Vector3(Math.random() - 0.5, Math.random() - 0.5, Math.random() - 0.5).normalize());
+        const orbitSpeeds = Array.from({ length: N }, () => 0.4 + Math.random() * 0.6);
+        const angles = new Float32Array(N);
+        for (let i = 0; i < N; i++)
+            angles[i] = i * 0.7;
+        this.orbitAngles = angles;
+        const MAX_DIST = r * 0.85;
+        const edges = [];
+        const degree = new Int32Array(N);
+        for (let i = 0; i < N; i++) {
+            for (let j = i + 1; j < N; j++) {
+                if (degree[i] >= 3 || degree[j] >= 3)
+                    continue;
+                if (basePos[i].distanceTo(basePos[j]) < MAX_DIST) {
+                    edges.push([i, j]);
+                    degree[i]++;
+                    degree[j]++;
+                }
+            }
+        }
+        const edgeVerts = new Float32Array(edges.length * 6);
+        const edgeCols = new Float32Array(edges.length * 6);
+        const nc = new THREE.Color(nodeColor);
+        const DIM = 0.06;
+        for (let e = 0; e < edges.length; e++) {
+            const [a, b] = edges[e];
+            edgeVerts.set([basePos[a].x, basePos[a].y, basePos[a].z, basePos[b].x, basePos[b].y, basePos[b].z], e * 6);
+            edgeCols.set([nc.r * DIM, nc.g * DIM, nc.b * DIM, nc.r * DIM, nc.g * DIM, nc.b * DIM], e * 6);
+        }
+        const edgeGeo = new THREE.BufferGeometry();
+        edgeGeo.setAttribute('position', new THREE.BufferAttribute(edgeVerts, 3));
+        edgeGeo.setAttribute('color', new THREE.BufferAttribute(edgeCols, 3));
+        const edgeMat = new THREE.LineBasicMaterial({
+            vertexColors: true, transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+        });
+        const nodeGeo = new THREE.SphereGeometry(0.055 * intensity, 8, 8);
+        const nc2 = new THREE.Color(nodeColor);
+        const nodeMat = new THREE.MeshBasicMaterial({
+            color: nc2, transparent: true, opacity: opacity * 0.55,
+            depthWrite: false, blending: THREE.AdditiveBlending,
+        });
+        const nodeMesh = new THREE.InstancedMesh(nodeGeo, nodeMat, N);
+        nodeMesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+        const pulsePos = new Float32Array(MAX_PULSES * 3);
+        const pulseBright = new Float32Array(MAX_PULSES);
+        const pulseGeo = new THREE.BufferGeometry();
+        pulseGeo.setAttribute('position', new THREE.BufferAttribute(pulsePos, 3));
+        pulseGeo.setAttribute('aBright', new THREE.BufferAttribute(pulseBright, 1));
+        const pc = new THREE.Color(pulseColor);
+        const pulseMat = new THREE.ShaderMaterial({
+            vertexShader: pulseVert, fragmentShader: pulseFrag,
+            uniforms: {
+                uSize: { value: 20 * intensity },
+                uColor: { value: new THREE.Vector3(pc.r, pc.g, pc.b) },
+                uOpacity: { value: opacity },
+            },
+            transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+        });
+        this.pulses = Array.from({ length: MAX_PULSES }, () => ({
+            fromIdx: 0, toIdx: 1, progress: 0, active: false,
+        }));
+        this.nextPulse = 0;
+        this.effectScene = { basePos, orbitAxes, orbitSpeeds, edges, edgeGeo, edgeMat, nodeMesh, pulseGeo, pulseMat };
+        this.materials.push(pulseMat);
+        this.group.add(new THREE.LineSegments(edgeGeo, edgeMat));
+        this.group.add(nodeMesh);
+        this.group.add(new THREE.Points(pulseGeo, pulseMat));
+    }
+    update(_elapsed, delta = 0.016) {
+        if (!this.effectScene)
+            return;
+        const { speed, orbitSpeed, signalSpeed, intensity } = this.config;
+        const dt = delta * speed;
+        const { basePos, orbitAxes, orbitSpeeds, edges, edgeGeo, nodeMesh, pulseGeo, pulseMat } = this.effectScene;
+        const N = this.N;
+        const angles = this.orbitAngles;
+        const curPos = [];
+        for (let i = 0; i < N; i++) {
+            angles[i] += dt * orbitSpeed * orbitSpeeds[i] * 0.4;
+            const base = basePos[i];
+            const axis = orbitAxes[i];
+            const ang = angles[i];
+            const cosA = Math.cos(ang), sinA = Math.sin(ang);
+            const dot = base.dot(axis);
+            this.tmpVec.set(base.x * cosA + (axis.y * base.z - axis.z * base.y) * sinA + axis.x * dot * (1 - cosA), base.y * cosA + (axis.z * base.x - axis.x * base.z) * sinA + axis.y * dot * (1 - cosA), base.z * cosA + (axis.x * base.y - axis.y * base.x) * sinA + axis.z * dot * (1 - cosA));
+            curPos.push(this.tmpVec.clone());
+            this.tmpMat.compose(this.tmpVec, this.tmpQuat, new THREE.Vector3(1, 1, 1));
+            nodeMesh.setMatrixAt(i, this.tmpMat);
+        }
+        nodeMesh.instanceMatrix.needsUpdate = true;
+        const edgePosAttr = edgeGeo.attributes.position;
+        for (let e = 0; e < edges.length; e++) {
+            const [a, b] = edges[e];
+            edgePosAttr.setXYZ(e * 2, curPos[a].x, curPos[a].y, curPos[a].z);
+            edgePosAttr.setXYZ(e * 2 + 1, curPos[b].x, curPos[b].y, curPos[b].z);
+        }
+        edgePosAttr.needsUpdate = true;
+        this.nextPulse -= delta;
+        if (this.nextPulse <= 0 && edges.length > 0) {
+            this.nextPulse = 0.4 / speed;
+            const idle = this.pulses.findIndex(p => !p.active);
+            if (idle >= 0) {
+                const e = Math.floor(Math.random() * edges.length);
+                this.pulses[idle] = { fromIdx: edges[e][0], toIdx: edges[e][1], progress: 0, active: true };
+            }
+        }
+        const ptPos = pulseGeo.attributes.position;
+        const ptBright = pulseGeo.attributes.aBright;
+        this.pulses.forEach((p, pi) => {
+            if (!p.active) {
+                ptBright.setX(pi, 0);
+                return;
+            }
+            p.progress += dt * signalSpeed * 0.9;
+            if (p.progress >= 1) {
+                p.active = false;
+                ptBright.setX(pi, 0);
+                return;
+            }
+            const pos = curPos[p.fromIdx].clone().lerp(curPos[p.toIdx], p.progress);
+            ptPos.setXYZ(pi, pos.x, pos.y, pos.z);
+            ptBright.setX(pi, 0.7 + 0.3 * Math.sin(p.progress * Math.PI));
+        });
+        ptPos.needsUpdate = true;
+        ptBright.needsUpdate = true;
+        pulseMat.uniforms.uSize.value = 20 * intensity;
+    }
+    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();
+            if (c.material && !Array.isArray(c.material))
+                c.material.dispose();
+        });
+        this.materials.forEach(m => m.dispose());
+        this.materials = [];
+        this.effectScene = null;
+        this.group.clear();
+        if (removeFromScene && this.group.parent)
+            this.group.parent.remove(this.group);
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"OrbEffectV.d.ts","sourceRoot":"","sources":["../../../src/three/effects/OrbEffectV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAgK/D,qBAAa,UAAU;IACnB,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,WAAW,CAAQ;IAC3B,OAAO,CAAC,KAAK,CAAK;gBACN,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,GAAE,MAAU;IAQ7E,OAAO,CAAC,KAAK;IAwGb,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IAOpD,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI;IAO9D,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAajD"}

package/dist/three/effects/OrbEffectV.js

@@ -0,0 +1,307 @@
+import * as THREE from 'three';
+const sharedVert = /* 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 coreFrag = /* glsl */ `
+  uniform float u_time;
+  uniform vec3  uInnerColor;
+  uniform vec3  uOuterColor;
+  uniform float uOpacity;
+  uniform float uNoiseAmount;
+  uniform float uIntensity;
+  uniform float uPulseSpeed;
+
+  varying vec3 vNormal;
+  varying vec3 vViewDir;
+  varying vec3 vWorldNormal;
+
+  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<6;i++){ v+=a*noise(p); p=p*2.13+vec3(1.7,9.2,3.7); a*=0.5; }
+    return v;
+  }
+
+  void main() {
+    vec3 nCoord = vWorldNormal * 5.5 + vec3(u_time * 0.35, u_time * 0.18, u_time * -0.22);
+    float f      = fbm(nCoord);
+
+    float cells  = smoothstep(0.54, 0.72, f) * 4.0;
+    float cool   = (1.0 - smoothstep(0.38, 0.50, f)) * 0.3;
+    float flares = smoothstep(0.70, 0.85, f) * 6.0;
+
+    float pulse  = 0.85 + 0.15 * sin(u_time * uPulseSpeed * 2.3);
+    float limb   = 1.0 - abs(dot(vNormal, vViewDir)) * 0.4;
+
+    vec3 col = mix(uOuterColor, uInnerColor, f * 1.8 + cells * 0.3);
+    col += uInnerColor * flares;
+    col -= uOuterColor * cool;
+    col *= pulse * limb * (1.0 + uNoiseAmount * cells);
+
+    float alpha = (0.85 + cells * 0.15) * uOpacity * uIntensity;
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const plasmaFrag = /* glsl */ `
+  uniform float u_time;
+  uniform float uLayerIndex;
+  uniform vec3  uInnerColor;
+  uniform vec3  uOuterColor;
+  uniform float uOpacity;
+  uniform float uNoiseAmount;
+  uniform float uPulseSpeed;
+  uniform float uIntensity;
+
+  varying vec3 vNormal;
+  varying vec3 vViewDir;
+  varying vec3 vWorldNormal;
+
+  vec3 hsv2rgb(float h, float s, float v){
+    vec3 rgb=clamp(abs(mod(h*6.+vec3(0.,4.,2.),6.)-3.)-1.,0.,1.);
+    return v*mix(vec3(1.),rgb,s);
+  }
+  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<5;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);
+    float ndv    = abs(dot(vNormal, viewDir));
+
+    float fresnel = pow(1.0 - ndv, 2.5 - uLayerIndex);
+
+    float f = fbm(vWorldNormal * (3.0 + uLayerIndex * 2.0) + vec3(u_time * (0.15 + uLayerIndex * 0.08)));
+
+    float hue      = mod(ndv * 0.5 - uLayerIndex * 0.2 + u_time * 0.05 + f * 0.15, 1.0);
+    vec3  iriCol   = hsv2rgb(hue, 0.9 - uLayerIndex * 0.2, 1.0);
+
+    float tendril  = smoothstep(0.62 - uLayerIndex * 0.04, 0.78, f);
+    float plasma   = smoothstep(0.50, 0.65, f) * 0.5;
+
+    float pulse    = 0.6 + 0.4 * sin(u_time * uPulseSpeed + uLayerIndex * 2.4);
+
+    vec3 col = iriCol + iriCol * (tendril * 2.0 + plasma);
+    col      = mix(col, uInnerColor, tendril * 0.3);
+
+    float noiseBlend = (1.0 - uNoiseAmount) + uNoiseAmount * f;
+    float alpha = fresnel * noiseBlend * uOpacity * pulse
+                  * (1.0 - uLayerIndex * 0.28) * uIntensity;
+    if (alpha < 0.004) discard;
+
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const glowFrag = /* glsl */ `
+  uniform float u_time;
+  uniform vec3  uOuterColor;
+  uniform float uOpacity;
+  uniform float uPulseSpeed;
+
+  varying vec3 vNormal;
+  varying vec3 vViewDir;
+
+  void main() {
+    float ndv    = abs(dot(normalize(vNormal), normalize(vViewDir)));
+    float fresnel = pow(1.0 - ndv, 1.2);
+    float pulse   = 0.55 + 0.45 * sin(u_time * uPulseSpeed * 0.7 + 1.2);
+    float alpha   = fresnel * uOpacity * pulse * 0.5;
+    if (alpha < 0.003) discard;
+    float hue  = mod(u_time * 0.04, 1.0);
+    vec3  tint = mix(uOuterColor, vec3(cos(hue*6.28)*0.5+0.5, cos((hue+0.33)*6.28)*0.5+0.5, cos((hue+0.67)*6.28)*0.5+0.5), 0.25);
+    gl_FragColor = vec4(tint, alpha);
+  }
+`;
+const coronaVert = /* glsl */ `
+  attribute float aAngle;
+  varying float vAngle;
+  void main() {
+    vAngle      = aAngle;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const coronaFrag = /* glsl */ `
+  uniform float u_time;
+  uniform vec3  uCoronaColor;
+  uniform float uOpacity;
+  uniform float uIntensity;
+  varying float vAngle;
+
+  vec3 hsv2rgb(float h, float s, float v){
+    vec3 rgb=clamp(abs(mod(h*6.+vec3(0.,4.,2.),6.)-3.)-1.,0.,1.);
+    return v*mix(vec3(1.),rgb,s);
+  }
+
+  void main() {
+    float hue    = mod(vAngle / 6.28318 + u_time * 0.15, 1.0);
+    vec3  col    = mix(uCoronaColor, hsv2rgb(hue, 0.8, 1.0), 0.6);
+    float pulse  = 0.6 + 0.4 * sin(u_time * 2.5 + vAngle * 3.0);
+    float alpha  = uOpacity * pulse * uIntensity;
+    gl_FragColor = vec4(col * (1.0 + pulse), alpha);
+  }
+`;
+export class OrbEffectV {
+    scene;
+    group;
+    materials = [];
+    config;
+    boundingRadius;
+    coronaGroup = null;
+    speed = 1;
+    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 { coreSize, glowLayers, innerColor, outerColor, coronaEnabled, coronaColor, noiseAmount, pulseSpeed, opacity, speed, intensity } = this.config;
+        this.speed = speed;
+        const ic = new THREE.Color(innerColor);
+        const oc = new THREE.Color(outerColor);
+        const cc = new THREE.Color(coronaColor);
+        const innerColorVec = new THREE.Vector3(ic.r, ic.g, ic.b);
+        const outerColorVec = new THREE.Vector3(oc.r, oc.g, oc.b);
+        const coronaColorVec = new THREE.Vector3(cc.r, cc.g, cc.b);
+        const coreR = this.boundingRadius * coreSize;
+        // Core material
+        const coreMat = new THREE.ShaderMaterial({
+            vertexShader: sharedVert,
+            fragmentShader: coreFrag,
+            uniforms: {
+                u_time: { value: 0 },
+                uInnerColor: { value: innerColorVec },
+                uOuterColor: { value: outerColorVec },
+                uOpacity: { value: opacity },
+                uNoiseAmount: { value: noiseAmount },
+                uIntensity: { value: intensity },
+                uPulseSpeed: { value: pulseSpeed * speed },
+            },
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.AdditiveBlending,
+        });
+        this.materials.push(coreMat);
+        const coreGeo = new THREE.SphereGeometry(coreR, 48, 48);
+        this.group.add(new THREE.Mesh(coreGeo, coreMat));
+        // Plasma shells
+        for (let i = 0; i < glowLayers; i++) {
+            const shellMat = new THREE.ShaderMaterial({
+                vertexShader: sharedVert,
+                fragmentShader: plasmaFrag,
+                uniforms: {
+                    u_time: { value: 0 },
+                    uLayerIndex: { value: glowLayers > 1 ? i / (glowLayers - 1) : 0 },
+                    uInnerColor: { value: innerColorVec },
+                    uOuterColor: { value: outerColorVec },
+                    uOpacity: { value: opacity },
+                    uNoiseAmount: { value: noiseAmount },
+                    uPulseSpeed: { value: pulseSpeed * speed },
+                    uIntensity: { value: intensity },
+                },
+                transparent: true,
+                depthWrite: false,
+                blending: THREE.AdditiveBlending,
+                side: THREE.BackSide,
+            });
+            this.materials.push(shellMat);
+            const layerT = glowLayers > 1 ? i / (glowLayers - 1) : 0;
+            const r = coreR * (1.35 + layerT * layerT * 1.8);
+            this.group.add(new THREE.Mesh(new THREE.SphereGeometry(r, 40, 40), shellMat));
+        }
+        // Outer diffuse glow
+        const glowMat = new THREE.ShaderMaterial({
+            vertexShader: sharedVert,
+            fragmentShader: glowFrag,
+            uniforms: {
+                u_time: { value: 0 },
+                uOuterColor: { value: outerColorVec },
+                uOpacity: { value: opacity * 0.6 },
+                uPulseSpeed: { value: pulseSpeed * speed },
+            },
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.AdditiveBlending,
+            side: THREE.BackSide,
+        });
+        this.materials.push(glowMat);
+        const glowR = coreR * (3.5 + glowLayers * 0.6);
+        this.group.add(new THREE.Mesh(new THREE.SphereGeometry(glowR, 32, 32), glowMat));
+        // Corona ring
+        if (coronaEnabled) {
+            const tubeSegs = 80;
+            const geo = new THREE.TorusGeometry(coreR * 2.8, coreR * 0.12, 8, tubeSegs);
+            const count = geo.attributes.position.count;
+            const angles = new Float32Array(count);
+            const pos = geo.attributes.position;
+            for (let i = 0; i < count; i++) {
+                angles[i] = Math.atan2(pos.getZ(i), pos.getX(i)) + Math.PI;
+            }
+            geo.setAttribute('aAngle', new THREE.BufferAttribute(angles, 1));
+            const coronaMat = new THREE.ShaderMaterial({
+                vertexShader: coronaVert,
+                fragmentShader: coronaFrag,
+                uniforms: {
+                    u_time: { value: 0 },
+                    uCoronaColor: { value: coronaColorVec },
+                    uOpacity: { value: opacity * 0.85 },
+                    uIntensity: { value: intensity },
+                },
+                transparent: true,
+                depthWrite: false,
+                blending: THREE.AdditiveBlending,
+            });
+            this.materials.push(coronaMat);
+            this.coronaGroup = new THREE.Group();
+            this.coronaGroup.rotation.set(Math.PI * 0.18, 0, Math.PI * 0.08);
+            this.coronaGroup.add(new THREE.Mesh(geo, coronaMat));
+            this.group.add(this.coronaGroup);
+        }
+    }
+    update(elapsed, delta = 0.016) {
+        for (const mat of this.materials)
+            mat.uniforms.u_time.value = elapsed;
+        if (this.coronaGroup) {
+            this.coronaGroup.rotation.z += delta * this.speed * 0.4;
+        }
+    }
+    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.coronaGroup = null;
+        this.group.clear();
+        if (removeFromScene && this.group.parent)
+            this.group.parent.remove(this.group);
+    }
+}

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

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

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

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