@3driseai/3drise-viewer 0.1.16 → 0.1.17

package/dist/components/effects/IceHaloEffect.js

@@ -0,0 +1,306 @@
+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';
+/**
+ * Atmospheric ice optics around the object as a light source: a dispersed 22° halo, sun dogs, a parhelic circle and a light pillar. Use for cold skies, suns, lamps, magic light.
+ *
+ * D = 2·asin(n·sin30°) − 60° per channel (n 1.307→1.317) · parhelia use the Bravais index n′ = √(n²−sin²e)/cos e
+ */
+const NOISE3 = /* glsl */ `
+  float hash13(vec3 p3){
+    p3 = fract(p3 * 0.1031);
+    p3 += dot(p3, p3.zyx + 31.32);
+    return fract((p3.x + p3.y) * p3.z);
+  }
+  float vnoise(vec3 p){
+    vec3 i = floor(p);
+    vec3 f = fract(p);
+    f = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);
+    float n000 = hash13(i);
+    float n100 = hash13(i + vec3(1.0, 0.0, 0.0));
+    float n010 = hash13(i + vec3(0.0, 1.0, 0.0));
+    float n110 = hash13(i + vec3(1.0, 1.0, 0.0));
+    float n001 = hash13(i + vec3(0.0, 0.0, 1.0));
+    float n101 = hash13(i + vec3(1.0, 0.0, 1.0));
+    float n011 = hash13(i + vec3(0.0, 1.0, 1.0));
+    float n111 = hash13(i + vec3(1.0, 1.0, 1.0));
+    return mix(mix(mix(n000, n100, f.x), mix(n010, n110, f.x), f.y),
+               mix(mix(n001, n101, f.x), mix(n011, n111, f.x), f.y), f.z);
+  }
+  // low-frequency fBm; the rotation between octaves hides the lattice
+  const mat3 FBM_ROT = mat3(0.00, 0.80, 0.60, -0.80, 0.36, -0.48, -0.60, -0.48, 0.64);
+  float fbm3(vec3 p, int octaves){
+    float a = 0.5, s = 0.0;
+    for (int i = 0; i < 5; i++){
+      if (i >= octaves) break;
+      s += a * vnoise(p);
+      p = FBM_ROT * p * 2.02;
+      a *= 0.5;
+    }
+    return s;
+  }
+`;
+// ---------------------------------------------------------------------------
+// Halos are refraction, not glow. A hexagonal ice prism has 60° side faces;
+// a ray through two of them is deviated by at least D = 2 asin(n sin30°) - 60°,
+// and randomly tumbling crystals pile light up at that minimum, so a ring of
+// radius D appears around the light with a razor inner edge and a diffuse
+// outer skirt. Ice is dispersive (n = 1.307 red, 1.317 blue), so the inner
+// edge is red and the outside washes to white-blue; inside the ring no light
+// is deviated at all, so the sky there is darker. The 90° prism faces give the
+// same construction at 46°. Flat plate crystals drift with their faces level,
+// so their 60° prisms act in the horizontal plane only: they put the same
+// caustic left and right of the source at the Bravais index
+// n' = sqrt(n^2 - sin^2 e)/cos e, which is why sun dogs sit a little further
+// out as the source climbs, and vanish above e = 61°. Reflections off those
+// same level faces give the parhelic circle and, off their ends, the pillar.
+// Everything is drawn on one billboard by measuring, per pixel, the angle
+// between the view ray and the direction to the source.
+// ---------------------------------------------------------------------------
+const haloVert = /* glsl */ `
+  uniform float uHaloScale;
+  uniform float uBound;
+  varying vec3 vViewPos;
+  varying vec3 vSunView;
+  varying float vScale;
+  varying float vHalf;
+  varying float vSrc;
+  void main(){
+    vec4 hostView = modelViewMatrix * vec4(0.0, 0.0, 0.0, 1.0);
+    float D = max(-hostView.z, 0.05);
+    // angular radius of the source; keep the 22 deg ring clear of it
+    float hostAng = atan(uBound / max(D, uBound * 1.02));
+    float s = max(uHaloScale, hostAng * 1.7 / 0.38397);
+    vScale = s;
+    float A = clamp(0.8029 * s * 1.3 + 0.10, 0.22, 1.31);
+    vHalf = A;
+    // apparent size of the source, in the same units the halo angles are measured in
+    vSrc = max(hostAng / s * 57.2957795, 0.6);
+    float zq = max(D - uBound * 1.05, 0.06);
+    vec3 c = hostView.xyz * (zq / D);
+    float hq = zq * tan(A) * 1.3;
+    vec3 p = c + vec3(position.x * hq, position.y * hq, 0.0);
+    vViewPos = p;
+    vSunView = hostView.xyz;
+    gl_Position = projectionMatrix * vec4(p, 1.0);
+  }
+`;
+const haloFrag = /* glsl */ `
+  uniform float uTime;
+  uniform vec3 uColor;
+  uniform float uIntensity;
+  uniform float uOpacity;
+  uniform float uSunDogs;
+  uniform float uOuterHalo;
+  uniform float uParhelicCircle;
+  uniform float uPillar;
+  uniform float uGlare;
+  ${NOISE3}
+  varying vec3 vViewPos;
+  varying vec3 vSunView;
+  varying float vScale;
+  varying float vHalf;
+  varying float vSrc;
+
+  const float DEG = 57.2957795;
+
+  // minimum deviation of a prism of apex angle 2*half (in degrees in, degrees out)
+  float minDev(float n, float sinHalf, float apex){
+    float q = n * sinHalf;
+    if (q >= 0.9999) return 999.0;
+    return 2.0 * asin(q) * DEG - apex;
+  }
+  // the caustic profile: nothing inside, a sharp edge, a 1/sqrt pile-up, a skirt
+  float ringProfile(float th, float d, float aa, float tail){
+    if (d > 500.0) return 0.0;
+    float x = th - d;
+    float e = smoothstep(-aa, aa, x);
+    return e * (0.45 / sqrt(max(x, 0.0) + 0.45)) * exp(-max(x, 0.0) / tail);
+  }
+
+  void main(){
+    vec3 d = normalize(vViewPos);
+    vec3 sV = normalize(vSunView);
+    // view space -> world space (the view matrix rotation is orthonormal)
+    vec3 dW = normalize((vec4(d, 0.0) * viewMatrix).xyz);
+    vec3 sW = normalize((vec4(sV, 0.0) * viewMatrix).xyz);
+    float cd = dot(dW, sW);
+    if (cd <= 0.05) discard;
+
+    // frame around the source: h horizontal (world XZ), vv upward
+    vec3 hx = cross(sW, vec3(0.0, 1.0, 0.0));
+    float hl = length(hx);
+    hx = hl > 0.02 ? hx / hl : normalize(cross(sW, vec3(1.0, 0.0, 0.0)));
+    vec3 vv = cross(hx, sW);
+
+    vec2 t = vec2(dot(dW, hx), dot(dW, vv)) / cd;      // gnomonic tangent plane
+    float rho = atan(length(t));
+    float edgeFade = 1.0 - smoothstep(vHalf * 0.8, vHalf * 0.99, rho);
+    if (edgeFade <= 0.001) discard;
+    float rhoP = rho / max(vScale, 0.02);              // physical angle from the source
+    float TH = rhoP * DEG;
+    vec2 dir = length(t) > 1e-6 ? normalize(t) : vec2(1.0, 0.0);
+    vec3 D3 = normalize(sW * cos(rhoP) + (hx * dir.x + vv * dir.y) * sin(rhoP));
+
+    float es = asin(clamp(sW.y, -1.0, 1.0));
+    float E = asin(clamp(D3.y, -1.0, 1.0));
+    vec2 a1 = vec2(D3.x, D3.z);
+    vec2 a0 = vec2(sW.x, sW.z);
+    float la1 = length(a1), la0 = length(a0);
+    a1 = la1 > 1e-4 ? a1 / la1 : vec2(1.0, 0.0);
+    a0 = la0 > 1e-4 ? a0 / la0 : vec2(1.0, 0.0);
+    float dphi = atan(a1.x * a0.y - a1.y * a0.x, dot(a1, a0)) * DEG;
+    float dE = (E - es) * DEG;
+
+    float aa = max(0.30, fwidth(TH) * 0.9);
+    // slow shimmer: crystal swarms drifting through the beam, never flickering
+    float shim = 0.86 + 0.3 * vnoise(vec3(dir * 2.1 + vec2(0.0, -uTime * 0.05), uTime * 0.09));
+
+    // ---- 22 deg halo, dispersed per channel ------------------------------
+    float nR = 1.307, nG = 1.3112, nB = 1.317;
+    float d22r = minDev(nR, 0.5, 60.0);
+    float d22g = minDev(nG, 0.5, 60.0);
+    float d22b = minDev(nB, 0.5, 60.0);
+    vec3 halo = vec3(ringProfile(TH, d22r, aa, 4.2),
+                     ringProfile(TH, d22g, aa, 5.0),
+                     ringProfile(TH, d22b, aa, 7.5)) * 0.8 * shim;
+
+    // ---- 46 deg halo from the 90 deg prism faces -------------------------
+    float s45 = 0.70710678;
+    vec3 halo46 = vec3(ringProfile(TH, minDev(nR, s45, 90.0), aa * 1.6, 7.0),
+                       ringProfile(TH, minDev(nG, s45, 90.0), aa * 1.6, 8.0),
+                       ringProfile(TH, minDev(nB, s45, 90.0), aa * 1.6, 11.0)) * 0.13 * uOuterHalo * shim;
+
+    // ---- sun dogs: the same caustic in the horizontal plane, Bravais index
+    float ce = max(cos(es), 0.05);
+    float se = sin(es);
+    float npR = sqrt(max(nR * nR - se * se, 0.0)) / ce;
+    float npG = sqrt(max(nG * nG - se * se, 0.0)) / ce;
+    float npB = sqrt(max(nB * nB - se * se, 0.0)) / ce;
+    float aph = abs(dphi);
+    float vert = exp(-dE * dE / (2.0 * 1.25 * 1.25)) * (1.0 - smoothstep(50.0, 61.0, abs(es) * DEG));
+    vec3 dogs = vec3(ringProfile(aph, minDev(npR, 0.5, 60.0), aa * 1.2, 5.0),
+                     ringProfile(aph, minDev(npG, 0.5, 60.0), aa * 1.2, 6.5),
+                     ringProfile(aph, minDev(npB, 0.5, 60.0), aa * 1.2, 11.0));
+    // the outward tail of a sun dog runs white along the parhelic circle
+    float tail = smoothstep(-aa, aa, aph - minDev(npG, 0.5, 60.0)) * exp(-max(aph - minDev(npG, 0.5, 60.0), 0.0) / 11.0);
+    dogs = (dogs + vec3(tail) * 0.12) * vert * 1.5 * uSunDogs * shim;
+
+    // ---- parhelic circle: reflection off the vertical faces of plates -----
+    float pc = exp(-dE * dE / (2.0 * 0.55 * 0.55)) / (1.0 + aph / 45.0);
+    pc *= uParhelicCircle * 0.085 * (0.8 + 0.4 * shim);
+
+    // ---- light pillar: reflection off the near-horizontal basal faces -----
+    float pilW = 1.1 + 0.06 * abs(dE);
+    float pil = exp(-pow(dphi * cos(E) / pilW, 2.0)) * (exp(-max(dE, 0.0) / 8.0) + 0.55 * exp(-max(-dE, 0.0) / 6.0));
+    pil *= uPillar * 0.5 * shim;
+
+    // ---- glare around the source -----------------------------------------
+    // the glare hugs the source, so it is sized by the source, not by a fixed angle
+    float G = vSrc;
+    float gl = uGlare * (0.95 * exp(-TH / (0.5 * G)) + 0.3 * exp(-TH / (1.5 * G)) + 0.07 * exp(-TH / (5.0 * G)));
+
+    vec3 tint = uColor;
+    vec3 col = (halo + halo46 + dogs) * mix(vec3(1.0), tint, 0.35)
+             + (pc + pil + gl) * tint;
+    col *= edgeFade * uIntensity * uOpacity;
+    float lum = max(col.r, max(col.g, col.b));
+    if (lum < 0.002) discard;
+    // premultiplied: the alpha follows the light, so the quad never shows as a rectangle
+    gl_FragColor = vec4(col, min(lum, 1.0));
+  }
+`;
+function createUniforms() {
+    return {
+        uTime: { value: 0 },
+        uSpeed: { value: 1 },
+        uIntensity: { value: 1 },
+        uOpacity: { value: 1 },
+        uColor: { value: new THREE.Color('#fff2dd') },
+        uHaloScale: { value: 0.35 },
+        uSunDogs: { value: 0.8 },
+        uOuterHalo: { value: 0.4 },
+        uParhelicCircle: { value: 0.35 },
+        uPillar: { value: 0.45 },
+        uGlare: { value: 0.9 },
+        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.uHaloScale.value = c.haloScale;
+    u.uSunDogs.value = c.sunDogs;
+    u.uOuterHalo.value = c.outerHalo;
+    u.uParhelicCircle.value = c.parhelicCircle;
+    u.uPillar.value = c.pillar;
+    u.uGlare.value = c.glare;
+    u.uBound.value = bound;
+}
+function build(u, c, bound, env) {
+    const mat = new THREE.ShaderMaterial({
+        vertexShader: haloVert, fragmentShader: haloFrag, uniforms: u,
+        transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, premultipliedAlpha: true, side: THREE.DoubleSide,
+    });
+    const quad = new THREE.PlaneGeometry(2, 2);
+    const sheet = new THREE.Mesh(quad, mat);
+    sheet.frustumCulled = false;
+    const group = new THREE.Group();
+    group.add(sheet);
+    return {
+        object: group,
+        materials: [mat],
+        apply(c2) {
+        },
+        update(dt, camera) {
+            u.uTime.value += dt * u.uSpeed.value;
+        },
+        dispose() {
+            quad.dispose();
+            mat.dispose();
+        },
+    };
+}
+/** Defaults for every knob, so an older saved config still renders. */
+const DEFAULTS = {
+    intensity: 1,
+    speed: 1,
+    color: '#fff2dd',
+    opacity: 1,
+    haloScale: 0.35,
+    sunDogs: 0.8,
+    outerHalo: 0.4,
+    parhelicCircle: 0.35,
+    pillar: 0.45,
+    glare: 0.9,
+};
+const IceHaloEffect = ({ 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]);
+    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 IceHaloEffect;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"LichtenbergEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/LichtenbergEffect.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;IAChC,kFAAkF;IAClF,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AA6cD,QAAA,MAAM,iBAAiB,EAAE,KAAK,CAAC,EAAE,CAAC,sBAAsB,CA+BvD,CAAC;AAEF,eAAe,iBAAiB,CAAC"}