@3driseai/3drise-viewer 0.1.16 → 0.1.18

package/dist/components/WallpaperGrid.js

@@ -0,0 +1,555 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { useFrame } from '@react-three/fiber';
+import { useObjectReady } from '../hooks/useObjectReady.js';
+import { useGridSurface } from '../hooks/useGridSurface.js';
+import { WallpaperGridMaterial } from '@3driseai/3drise-core';
+// Side-effect import registers <wallpaperGridMaterial> via extend().
+void WallpaperGridMaterial;
+/** WallpaperGridConfig defaults. Must match the catalog entry in grid-defaults.json exactly. */
+export const defaultWallpaperGridConfig = {
+    cellSize: 10,
+    size: 50,
+    flat: true,
+    segments: undefined,
+    lineMode: 2,
+    cellMode: 2,
+    lineWidth: 2,
+    sectionSize: 0,
+    sectionWidth: 1.4,
+    animSpeed: 1,
+    animScale: 0.6,
+    animIntensity: 0.55,
+    fadeDistance: undefined,
+    fadeStrength: 0.7,
+    displace: 0,
+    group: -1,
+    cycleTime: 12,
+    motif: 0.5,
+    levels: 11,
+    lineColor: '#f3d79b',
+    sectionColor: '#7fd6ff',
+    cellColor: '#101c50',
+    glowColor: '#ff9ec7',
+    bgColor: '#05070a',
+    bgOpacity: 0,
+    followMouse: false,
+    reveal: 1,
+    revealDuration: 0,
+};
+const gridFragHeader = /* glsl */ `
+  precision highp float;
+
+  uniform float u_time;
+  uniform float u_cellSize;
+  uniform float u_lineWidth;
+  uniform float u_sectionSize;
+  uniform float u_sectionWidth;
+  uniform vec3  u_lineColor;
+  uniform vec3  u_sectionColor;
+  uniform vec3  u_cellColor;
+  uniform vec3  u_glowColor;
+  uniform vec3  u_bgColor;
+  uniform float u_bgOpacity;
+  uniform float u_lineMode;
+  uniform float u_cellMode;
+  uniform float u_animSpeed;
+  uniform float u_animScale;
+  uniform float u_animIntensity;
+  uniform float u_fadeDistance;
+  uniform float u_fadeStrength;
+  uniform vec2  u_focus;
+  uniform float u_reveal;
+
+  varying vec2 vGridPos;
+
+  float lineAt(float c, float width, float fp){
+    float d = abs(fract(c - 0.5) - 0.5);
+    return 1.0 - clamp(d / max(fp * max(width, 0.05), 1e-6), 0.0, 1.0);
+  }
+`;
+const gridCommon = /* glsl */ `
+  const float PI  = 3.14159265359;
+  const float TAU = 6.28318530718;
+
+  float hash21(vec2 p){
+    p = fract(p * vec2(123.34, 456.21));
+    p += dot(p, p + 45.32);
+    return fract(p.x * p.y);
+  }
+`;
+const gridTail = /* glsl */ `
+    // ---- line animation --------------------------------------------------
+    float lineAnim = 1.0;
+    if (u_lineMode > 0.5){
+      if (u_lineMode < 1.5){
+        lineAnim = 0.5 + 0.5 * sin(cellDist * u_animScale - t);
+      } else if (u_lineMode < 2.5){
+        lineAnim = 0.5 + 0.5 * sin(flowCoord * u_animScale - t);
+      } else if (u_lineMode < 3.5){
+        float s = fract(scanCoord * 0.05 * u_animScale - t * 0.15);
+        lineAnim = 0.25 + smoothstep(0.0, 0.15, s) * (1.0 - smoothstep(0.15, 0.35, s));
+      } else {
+        lineAnim = 0.5 + 0.5 * sin(t);
+      }
+    }
+    lineAnim = mix(1.0, lineAnim, u_animIntensity);
+
+    // ---- cell fill -------------------------------------------------------
+    float cell = 0.0;
+    if (u_cellMode > 0.5){
+      if (u_cellMode < 1.5){
+        cell = 0.5 + 0.5 * sin(flowCoord * 0.5 * u_animScale - t);
+      } else if (u_cellMode < 2.5){
+        cell = 0.5 + 0.5 * sin(t * (0.6 + cellH) + cellH * TAU);
+      } else if (u_cellMode < 3.5){
+        cell = smoothstep(0.6, 1.0, sin(cellDist * u_animScale - t));
+      } else {
+        cell = step(0.5, cellH) * (0.5 + 0.5 * sin(t));
+      }
+    }
+    cell *= u_animIntensity * edgeKeep;
+
+    float tone = step(0.55, cellH);
+
+    vec3 col = u_bgColor * u_bgOpacity;
+    float a  = u_bgOpacity;
+
+    col += mix(u_cellColor, u_cellColor * 2.2, tone) * cell;
+    a = max(a, cell * 0.9);
+    float linesI = lines * lineAnim;
+    col += u_lineColor * linesI;            a = max(a, linesI);
+    float accentI = accent * lineAnim;
+    col += u_sectionColor * accentI;        a = max(a, accentI);
+    col += u_glowColor * (linesI * 0.2 + cell * 0.35) * u_animIntensity;
+
+    col = col * regionMask + extraCol;
+    a   = max(a * regionMask, extraA);
+
+    float fade = 1.0 - smoothstep(1.0 - u_fadeStrength, 1.0, fadeR);
+    col *= fade;
+    a   *= fade;
+
+    // ---- reveal ----------------------------------------------------------
+    // The build boundary sweeps outward from the focus point with a bright
+    // leading edge, so the grid reads as assembling itself.
+    if (u_reveal < 0.999){
+      float rd = length(vGridPos - u_focus) / max(u_fadeDistance, 1e-4);
+      float edge = u_reveal * 1.1;
+      float mask = 1.0 - smoothstep(edge - 0.05, edge, rd);
+      float front = mask * smoothstep(edge - 0.22, edge - 0.05, rd);
+      col = col * mask + u_glowColor * front * (a * 1.8 + 0.08);
+      a   = max(a * mask, front * 0.10);
+    }
+
+    if (a < 0.002) discard;
+    gl_FragColor = vec4(col, a);
+  }
+`;
+const gridVertexHead = /* glsl */ `
+  uniform float u_time;
+  uniform float u_cellSize;
+  uniform float u_displace;
+  uniform float u_animSpeed;
+  uniform float u_animScale;
+
+  varying vec2 vGridPos;
+`;
+// ---------------------------------------------------------------------------
+// The 17 wallpaper groups (Farris, "Creating Symmetry").
+// Each group is listed by its ITA general positions in lattice coordinates:
+// [a, b, c, d, tx, ty] maps (x, y) to (a x + b y + tx, c x + d y + ty).
+// These are the coset representatives of the group modulo the lattice;
+// centred groups (cm, cmm) use the conventional rectangular cell and carry
+// the centring translation (1/2, 1/2) as extra representatives. Glide
+// reflections are reflections with half-lattice translations.
+// Lattices: 0 oblique, 1 rectangular, 2 centred rectangular (conventional),
+// 3 square, 4 hexagonal (ITA setting, 120 degrees between a and b).
+// ---------------------------------------------------------------------------
+const WP_NAMES = ['p1', 'p2', 'pm', 'pg', 'cm', 'pmm', 'pmg', 'pgg', 'cmm', 'p4', 'p4m', 'p4g', 'p3', 'p3m1', 'p31m', 'p6', 'p6m'];
+const WP_LATTICE = [0, 0, 1, 1, 2, 1, 1, 1, 2, 3, 3, 3, 4, 4, 4, 4, 4];
+// lattice basis, columns e1 = (m[0], m[1]), e2 = (m[2], m[3]), cell units; unit-cell area ~1
+const WP_BASIS = [
+    [1.05, 0, 0.287, 0.884],
+    [1.2, 0, 0, 0.84],
+    [1.5, 0, 0, 1.3],
+    [1, 0, 0, 1],
+    [1.07, 0, -0.535, 0.535 * Math.sqrt(3)],
+];
+const WP_I = [1, 0, 0, 1, 0, 0];
+const WP_OPS = [
+    [WP_I],
+    [WP_I, [-1, 0, 0, -1, 0, 0]],
+    [WP_I, [-1, 0, 0, 1, 0, 0]],
+    [WP_I, [-1, 0, 0, 1, 0, 0.5]],
+    [WP_I, [-1, 0, 0, 1, 0, 0], [1, 0, 0, 1, 0.5, 0.5], [-1, 0, 0, 1, 0.5, 0.5]],
+    [WP_I, [-1, 0, 0, -1, 0, 0], [-1, 0, 0, 1, 0, 0], [1, 0, 0, -1, 0, 0]],
+    [WP_I, [-1, 0, 0, -1, 0, 0], [-1, 0, 0, 1, 0.5, 0], [1, 0, 0, -1, 0.5, 0]],
+    [WP_I, [-1, 0, 0, -1, 0, 0], [-1, 0, 0, 1, 0.5, 0.5], [1, 0, 0, -1, 0.5, 0.5]],
+    [WP_I, [-1, 0, 0, -1, 0, 0], [-1, 0, 0, 1, 0, 0], [1, 0, 0, -1, 0, 0],
+        [1, 0, 0, 1, 0.5, 0.5], [-1, 0, 0, -1, 0.5, 0.5], [-1, 0, 0, 1, 0.5, 0.5], [1, 0, 0, -1, 0.5, 0.5]],
+    [WP_I, [-1, 0, 0, -1, 0, 0], [0, -1, 1, 0, 0, 0], [0, 1, -1, 0, 0, 0]],
+    [WP_I, [-1, 0, 0, -1, 0, 0], [0, -1, 1, 0, 0, 0], [0, 1, -1, 0, 0, 0],
+        [-1, 0, 0, 1, 0, 0], [1, 0, 0, -1, 0, 0], [0, 1, 1, 0, 0, 0], [0, -1, -1, 0, 0, 0]],
+    [WP_I, [-1, 0, 0, -1, 0, 0], [0, -1, 1, 0, 0, 0], [0, 1, -1, 0, 0, 0],
+        [-1, 0, 0, 1, 0.5, 0.5], [1, 0, 0, -1, 0.5, 0.5], [0, 1, 1, 0, 0.5, 0.5], [0, -1, -1, 0, 0.5, 0.5]],
+    [WP_I, [0, -1, 1, -1, 0, 0], [-1, 1, -1, 0, 0, 0]],
+    [WP_I, [0, -1, 1, -1, 0, 0], [-1, 1, -1, 0, 0, 0],
+        [0, -1, -1, 0, 0, 0], [-1, 1, 0, 1, 0, 0], [1, 0, 1, -1, 0, 0]],
+    [WP_I, [0, -1, 1, -1, 0, 0], [-1, 1, -1, 0, 0, 0],
+        [0, 1, 1, 0, 0, 0], [1, -1, 0, -1, 0, 0], [-1, 0, -1, 1, 0, 0]],
+    [WP_I, [0, -1, 1, -1, 0, 0], [-1, 1, -1, 0, 0, 0],
+        [-1, 0, 0, -1, 0, 0], [0, 1, -1, 1, 0, 0], [1, -1, 1, 0, 0, 0]],
+    [WP_I, [0, -1, 1, -1, 0, 0], [-1, 1, -1, 0, 0, 0],
+        [-1, 0, 0, -1, 0, 0], [0, 1, -1, 1, 0, 0], [1, -1, 1, 0, 0, 0],
+        [0, -1, -1, 0, 0, 0], [-1, 1, 0, 1, 0, 0], [1, 0, 1, -1, 0, 0],
+        [0, 1, 1, 0, 0, 0], [1, -1, 0, -1, 0, 0], [-1, 0, -1, 1, 0, 0]],
+];
+// Motif wave-vectors (integer, dual-lattice coordinates) and their base amplitudes.
+// (1,1) comes first because it survives every extinction rule (centring, glides).
+const WP_K = [1, 1, 2, 0, 1, -2, 2, 1, 3, 1, 1, 3];
+const WP_AMP = [1, 0.8, 0.62, 0.5, 0.4, 0.33];
+const WP_PHASE0 = [0.3, 1.9, 4.1, 2.7, 5.3, 0.9];
+const WP_OMEGA = [0.11, -0.083, 0.067, -0.052, 0.043, -0.037];
+/** Pure: the uniform tables for wallpaper group `index` (0..16, standard order). */
+function wallpaperTables(index) {
+    const gi = Math.min(16, Math.max(0, Math.round(index)));
+    const ops = WP_OPS[gi];
+    const b = WP_BASIS[WP_LATTICE[gi]];
+    const R = new Float32Array(48);
+    const T = new Float32Array(24);
+    const ops6 = new Float64Array(72);
+    for (let i = 0; i < ops.length; i++) {
+        const o = ops[i];
+        // GLSL mat2 is column-major: (a, c, b, d)
+        R[i * 4] = o[0];
+        R[i * 4 + 1] = o[2];
+        R[i * 4 + 2] = o[1];
+        R[i * 4 + 3] = o[3];
+        T[i * 2] = o[4];
+        T[i * 2 + 1] = o[5];
+        for (let j = 0; j < 6; j++)
+            ops6[i * 6 + j] = o[j];
+    }
+    const det = b[0] * b[3] - b[2] * b[1];
+    // inverse basis, column-major
+    const basisInv = new Float32Array([b[3] / det, -b[1] / det, -b[2] / det, b[0] / det]);
+    // Symmetry axes. A reflection with Cartesian normal n and translation t
+    // fixes (up to a translation tau of the group) the lines n.p = n.(t + tau)/2.
+    // Those lines are mirrors when some tau cancels the component along the
+    // axis, and glide axes otherwise.
+    const axes = new Float32Array(24);
+    const axesKind = new Float32Array(18);
+    let axisCount = 0;
+    const tx = [];
+    const ty = [];
+    for (let i = 0; i < ops.length; i++) {
+        const o = ops[i];
+        if (o[0] !== 1 || o[1] !== 0 || o[2] !== 0 || o[3] !== 1)
+            continue;
+        for (let m = -4; m <= 4; m++)
+            for (let n = -4; n <= 4; n++) {
+                const lx = m + o[4], ly = n + o[5];
+                tx.push(b[0] * lx + b[2] * ly);
+                ty.push(b[1] * lx + b[3] * ly);
+            }
+    }
+    for (let i = 0; i < ops.length; i++) {
+        const o = ops[i];
+        if (o[0] * o[3] - o[1] * o[2] > -0.5)
+            continue;
+        // Cartesian linear part C = B M B^-1
+        const m00 = o[0] * b[0] + o[2] * b[2], m01 = o[1] * b[0] + o[3] * b[2];
+        const m10 = o[0] * b[1] + o[2] * b[3], m11 = o[1] * b[1] + o[3] * b[3];
+        const c00 = (m00 * b[3] - m01 * b[1]) / det, c01 = (-m00 * b[2] + m01 * b[0]) / det;
+        const c10 = (m10 * b[3] - m11 * b[1]) / det, c11 = (-m10 * b[2] + m11 * b[0]) / det;
+        // I - C = 2 n n^T
+        let nx = 1 - c00, ny = -c10;
+        if (nx * nx + ny * ny < 1e-6) {
+            nx = -c01;
+            ny = 1 - c11;
+        }
+        const nl = Math.hypot(nx, ny);
+        nx /= nl;
+        ny /= nl;
+        if (ny < -1e-6 || (Math.abs(ny) <= 1e-6 && nx < 0)) {
+            nx = -nx;
+            ny = -ny;
+        }
+        let dup = false;
+        for (let a = 0; a < axisCount; a++)
+            if (Math.abs(axes[a * 4] * nx + axes[a * 4 + 1] * ny) > 0.999)
+                dup = true;
+        if (dup || axisCount >= 6)
+            continue;
+        const ux = -ny, uy = nx;
+        const cx = b[0] * o[4] + b[2] * o[5], cy = b[1] * o[4] + b[3] * o[5];
+        let delta = 1e9, period = 1e9;
+        for (let k = 0; k < tx.length; k++) {
+            const dn = Math.abs(nx * tx[k] + ny * ty[k]);
+            const du = Math.abs(ux * tx[k] + uy * ty[k]);
+            if (dn > 1e-5)
+                delta = Math.min(delta, dn);
+            else if (du > 1e-5)
+                period = Math.min(period, du);
+        }
+        const h = delta * 0.5;
+        const on = nx * cx + ny * cy;
+        const o0 = on * 0.5 - Math.floor(on * 0.5 / delta) * delta;
+        const kind = [0.5, 0.5];
+        for (let k = 0; k < tx.length; k++) {
+            const mm = (nx * (cx + tx[k]) + ny * (cy + ty[k])) * 0.5;
+            const j = Math.round((mm - o0) / h);
+            if (Math.abs(mm - o0 - j * h) > 1e-4)
+                continue;
+            const g = ux * (cx + tx[k]) + uy * (cy + ty[k]);
+            const r = g - Math.round(g / period) * period;
+            if (Math.abs(r) < 1e-4)
+                kind[((j % 2) + 2) % 2] = 1;
+        }
+        axes[axisCount * 4] = nx;
+        axes[axisCount * 4 + 1] = ny;
+        axes[axisCount * 4 + 2] = o0;
+        axes[axisCount * 4 + 3] = h;
+        axesKind[axisCount * 3] = kind[0];
+        axesKind[axisCount * 3 + 1] = kind[1];
+        axesKind[axisCount * 3 + 2] = period;
+        axisCount++;
+    }
+    return { name: WP_NAMES[gi], lattice: WP_LATTICE[gi], count: ops.length, ops: ops6, R, T, basisInv, axes, axesKind, axisCount };
+}
+// RMS of the symmetrised field for the current motif terms. Every term
+// cos(2 pi k.(M q + s) + phi) is a plane wave with vector M^T k; waves with the
+// same vector (up to sign) add as complex amplitudes, and the mean square of a
+// sum of distinct plane waves is half the sum of their squared amplitudes.
+function wallpaperRms(tab, wave, sk, sre, sim) {
+    let n = 0;
+    for (let g = 0; g < tab.count; g++) {
+        const a = tab.ops[g * 6], b = tab.ops[g * 6 + 1], c = tab.ops[g * 6 + 2], d = tab.ops[g * 6 + 3];
+        const sx = tab.ops[g * 6 + 4], sy = tab.ops[g * 6 + 5];
+        for (let j = 0; j < 6; j++) {
+            const amp = wave[j * 2];
+            if (amp <= 0)
+                continue;
+            const kx = WP_K[j * 2], ky = WP_K[j * 2 + 1];
+            let px = a * kx + c * ky, py = b * kx + d * ky;
+            let ph = wave[j * 2 + 1] + 2 * Math.PI * (kx * sx + ky * sy);
+            if (px < 0 || (px === 0 && py < 0)) {
+                px = -px;
+                py = -py;
+                ph = -ph;
+            }
+            let slot = -1;
+            for (let s = 0; s < n; s++)
+                if (sk[s * 2] === px && sk[s * 2 + 1] === py) {
+                    slot = s;
+                    break;
+                }
+            if (slot < 0) {
+                slot = n;
+                n++;
+                sk[slot * 2] = px;
+                sk[slot * 2 + 1] = py;
+                sre[slot] = 0;
+                sim[slot] = 0;
+            }
+            sre[slot] += amp * Math.cos(ph);
+            sim[slot] += amp * Math.sin(ph);
+        }
+    }
+    let sum = 0;
+    for (let s = 0; s < n; s++)
+        sum += sre[s] * sre[s] + sim[s] * sim[s];
+    return Math.sqrt(sum * 0.5);
+}
+function createExtraUniforms() {
+    return {
+        u_wave: { value: new Float32Array(12) },
+        u_RA: { value: new Float32Array(48) },
+        u_TA: { value: new Float32Array(24) },
+        u_countA: { value: 1 },
+        u_basisA: { value: new Float32Array([1, 0, 0, 1]) },
+        u_normA: { value: 1 },
+        u_axA: { value: new Float32Array(24) },
+        u_axKA: { value: new Float32Array(18) },
+        u_axNA: { value: 0 },
+        u_RB: { value: new Float32Array(48) },
+        u_TB: { value: new Float32Array(24) },
+        u_countB: { value: 1 },
+        u_basisB: { value: new Float32Array([1, 0, 0, 1]) },
+        u_normB: { value: 1 },
+        u_axB: { value: new Float32Array(24) },
+        u_axKB: { value: new Float32Array(18) },
+        u_axNB: { value: 0 },
+        u_mix: { value: 0 },
+        u_mixGain: { value: 1 },
+    };
+}
+function createRuntime(u, renderer, c) {
+    const tables = [];
+    for (let i = 0; i < 17; i++)
+        tables.push(wallpaperTables(i));
+    return {
+        tables,
+        clock: 0,
+        motion: 0,
+        shownA: -1,
+        shownB: -1,
+        sk: new Int32Array(160),
+        sre: new Float64Array(80),
+        sim: new Float64Array(80),
+    };
+}
+function wallpaperLoad(tab, R, T, basis, ax, axK) {
+    R.set(tab.R);
+    T.set(tab.T);
+    basis.set(tab.basisInv);
+    ax.set(tab.axes);
+    axK.set(tab.axesKind);
+}
+function updateRuntime(rt, u, c, dt, renderer) {
+    const speed = u.u_animSpeed ? u.u_animSpeed.value : c.animSpeed;
+    const group = u.u_group ? u.u_group.value : c.group;
+    const cycle = Math.max(0.5, u.u_cycleTime ? u.u_cycleTime.value : c.cycleTime);
+    const motif = Math.min(1, Math.max(0, u.u_motif ? u.u_motif.value : c.motif));
+    rt.clock += dt;
+    rt.motion += dt * speed;
+    // which groups are showing: a fixed one, or the cycle (starting at p6m)
+    let ga = 0, gb = 0, mix = 0;
+    if (group >= -0.5) {
+        ga = Math.min(16, Math.max(0, Math.round(group)));
+        gb = ga;
+    }
+    else {
+        const s = rt.clock / cycle + 16;
+        const i = Math.floor(s);
+        const f = s - i;
+        ga = i % 17;
+        gb = (i + 1) % 17;
+        const x = Math.min(1, Math.max(0, (f - 0.62) / 0.38));
+        mix = x * x * (3 - 2 * x);
+    }
+    const A = rt.tables[ga], B = rt.tables[gb];
+    if (ga !== rt.shownA) {
+        rt.shownA = ga;
+        wallpaperLoad(A, u.u_RA.value, u.u_TA.value, u.u_basisA.value, u.u_axA.value, u.u_axKA.value);
+        u.u_countA.value = A.count;
+        u.u_axNA.value = A.axisCount;
+    }
+    if (gb !== rt.shownB) {
+        rt.shownB = gb;
+        wallpaperLoad(B, u.u_RB.value, u.u_TB.value, u.u_basisB.value, u.u_axB.value, u.u_axKB.value);
+        u.u_countB.value = B.count;
+        u.u_axNB.value = B.axisCount;
+    }
+    // motif: wave-vectors fade in one after another as motif grows; phases drift slowly
+    const wave = u.u_wave.value;
+    const reach = 1 + motif * 5;
+    for (let j = 0; j < 6; j++) {
+        wave[j * 2] = WP_AMP[j] * Math.min(1, Math.max(0, reach - j));
+        wave[j * 2 + 1] = WP_PHASE0[j] + WP_OMEGA[j] * rt.motion;
+    }
+    const floorRms = 0.08;
+    u.u_normA.value = 1 / Math.max(wallpaperRms(A, wave, rt.sk, rt.sre, rt.sim), floorRms);
+    u.u_normB.value = mix > 0 ? 1 / Math.max(wallpaperRms(B, wave, rt.sk, rt.sre, rt.sim), floorRms) : 1;
+    u.u_mix.value = mix;
+    // two independent unit-RMS fields mixed by (1-x, x) have RMS sqrt((1-x)^2 + x^2)
+    u.u_mixGain.value = 1 / Math.sqrt((1 - mix) * (1 - mix) + mix * mix);
+}
+function disposeRuntime(rt) {
+    rt.tables.length = 0;
+}
+// ---------------------------------------------------------------------------
+// Farris' recipe: a lattice-periodic motif m(q) summed over the coset
+// representatives g of a wallpaper group, F(p) = sum_g m(g.q), q = B^-1 p.
+// For any h in the group, {g h} runs over the same cosets, and m ignores
+// lattice translations, so F(h.p) = F(p) exactly: the picture has precisely
+// the group's mirrors, glides and rotation centres, and tiles seamlessly.
+// Level sets of F are the lines; its value bands are the cells.
+// ---------------------------------------------------------------------------
+const wallpaperField = /* glsl */ `
+  uniform vec2  u_wave[6];
+  uniform mat2  u_RA[12];
+  uniform vec2  u_TA[12];
+  uniform float u_countA;
+  uniform mat2  u_basisA;
+  uniform float u_normA;
+  uniform mat2  u_RB[12];
+  uniform vec2  u_TB[12];
+  uniform float u_countB;
+  uniform mat2  u_basisB;
+  uniform float u_normB;
+  uniform float u_mix;
+  uniform float u_mixGain;
+
+  float wpMotif(vec2 q){
+    vec2 a = TAU * q;
+    return u_wave[0].x * cos(dot(a, vec2(1.0, 1.0)) + u_wave[0].y)
+         + u_wave[1].x * cos(dot(a, vec2(2.0, 0.0)) + u_wave[1].y)
+         + u_wave[2].x * cos(dot(a, vec2(1.0, -2.0)) + u_wave[2].y)
+         + u_wave[3].x * cos(dot(a, vec2(2.0, 1.0)) + u_wave[3].y)
+         + u_wave[4].x * cos(dot(a, vec2(3.0, 1.0)) + u_wave[4].y)
+         + u_wave[5].x * cos(dot(a, vec2(1.0, 3.0)) + u_wave[5].y);
+  }
+
+  float wpSym(vec2 p, mat2 Bi, mat2 R[12], vec2 T[12], float n){
+    vec2 q = Bi * p;
+    q -= floor(q);
+    float s = 0.0;
+    for (int i = 0; i < 12; i++){
+      if (float(i) >= n) break;
+      s += wpMotif(R[i] * q + T[i]);
+    }
+    return s;
+  }
+
+  // unit-RMS field, crossfaded between group A and group B
+  float wpField(vec2 p){
+    float f = wpSym(p, u_basisA, u_RA, u_TA, u_countA) * u_normA;
+    if (u_mix > 0.001){
+      float g = wpSym(p, u_basisB, u_RB, u_TB, u_countB) * u_normB;
+      f = mix(f, g, u_mix) * u_mixGain;
+    }
+    return f;
+  }
+`;
+/**
+ * Wallpaper-group kaleidoscope: a drifting lattice-periodic Fourier motif summed over the coset representatives of one of the 17 plane crystallographic groups. The runtime builds the group tables and crossfades from group to group.
+ */
+export function WallpaperGrid({ config = defaultWallpaperGridConfig, groupProps, onObjectReady, onObjectDispose }) {
+    const matRef = useRef(null);
+    const rootRef = useRef(null);
+    const meshRef = useRef(null);
+    useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
+    const { cellSize, size, segments, flat, lineMode, cellMode, lineWidth, sectionSize, sectionWidth, animSpeed, animScale, animIntensity, fadeDistance, fadeStrength, displace, group, cycleTime, motif, levels, lineColor, sectionColor, cellColor, glowColor, bgColor, bgOpacity, followMouse, reveal, revealDuration, } = config;
+    // the motif has up to ~3 waves per unit cell, so 16 vertices per cell keep the displaced relief smooth
+    const segs = segments ?? (displace > 0 ? Math.min(512, Math.max(96, Math.ceil(size / Math.max(cellSize, 1e-4)) * 16)) : 1);
+    const fade = fadeDistance ?? size * 0.5;
+    const colors = useMemo(() => ({
+        line: new THREE.Color(lineColor),
+        section: new THREE.Color(sectionColor),
+        cell: new THREE.Color(cellColor),
+        glow: new THREE.Color(glowColor),
+        bg: new THREE.Color(bgColor),
+    }), [lineColor, sectionColor, cellColor, glowColor, bgColor]);
+    useGridSurface(matRef, meshRef, { followMouse, reveal, revealDuration });
+    // the simulation behind this grid: created on mount, stepped every frame
+    const runtimeRef = useRef(null);
+    useFrame((state, delta) => {
+        const mat = matRef.current;
+        if (!mat)
+            return;
+        if (!runtimeRef.current)
+            runtimeRef.current = createRuntime(mat.uniforms, state.gl, config);
+        updateRuntime(runtimeRef.current, mat.uniforms, config, Math.min(delta, 0.1), state.gl);
+    });
+    useEffect(() => () => {
+        if (runtimeRef.current) {
+            disposeRuntime(runtimeRef.current);
+            runtimeRef.current = null;
+        }
+    }, []);
+    return (_jsx("group", { ref: rootRef, ...groupProps, children: _jsxs("mesh", { ref: meshRef, rotation: flat ? [-Math.PI / 2, 0, 0] : [0, 0, 0], children: [_jsx("planeGeometry", { args: [size, size, segs, segs] }), _jsx("wallpaperGridMaterial", { ref: matRef, transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, side: THREE.DoubleSide, u_cellSize: cellSize, u_lineWidth: lineWidth, u_sectionSize: sectionSize, u_sectionWidth: sectionWidth, u_lineMode: lineMode, u_cellMode: cellMode, u_animSpeed: animSpeed, u_animScale: animScale, u_animIntensity: animIntensity, u_fadeDistance: fade, u_fadeStrength: fadeStrength, u_displace: displace, u_group: group, u_cycleTime: cycleTime, u_motif: motif, u_levels: levels, u_lineColor: colors.line, u_sectionColor: colors.section, u_cellColor: colors.cell, u_glowColor: colors.glow, u_bgColor: colors.bg, u_bgOpacity: bgOpacity }, WallpaperGridMaterial.key)] }) }));
+}
+export default WallpaperGrid;

