@mkbabb/glass-ui 4.0.1 → 4.1.0

package/dist/dot-matrix.d.ts

@@ -0,0 +1 @@
+export * from "./components/custom/dot-matrix";

package/dist/dot-matrix.js

@@ -0,0 +1,630 @@
+import { t as e } from "./_plugin-vue_export-helper-C1je1s0u.js";
+import { t } from "./usePointerVelocityField-QLsy3_kv.js";
+import { n, o as r, r as i, s as a } from "./procedural-color.wgsl-m7Zgv35j.js";
+import { a as o, t as s } from "./useGpuSubstrate-4pTcp6mX.js";
+import { c } from "./color-Cs0-oxYL.js";
+import { a as l, c as u, d, i as f, l as p, n as m, o as h, r as g, s as _, t as v, u as y } from "./dotMatrixField-D_x9_1qq.js";
+import { computed as b, createElementBlock as x, createElementVNode as S, defineComponent as C, normalizeStyle as w, onScopeDispose as T, openBlock as E, useTemplateRef as D, watch as O } from "vue";
+//#region src/components/custom/dot-matrix/shaders/dot-matrix.wgsl.ts
+var k = `
+const PI: f32 = 3.141592653589793;
+const TAU: f32 = 6.283185307179586;
+const MAX_DOT_STOPS: i32 = 4;
+// The golden-angle constant (transcribes dotMatrixField.ts GOLDEN_ANGLE = PI*(3-sqrt5)).
+const GOLDEN_ANGLE: f32 = 2.399963229728653;
+
+struct Dot {
+  // (unitPos.xyz, sphereIdx)
+  data: vec4<f32>,
+};
+
+// ── Render uniforms (the typed-struct source-of-truth — see uniformBridgeWGPU.ts) ──
+struct Uniforms {
+  // u0: (uResolutionX, uResolutionY, uDpr, uTime)
+  u0: vec4<f32>,
+  // u1: (uRadius, uDotSize, uBaseOpacity, uAspect)
+  u1: vec4<f32>,
+  // u2: (uFacingLo, uFacingHi, uSizeLo, uSizeHi)
+  u2: vec4<f32>,
+  // u3: (uParallax, uPointerPush, uPointerBloom, uPointerActive)
+  u3: vec4<f32>,
+  // u4: (uPointerX, uPointerY, uSphere2Scale, uBreathRadius)
+  u4: vec4<f32>,
+  // u5: (uSphere2OffsetX, uSphere2OffsetY, uHasBackground, _pad)
+  u5: vec4<f32>,
+  spin: mat3x3<f32>,
+  // ints: (uStopCount, uDotCount, uSpheres, _pad)
+  ints: vec4<i32>,
+  // bg: (background.rgb, _pad)
+  bg: vec4<f32>,
+  palette: array<vec4<f32>, 4>,
+};
+
+@group(0) @binding(0) var<uniform> u: Uniforms;
+@group(0) @binding(1) var<storage, read> dots: array<Dot>;
+
+${n}
+${i}
+
+// The §T2 depth-fade (transcribes dotMatrixField.ts facingFade): the rotated-normal's z
+// → a SOFT facing term → opacity + size ramps. NOT a binary back-face cull.
+fn facingTerm(n: vec3<f32>) -> f32 {
+  return clamp(n.z * 0.5 + 0.5, 0.0, 1.0);   // 1 = dead-front, 0 = dead-back
+}
+
+// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].
+fn samplePaletteLin(t: f32) -> vec3<f32> {
+  let stopCount = u.ints.x;
+  if (stopCount <= 1) { return u.palette[0].rgb; }
+  let n = f32(stopCount);
+  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);
+  let i0 = i32(floor(ft));
+  let i1 = min(i0 + 1, stopCount - 1);
+  let f = ft - f32(i0);
+  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i0].rgb);
+  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i1].rgb);
+  return oklabToLinearSrgb(mix(labA, labB, f));
+}
+
+struct VSOut {
+  @builtin(position) pos: vec4<f32>,
+  @location(0) local: vec2<f32>,   // [-1,1] billboard-local coords for the SDF circle
+  @location(1) bright: f32,        // facing-driven brightness [0, ~1.6]
+  @location(2) alpha: f32,         // facing-driven opacity
+  @location(3) tone: f32,          // palette tone (0 = bright cream near-front, 1 = amber rim)
+};
+
+@vertex
+fn vs_main(
+  @builtin(vertex_index) vi: u32,
+  @builtin(instance_index) ii: u32,
+) -> VSOut {
+  // Two-triangle quad corners in billboard-local space (camera-facing by construction).
+  var corners = array<vec2<f32>, 6>(
+    vec2<f32>(-1.0, -1.0), vec2<f32>(1.0, -1.0), vec2<f32>(-1.0, 1.0),
+    vec2<f32>(-1.0, 1.0), vec2<f32>(1.0, -1.0), vec2<f32>(1.0, 1.0),
+  );
+  let local = corners[vi];
+
+  let dot = dots[ii].data;
+  var unitPos = dot.xyz;          // the STATIC phyllotaxis position (JS-computed)
+  let sphereIdx = dot.w;
+
+  // The breathing radius pulse (transcribes breathRadius — 1 at rest).
+  let breath = u.u4.w;
+  // Per-sphere offset/scale (the reference two-globe composition).
+  var sphereScale = u.u1.x;       // uRadius
+  var sphereOffset = vec2<f32>(0.0, 0.0);
+  if (sphereIdx > 0.5) {
+    sphereScale = u.u1.x * u.u4.z;             // uRadius * uSphere2Scale
+    sphereOffset = vec2<f32>(u.u5.x, u.u5.y);  // uSphere2Offset
+  }
+
+  // The rotated surface NORMAL = spin · unitPos (the §T2 facing source). The spin matrix
+  // is the slow tilted Y-rotation (dotMatrixField.ts spinMatrix).
+  let n = u.spin * unitPos;
+  let facing = facingTerm(n);
+
+  // Pointer-repel/attract — a soft Gaussian dimple lifts the dot radially off the surface
+  // near the cursor (the §T7 local perturbation). The pointer is in NDC (-1..1); a repel
+  // (push>0) pushes the dot OUT, an attract (push<0) pulls IN. Velocity scales the push.
+  let pAct = u.u3.w;
+  let pointerNdc = vec2<f32>(u.u4.x * 2.0 - 1.0, 1.0 - u.u4.y * 2.0);
+  let screenN = n.xy * sphereScale + sphereOffset;
+  let toPointer = screenN - pointerNdc;
+  let pd = length(toPointer);
+  let dimple = exp(-pd * pd * 18.0) * u.u3.y * pAct;   // soft Gaussian falloff × push
+  // Lift along the rotated normal's screen projection (radially through the shell).
+  let lift = n.xy * dimple;
+
+  // Project the rotated normal to the screen (orthographic — the §T5 flat hero look),
+  // scaled by the sphere radius + the breathing, plus the per-sphere offset + the dimple
+  // lift + the pointer-parallax screen-center track.
+  let parallaxOff = (pointerNdc) * u.u3.x * pAct;       // uParallax · pointer · active
+  let center2d = n.xy * sphereScale * breath + sphereOffset + lift + parallaxOff;
+
+  // The depth-of-field dot-size taper (transcribes facingFade size): 0.6 + 0.4·facing,
+  // plus the accel-burst bloom scale near the cursor.
+  let sizeTaper = u.u2.z + u.u2.w * facing;
+  let burstScale = 1.0 + u.u3.z * exp(-pd * pd * 12.0);
+  let dotR = u.u1.y * sizeTaper * burstScale;            // uDotSize · taper · burst
+
+  let offX = local.x * dotR;
+  let offY = local.y * dotR;
+
+  // The opacity ramp (transcribes facingFade opacity): facingLo + facingHi·facing, scaled
+  // by the base opacity + a faint burst brightness lift near the cursor.
+  let facingOpacity = u.u2.x + u.u2.y * facing;          // facingLo + facingHi·facing
+  let burstBright = 1.0 + u.u3.z * 0.8 * exp(-pd * pd * 12.0);
+
+  // The whole sphere + quad is built in a SQUARE space (so the globe stays circular); the
+  // final clip-space x divides by aspect so a wide canvas does not squash it into an
+  // ellipse (aspect ≥ 1 → x shrinks; aspect < 1 → x grows). This keeps the dot quads round
+  // AND the sphere circular in PIXELS regardless of the canvas aspect.
+  let aspect = max(u.u1.w, 1e-4);
+  let clipX = (center2d.x + offX) / aspect;
+  let clipY = center2d.y + offY;
+
+  var out: VSOut;
+  out.pos = vec4<f32>(clipX, clipY, 0.0, 1.0);
+  out.local = local;
+  out.bright = facingOpacity * burstBright;
+  out.alpha = clamp(u.u1.z * facingOpacity * burstBright, 0.0, 1.0);
+  // The palette tone reads the DEPTH (not the opacity): the near-front samples the bright
+  // cream stop[0] (tone 0), the rim/far the darker amber stop (tone → 1), so the depth-shell
+  // reads TONALLY on BOTH a dark AND a light ground (a light-ground globe can't lean on the
+  // opacity fade alone — over a light card a faded dot reads brighter, inverting the shell).
+  out.tone = clamp(1.0 - facing, 0.0, 1.0);
+  return out;
+}
+
+@fragment
+fn fs_main(in: VSOut) -> @location(0) vec4<f32> {
+  // The crisp fwidth-smoothstep SDF circle (the ONE AA canon — the band is ~1px wide at
+  // any DPR/zoom, so fine sub-2px dots stay crisp). d = |uv| - 1; aa = fwidth(d).
+  let d = length(in.local) - 1.0;
+  let aa = max(fwidth(d), 1e-4);
+  let coverage = 1.0 - smoothstep(-aa, aa, d);
+  if (coverage < 0.002) { discard; }
+
+  // The palette tints the dot by DEPTH (near-front cream → rim amber); the brightness lights
+  // the core. The near hemisphere reads as the bright warm-cream stop, the rim/far fading to
+  // the darker amber — the translucent dot-shell on both grounds.
+  let lin = samplePaletteLin(in.tone) * clamp(in.bright, 0.0, 1.6);
+  let alpha = in.alpha * coverage;
+  let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));
+  // Premultiplied-alpha output (the translucent dot-shell additive over the clear).
+  return vec4<f32>(rgb * alpha, alpha);
+}
+`, A = "#version 300 es\nprecision highp float;\n\n#define MAX_DOT_STOPS 4\n#define GOLDEN_ANGLE 2.399963229728653\n\n// The static quad corner (6 verts: two triangles) + the instanced per-dot data.\nin vec2 aCorner;          // billboard-local [-1,1]\nin vec4 aDot;             // (unitPos.xyz, sphereIdx) — instanced (divisor 1)\n\nuniform vec4 uU0;         // (resX, resY, dpr, time)\nuniform vec4 uU1;         // (radius, dotSize, baseOpacity, aspect)\nuniform vec4 uU2;         // (facingLo, facingHi, sizeLo, sizeHi)\nuniform vec4 uU3;         // (parallax, pointerPush, pointerBloom, pointerActive)\nuniform vec4 uU4;         // (pointerX, pointerY, sphere2Scale, breathRadius)\nuniform vec4 uU5;         // (sphere2OffsetX, sphere2OffsetY, hasBackground, _pad)\nuniform mat3 uSpin;       // the slow tilted Y-rotation\n\nout vec2 vLocal;          // [-1,1] billboard-local for the SDF circle\nout float vBright;        // facing-driven brightness\nout float vAlpha;         // facing-driven opacity\nout float vTone;          // palette tone (0 = bright cream near-front, 1 = amber rim)\n\nfloat facingTerm(vec3 n) {\n  return clamp(n.z * 0.5 + 0.5, 0.0, 1.0);   // 1 = dead-front\n}\n\nvoid main() {\n  vec3 unitPos = aDot.xyz;\n  float sphereIdx = aDot.w;\n\n  float breath = uU4.w;\n  float sphereScale = uU1.x;\n  vec2 sphereOffset = vec2(0.0);\n  if (sphereIdx > 0.5) {\n    sphereScale = uU1.x * uU4.z;\n    sphereOffset = vec2(uU5.x, uU5.y);\n  }\n\n  // The rotated surface normal = spin · unitPos (the §T2 facing source).\n  vec3 n = uSpin * unitPos;\n  float facing = facingTerm(n);\n\n  // Pointer-repel/attract dimple (the §T7 local perturbation).\n  float pAct = uU3.w;\n  vec2 pointerNdc = vec2(uU4.x * 2.0 - 1.0, 1.0 - uU4.y * 2.0);\n  vec2 screenN = n.xy * sphereScale + sphereOffset;\n  vec2 toPointer = screenN - pointerNdc;\n  float pd = length(toPointer);\n  float dimple = exp(-pd * pd * 18.0) * uU3.y * pAct;\n  vec2 lift = n.xy * dimple;\n\n  vec2 parallaxOff = pointerNdc * uU3.x * pAct;\n  vec2 center2d = n.xy * sphereScale * breath + sphereOffset + lift + parallaxOff;\n\n  // The depth-of-field size taper + the accel-burst bloom scale.\n  float sizeTaper = uU2.z + uU2.w * facing;\n  float burstScale = 1.0 + uU3.z * exp(-pd * pd * 12.0);\n  float dotR = uU1.y * sizeTaper * burstScale;\n\n  float offX = aCorner.x * dotR;\n  float offY = aCorner.y * dotR;\n\n  float facingOpacity = uU2.x + uU2.y * facing;\n  float burstBright = 1.0 + uU3.z * 0.8 * exp(-pd * pd * 12.0);\n\n  vLocal = aCorner;\n  vBright = facingOpacity * burstBright;\n  vAlpha = clamp(uU1.z * facingOpacity * burstBright, 0.0, 1.0);\n  // The palette tone reads the DEPTH (near-front bright cream → rim amber) so the depth-shell\n  // reads tonally on BOTH a dark AND a light ground.\n  vTone = clamp(1.0 - facing, 0.0, 1.0);\n\n  // The whole sphere + quad is built in a SQUARE space (so the globe stays circular); the\n  // final clip-space x divides by aspect so a wide canvas does not squash it into an ellipse.\n  float aspect = max(uU1.w, 1e-4);\n  gl_Position = vec4((center2d.x + offX) / aspect, center2d.y + offY, 0.0, 1.0);\n}", j = `#version 300 es
+precision highp float;
+
+#define MAX_DOT_STOPS 4
+
+in vec2 vLocal;
+in float vBright;
+in float vAlpha;
+in float vTone;
+out vec4 fragColor;
+
+uniform vec4 uBg;                       // (background.rgb, hasBackground)
+uniform int  uStopCount;
+uniform vec3 uPalette[MAX_DOT_STOPS];   // linear-sRGB stops
+
+const mat2 FBM_ROT = mat2(0.8, 0.6, -0.6, 0.8);
+
+${r}
+${a}
+
+vec3 samplePaletteLin(float t) {
+  if (uStopCount <= 1) return uPalette[0];
+  float n = float(uStopCount);
+  float ft = clamp(t, 0.0, 1.0) * (n - 1.0);
+  int i0 = int(floor(ft));
+  int i1 = min(i0 + 1, uStopCount - 1);
+  float f = ft - float(i0);
+  vec3 lmsA = LINEAR_SRGB_TO_LMS * uPalette[i0];
+  vec3 lmsB = LINEAR_SRGB_TO_LMS * uPalette[i1];
+  vec3 labA = LMS_TO_OKLAB * (sign(lmsA) * pow(abs(lmsA), vec3(1.0 / 3.0)));
+  vec3 labB = LMS_TO_OKLAB * (sign(lmsB) * pow(abs(lmsB), vec3(1.0 / 3.0)));
+  return oklabToLinearSrgb(mix(labA, labB, f));
+}
+
+void main() {
+  // The crisp fwidth-smoothstep SDF circle (the ONE AA canon; ~1px band at any DPR).
+  float d = length(vLocal) - 1.0;
+  float aa = max(fwidth(d), 1e-4);
+  float coverage = 1.0 - smoothstep(-aa, aa, d);
+  if (coverage < 0.002) discard;
+
+  vec3 lin = samplePaletteLin(vTone) * clamp(vBright, 0.0, 1.6);
+  float alpha = vAlpha * coverage;
+  vec3 rgb = clamp(linearToSrgb(lin), vec3(0.0), vec3(1.0));
+  fragColor = vec4(rgb * alpha, alpha);
+}`, M = 4e3, N = 4, P = [{
+	L: .92,
+	C: .03,
+	h: 78
+}, {
+	L: .84,
+	C: .07,
+	h: 62
+}], F = {
+	dotCount: 2400,
+	radius: .42,
+	dotSize: 1.8,
+	baseOpacity: .5,
+	depthFade: .85,
+	rotationSpeed: .07,
+	axisTilt: 23,
+	spheres: 1,
+	breathing: 0,
+	palette: P,
+	background: "transparent",
+	interactive: !1,
+	pointerMode: "repel",
+	parallax: .08,
+	respectReducedMotion: !0
+}, I = {
+	x: .62,
+	y: .32
+}, L = .46;
+function R() {
+	return {
+		x: .5,
+		y: .5,
+		active: 0,
+		push: 0,
+		bloom: 0
+	};
+}
+var z = 240, B = {
+	u0: 0,
+	u1: 4,
+	u2: 8,
+	u3: 12,
+	u4: 16,
+	u5: 20,
+	spin0: 24,
+	spin1: 28,
+	spin2: 32,
+	ints: 36,
+	bg: 40,
+	palette: 44
+};
+function V() {
+	let e = new ArrayBuffer(z);
+	return {
+		buffer: e,
+		f32: new Float32Array(e),
+		i32: new Int32Array(e)
+	};
+}
+function H(e) {
+	let t = Math.min(Math.max(Math.floor(e.dotCount), 1), 4e3), n = e.spheres === 2 ? 2 : 1, r = t * n, i = new Float32Array(r * 4), a = 0;
+	for (let e = 0; e < n; e++) for (let n = 0; n < t; n++) {
+		let r = y(n, t);
+		i[a + 0] = r.x, i[a + 1] = r.y, i[a + 2] = r.z, i[a + 3] = e, a += 4;
+	}
+	return i;
+}
+function U(e) {
+	return Math.min(Math.max(Math.floor(e.dotCount), 1), 4e3) * (e.spheres === 2 ? 2 : 1);
+}
+function W(e, t, n) {
+	return e * t * 2 / Math.max(n, 1);
+}
+function G(e, t, n, r, i, a, o, s) {
+	let { f32: l, i32: u } = e, f = Math.min(r.w, r.h) || 1, p = r.w / Math.max(r.h, 1);
+	l[B.u0 + 0] = r.w, l[B.u0 + 1] = r.h, l[B.u0 + 2] = i, l[B.u0 + 3] = n, l[B.u1 + 0] = t.radius, l[B.u1 + 1] = W(t.dotSize, i, f), l[B.u1 + 2] = t.baseOpacity, l[B.u1 + 3] = p, l[B.u2 + 0] = .15, l[B.u2 + 1] = .85 * t.depthFade, l[B.u2 + 2] = .6, l[B.u2 + 3] = .4, l[B.u3 + 0] = t.parallax, l[B.u3 + 1] = a.push, l[B.u3 + 2] = a.bloom, l[B.u3 + 3] = a.active, l[B.u4 + 0] = a.x, l[B.u4 + 1] = a.y, l[B.u4 + 2] = L, l[B.u4 + 3] = o, l[B.u5 + 0] = I.x, l[B.u5 + 1] = I.y, l[B.u5 + 2] = t.background === "transparent" ? 0 : 1, l[B.u5 + 3] = 0;
+	let m = d(n, t.axisTilt * Math.PI / 180, t.rotationSpeed);
+	l[B.spin0 + 0] = m[0], l[B.spin0 + 1] = m[3], l[B.spin0 + 2] = m[6], l[B.spin0 + 3] = 0, l[B.spin1 + 0] = m[1], l[B.spin1 + 1] = m[4], l[B.spin1 + 2] = m[7], l[B.spin1 + 3] = 0, l[B.spin2 + 0] = m[2], l[B.spin2 + 1] = m[5], l[B.spin2 + 2] = m[8], l[B.spin2 + 3] = 0;
+	let h = Math.min(s.length, 4);
+	if (u[B.ints + 0] = h, u[B.ints + 1] = U(t), u[B.ints + 2] = t.spheres === 2 ? 2 : 1, u[B.ints + 3] = 0, t.background === "transparent") l[B.bg + 0] = 0, l[B.bg + 1] = 0, l[B.bg + 2] = 0, l[B.bg + 3] = 0;
+	else {
+		let e = c(t.background);
+		l[B.bg + 0] = e[0], l[B.bg + 1] = e[1], l[B.bg + 2] = e[2], l[B.bg + 3] = 1;
+	}
+	for (let e = 0; e < 4; e++) {
+		let t = B.palette + e * 4, n = c(s[Math.min(e, h - 1)] ?? s[0]);
+		l[t + 0] = n[0], l[t + 1] = n[1], l[t + 2] = n[2], l[t + 3] = 0;
+	}
+	return e;
+}
+//#endregion
+//#region src/components/custom/dot-matrix/composables/useDotSphere.ts
+var K = 64, q = 128, J = 8, Y = 1, X = 2;
+function Z(e) {
+	return {
+		w: e.width || 1,
+		h: e.height || 1
+	};
+}
+function ee(e) {
+	let { canvas: t, config: n, getPalette: r, pointer: i, shouldContinue: a, onFrame: s } = e;
+	return function(e, c, l) {
+		let d = e.createShaderModule({
+			label: "[DotMatrix] dot-matrix.wgsl",
+			code: k
+		}), f = H(n), p = U(n), m = e.createBuffer({
+			label: "[DotMatrix] dots",
+			size: p * 16,
+			usage: q | J,
+			mappedAtCreation: !0
+		});
+		new Float32Array(m.getMappedRange()).set(f), m.unmap();
+		let h = e.createBuffer({
+			label: "[DotMatrix] render-uniforms",
+			size: V().buffer.byteLength,
+			usage: K | J
+		}), g = e.createBindGroupLayout({
+			label: "[DotMatrix] bgl",
+			entries: [{
+				binding: 0,
+				visibility: Y | X,
+				buffer: { type: "uniform" }
+			}, {
+				binding: 1,
+				visibility: Y,
+				buffer: { type: "read-only-storage" }
+			}]
+		}), _ = e.createRenderPipeline({
+			label: "[DotMatrix] render-pipeline",
+			layout: e.createPipelineLayout({ bindGroupLayouts: [g] }),
+			vertex: {
+				module: d,
+				entryPoint: "vs_main"
+			},
+			fragment: {
+				module: d,
+				entryPoint: "fs_main",
+				targets: [{
+					format: l,
+					blend: {
+						color: {
+							srcFactor: "one",
+							dstFactor: "one-minus-src-alpha",
+							operation: "add"
+						},
+						alpha: {
+							srcFactor: "one",
+							dstFactor: "one-minus-src-alpha",
+							operation: "add"
+						}
+					}
+				}]
+			},
+			primitive: { topology: "triangle-list" }
+		}), v = e.createBindGroup({
+			label: "[DotMatrix] bg",
+			layout: g,
+			entries: [{
+				binding: 0,
+				resource: { buffer: h }
+			}, {
+				binding: 1,
+				resource: { buffer: m }
+			}]
+		}), y = V();
+		function b() {
+			let e = o(), n = t.clientWidth || 320, r = t.clientHeight || 320, i = Math.max(1, Math.round(n * e)), a = Math.max(1, Math.round(r * e));
+			(t.width !== i || t.height !== a) && (t.width = i, t.height = a);
+		}
+		function x(a) {
+			s?.(a);
+			let l = o(), d = u(a, n.breathing, .6);
+			G(y, n, a, Z(t), l, i, d, r()), e.queue.writeBuffer(h, 0, y.buffer);
+			let f = c.getCurrentTexture().createView(), m = e.createCommandEncoder({ label: "[DotMatrix] frame" }), g = m.beginRenderPass({ colorAttachments: [{
+				view: f,
+				clearValue: te(n),
+				loadOp: "clear",
+				storeOp: "store"
+			}] });
+			g.setPipeline(_), g.setBindGroup(0, v), g.draw(6, p, 0, 0), g.end(), e.queue.submit([m.finish()]);
+		}
+		return {
+			frame: x,
+			shouldContinue: a,
+			resize: b,
+			teardown: () => {
+				m.destroy(), h.destroy();
+			}
+		};
+	};
+}
+function te(e) {
+	if (e.background === "transparent") return {
+		r: 0,
+		g: 0,
+		b: 0,
+		a: 0
+	};
+	let t = c(e.background);
+	return {
+		r: t[0],
+		g: t[1],
+		b: t[2],
+		a: 1
+	};
+}
+function Q(e, t, n) {
+	let r = e.createShader(t);
+	if (e.shaderSource(r, n), e.compileShader(r), !e.getShaderParameter(r, e.COMPILE_STATUS)) {
+		let t = e.getShaderInfoLog(r);
+		throw e.deleteShader(r), Error(`[DotMatrix] shader compile failed: ${t}`);
+	}
+	return r;
+}
+function ne(e) {
+	let { canvas: t, config: n, getPalette: r, pointer: i, shouldContinue: a, onFrame: s } = e;
+	return function(e) {
+		let l = Q(e, e.VERTEX_SHADER, A), f = Q(e, e.FRAGMENT_SHADER, j), p = e.createProgram();
+		if (e.attachShader(p, l), e.attachShader(p, f), e.linkProgram(p), !e.getProgramParameter(p, e.LINK_STATUS)) throw Error(`[DotMatrix] link failed: ${e.getProgramInfoLog(p)}`);
+		e.deleteShader(l), e.deleteShader(f);
+		let m = H(n), h = U(n), g = e.createVertexArray();
+		e.bindVertexArray(g);
+		let _ = e.createBuffer();
+		e.bindBuffer(e.ARRAY_BUFFER, _), e.bufferData(e.ARRAY_BUFFER, new Float32Array([
+			-1,
+			-1,
+			1,
+			-1,
+			-1,
+			1,
+			-1,
+			1,
+			1,
+			-1,
+			1,
+			1
+		]), e.STATIC_DRAW);
+		let v = e.getAttribLocation(p, "aCorner");
+		e.enableVertexAttribArray(v), e.vertexAttribPointer(v, 2, e.FLOAT, !1, 0, 0);
+		let y = e.createBuffer();
+		e.bindBuffer(e.ARRAY_BUFFER, y), e.bufferData(e.ARRAY_BUFFER, m, e.STATIC_DRAW);
+		let b = e.getAttribLocation(p, "aDot");
+		e.enableVertexAttribArray(b), e.vertexAttribPointer(b, 4, e.FLOAT, !1, 0, 0), e.vertexAttribDivisor(b, 1), e.bindVertexArray(null);
+		let x = (t) => e.getUniformLocation(p, t), S = x("uU0"), C = x("uU1"), w = x("uU2"), T = x("uU3"), E = x("uU4"), D = x("uU5"), O = x("uSpin"), k = x("uBg"), M = x("uStopCount"), N = x("uPalette[0]");
+		function P() {
+			let n = o(), r = t.clientWidth || 320, i = t.clientHeight || 320, a = Math.max(1, Math.round(r * n)), s = Math.max(1, Math.round(i * n));
+			(t.width !== a || t.height !== s) && (t.width = a, t.height = s), e.viewport(0, 0, t.width, t.height);
+		}
+		function F(a) {
+			s?.(a);
+			let l = o(), f = t.width || 1, m = t.height || 1, _ = Math.min(f, m) || 1, v = f / Math.max(m, 1), y = u(a, n.breathing, .6);
+			if (e.useProgram(p), e.bindVertexArray(g), e.enable(e.BLEND), e.blendFunc(e.ONE, e.ONE_MINUS_SRC_ALPHA), n.background === "transparent") e.clearColor(0, 0, 0, 0);
+			else {
+				let t = c(n.background);
+				e.clearColor(t[0], t[1], t[2], 1);
+			}
+			e.clear(e.COLOR_BUFFER_BIT);
+			let b = n.dotSize * l * 2 / _;
+			e.uniform4f(S, f, m, l, a), e.uniform4f(C, n.radius, b, n.baseOpacity, v), e.uniform4f(w, .15, .85 * n.depthFade, .6, .4), e.uniform4f(T, n.parallax, i.push, i.bloom, i.active), e.uniform4f(E, i.x, i.y, L, y), e.uniform4f(D, I.x, I.y, n.background === "transparent" ? 0 : 1, 0);
+			let x = d(a, n.axisTilt * Math.PI / 180, n.rotationSpeed);
+			e.uniformMatrix3fv(O, !1, [
+				x[0],
+				x[3],
+				x[6],
+				x[1],
+				x[4],
+				x[7],
+				x[2],
+				x[5],
+				x[8]
+			]);
+			let A = r(), j = Math.min(A.length, 4);
+			if (e.uniform1i(M, j), n.background === "transparent") e.uniform4f(k, 0, 0, 0, 0);
+			else {
+				let t = c(n.background);
+				e.uniform4f(k, t[0], t[1], t[2], 1);
+			}
+			let P = new Float32Array(12);
+			for (let e = 0; e < 4; e++) {
+				let t = c(A[Math.min(e, j - 1)] ?? A[0]);
+				P[e * 3 + 0] = t[0], P[e * 3 + 1] = t[1], P[e * 3 + 2] = t[2];
+			}
+			e.uniform3fv(N, P), e.drawArraysInstanced(e.TRIANGLES, 0, 6, h), e.bindVertexArray(null);
+		}
+		return {
+			frame: F,
+			shouldContinue: a,
+			resize: P,
+			teardown: () => {
+				e.deleteProgram(p), e.deleteVertexArray(g), e.deleteBuffer(_), e.deleteBuffer(y);
+			}
+		};
+	};
+}
+//#endregion
+//#region src/components/custom/dot-matrix/composables/useDotMatrix.ts
+function re(e) {
+	return e === "attract" ? -1 : 1;
+}
+function $(e, n) {
+	let { config: r, getPalette: i } = n, a = n.mode ?? "live", o = t({ respectReducedMotion: r.respectReducedMotion }), c = R(), l = null, u = 0;
+	function d(e) {
+		let t = u > 0 ? (e - u) * 1e3 : 16.7;
+		if (u = e, o.tick(t), !r.interactive || !o.active.value) {
+			c.active += (0 - c.active) * .12, c.push *= .9, c.bloom *= .9;
+			return;
+		}
+		let n = o.smoothedPosition.value;
+		c.x = n.x, c.y = n.y, c.active += (1 - c.active) * .2;
+		let i = o.speed.value, a = re(r.pointerMode) * Math.min(.35, .08 + i * .6);
+		c.push += (a - c.push) * .2, c.bloom = Math.max(c.bloom * .9, o.burst.value);
+	}
+	let f = () => {
+		o.onPointerEnter(), r.interactive && l?.wake();
+	}, p = (e) => {
+		o.onPointerMove(e), r.interactive && l?.wake();
+	}, m = (e) => e.parentElement ?? e;
+	function h(e) {
+		let t = m(e);
+		t.addEventListener("pointermove", p), t.addEventListener("pointerenter", f), t.addEventListener("pointerleave", o.onPointerLeave);
+	}
+	function g(e) {
+		let t = m(e);
+		t.removeEventListener("pointermove", p), t.removeEventListener("pointerenter", f), t.removeEventListener("pointerleave", o.onPointerLeave);
+	}
+	let _ = () => {
+		let t = e.value;
+		if (!t) return null;
+		if (!l) {
+			h(t);
+			let e = {
+				canvas: t,
+				config: r,
+				getPalette: i,
+				pointer: c,
+				shouldContinue: () => !0,
+				onFrame: d
+			};
+			l = s(t, {
+				mode: a,
+				respectReducedMotion: r.respectReducedMotion,
+				setupWGPU: ee(e),
+				setupGL: ne(e)
+			}), l.armAsync();
+		}
+		return l;
+	};
+	queueMicrotask(() => _());
+	let v = {
+		get backend() {
+			return _()?.backend ?? "webgpu";
+		},
+		pause: () => _()?.suspend("manual"),
+		resume: () => _()?.resume("manual"),
+		wake: () => _()?.wake(),
+		renderAt: (e) => _()?.renderAt(e),
+		get reducedMotion() {
+			return l?.reducedMotion ?? !1;
+		},
+		dispose: () => {
+			let t = e.value;
+			t && g(t), o.dispose(), l?.dispose();
+		}
+	};
+	return T(() => v.dispose()), v;
+}
+//#endregion
+//#region src/components/custom/dot-matrix/DotMatrix.vue
+var ie = /* @__PURE__ */ e(/* @__PURE__ */ C({
+	__name: "DotMatrix",
+	props: {
+		config: { default: () => F },
+		paused: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	emits: ["update:paused"],
+	setup(e, { expose: t }) {
+		let n = D("canvasRef"), r = $(n, {
+			config: e.config,
+			getPalette: () => e.config.palette
+		});
+		O(() => e.paused, (e) => e ? r.pause() : r.resume(), { immediate: !0 });
+		let i = b(() => {
+			let t = e.config.background;
+			if (t !== "transparent") return `oklch(${t.L} ${t.C} ${t.h})`;
+		});
+		return t({
+			pause: r.pause,
+			resume: r.resume,
+			wake: r.wake,
+			renderAt: r.renderAt
+		}), (e, t) => (E(), x("div", {
+			class: "dot-matrix-wrapper",
+			style: w(i.value ? { background: i.value } : void 0)
+		}, [S("canvas", {
+			ref_key: "canvasRef",
+			ref: n,
+			class: "dot-matrix-canvas",
+			"aria-hidden": "true",
+			"data-testid": "dot-matrix-canvas"
+		}, null, 512)], 4));
+	}
+}), [["__scopeId", "data-v-1f36e34c"]]);
+//#endregion
+export { F as DEFAULT_DOT_MATRIX_CONFIG, ie as DotMatrix, v as FACING_HI, m as FACING_LO, g as GOLDEN_ANGLE, f as GOLDEN_RATIO, M as MAX_DOTS, N as MAX_DOT_STOPS, l as SIZE_TAPER_BASE, h as SIZE_TAPER_GAIN, P as WARM_IDENTITY_PALETTE, _ as applyMat3, u as breathRadius, p as facingFade, y as fibonacciDot, d as spinMatrix, $ as useDotMatrix };

package/dist/dotMatrixField-D_x9_1qq.js

@@ -0,0 +1,48 @@
+//#region src/components/custom/dot-matrix/composables/dotMatrixField.ts
+var e = (1 + Math.sqrt(5)) / 2, t = Math.PI * (3 - Math.sqrt(5));
+function n(e, n) {
+	let r = Math.max(n, 1), i = 1 - 2 * (e + .5) / r, a = Math.sqrt(Math.max(0, 1 - i * i)), o = e * t;
+	return {
+		x: Math.cos(o) * a,
+		y: i,
+		z: Math.sin(o) * a
+	};
+}
+var r = .15, i = .85, a = .6, o = .4;
+function s(e, t = 1) {
+	let n = d(e.z * .5 + .5);
+	return {
+		opacity: r + i * t * n,
+		size: a + o * n,
+		facing: n
+	};
+}
+function c(e, t, n) {
+	let r = n * e, i = Math.sin(t), a = Math.cos(t), o = Math.cos(r), s = Math.sin(r), c = 1 - o;
+	return [
+		o + i * i * c,
+		i * a * c - 0 * s,
+		i * 0 * c + a * s,
+		a * i * c + 0 * s,
+		o + a * a * c,
+		a * 0 * c - i * s,
+		0 * i * c - a * s,
+		0 * a * c + i * s,
+		o + 0 * c
+	];
+}
+function l(e, t) {
+	return {
+		x: e[0] * t.x + e[1] * t.y + e[2] * t.z,
+		y: e[3] * t.x + e[4] * t.y + e[5] * t.z,
+		z: e[6] * t.x + e[7] * t.y + e[8] * t.z
+	};
+}
+function u(e, t, n) {
+	return 1 + t * Math.sin(e * n);
+}
+function d(e) {
+	return e < 0 ? 0 : e > 1 ? 1 : e;
+}
+//#endregion
+export { a, u as c, c as d, e as i, s as l, r as n, o, t as r, l as s, i as t, n as u };