@3driseai/3drise-viewer 0.1.16 → 0.1.17

package/dist/components/effects/GalaxyEffect.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { AnimationOptions, GalaxyConfig } from '@3driseai/3drise-core';
+import type { ObjectReadyProps } from '../../types/objectReady';
+export interface GalaxyEffectProps extends ObjectReadyProps {
+    boundingRadius: number;
+    config: GalaxyConfig;
+    animations?: AnimationOptions[];
+    /** True when the effect is attached to an object, so it can react to the host. */
+    hasHost?: boolean;
+}
+declare const GalaxyEffect: React.FC<GalaxyEffectProps>;
+export default GalaxyEffect;
+//# sourceMappingURL=GalaxyEffect.d.ts.map

package/dist/components/effects/GalaxyEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GalaxyEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/GalaxyEffect.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsD,MAAM,OAAO,CAAC;AAG3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG5E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,WAAW,iBAAkB,SAAQ,gBAAgB;IACvD,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAChC,kFAAkF;IAClF,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AA8VD,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CA+B7C,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/components/effects/GalaxyEffect.js

@@ -0,0 +1,374 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { useFrame } from '@react-three/fiber';
+import { applyGenerativeAnimations } from '../../utils/handleGenerativeEffectsAnimations.js';
+import { useObjectReady } from '../../hooks/useObjectReady.js';
+/**
+ * A spiral galaxy from density-wave theory: nested elliptical orbits twist into arms, lit by young blue stars, dust lanes and a warm bulge. Use for space, cosmic, sci-fi scenes.
+ *
+ * Kalnajs ellipses: orbit a rotated by θ(a) = k·a · flat rotation curve Ω ∝ 1/r · arms = where the ellipses crowd
+ */
+// ---------------------------------------------------------------------------
+// Density-wave spiral (Lin-Shu, drawn the way Kalnajs showed it).
+// Every star moves on a centred ellipse whose size is a (0..1). The ellipse
+// for size a is turned by theta(a) = armTwist * a, so neighbouring orbits are
+// slightly rotated against each other. Where the rotated ellipses crowd
+// together the surface density is higher, and those crowded strips form two
+// trailing spiral arms. The stars themselves keep moving (flat rotation curve,
+// Omega ~ 1/r) and flow through the arms; only the pattern stays, turning
+// slowly at the pattern speed. Young, hot stars are born where the gas is
+// compressed (in the arms) and die before they leave them, so blue light
+// traces the arms while old stars stay smooth and warm.
+// ---------------------------------------------------------------------------
+const orbitCommon = /* glsl */ `
+  uniform float uTime;
+  uniform float uRadius;
+  uniform float uArmTwist;
+  uniform float uEllipticity;
+  uniform float uBound;
+
+  const float PATTERN_SPEED = 0.035;
+
+  // position on the disk for orbit size a and orbital phase M
+  vec2 orbitPos(float a, float M, float twistOffset){
+    float R = a * uRadius * uBound;
+    float th = a * uArmTwist + uTime * PATTERN_SPEED + twistOffset;
+    // centred ellipse, long axis along x before the twist
+    vec2 p = vec2(R * cos(M), R * (1.0 - uEllipticity) * sin(M));
+    float c = cos(th), s = sin(th);
+    return vec2(c * p.x - s * p.y, s * p.x + c * p.y);
+  }
+
+  // Phase advance: flat rotation curve (v = const, Omega = v / r), softened at the centre.
+  float orbitPhase(float a, float M0){
+    return M0 + uTime * 0.22 / (a + 0.12);
+  }
+
+  // Density contrast of the arm at orbit a, orbital phase M: the ellipses crowd at
+  // the ends of their minor axis (M = +-pi/2), where neighbouring orbits run closest.
+  float armness(float M){
+    return pow(0.5 + 0.5 * cos(2.0 * M - 3.14159265), 3.0);
+  }
+`;
+const starVert = /* glsl */ `
+  attribute vec4 aOrbit;   // a (0..1), M0, kind (0 disk old, 1 disk young, 2 bulge, 3 HII knot), seed
+  attribute vec3 aExtra;   // bulge position (unit gaussian) or (z offset, size, temperature)
+  uniform float uIntensity;
+  uniform float uBulgeSize;
+  ${orbitCommon}
+  varying vec3 vCol;
+  varying float vAlpha;
+  varying float vSoft;
+  uniform vec3 uColor;
+  uniform vec3 uCoreColor;
+
+  void main(){
+    float a = aOrbit.x;
+    float kind = aOrbit.z;
+    float seed = aOrbit.w;
+    vec3 pos;
+    float bright;
+    float size;
+    vSoft = 0.0;
+    if (kind > 1.5 && kind < 2.5){
+      // bulge: a slowly turning oblate gaussian of old stars
+      float spin = uTime * 0.12;
+      vec3 g = aExtra * uBulgeSize * uRadius * uBound * 0.55;
+      g.y *= 0.62;
+      float c = cos(spin), s = sin(spin);
+      pos = vec3(c * g.x - s * g.z, g.y, s * g.x + c * g.z);
+      float r = length(aExtra);
+      bright = 0.55 * exp(-r * r * 0.35);
+      size = 1.1 + seed;
+      vCol = mix(uCoreColor, vec3(1.0, 0.93, 0.82), seed * 0.4);
+    } else {
+      float M = orbitPhase(a, aOrbit.y);
+      vec2 p = orbitPos(a, M, 0.0);
+      // the disk thins toward the edge and flares slightly
+      float h = aExtra.x * uRadius * uBound * (0.018 + 0.03 * exp(-a * 6.0));
+      pos = vec3(p.x, h, p.y);
+      float arm = armness(M);
+      // radial light profile of an exponential disk
+      float disk = exp(-a * 1.7);
+      if (kind < 0.5){
+        bright = 0.5 * disk * (0.4 + 0.6 * arm);
+        size = aExtra.y * 1.3;
+        // old population: warm white, a touch redder outward
+        vCol = mix(vec3(1.0, 0.9, 0.78), vec3(1.0, 0.82, 0.7), a);
+      } else if (kind < 1.5){
+        // young population: only lives in the arm it was born in
+        bright = 1.7 * disk * smoothstep(0.12, 0.9, arm) * (0.4 + 0.6 * smoothstep(0.05, 0.25, a));
+        size = aExtra.y * 1.25;
+        vCol = mix(uColor, vec3(0.85, 0.92, 1.0), aExtra.z);
+      } else {
+        // HII regions: soft pink knots of ionised hydrogen, strung along the arms
+        bright = 0.5 * disk * smoothstep(0.55, 0.95, arm);
+        size = aExtra.y * 5.0;
+        vSoft = 1.0;
+        vCol = vec3(1.0, 0.45, 0.62);
+      }
+    }
+    vAlpha = bright;
+    vec4 mv = modelViewMatrix * vec4(pos, 1.0);
+    gl_PointSize = size * (0.9 + 0.4 * uIntensity) * (22.0 * uBound / max(-mv.z, 0.05));
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+const starFrag = /* glsl */ `
+  uniform float uIntensity;
+  uniform float uOpacity;
+  varying vec3 vCol;
+  varying float vAlpha;
+  varying float vSoft;
+  void main(){
+    float d = length(gl_PointCoord - 0.5) * 2.0;
+    if (d > 1.0 || vAlpha < 0.001) discard;
+    // point-spread: a tight core and a faint halo; HII knots are all halo
+    float core = exp(-d * d * 14.0);
+    float halo = exp(-d * 3.0) * 0.3;
+    float g = mix(core + halo, exp(-d * d * 3.0) * 0.35, vSoft) * (1.0 - smoothstep(0.8, 1.0, d));
+    vec3 c = vCol * g * vAlpha * uIntensity * uOpacity;
+    gl_FragColor = vec4(c, 1.0);
+  }
+`;
+// Dust sits on the inner (concave) edge of each arm, where the gas is shocked
+// before the new stars light up: the same orbits, a little behind in angle.
+const dustVert = /* glsl */ `
+  attribute vec4 aOrbit;   // a, M0, size, seed
+  ${orbitCommon}
+  uniform float uDust;
+  varying float vAlpha;
+  void main(){
+    float a = aOrbit.x;
+    float M = orbitPhase(a, aOrbit.y);
+    vec2 p = orbitPos(a, M, -0.22);
+    float arm = armness(M);
+    vAlpha = uDust * smoothstep(0.45, 0.95, arm) * smoothstep(0.14, 0.32, a) * (1.0 - smoothstep(0.75, 1.0, a));
+    vec4 mv = modelViewMatrix * vec4(p.x, (aOrbit.w - 0.5) * 0.02 * uRadius * uBound, p.y, 1.0);
+    gl_PointSize = aOrbit.z * (70.0 * uBound / max(-mv.z, 0.05));
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+const dustFrag = /* glsl */ `
+  uniform float uOpacity;
+  varying float vAlpha;
+  void main(){
+    float d = length(gl_PointCoord - 0.5) * 2.0;
+    if (d > 1.0 || vAlpha < 0.002) discard;
+    float a = exp(-d * d * 3.0) * (1.0 - d) * vAlpha * uOpacity * 0.16;
+    // premultiplied: dark reddish-brown dust that absorbs the light behind it
+    gl_FragColor = vec4(vec3(0.06, 0.035, 0.025) * a, a);
+  }
+`;
+const coreVert = /* glsl */ `
+  uniform float uRadius;
+  uniform float uBulgeSize;
+  uniform float uBound;
+  varying vec2 vUv;
+  void main(){
+    vUv = uv;
+    vec4 mv = modelViewMatrix * vec4(0.0, 0.0, 0.0, 1.0);
+    mv.xy += position.xy * uRadius * uBound * (uBulgeSize * 1.6 + 0.12);
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+const coreFrag = /* glsl */ `
+  uniform vec3 uCoreColor;
+  uniform float uIntensity;
+  uniform float uOpacity;
+  varying vec2 vUv;
+  void main(){
+    float d = length(vUv - 0.5) * 2.0;
+    // de Vaucouleurs-like surface brightness: a sharp nucleus and a broad glow
+    float g = exp(-7.67 * (pow(d + 0.02, 0.25) - 0.376)) * 0.9;
+    g *= 1.0 - smoothstep(0.7, 1.0, d);
+    vec3 c = mix(uCoreColor, vec3(1.0, 0.97, 0.92), exp(-d * 12.0)) * g * uIntensity * uOpacity;
+    float lum = max(c.r, max(c.g, c.b));
+    if (lum < 0.002) discard;
+    // premultiplied: the alpha follows the light, so the quad never shows as a rectangle
+    gl_FragColor = vec4(c, min(lum, 1.0));
+  }
+`;
+function mulberry32(seed) {
+    return () => {
+        seed |= 0;
+        seed = (seed + 0x6d2b79f5) | 0;
+        let r = Math.imul(seed ^ (seed >>> 15), 1 | seed);
+        r = (r + Math.imul(r ^ (r >>> 7), 61 | r)) ^ r;
+        return ((r ^ (r >>> 14)) >>> 0) / 4294967296;
+    };
+}
+function gaussian(rand) {
+    return Math.sqrt(-2 * Math.log(1 - rand() * 0.9999)) * Math.cos(Math.PI * 2 * rand());
+}
+/** Star attributes: an exponential disk (old + young + HII) and a gaussian bulge. */
+function buildStars(count) {
+    const n = Math.round(Math.min(Math.max(count, 2000), 40000));
+    const rand = mulberry32(7);
+    const orbit = new Float32Array(n * 4);
+    const extra = new Float32Array(n * 3);
+    for (let i = 0; i < n; i++) {
+        const k = rand();
+        let kind = 0;
+        if (k < 0.16)
+            kind = 2;
+        else if (k < 0.5)
+            kind = 1;
+        else if (k < 0.515)
+            kind = 3;
+        // exponential disk: surface density ~ e^(-r/h); sample the radius from r e^(-r/h)
+        let a = 2;
+        for (let tries = 0; tries < 8 && a > 1; tries++)
+            a = -Math.log(rand() * rand() + 1e-6) / 3.3;
+        if (a > 1)
+            a = rand();
+        a = Math.max(a, 0.02 + rand() * 0.03);
+        orbit[i * 4] = a;
+        orbit[i * 4 + 1] = rand() * Math.PI * 2;
+        orbit[i * 4 + 2] = kind;
+        orbit[i * 4 + 3] = rand();
+        if (kind === 2) {
+            extra[i * 3] = gaussian(rand);
+            extra[i * 3 + 1] = gaussian(rand);
+            extra[i * 3 + 2] = gaussian(rand);
+        }
+        else {
+            extra[i * 3] = gaussian(rand);
+            extra[i * 3 + 1] = 0.6 + Math.pow(rand(), 3) * 1.8;
+            extra[i * 3 + 2] = rand();
+        }
+    }
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(n * 3), 3));
+    geo.setAttribute('aOrbit', new THREE.BufferAttribute(orbit, 4));
+    geo.setAttribute('aExtra', new THREE.BufferAttribute(extra, 3));
+    return geo;
+}
+function buildDust(count) {
+    const n = Math.round(Math.min(Math.max(count, 2000), 40000) * 0.12);
+    const rand = mulberry32(19);
+    const orbit = new Float32Array(n * 4);
+    for (let i = 0; i < n; i++) {
+        orbit[i * 4] = 0.05 + Math.pow(rand(), 0.8) * 0.9;
+        orbit[i * 4 + 1] = rand() * Math.PI * 2;
+        orbit[i * 4 + 2] = 0.6 + rand() * 0.9;
+        orbit[i * 4 + 3] = rand();
+    }
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(n * 3), 3));
+    geo.setAttribute('aOrbit', new THREE.BufferAttribute(orbit, 4));
+    return geo;
+}
+function createUniforms() {
+    return {
+        uTime: { value: 0 },
+        uSpeed: { value: 1 },
+        uIntensity: { value: 1 },
+        uOpacity: { value: 1 },
+        uColor: { value: new THREE.Color() },
+        uCoreColor: { value: new THREE.Color() },
+        uRadius: { value: 3 },
+        uArmTwist: { value: 5.5 },
+        uEllipticity: { value: 0.32 },
+        uBulgeSize: { value: 0.22 },
+        uDust: { value: 0.6 },
+        uBound: { value: 1 },
+    };
+}
+function applyConfig(u, c, bound, env) {
+    u.uSpeed.value = c.speed;
+    u.uIntensity.value = c.intensity;
+    u.uOpacity.value = c.opacity;
+    u.uColor.value.set(c.color);
+    u.uCoreColor.value.set(c.coreColor);
+    u.uRadius.value = c.radius;
+    u.uArmTwist.value = c.armTwist;
+    u.uEllipticity.value = c.ellipticity;
+    u.uBulgeSize.value = c.bulgeSize;
+    u.uDust.value = c.dust;
+    u.uBound.value = bound;
+}
+function build(u, c, bound, env) {
+    const add = { transparent: true, depthWrite: false, blending: THREE.AdditiveBlending };
+    const starMat = new THREE.ShaderMaterial({ vertexShader: starVert, fragmentShader: starFrag, uniforms: u, ...add });
+    const dustMat = new THREE.ShaderMaterial({
+        vertexShader: dustVert, fragmentShader: dustFrag, uniforms: u,
+        transparent: true, depthWrite: false, blending: THREE.NormalBlending, premultipliedAlpha: true,
+    });
+    const coreMat = new THREE.ShaderMaterial({ vertexShader: coreVert, fragmentShader: coreFrag, uniforms: u, ...add, premultipliedAlpha: true });
+    const starGeo = buildStars(c.starCount);
+    const dustGeo = buildDust(c.starCount);
+    const quad = new THREE.PlaneGeometry(2, 2);
+    const stars = new THREE.Points(starGeo, starMat);
+    const dust = new THREE.Points(dustGeo, dustMat);
+    const core = new THREE.Mesh(quad, coreMat);
+    stars.frustumCulled = false;
+    dust.frustumCulled = false;
+    core.frustumCulled = false;
+    core.renderOrder = 0;
+    stars.renderOrder = 1;
+    dust.renderOrder = 2;
+    const disk = new THREE.Group();
+    disk.add(core, stars, dust);
+    const group = new THREE.Group();
+    group.add(disk);
+    return {
+        object: group,
+        materials: [starMat, dustMat, coreMat],
+        apply(c2) {
+            disk.rotation.set((c2.tilt * Math.PI) / 180, 0, 0);
+        },
+        update(dt, camera) {
+            u.uTime.value += dt * u.uSpeed.value;
+        },
+        dispose() {
+            starGeo.dispose();
+            dustGeo.dispose();
+            quad.dispose();
+            starMat.dispose();
+            dustMat.dispose();
+            coreMat.dispose();
+        },
+    };
+}
+/** Defaults for every knob, so an older saved config still renders. */
+const DEFAULTS = {
+    intensity: 1,
+    speed: 1,
+    color: '#9fc4ff',
+    opacity: 0.9,
+    starCount: 18000,
+    radius: 3,
+    armTwist: 5.5,
+    ellipticity: 0.32,
+    bulgeSize: 0.22,
+    dust: 0.6,
+    tilt: 22,
+    coreColor: '#ffd9a8',
+};
+const GalaxyEffect = ({ boundingRadius, config, animations, hasHost = false, onObjectReady, onObjectDispose }) => {
+    const rootRef = useRef(null);
+    const animCache = useRef({});
+    useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
+    // a standalone effect gets boundingRadius 1
+    const b = boundingRadius > 0 ? boundingRadius : 1;
+    const cfg = useMemo(() => ({ ...DEFAULTS, ...config }), [config]);
+    const env = useMemo(() => ({ hasHost: hasHost }), [hasHost]);
+    // uniforms outlive the objects, so keyframe animations survive a rebuild
+    const uniforms = useMemo(() => createUniforms(), []);
+    // rebuilt only when the host size or a structural knob changes
+    const instance = useMemo(() => build(uniforms, { ...DEFAULTS, ...config }, b, env), [uniforms, b, env, cfg.starCount]);
+    useEffect(() => () => instance.dispose(), [instance]);
+    useLayoutEffect(() => {
+        applyConfig(uniforms, cfg, b, env);
+        instance.apply(cfg);
+    }, [instance, uniforms, cfg, b, env]);
+    useFrame((state, delta) => {
+        instance.update(Math.min(delta, 0.1), state.camera);
+        if (animations?.length)
+            applyGenerativeAnimations(instance.materials, animations, animCache.current, Date.now(), false);
+    });
+    return (_jsx("group", { ref: rootRef, children: _jsx("primitive", { object: instance.object }) }));
+};
+export default GalaxyEffect;

package/dist/components/effects/HarmonicShellEffect.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { AnimationOptions, HarmonicShellConfig } from '@3driseai/3drise-core';
+import type { ObjectReadyProps } from '../../types/objectReady';
+export interface HarmonicShellEffectProps extends ObjectReadyProps {
+    boundingRadius: number;
+    config: HarmonicShellConfig;
+    animations?: AnimationOptions[];
+}
+declare const HarmonicShellEffect: React.FC<HarmonicShellEffectProps>;
+export default HarmonicShellEffect;
+//# sourceMappingURL=HarmonicShellEffect.d.ts.map

package/dist/components/effects/HarmonicShellEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HarmonicShellEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/HarmonicShellEffect.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAGnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,WAAW,wBAAyB,SAAQ,gBAAgB;IAC9D,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACnC;AA0KD,QAAA,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC,wBAAwB,CA2D3D,CAAC;AACF,eAAe,mBAAmB,CAAC"}

package/dist/components/effects/HarmonicShellEffect.js

@@ -0,0 +1,209 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { useFrame } from '@react-three/fiber';
+import { applyGenerativeAnimations } from '../../utils/handleGenerativeEffectsAnimations.js';
+import { useObjectReady } from '../../hooks/useObjectReady.js';
+/**
+ * An iridescent shell around the host, displaced by real spherical harmonics
+ * up to l = 4 whose weights drift slowly. The colour is thin-film
+ * interference, as on a soap bubble, and the lines where the harmonic field
+ * crosses zero glow.
+ */
+/** Band (l) of each of the 24 real-SH terms in the shader. */
+const SH_BANDS = [1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4];
+function mulberry32(seed) {
+    return () => {
+        seed |= 0;
+        seed = (seed + 0x6d2b79f5) | 0;
+        let r = Math.imul(seed ^ (seed >>> 15), 1 | seed);
+        r = (r + Math.imul(r ^ (r >>> 7), 61 | r)) ^ r;
+        return ((r ^ (r >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** Fixed per-term frequencies and phases, so the same config always moves the same way. */
+function createHarmonicState() {
+    const rand = mulberry32(7);
+    const f1 = new Float32Array(24), f2 = new Float32Array(24), p1 = new Float32Array(24), p2 = new Float32Array(24);
+    for (let i = 0; i < 24; i++) {
+        f1[i] = 0.13 + 0.3 * rand();
+        f2[i] = 0.07 + 0.2 * rand();
+        p1[i] = rand() * Math.PI * 2;
+        p2[i] = rand() * Math.PI * 2;
+    }
+    // per-band gate, eased so changing `degree` blends bands in and out
+    return { f1, f2, p1, p2, gate: new Float32Array([0, 0, 0, 0, 0]) };
+}
+/**
+ * Writes the 24 weights for time T into `out`. Bands above `degree` fade
+ * out; the top band leads and lower bands sit at about half strength.
+ */
+function updateHarmonicWeights(state, out, T, degree, dt) {
+    const deg = Math.round(Math.min(Math.max(degree, 1), 4));
+    const ease = Math.min(1, dt * 2.5);
+    let energy = 0;
+    for (let l = 1; l <= 4; l++) {
+        // l = 1 only shifts the shell sideways, so it stays quiet unless it is the only band
+        const target = l > deg ? 0 : l === deg ? 1 : l === 1 ? 0.2 : 0.55;
+        state.gate[l] += (target - state.gate[l]) * ease;
+        energy += state.gate[l] * state.gate[l] * (2 * l + 1);
+    }
+    const norm = 1 / Math.sqrt(Math.max(energy / 5, 1e-3));
+    for (let i = 0; i < 24; i++) {
+        const g = state.gate[SH_BANDS[i]];
+        out[i] = g * norm * (0.7 * Math.sin(T * state.f1[i] + state.p1[i]) + 0.3 * Math.sin(T * state.f2[i] + state.p2[i]));
+    }
+}
+const vert = /* glsl */ `
+  uniform float uW[24];
+  uniform float uAmplitude;
+  uniform float uBound;
+  uniform float uSizeMultiplier;
+  varying vec3  vNormal;
+  varying vec3  vViewDir;
+  varying float vField;
+
+  // Real spherical harmonics for l = 1..4, as polynomials in the unit vector,
+  // each scaled so its peak is about 1. The CPU animates the 24 weights.
+  float sh(vec3 n){
+    float x = n.x, y = n.y, z = n.z;
+    float x2 = x * x, y2 = y * y, z2 = z * z;
+    float s = 0.0;
+    s += uW[0] * y + uW[1] * z + uW[2] * x;
+    s += uW[3] * 2.0 * x * y + uW[4] * 2.0 * y * z + uW[5] * (1.5 * z2 - 0.5)
+       + uW[6] * 2.0 * x * z + uW[7] * (x2 - y2);
+    s += uW[8]  * y * (3.0 * x2 - y2)
+       + uW[9]  * 5.2 * x * y * z
+       + uW[10] * 0.8 * y * (5.0 * z2 - 1.0)
+       + uW[11] * 0.5 * z * (5.0 * z2 - 3.0)
+       + uW[12] * 0.8 * x * (5.0 * z2 - 1.0)
+       + uW[13] * 2.6 * z * (x2 - y2)
+       + uW[14] * x * (x2 - 3.0 * y2);
+    s += uW[15] * 4.0 * x * y * (x2 - y2)
+       + uW[16] * 3.0 * y * z * (3.0 * x2 - y2)
+       + uW[17] * 1.5 * x * y * (7.0 * z2 - 1.0)
+       + uW[18] * 0.95 * y * z * (7.0 * z2 - 3.0)
+       + uW[19] * 0.125 * (35.0 * z2 * z2 - 30.0 * z2 + 3.0)
+       + uW[20] * 0.95 * x * z * (7.0 * z2 - 3.0)
+       + uW[21] * 0.78 * (x2 - y2) * (7.0 * z2 - 1.0)
+       + uW[22] * 3.0 * x * z * (x2 - 3.0 * y2)
+       + uW[23] * (x2 * (x2 - 3.0 * y2) - y2 * (3.0 * x2 - y2));
+    return s;
+  }
+
+  vec3 shellPoint(vec3 n, out float f){
+    f = sh(n);
+    return n * uBound * uSizeMultiplier * (1.0 + uAmplitude * f);
+  }
+
+  void main(){
+    vec3 n = normalize(position);
+    float f, f1, f2;
+    vec3 p0 = shellPoint(n, f);
+
+    // normal from two nearby points on the displaced surface
+    vec3 up = abs(n.y) > 0.99 ? vec3(1.0, 0.0, 0.0) : vec3(0.0, 1.0, 0.0);
+    vec3 t1 = normalize(cross(n, up));
+    vec3 t2 = cross(n, t1);
+    vec3 p1 = shellPoint(normalize(n + t1 * 0.01), f1);
+    vec3 p2 = shellPoint(normalize(n + t2 * 0.01), f2);
+    vec3 nrm = normalize(cross(p1 - p0, p2 - p0));
+    if (dot(nrm, n) < 0.0) nrm = -nrm;
+
+    vField = f;
+    vec4 mv = modelViewMatrix * vec4(p0, 1.0);
+    vNormal = normalize(normalMatrix * nrm);
+    vViewDir = normalize(-mv.xyz);
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+const frag = /* glsl */ `
+  uniform vec3  uColor;
+  uniform vec3  uRimColor;
+  uniform float uOpacity;
+  uniform float uIntensity;
+  uniform float uFilmThickness;
+  uniform float uNodalLines;
+  varying vec3  vNormal;
+  varying vec3  vViewDir;
+  varying float vField;
+
+  const float TAU = 6.28318530718;
+
+  void main(){
+    vec3 N = normalize(vNormal);
+    vec3 V = normalize(vViewDir);
+    float ndv = abs(dot(N, V));
+
+    // Thin-film interference, as on a soap bubble: a film of index 1.33 and
+    // thickness d delays the inner reflection by 2*n*d*cos(theta_t). Each
+    // wavelength interferes on its own, which splits white light into bands.
+    // The film is thicker where the harmonic pushes the shell out, so the
+    // colour bands follow the shape.
+    float cosT = sqrt(max(1.0 - (1.0 - ndv * ndv) / (1.33 * 1.33), 0.0));
+    float opd  = 2.0 * 1.33 * uFilmThickness * (1.0 + 0.35 * vField) * cosT;
+    vec3 film  = 0.5 + 0.5 * cos(TAU * opd / vec3(650.0, 532.0, 450.0));
+
+    float fres = pow(1.0 - ndv, 3.0);
+    vec3 col = uColor * 0.25 + film * (0.2 + 0.8 * fres);
+    col = mix(col, uRimColor, fres * 0.45);
+
+    // nodal lines: where the harmonic field crosses zero
+    float nd = abs(vField) / max(fwidth(vField), 1e-4);
+    float nodal = (1.0 - smoothstep(0.5, 1.5, nd)) * uNodalLines;
+    col += uRimColor * nodal * 1.5;
+
+    float a = (0.06 + 0.9 * fres + nodal * 0.8) * uOpacity;
+    if (a < 0.003) discard;
+    gl_FragColor = vec4(col * uIntensity, a);
+  }
+`;
+const HarmonicShellEffect = ({ boundingRadius, config, animations, onObjectReady, onObjectDispose }) => {
+    const { intensity, speed, color, opacity, degree = 3, amplitude = 0.22, sizeMultiplier = 1.35, filmThickness = 380, nodalLines = 0.6, rimColor = '#bfe8ff', } = config;
+    const rootRef = useRef(null);
+    const animCache = useRef({});
+    useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
+    const state = useMemo(createHarmonicState, []);
+    const uniforms = useMemo(() => ({
+        uTime: { value: 0 },
+        uSpeed: { value: 1 },
+        uIntensity: { value: 1 },
+        uOpacity: { value: 1 },
+        uColor: { value: new THREE.Color() },
+        uRimColor: { value: new THREE.Color() },
+        uAmplitude: { value: 0.22 },
+        uBound: { value: 1 },
+        uSizeMultiplier: { value: 1.35 },
+        uFilmThickness: { value: 380 },
+        uNodalLines: { value: 0.6 },
+        uDegree: { value: 3 },
+        uW: { value: new Float32Array(24) },
+    }), []);
+    const material = useMemo(() => new THREE.ShaderMaterial({ vertexShader: vert, fragmentShader: frag, uniforms, transparent: true, depthWrite: false, blending: THREE.AdditiveBlending }), [uniforms]);
+    useEffect(() => () => material.dispose(), [material]);
+    const materials = useMemo(() => [material], [material]);
+    // the vertex shader displaces a unit sphere, so the mesh never needs rebuilding
+    const geometry = useMemo(() => new THREE.SphereGeometry(1, 192, 128), []);
+    useEffect(() => () => geometry.dispose(), [geometry]);
+    useLayoutEffect(() => {
+        uniforms.uSpeed.value = speed;
+        uniforms.uIntensity.value = intensity;
+        uniforms.uOpacity.value = opacity;
+        uniforms.uColor.value.set(color);
+        uniforms.uRimColor.value.set(rimColor);
+        uniforms.uAmplitude.value = amplitude;
+        uniforms.uBound.value = boundingRadius;
+        uniforms.uSizeMultiplier.value = sizeMultiplier;
+        uniforms.uFilmThickness.value = filmThickness;
+        uniforms.uNodalLines.value = nodalLines;
+        uniforms.uDegree.value = degree;
+    }, [uniforms, speed, intensity, opacity, color, rimColor, amplitude, boundingRadius, sizeMultiplier, filmThickness, nodalLines, degree]);
+    useFrame((_, delta) => {
+        uniforms.uTime.value += delta * uniforms.uSpeed.value;
+        updateHarmonicWeights(state, uniforms.uW.value, uniforms.uTime.value, uniforms.uDegree.value, delta);
+        if (animations?.length)
+            applyGenerativeAnimations(materials, animations, animCache.current, Date.now(), false);
+    });
+    return (_jsx("group", { ref: rootRef, children: _jsx("mesh", { geometry: geometry, material: material }) }));
+};
+export default HarmonicShellEffect;

package/dist/components/effects/IceCrystalsEffect.d.ts

@@ -1,7 +1,7 @@
-import React from "react";
-import type { IceCrystalsConfig, AnimationOptions } from "@3driseai/3drise-core";
+import React from 'react';
+import type { AnimationOptions, IceCrystalsConfig } from '@3driseai/3drise-core';
 import type { ObjectReadyProps } from '../../types/objectReady';
-interface IceCrystalsEffectProps extends ObjectReadyProps {
+export interface IceCrystalsEffectProps extends ObjectReadyProps {
     boundingRadius: number;
     config: IceCrystalsConfig;
     animations?: AnimationOptions[];

package/dist/components/effects/IceCrystalsEffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IceCrystalsEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/IceCrystalsEffect.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEjF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,UAAU,sBAAuB,SAAQ,gBAAgB;IACrD,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACnC;AAmED,QAAA,MAAM,iBAAiB,EAAE,KAAK,CAAC,EAAE,CAAC,sBAAsB,CAwHvD,CAAC;AACF,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"IceCrystalsEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/IceCrystalsEffect.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsD,MAAM,OAAO,CAAC;AAG3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAGjF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,WAAW,sBAAuB,SAAQ,gBAAgB;IAC5D,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACnC;AA+PD,QAAA,MAAM,iBAAiB,EAAE,KAAK,CAAC,EAAE,CAAC,sBAAsB,CAyEvD,CAAC;AAEF,eAAe,iBAAiB,CAAC"}