package/dist/components/cursor/CursorController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CursorController.d.ts","sourceRoot":"","sources":["../../../src/components/cursor/CursorController.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAGhE,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AACrC,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC7E,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,MAAM,WAAW,qBAAsB,SAAQ,gBAAgB;IAC3D,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;IACzB,YAAY,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACnC,kBAAkB,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;CACjD;AAGD,QAAA,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC,qBAAqB,CAAiW,CAAC;AACxZ,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"CursorController.d.ts","sourceRoot":"","sources":["../../../src/components/cursor/CursorController.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAGhE,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AACrC,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC7E,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,MAAM,WAAW,qBAAsB,SAAQ,gBAAgB;IAC3D,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;IACzB,YAAY,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACnC,kBAAkB,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;CACjD;AAGD,QAAA,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC,qBAAqB,CAK1C,CAAC;AACb,eAAe,gBAAgB,CAAC"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"BlackHoleEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/BlackHoleEffect.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE/E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,UAAU,oBAAqB,SAAQ,gBAAgB;IACnD,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACnC;AAsHD,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAwEnD,CAAC;AACF,eAAe,eAAe,CAAC"}
+{"version":3,"file":"BlackHoleEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/BlackHoleEffect.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsD,MAAM,OAAO,CAAC;AAG3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAG/E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,WAAW,oBAAqB,SAAQ,gBAAgB;IAC1D,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACnC;AA2PD,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CA6FnD,CAAC;AAEF,eAAe,eAAe,CAAC"}