@3driseai/3drise-core 1.0.1

package/dist/three/effects/ConstellationEffectV.js

@@ -0,0 +1,207 @@
+import * as THREE from 'three';
+const starVertShader = /* glsl */ `
+  attribute float aPhase;
+  attribute float aSize;
+
+  uniform float u_time;
+  uniform float uTwinkleSpeed;
+  uniform float uPointSize;
+
+  varying float vAlpha;
+  varying float vBrightness;
+
+  void main() {
+    float twinkle  = 0.5 + 0.5 * sin(u_time * uTwinkleSpeed + aPhase);
+    float twinkle2 = 0.5 + 0.5 * sin(u_time * uTwinkleSpeed * 1.618 + aPhase * 2.3);
+    vAlpha      = 0.35 + 0.65 * twinkle;
+    vBrightness = twinkle2;
+
+    vec4 mv     = modelViewMatrix * vec4(position, 1.0);
+    gl_PointSize = uPointSize * aSize * (twinkle * 0.6 + 0.4) * (260.0 / -mv.z);
+    gl_Position  = projectionMatrix * mv;
+  }
+`;
+const starFragShader = /* glsl */ `
+  uniform vec3  uColor;
+  uniform float uOpacity;
+
+  varying float vAlpha;
+  varying float vBrightness;
+
+  void main() {
+    vec2  coord = gl_PointCoord - vec2(0.5);
+    float dist  = length(coord);
+    if (dist > 0.5) discard;
+
+    float glow = exp(-dist * dist * 10.0);
+
+    float cx = exp(-abs(coord.x) * 16.0) * exp(-coord.y*coord.y * 40.0);
+    float cy = exp(-abs(coord.y) * 16.0) * exp(-coord.x*coord.x * 40.0);
+    float spike = (cx + cy) * 0.5 * vBrightness;
+
+    float core  = exp(-dist * dist * 80.0);
+    vec3  col   = mix(uColor, vec3(1.0, 1.0, 1.0), core * 0.7 + spike * 0.3);
+
+    gl_FragColor = vec4(col, vAlpha * uOpacity * (glow + spike + core));
+  }
+`;
+const lineVertShader = /* glsl */ `
+  attribute float aLinePhase;
+  attribute float aLineSeed;
+
+  uniform float u_time;
+  uniform float uPulseSpeed;
+
+  varying float vLineAlpha;
+
+  void main() {
+    float pulse  = 0.5 + 0.5 * sin(u_time * uPulseSpeed + aLinePhase);
+    float pulse2 = 0.5 + 0.5 * sin(u_time * uPulseSpeed * aLineSeed + aLinePhase * 1.7);
+    vLineAlpha   = pulse * pulse2;
+
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const lineFragShader = /* glsl */ `
+  uniform vec3  uColor;
+  uniform float uLineOpacity;
+
+  varying float vLineAlpha;
+
+  void main() {
+    gl_FragColor = vec4(uColor, vLineAlpha * uLineOpacity);
+  }
+`;
+function fibonacciSphere(count, radius) {
+    const positions = new Float32Array(count * 3);
+    const golden = Math.PI * (3 - Math.sqrt(5));
+    for (let i = 0; i < count; i++) {
+        const y = 1 - (i / (count - 1)) * 2;
+        const r = Math.sqrt(Math.max(0, 1 - y * y));
+        const theta = golden * i;
+        positions[i * 3] = Math.cos(theta) * r * radius;
+        positions[i * 3 + 1] = y * radius;
+        positions[i * 3 + 2] = Math.sin(theta) * r * radius;
+    }
+    return positions;
+}
+export class ConstellationEffectV {
+    scene;
+    group;
+    materials = [];
+    config;
+    boundingRadius;
+    starMat = null;
+    lineMat = null;
+    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 { starCount, connectRadius, orbitRadius, twinkleSpeed, lineOpacity, starSize, color, opacity } = this.config;
+        const r = this.boundingRadius * orbitRadius;
+        const connR = this.boundingRadius * connectRadius;
+        const c = new THREE.Color(color);
+        const colorVec = new THREE.Vector3(c.r, c.g, c.b);
+        const positions = fibonacciSphere(starCount, r);
+        const phases = new Float32Array(starCount);
+        const sizes = new Float32Array(starCount);
+        for (let i = 0; i < starCount; i++) {
+            phases[i] = Math.random() * Math.PI * 2;
+            sizes[i] = 0.5 + Math.random() * 1.0;
+        }
+        const sGeo = new THREE.BufferGeometry();
+        sGeo.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+        sGeo.setAttribute('aPhase', new THREE.BufferAttribute(phases, 1));
+        sGeo.setAttribute('aSize', new THREE.BufferAttribute(sizes, 1));
+        const sMat = new THREE.ShaderMaterial({
+            vertexShader: starVertShader,
+            fragmentShader: starFragShader,
+            uniforms: {
+                u_time: { value: 0 },
+                uTwinkleSpeed: { value: twinkleSpeed },
+                uPointSize: { value: starSize * 220 },
+                uColor: { value: colorVec },
+                uOpacity: { value: opacity },
+            },
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.AdditiveBlending,
+        });
+        this.starMat = sMat;
+        this.materials.push(sMat);
+        this.group.add(new THREE.Points(sGeo, sMat));
+        // Connection lines
+        const lineVerts = [];
+        const linePhases = [];
+        const lineSeeds = [];
+        for (let i = 0; i < starCount; i++) {
+            for (let j = i + 1; j < starCount; j++) {
+                const ax = positions[i * 3], ay = positions[i * 3 + 1], az = positions[i * 3 + 2];
+                const bx = positions[j * 3], by = positions[j * 3 + 1], bz = positions[j * 3 + 2];
+                const dx = ax - bx, dy = ay - by, dz = az - bz;
+                if (Math.sqrt(dx * dx + dy * dy + dz * dz) < connR) {
+                    lineVerts.push(ax, ay, az, bx, by, bz);
+                    const ph = Math.random() * Math.PI * 2;
+                    const sd = 0.5 + Math.random() * 1.5;
+                    linePhases.push(ph, ph);
+                    lineSeeds.push(sd, sd);
+                }
+            }
+        }
+        const lGeo = new THREE.BufferGeometry();
+        lGeo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(lineVerts), 3));
+        lGeo.setAttribute('aLinePhase', new THREE.BufferAttribute(new Float32Array(linePhases), 1));
+        lGeo.setAttribute('aLineSeed', new THREE.BufferAttribute(new Float32Array(lineSeeds), 1));
+        const lMat = new THREE.ShaderMaterial({
+            vertexShader: lineVertShader,
+            fragmentShader: lineFragShader,
+            uniforms: {
+                u_time: { value: 0 },
+                uPulseSpeed: { value: 0.4 },
+                uColor: { value: colorVec },
+                uLineOpacity: { value: lineOpacity },
+            },
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.AdditiveBlending,
+        });
+        this.lineMat = lMat;
+        this.materials.push(lMat);
+        this.group.add(new THREE.LineSegments(lGeo, lMat));
+    }
+    update(elapsed, delta = 0.016) {
+        const { speed } = this.config;
+        this.group.rotation.y += delta * speed * 0.18;
+        this.group.rotation.x += delta * speed * 0.04;
+        if (this.starMat)
+            this.starMat.uniforms.u_time.value = elapsed;
+        if (this.lineMat)
+            this.lineMat.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.starMat = null;
+        this.lineMat = null;
+        this.group.clear();
+        if (removeFromScene && this.group.parent)
+            this.group.parent.remove(this.group);
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"DataStreamEffectV.d.ts","sourceRoot":"","sources":["../../../src/three/effects/DataStreamEffectV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AA0EtE,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;IAwCb,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/DataStreamEffectV.js

@@ -0,0 +1,151 @@
+import * as THREE from 'three';
+const vertexShader = /* glsl */ `
+  attribute float aT;
+  attribute float aOffset;
+  attribute float aStrand;
+
+  uniform float u_time;
+  uniform float u_speed;
+  uniform float uRadius;
+  uniform float uTurns;
+  uniform float uHeight;
+  uniform float uPointSize;
+  uniform float uIntensity;
+
+  varying float vAlpha;
+  varying vec3  vColor;
+
+  vec3 palette(float t) {
+    vec3 cold = vec3(0.05, 0.15, 0.9);
+    vec3 mid  = vec3(0.0,  0.85, 1.0);
+    vec3 hot  = vec3(1.0,  0.92, 0.55);
+    if (t < 0.5) return mix(cold, mid,  t * 2.0);
+    else          return mix(mid,  hot, (t - 0.5) * 2.0);
+  }
+
+  void main() {
+    const float TAU = 6.28318530718;
+
+    float dir    = aStrand > 0.5 ? -1.0 : 1.0;
+    float phase  = aStrand > 0.5 ? TAU * 0.5 : 0.0;
+    float t      = fract(aT + aOffset + u_time * u_speed * dir);
+
+    float angle  = t * uTurns * TAU + phase;
+    float y      = (t - 0.5) * uHeight;
+
+    float rWave  = uRadius * (1.0 + 0.06 * sin(t * TAU * 3.0 + u_time * 2.0));
+    vec3 helixPos = vec3(cos(angle) * rWave, y, sin(angle) * rWave);
+
+    float nearHead = smoothstep(0.0, 0.10, t);
+    float nearTail = 1.0 - smoothstep(0.88, 1.0, t);
+    vAlpha = nearHead * nearTail;
+
+    float tColor  = aStrand > 0.5 ? 1.0 - t : t;
+    vColor        = palette(tColor);
+    if (aStrand > 0.5) vColor = mix(vColor, vColor.zxy, 0.25);
+
+    float sizeT  = aStrand > 0.5 ? 1.0 - t : t;
+    float sizeMod = 0.3 + 0.7 * pow(sizeT, 0.4);
+
+    vec4 mv = modelViewMatrix * vec4(helixPos, 1.0);
+    gl_PointSize = uPointSize * sizeMod * uIntensity * (280.0 / -mv.z);
+    gl_Position  = projectionMatrix * mv;
+  }
+`;
+const fragmentShader = /* glsl */ `
+  varying float vAlpha;
+  varying vec3  vColor;
+  uniform float uOpacity;
+
+  void main() {
+    vec2  coord = gl_PointCoord - vec2(0.5);
+    float dist  = length(coord);
+    if (dist > 0.5) discard;
+
+    float glow  = exp(-dist * dist * 9.0);
+
+    float cx = exp(-abs(coord.x) * 18.0) * exp(-coord.y*coord.y * 28.0);
+    float cy = exp(-abs(coord.y) * 18.0) * exp(-coord.x*coord.x * 28.0);
+    float star = (cx + cy) * 0.25;
+
+    gl_FragColor = vec4(vColor, vAlpha * uOpacity * (glow + star));
+  }
+`;
+export class DataStreamEffectV {
+    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, spiralTurns, streamRadius, inward, particleSize, opacity, speed, intensity } = this.config;
+        const r = this.boundingRadius * streamRadius;
+        const h = this.boundingRadius * 2.6;
+        const total = particleCount * 2;
+        const tArr = new Float32Array(total);
+        const offsetArr = new Float32Array(total);
+        const strandArr = new Float32Array(total);
+        for (let i = 0; i < total; i++) {
+            const half = i < particleCount ? 0 : 1;
+            const localI = i % particleCount;
+            tArr[i] = localI / particleCount;
+            offsetArr[i] = Math.random();
+            strandArr[i] = half;
+        }
+        const geo = new THREE.BufferGeometry();
+        geo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(total * 3), 3));
+        geo.setAttribute('aT', new THREE.BufferAttribute(tArr, 1));
+        geo.setAttribute('aOffset', new THREE.BufferAttribute(offsetArr, 1));
+        geo.setAttribute('aStrand', new THREE.BufferAttribute(strandArr, 1));
+        const mat = new THREE.ShaderMaterial({
+            vertexShader,
+            fragmentShader,
+            uniforms: {
+                u_time: { value: 0 },
+                u_speed: { value: speed * (inward ? -1 : 1) },
+                uRadius: { value: r },
+                uTurns: { value: spiralTurns },
+                uHeight: { value: h },
+                uPointSize: { value: particleSize * 80 },
+                uIntensity: { value: intensity },
+                uOpacity: { value: opacity },
+            },
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.AdditiveBlending,
+        });
+        this.materials.push(mat);
+        this.group.add(new THREE.Points(geo, mat));
+    }
+    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/DnaHelixEffectV.d.ts

@@ -0,0 +1,24 @@
+import * as THREE from 'three';
+import type { DnaHelixConfig } from "../../types/generativeEffects";
+export declare class DnaHelixEffectV {
+    private scene;
+    private group;
+    private materials;
+    private config;
+    private boundingRadius;
+    private strands;
+    private boltGeo;
+    private boltPtsGeo;
+    private boltPtsMat;
+    private boltStates;
+    private washProgress;
+    private dotMat;
+    private numStrands;
+    private N;
+    constructor(scene: THREE.Scene, config: DnaHelixConfig, boundingRadius?: number);
+    private build;
+    update(elapsed: number, delta?: number): void;
+    updateConfig(config: DnaHelixConfig, boundingRadius?: number): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=DnaHelixEffectV.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DnaHelixEffectV.d.ts","sourceRoot":"","sources":["../../../src/three/effects/DnaHelixEffectV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAmEpE,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;IACvB,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,UAAU,CAAM;IACxB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,CAAC,CAAO;gBACJ,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,cAAc,GAAE,MAAU;IAQlF,OAAO,CAAC,KAAK;IAwIb,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IA2FpD,YAAY,CAAC,MAAM,EAAE,cAAc,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI;IAOnE,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAmBjD"}