From 1e29798c938e8c7d01bbe3231ecb6731f3133fcb Mon Sep 17 00:00:00 2001 From: Deepak Kumar Date: Wed, 8 Apr 2026 17:01:51 +0530 Subject: [PATCH] feat: add Orb component with state-driven flow patterns Adds a 3D WebGL orb with four animation states (idle, attune, pulse, surge), smooth palette transitions, customisable color and speed props, and a NEW-tagged docs page with live demo controls. Co-Authored-By: Claude Sonnet 4.6 --- apps/web/src/lib/config/navigation.ts | 4 + apps/web/src/lib/docs/generated-manifest.ts | 10 + apps/web/src/routes/docs/orb/+page.svx | 99 ++++++ apps/web/src/routes/docs/orb/OrbDemo.svelte | 54 ++++ apps/web/static/registry/components.json | 5 + apps/web/static/registry/registry.json | 37 +++ bun.lock | 2 +- .../motion-core/src/lib/components/index.ts | 2 + .../src/lib/components/orb/Orb.svelte | 60 ++++ .../src/lib/components/orb/OrbScene.svelte | 290 ++++++++++++++++++ .../src/lib/components/orb/component.json | 37 +++ .../src/lib/components/orb/noise.glsl.ts | 29 ++ .../src/lib/components/orb/orb.glsl.ts | 114 +++++++ .../src/lib/components/orb/types.ts | 14 + 14 files changed, 756 insertions(+), 1 deletion(-) create mode 100644 apps/web/src/routes/docs/orb/+page.svx create mode 100644 apps/web/src/routes/docs/orb/OrbDemo.svelte create mode 100644 packages/motion-core/src/lib/components/orb/Orb.svelte create mode 100644 packages/motion-core/src/lib/components/orb/OrbScene.svelte create mode 100644 packages/motion-core/src/lib/components/orb/component.json create mode 100644 packages/motion-core/src/lib/components/orb/noise.glsl.ts create mode 100644 packages/motion-core/src/lib/components/orb/orb.glsl.ts create mode 100644 packages/motion-core/src/lib/components/orb/types.ts diff --git a/apps/web/src/lib/config/navigation.ts b/apps/web/src/lib/config/navigation.ts index a2dafd8..7842c1f 100644 --- a/apps/web/src/lib/config/navigation.ts +++ b/apps/web/src/lib/config/navigation.ts @@ -117,6 +117,10 @@ export const docsNavigation: DocItem[] = [ slug: "neural-noise", name: "Neural Noise", }, + { + slug: "orb", + name: "Orb", + }, { slug: "pixelated-image", name: "Pixelated Image", diff --git a/apps/web/src/lib/docs/generated-manifest.ts b/apps/web/src/lib/docs/generated-manifest.ts index 2f6ab97..5429d63 100644 --- a/apps/web/src/lib/docs/generated-manifest.ts +++ b/apps/web/src/lib/docs/generated-manifest.ts @@ -253,6 +253,16 @@ export const docsManifest: ComponentInfo[] = [ three: "^0.182.0", }, }, + { + slug: "orb", + name: "Orb", + category: "canvas", + introducedAt: "2026-04-08", + dependencies: { + "@threlte/core": "^8.3.1", + three: "^0.182.0", + }, + }, { slug: "pixelated-image", name: "Pixelated Image", diff --git a/apps/web/src/routes/docs/orb/+page.svx b/apps/web/src/routes/docs/orb/+page.svx new file mode 100644 index 0000000..a7d8361 --- /dev/null +++ b/apps/web/src/routes/docs/orb/+page.svx @@ -0,0 +1,99 @@ +--- +name: Orb +description: A 3D animated orb with state-driven flow patterns — idle drift, attune swirl, pulse breathing, surge churn — and smooth palette transitions between states. +--- + + + +## Installation + + + + Run the following command to install the component and its dependencies: + + + + Import the component into your Svelte file: + +```ts +import { Orb } from "$lib/motion-core"; +``` + + + + +## Usage + + + + + +## Props + +### Orb + + + +### OrbState + +| Value | Description | +|-------|-------------| +| `idle` | Gentle meandering drift with a deep purple palette. | +| `attune` | Tangential swirl — colors visibly rotate around the sphere. | +| `pulse` | Radial breathing — colors expand outward and contract back. | +| `surge` | Lissajous orbital churn — rapid multi-axis movement. | diff --git a/apps/web/src/routes/docs/orb/OrbDemo.svelte b/apps/web/src/routes/docs/orb/OrbDemo.svelte new file mode 100644 index 0000000..31a1bfd --- /dev/null +++ b/apps/web/src/routes/docs/orb/OrbDemo.svelte @@ -0,0 +1,54 @@ + + + + +
+
+ {#each states as s (s)} + + {/each} +
+
+ + +
+
diff --git a/apps/web/static/registry/components.json b/apps/web/static/registry/components.json index 3e251dc..2fc5253 100644 --- a/apps/web/static/registry/components.json +++ b/apps/web/static/registry/components.json @@ -53,6 +53,11 @@ "components/marquee/Marquee.svelte": "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", "components/neural-noise/NeuralNoise.svelte": "PHNjcmlwdCBsYW5nPSJ0cyI+CglpbXBvcnQgeyBDYW52YXMgfSBmcm9tICJAdGhyZWx0ZS9jb3JlIjsKCWltcG9ydCBTY2VuZSBmcm9tICIuL05ldXJhbE5vaXNlU2NlbmUuc3ZlbHRlIjsKCWltcG9ydCB7IGNuIH0gZnJvbSAiLi4vdXRpbHMvY24iOwoJaW1wb3J0IHsgTm9Ub25lTWFwcGluZyB9IGZyb20gInRocmVlIjsKCWltcG9ydCB0eXBlIHsgQ29tcG9uZW50UHJvcHMgfSBmcm9tICJzdmVsdGUiOwoKCXR5cGUgU2NlbmVQcm9wcyA9IENvbXBvbmVudFByb3BzPHR5cGVvZiBTY2VuZT47CgoJaW50ZXJmYWNlIFByb3BzIHsKCQkvKioKCQkgKiBBZGRpdGlvbmFsIENTUyBjbGFzc2VzIGZvciB0aGUgY29udGFpbmVyLgoJCSAqLwoJCWNsYXNzPzogc3RyaW5nOwoJCS8qKgoJCSAqIFNwZWVkIG9mIHRoZSBub2lzZSBhbmltYXRpb24uCgkJICogQGRlZmF1bHQgMS4wCgkJICovCgkJc3BlZWQ/OiBTY2VuZVByb3BzWyJzcGVlZCJdOwoJCVtrZXk6IHN0cmluZ106IHVua25vd247Cgl9CgoJbGV0IHsgY2xhc3M6IGNsYXNzTmFtZSA9ICIiLCBzcGVlZCA9IDEuMCwgLi4ucmVzdCB9OiBQcm9wcyA9ICRwcm9wcygpOwoKCWNvbnN0IGRwciA9IHR5cGVvZiB3aW5kb3cgIT09ICJ1bmRlZmluZWQiID8gd2luZG93LmRldmljZVBpeGVsUmF0aW8gOiAxOwo8L3NjcmlwdD4KCjxkaXYgY2xhc3M9e2NuKCJyZWxhdGl2ZSBoLWZ1bGwgdy1mdWxsIG92ZXJmbG93LWhpZGRlbiIsIGNsYXNzTmFtZSl9IHsuLi5yZXN0fT4KCTxkaXYgY2xhc3M9ImFic29sdXRlIGluc2V0LTAgei0wIj4KCQk8Q2FudmFzIHtkcHJ9IHRvbmVNYXBwaW5nPXtOb1RvbmVNYXBwaW5nfT4KCQkJPFNjZW5lIHtzcGVlZH0gLz4KCQk8L0NhbnZhcz4KCTwvZGl2Pgo8L2Rpdj4K", "components/neural-noise/NeuralNoiseScene.svelte": "<script lang="ts">
	import { T, useTask, useThrelte } from "@threlte/core";
	import { Vector2, ShaderMaterial } from "three";

	interface Props {
		/**
		 * Speed of the noise animation.
		 * @default 1.0
		 */
		speed?: number;
	}

	let { speed = 1.0 }: Props = $props();

	let time = 0;
	let material = $state<ShaderMaterial>();
	const { size } = useThrelte();

	const vertexShader = `
    varying vec2 vUv;
    void main() {
      vUv = uv;
      gl_Position = vec4(position, 1.0);
    }
  `;

	const fragmentShader = `
  #ifdef GL_ES
    precision highp float;
  #endif
  uniform float uTime;
  uniform vec2 uResolution;
  varying vec2 vUv;

  vec4 buf[8];

  vec4 sigmoid(vec4 x) {
      return 1. / (1. + exp(-x));
  }

  vec4 cppn_fn(vec2 coordinate, float in0, float in1, float in2) {
      buf[6] = vec4(coordinate.x, coordinate.y, 0.394833 + in0, 0.36 + in1);
      buf[7] = vec4(0.14 + in2, sqrt(coordinate.x * coordinate.x + coordinate.y * coordinate.y), 0., 0.);

      buf[0] = mat4(vec4(6.540426, -3.612603, 0.759088, -1.136130), vec4(2.458271, 3.166036, 0.861174, 1.084861), vec4(-5.767454, -5.380386, 1.645391, -4.774287), vec4(5.528117, -5.542865, -0.909253, 3.251348)) * buf[6] + mat4(vec4(2.061491, -5.722911, 3.975766, 1.313651), vec4(-0.583046, 0.583926, -1.766196, -6.049330), vec4(0.000000, 0.000000, 0.000000, 0.000000), vec4(0.000000, 0.000000, 0.000000, -0.979990)) * buf[7] + vec4(1.253282, 1.124391, -1.796998, 3.539383);
      buf[1] = mat4(vec4(-3.979783, -6.061274, 1.429133, -4.909088), vec4(0.863146, 1.743291, 6.246279, 1.610654), vec4(2.494139, -3.501204, 1.645448, 4.961241), vec4(2.743589, 8.209261, 0.285961, -1.165539)) * buf[6] + mat4(vec4(5.587056, -12.081923, 0.472623, 15.870829), vec4(2.987511, 3.129433, -1.646950, -0.997152), vec4(0.000000, 0.000000, 0.000000, 0.000000), vec4(0.000000, 0.000000, 1.342039, 0.000000)) * buf[7] + vec4(-5.026926, -6.573602, -0.881249, 3.013238);
      buf[0] = sigmoid(buf[0]);
      buf[1] = sigmoid(buf[1]);

      buf[2] = mat4(vec4(-15.219568, 8.095543, -1.079261, -1.938198), vec4(-5.951362, 5.808604, 2.639378, 0.299649), vec4(-7.314523, 7.924815, 4.204860, 5.570548), vec4(5.389631, 8.979051, -1.914519, -0.494928)) * buf[6] + mat4(vec4(-11.967154, -11.608155, 6.991450, 10.966565), vec4(2.070100, -6.263192, -1.705036, -0.667190), vec4(0.523107, -0.459430, 0.000000, 0.000000), vec4(0.284982, 0.000000, 0.000000, 0.000000)) * buf[7] + vec4(-4.171640, -1.932802, -5.524558, -3.640119);
      buf[3] = mat4(vec4(2.365542, -13.738922, 2.498075, 3.233465), vec4(0.643007, 11.925601, 1.914105, 0.599957), vec4(-1.221195, 4.480722, 1.473398, 3.153624), vec4(5.003925, 13.000481, 3.758183, -4.556190)) * buf[6] + mat4(vec4(-0.394945, 7.675101, -3.142568, 5.357695), vec4(0.639362, 3.714393, -0.810838, -0.391749), vec4(-0.464944, 0.000000, 0.000000, 0.000000), vec4(-0.389630, 0.000000, 0.000000, 0.000000)) * buf[7] + vec4(-0.114427, -21.621881, 0.701516, 1.232972);
      buf[2] = sigmoid(buf[2]);
      buf[3] = sigmoid(buf[3]);

      buf[4] = mat4(vec4(5.214916, -7.183024, 1.469022, 2.659262), vec4(-5.601878, -25.359100, 5.252814, -0.655123), vec4(-10.577590, 24.426087, 21.102104, 37.546658), vec4(4.065813, -1.962523, 2.345880, -1.372816)) * buf[0] + mat4(vec4(-17.652600, -10.507558, 2.258741, 13.903974), vec4(7.151527, -502.754430, -12.642513, 1.491614), vec4(-10.983244, 21.518553, -9.701768, -0.763599), vec4(5.383626, 1.481954, -4.191162, -3.894631)) * buf[1] + mat4(vec4(12.664431, -15.129719, 2.151841, 1.795598), vec4(-30.483650, -1.834536, 1.454253, -1.111877), vec4(19.872723, -7.337935, -42.221286, -98.527090), vec4(7.216338, -2.263902, -2.272176, -36.142323)) * buf[2] + mat4(vec4(-16.298317, 3.547200, -0.431612, -9.444417), vec4(57.930017, -34.999026, 14.952836, -4.153475), vec4(-0.074703, -3.865648, -8.190795, 3.152397), vec4(-12.559385, -7.077619, 1.490437, -0.821154)) * buf[3] + vec4(-7.679140, 15.927437, 1.320773, -1.668611);
      buf[5] = mat4(vec4(-2.091698, -0.372762, -3.770383, -21.367174), vec4(-5.697247, -9.359080, 0.925290, 8.825610), vec4(11.100940, -22.348068, 13.625772, -18.693201), vec4(-0.342905, -3.990560, -2.462611, -0.450335)) * buf[0] + mat4(vec4(6.687929, -4.366184, -6.303765, -3.868115), vec4(1.546285, 6.548891, 0.998681, -0.083997), vec4(5.279798, -2.218040, 3.712769, -0.298296), vec4(-5.797390, 10.134961, -2.544084, -5.965605)) * buf[1] + mat4(vec4(-2.513259, -5.240878, -0.942249, -0.162853), vec4(0.203108, 0.537381, 5.827728, -1.302477), vec4(-1.326992, 2.011129, -6.243599, -3.728635), vec4(-13.562562, 9.115861, -0.917375, -3.623510)) * buf[2] + mat4(vec4(-8.645013, 6.554667, -6.261104, -5.593337), vec4(-0.577831, -1.077275, 37.875883, 5.736769), vec4(13.370495, 3.714665, 7.145225, -4.595878), vec4(2.719207, 3.602191, -5.682993, -2.365346)) * buf[3] + vec4(-5.900081, -3.887117, 0.552824, 8.595030);
      buf[4] = sigmoid(buf[4]);
      buf[5] = sigmoid(buf[5]);

      buf[6] = mat4(vec4(-1.611020, 2.387368, 1.467523, 0.209175), vec4(-28.793737, -7.139095, 0.567920, 4.656581), vec4(-10.948610, 39.662380, 0.743185, -10.095605), vec4(-1.494739, -1.548395, 0.730132, 2.168768)) * buf[0] + mat4(vec4(3.254775, 21.489103, -2.064689, -3.310059), vec4(-3.731663, -3.379216, -7.223193, -0.236858), vec4(13.334908, 0.791601, 6.748804, 4.633943), vec4(-5.918355, -17.471011, -5.732809, -1.645197)) * buf[1] + mat4(vec4(0.181934, -7.536463, -7.213122, -4.152557), vec4(-3.522382, -0.123593, -1.281234, 1.253653), vec4(9.745018, -22.853785, 2.062431, 0.099892), vec4(-4.319631, -17.730087, 1.787673, 5.302670)) * buf[2] + mat4(vec4(-6.545563, -15.790176, -7.403832, -5.832917), vec4(-43.591583, 28.551912, -16.001610, 18.847280), vec4(3.016699, 7.739835, 1.979384, 8.657522), vec4(-5.023757, -4.450633, -4.476800, -5.501044)) * buf[3] + mat4(vec4(1.698556, -67.435978, 6.897715, 1.900483), vec4(1.868035, 3.698088, 2.523111, 3.338005), vec4(11.158006, 1.762130, 3.292240, 8.073157), vec4(-4.256034, -306.180312, 8.581904, -18.178676)) * buf[4] + mat4(vec4(1.437698, -4.832095, 3.853480, -6.348217), vec4(1.354331, -1.264004, 9.932754, 3.113412), vec4(-5.294902, -0.949709, 0.128142, 3.326965), vec4(29.735424, -4.918278, 6.104408, 4.350323)) * buf[5] + vec4(7.445287, 12.161633, -3.770339, -4.775214);
      buf[7] = mat4(vec4(-8.265602, -4.702702, 5.098234, 0.606081), vec4(7.655864, -17.159490, 16.519390, -8.884479), vec4(-4.036479, -2.394687, -3.608247, -1.986653), vec4(-2.216774, -1.813565, -5.975987, 4.884645)) * buf[0] + mat4(vec4(5.393409, 3.507655, -2.819113, -2.702897), vec4(-6.749723, -0.278449, 1.495870, -5.051714), vec4(13.122226, 16.734630, -2.939748, -4.101023), vec4(-15.382187, -5.030483, -6.259933, 1.546973)) * buf[1] + mat4(vec4(5.272034, -0.940116, -5.171144, 4.755022), vec4(5.474831, 5.508097, 1.742591, -2.596731), vec4(3.100543, 0.163426, -104.563410, 16.949184), vec4(-5.540225, -2.392001, 3.835010, -1.936425)) * buf[2] + mat4(vec4(-6.321256, 1.794612, -13.604192, -3.806052), vec4(6.658346, 31.911177, 25.164474, 92.172378), vec4(12.297573, 4.150304, -0.731440, 6.768467), vec4(-5.563958, 4.034772, 5.827125, 0.565392)) * buf[3] + mat4(vec4(3.499244, -196.268100, -9.777457, 2.814263), vec4(3.480650, -3.184635, 5.443009, 5.180422), vec4(-2.858783, 15.585794, 1.286396, 2.025228), vec4(-71.252710, -62.441242, -9.509550, 0.506703)) * buf[4] + mat4(vec4(-12.229053, -10.800056, -7.347415, 4.390294), vec4(10.782412, 5.633738, 0.281580, -4.734872), vec4(-13.422884, -7.039391, 5.862442, 6.936266), vec4(-0.016766, 8.918980, 2.978114, 5.150952)) * buf[5] + vec4(2.241527, -6.705987, -0.988610, -3.351508);
      buf[6] = sigmoid(buf[6]);
      buf[7] = sigmoid(buf[7]);

      buf[0] = mat4(vec4(1.679426, 1.381747, 2.962545, 0.000000), vec4(-1.883441, -1.480694, -3.592452, 0.276962), vec4(-1.750944, -1.091806, -2.313352, 0.000000), vec4(0.266223, 1.434674, 0.441785, 0.000000)) * buf[0] + mat4(vec4(-0.629910, -1.612272, -0.770600, 0.000000), vec4(0.178290, 0.183002, 1.512083, 0.000000), vec4(-2.965440, -2.581994, -4.900105, 0.000000), vec4(0.855587, 1.186808, 2.517632, 0.000000)) * buf[1] + mat4(vec4(-1.258437, -1.055216, -2.168840, -0.780865), vec4(-0.720022, -0.526660, -1.438251, 0.000000), vec4(0.153453, 0.151961, 0.272854, -0.783078), vec4(1.587162, 0.886194, 0.363603, 0.000000)) * buf[2] + mat4(vec4(-1.559180, -0.711704, -4.351660, 0.012176), vec4(-22.641187, -18.831468, -41.954372, 0.000000), vec4(0.637920, 0.547065, 2.189343, -1.299702), vec4(-1.548989, -1.307593, -1.193073, 0.000000)) * buf[3] + mat4(vec4(-0.492521, 0.552633, -1.561702, 1.183937), vec4(0.956093, 0.221101, 1.640221, 1.199880), vec4(-1.056071, -2.664828, 0.863986, 0.000000), vec4(1.182598, 0.650587, 3.406331, 0.000000)) * buf[4] + mat4(vec4(0.354467, 0.329379, -0.537564, 1.214906), vec4(0.918448, -0.481778, -1.061483, -1.274231), vec4(2.796453, 1.000196, 4.684665, 0.000000), vec4(0.130426, 1.112316, 1.408710, 0.000000)) * buf[5] + mat4(vec4(-0.834081, -1.403319, -4.104067, 0.000000), vec4(3.166436, 2.638297, 4.957615, 0.831465), vec4(-3.172471, -3.204905, -5.549295, 0.320019), vec4(-1.903405, -2.249092, -5.301307, 0.000000)) * buf[6] + mat4(vec4(1.520384, -1.100839, 4.315299, 0.785230), vec4(1.521056, 1.265135, 2.683903, 0.000000), vec4(2.978947, 2.379847, 5.234726, 0.000000), vec4(2.227042, 1.575676, 3.802864, 0.879809)) * buf[7] + vec4(-2.903960, -3.617148, 1.865247, 0.000000);
      buf[0] = sigmoid(buf[0]);

      return vec4(buf[0].xyz, 1.0);
  }

  void main() {
    vec2 uv = vUv * 2.0 - 1.0;
    uv.y *= -1.0;

    vec4 color = cppn_fn(uv, 0.1 * sin(0.3 * uTime), 0.1 * sin(0.69 * uTime), 0.1 * sin(0.44 * uTime));

    gl_FragColor = vec4(color.rgb, 1.0);
  }
  `;

	useTask((delta) => {
		time += delta * speed;
		if (material) {
			material.uniforms.uTime.value = time;
			material.uniforms.uResolution.value.set($size.width, $size.height);
		}
	});
</script>

<T.Mesh>
	<T.PlaneGeometry args={[2, 2]} />
	<T.ShaderMaterial
		bind:ref={material}
		{vertexShader}
		{fragmentShader}
		transparent
		uniforms={{
			uTime: { value: 0 },
			uResolution: { value: new Vector2(1, 1) },
		}}
	/>
</T.Mesh>
", + "components/orb/Orb.svelte": "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", + "components/orb/OrbScene.svelte": "<script lang="ts">
	import { T, useTask, useThrelte } from "@threlte/core";
	import { Color, ShaderMaterial, Mesh, Vector3 } from "three";
	import { orbVertex, orbFragment } from "./orb.glsl";
	import type { OrbState, StateConfig } from "./types";

	interface Props {
		/**
		 * Current animation state of the orb.
		 * @default "idle"
		 */
		orbState?: OrbState;
		/**
		 * Audio amplitude in [0, 1] that drives reactive pulse.
		 * @default 0
		 */
		amplitude?: number;
		/**
		 * Base color for the orb palette and rim glow. The full 5-color palette
		 * is derived from this hue using HSL variations.
		 * @default "#6933ff"
		 */
		color?: string;
		/**
		 * Speed multiplier applied to the entire animation. 1 is default, 2 is double speed.
		 * @default 1
		 */
		speed?: number;
	}

	let { orbState = "idle", amplitude = 0, color = "#6933ff", speed = 1 }: Props = $props();

	const idlePalette: StateConfig["palette"] = [
		[0.04, 0.01, 0.25],
		[0.92, 0.42, 0.5],
		[0.22, 0.04, 0.5],
		[0.88, 0.58, 0.48],
		[0.1, 0.04, 0.45],
	];

	const STATES: Record<OrbState, StateConfig> = {
		idle: {
			palette: idlePalette,
			fresnelColor: [0.55, 0.3, 0.82],
			fresnelStrength: 0.8,
			noiseSpeed: 0.5,
			flowDrift: 1,
			flowOut: 0,
			flowIn: 0,
			flowPulse: 0,
			flowSwirl: 0,
			basePulse: 0,
		},
		attune: {
			palette: idlePalette,
			fresnelColor: [0.55, 0.3, 0.82],
			fresnelStrength: 1.1,
			noiseSpeed: 0.9,
			flowDrift: 0,
			flowOut: 0,
			flowIn: 1.6,
			flowPulse: 0,
			flowSwirl: 0,
			basePulse: 0.01,
		},
		pulse: {
			palette: idlePalette,
			fresnelColor: [0.55, 0.3, 0.82],
			fresnelStrength: 1.3,
			noiseSpeed: 0.8,
			flowDrift: 0,
			flowOut: 0,
			flowIn: 0,
			flowPulse: 1,
			flowSwirl: 0,
			basePulse: 0.01,
		},
		surge: {
			palette: idlePalette,
			fresnelColor: [0.55, 0.3, 0.82],
			fresnelStrength: 1.2,
			noiseSpeed: 2.0,
			flowDrift: 0,
			flowOut: 0,
			flowIn: 0,
			flowPulse: 0,
			flowSwirl: 1.5,
			basePulse: 0.03,
		},
	};

	const LERP_KEYS: (keyof StateConfig)[] = [
		"noiseSpeed",
		"fresnelStrength",
		"flowDrift",
		"flowOut",
		"flowIn",
		"flowPulse",
		"flowSwirl",
	];

	// Material refs — updated by useTask
	let orbMaterial = $state<ShaderMaterial>();
	let orbMesh = $state<Mesh>();

	// Pre-allocated Color objects for palette derivation (reused each frame)
	const _base = new Color();
	const _hsl = { h: 0, s: 0, l: 0 };
	const _pal = Array.from({ length: 5 }, () => new Color());
	const _fresnel = new Color();

	function applyCustomColor(hex: string, u: Record<string, { value: unknown }>) {
		_base.set(hex);
		_base.getHSL(_hsl);
		const { h, s } = _hsl;

		// Derive 5 harmonious palette entries from the base hue
		_pal[0].setHSL(h, Math.min(s * 1.2, 1), 0.08);           // very dark
		_pal[1].setHSL((h + 0.05) % 1, s * 0.85, 0.65);          // bright, slight shift
		_pal[2].setHSL(h, Math.min(s * 1.1, 1), 0.22);            // mid
		_pal[3].setHSL((h + 0.08) % 1, s * 0.65, 0.72);          // light, more shift
		_pal[4].setHSL(h, s * 0.9, 0.14);                         // deep

		for (let i = 0; i < 5; i++) {
			const c = _pal[i];
			(u[`uPalA${i}`].value as Vector3).set(c.r, c.g, c.b);
			(u[`uPalB${i}`].value as Vector3).set(c.r, c.g, c.b);
		}
		u.uPaletteBlend.value = 0;

		// Fresnel: brighter, saturated version of the base hue
		_fresnel.setHSL(h, Math.min(s * 1.3, 1), 0.68);
		(u.uFresnelColor.value as Vector3).set(_fresnel.r, _fresnel.g, _fresnel.b);
	}

	// Transition mutable state (not reactive — mutated in task)
	let elapsed = 0;
	let smoothAmp = 0;
	let currentOrbState: OrbState = "idle";
	let transitionProgress = 1;
	let snapScalars: Partial<Record<keyof StateConfig, number>> = {};
	let snapFresnel = [0.55, 0.3, 0.82];
	let targetConfig: StateConfig = STATES.idle;

	const initCfg = STATES.idle;

	// Uniform initial values (passed once; updated imperatively via ref)
	const orbUniforms = {
		uTime: { value: 0 },
		uLightPos: { value: new Vector3(-2.5, 1.0, 3.0) },
		uAmplitude: { value: 0 },
		uNoiseSpeed: { value: initCfg.noiseSpeed },
		uFlowDrift: { value: initCfg.flowDrift },
		uFlowOut: { value: 0 },
		uFlowIn: { value: 0 },
		uFlowPulse: { value: 0 },
		uFlowSwirl: { value: 0 },
		uFresnelColor: { value: new Vector3(...initCfg.fresnelColor) },
		uFresnelStrength: { value: initCfg.fresnelStrength },
		uPaletteBlend: { value: 0 },
		uPalA0: { value: new Vector3(...initCfg.palette[0]) },
		uPalA1: { value: new Vector3(...initCfg.palette[1]) },
		uPalA2: { value: new Vector3(...initCfg.palette[2]) },
		uPalA3: { value: new Vector3(...initCfg.palette[3]) },
		uPalA4: { value: new Vector3(...initCfg.palette[4]) },
		uPalB0: { value: new Vector3(...initCfg.palette[0]) },
		uPalB1: { value: new Vector3(...initCfg.palette[1]) },
		uPalB2: { value: new Vector3(...initCfg.palette[2]) },
		uPalB3: { value: new Vector3(...initCfg.palette[3]) },
		uPalB4: { value: new Vector3(...initCfg.palette[4]) },
	};

	function lerp(a: number, b: number, t: number) {
		return a + (b - a) * t;
	}

	function startTransition(newOrbState: OrbState) {
		if (!orbMaterial) return;
		const u = orbMaterial.uniforms;

		// Snapshot palette A from current blended position
		if (transitionProgress < 1) {
			const b = transitionProgress;
			for (let i = 0; i < 5; i++) {
				const a = u[`uPalA${i}`].value as Vector3;
				const bv = u[`uPalB${i}`].value as Vector3;
				a.lerpVectors(a.clone(), bv, b);
			}
		} else {
			for (let i = 0; i < 5; i++) {
				(u[`uPalA${i}`].value as Vector3).copy(u[`uPalB${i}`].value as Vector3);
			}
		}

		const cfg = STATES[newOrbState];
		for (let i = 0; i < 5; i++) {
			(u[`uPalB${i}`].value as Vector3).set(...cfg.palette[i]);
		}

		// Snapshot current scalar uniform values
		snapScalars = {};
		for (const k of LERP_KEYS) {
			const uKey = `u${k[0].toUpperCase()}${k.slice(1)}`;
			snapScalars[k] = u[uKey].value as number;
		}
		const fc = u.uFresnelColor.value as Vector3;
		snapFresnel = [fc.x, fc.y, fc.z];

		targetConfig = cfg;
		currentOrbState = newOrbState;
		transitionProgress = 0;
	}

	const { scene } = useThrelte();
	scene.background = null;

	useTask((delta) => {
		if (!orbMaterial || !orbMesh) return;

		elapsed += delta * speed;
		const u = orbMaterial.uniforms;

		if (orbState !== currentOrbState) startTransition(orbState);

		// Advance transition
		if (transitionProgress < 1) {
			transitionProgress = Math.min(1, transitionProgress + delta / 0.4);
			const ease = transitionProgress * (2 - transitionProgress);
			u.uPaletteBlend.value = ease;

			for (const k of LERP_KEYS) {
				const uKey = `u${k[0].toUpperCase()}${k.slice(1)}`;
				u[uKey].value = lerp(
					snapScalars[k] ?? (targetConfig[k] as number),
					targetConfig[k] as number,
					ease,
				);
			}

			const fc = u.uFresnelColor.value as Vector3;
			fc.set(
				lerp(snapFresnel[0], targetConfig.fresnelColor[0], ease),
				lerp(snapFresnel[1], targetConfig.fresnelColor[1], ease),
				lerp(snapFresnel[2], targetConfig.fresnelColor[2], ease),
			);
		}

		// Smooth amplitude: fast attack, slow release
		const rising = amplitude > smoothAmp;
		smoothAmp += (amplitude - smoothAmp) * Math.min(1, delta * (rising ? 14 : 4));

		u.uTime.value = elapsed;
		u.uAmplitude.value = smoothAmp;

		// Color override: derive full palette + fresnel from user-provided color
		if (color) applyCustomColor(color, u);

		// Gentle breathing
		const basePulse = STATES[currentOrbState].basePulse;
		orbMesh.scale.setScalar(1 + basePulse * Math.sin(elapsed * 2.5) * 0.5);
		orbMesh.rotation.y = elapsed * 0.12;
	});
</script>

<T.PerspectiveCamera makeDefault fov={50} near={0.1} far={100} position={[0, 0, 4]} />

<T.Mesh bind:ref={orbMesh}>
	<T.SphereGeometry args={[0.75, 128, 128]} />
	<T.ShaderMaterial
		bind:ref={orbMaterial}
		vertexShader={orbVertex}
		fragmentShader={orbFragment}
		uniforms={orbUniforms}
	/>
</T.Mesh>
", + "components/orb/orb.glsl.ts": "aW1wb3J0IHsgc2ltcGxleDNEIH0gZnJvbSAiLi9ub2lzZS5nbHNsIjsKCmV4cG9ydCBjb25zdCBvcmJWZXJ0ZXggPSBgCiAgdmFyeWluZyB2ZWMzIHZOb3JtYWwsIHZPYmpQb3MsIHZXb3JsZFBvczsKICB2b2lkIG1haW4oKXsKICAgIHZOb3JtYWwgPSBub3JtYWxpemUobm9ybWFsTWF0cml4ICogbm9ybWFsKTsKICAgIHZPYmpQb3MgPSBwb3NpdGlvbjsKICAgIHZXb3JsZFBvcyA9IChtb2RlbE1hdHJpeCAqIHZlYzQocG9zaXRpb24sMS4wKSkueHl6OwogICAgZ2xfUG9zaXRpb24gPSBwcm9qZWN0aW9uTWF0cml4ICogbW9kZWxWaWV3TWF0cml4ICogdmVjNChwb3NpdGlvbiwxLjApOwogIH0KYDsKCmV4cG9ydCBjb25zdCBvcmJGcmFnbWVudCA9IGAKICB1bmlmb3JtIGZsb2F0IHVUaW1lOwogIHVuaWZvcm0gdmVjMyB1TGlnaHRQb3M7CiAgdW5pZm9ybSBmbG9hdCB1QW1wbGl0dWRlOwogIHVuaWZvcm0gZmxvYXQgdU5vaXNlU3BlZWQ7CiAgdW5pZm9ybSB2ZWMzIHVGcmVzbmVsQ29sb3I7CiAgdW5pZm9ybSBmbG9hdCB1RnJlc25lbFN0cmVuZ3RoOwoKICB1bmlmb3JtIGZsb2F0IHVGbG93RHJpZnQ7CiAgdW5pZm9ybSBmbG9hdCB1Rmxvd091dDsKICB1bmlmb3JtIGZsb2F0IHVGbG93SW47CiAgdW5pZm9ybSBmbG9hdCB1Rmxvd1B1bHNlOwogIHVuaWZvcm0gZmxvYXQgdUZsb3dTd2lybDsKCiAgdW5pZm9ybSB2ZWMzIHVQYWxBMCwgdVBhbEExLCB1UGFsQTIsIHVQYWxBMywgdVBhbEE0OwogIHVuaWZvcm0gdmVjMyB1UGFsQjAsIHVQYWxCMSwgdVBhbEIyLCB1UGFsQjMsIHVQYWxCNDsKICB1bmlmb3JtIGZsb2F0IHVQYWxldHRlQmxlbmQ7CgogIHZhcnlpbmcgdmVjMyB2Tm9ybWFsLCB2T2JqUG9zLCB2V29ybGRQb3M7CgogICR7c2ltcGxleDNEfQoKICB2ZWMzIHBhbGV0dGVNaXgodmVjMyBjMCwgdmVjMyBjMSwgdmVjMyBjMiwgdmVjMyBjMywgdmVjMyBjNCwgZmxvYXQgbjEsIGZsb2F0IG4yLCBmbG9hdCBuMywgZmxvYXQgbjQpewogICAgdmVjMyBjID0gbWl4KGMwLCBjMSwgc21vb3Roc3RlcCguMTUsIC42NSwgbjEpKTsKICAgIGMgPSBtaXgoYywgYzIsIHNtb290aHN0ZXAoLjIsIC41NSwgbjIpKTsKICAgIGMgPSBtaXgoYywgYzMsIHNtb290aHN0ZXAoLjQsIC43NSwgbjMpICogLjYpOwogICAgYyA9IG1peChjLCBjNCwgc21vb3Roc3RlcCguMSwgLjQsIG40KSAqIC40KTsKICAgIHJldHVybiBjOwogIH0KCiAgdm9pZCBtYWluKCl7CiAgICB2ZWMzIE4gPSBub3JtYWxpemUodk5vcm1hbCk7CiAgICB2ZWMzIFYgPSBub3JtYWxpemUoY2FtZXJhUG9zaXRpb24gLSB2V29ybGRQb3MpOwogICAgdmVjMyBMID0gbm9ybWFsaXplKHVMaWdodFBvcyAtIHZXb3JsZFBvcyk7CgogICAgZmxvYXQgdCA9IHVUaW1lICogdU5vaXNlU3BlZWQ7CiAgICB2ZWMzIHJhZGlhbCA9IG5vcm1hbGl6ZSh2T2JqUG9zICsgdmVjMygwLjAwMSkpOwogICAgdmVjMyB0YW5nZW50ID0gbm9ybWFsaXplKGNyb3NzKHJhZGlhbCwgdmVjMygwLjAsIDEuMCwgMC4wMDEpKSk7CgogICAgZmxvYXQgYXVkaW9BY3RpdmUgPSB1Rmxvd091dCArIHVGbG93SW4gKyB1Rmxvd1B1bHNlOwoKICAgIHZlYzMgcCA9IHZPYmpQb3MgKiAxLjI7CgogICAgLy8gSWRsZTogZ2VudGxlIG1lYW5kZXJpbmcKICAgIHAgKz0gdmVjMyhzaW4odCowLjMpKjAuMTUsIHNpbih0KjAuMikqMC4yLCBjb3ModCowLjI1KSowLjE1KSAqIHVGbG93RHJpZnQ7CgogICAgLy8gRGljdGF0aW9uOiBzdHJvbmcgdmVydGljYWwgc2xpZGUKICAgIHAgKz0gdmVjMygwLjAsIHNpbih0ICogMS44KSAqIDAuNSArIHNpbih0ICogMi45KSAqIDAuMTUsIDAuMCkgKiB1Rmxvd091dDsKICAgIHAgKz0gdmVjMyhzaW4odCAqIDAuNCkgKiAwLjA4LCAwLjAsIGNvcyh0ICogMC4zKSAqIDAuMDgpICogdUZsb3dPdXQ7CgogICAgLy8gTGlzdGVuaW5nOiB0YW5nZW50aWFsIHN3aXJsIOKAlCBjb2xvcnMgdmlzaWJseSByb3RhdGUgYXJvdW5kIHRoZSBzcGhlcmUKICAgIHAgKz0gdGFuZ2VudCAqIHNpbih0ICogMS4yKSAqIDAuNSAqIHVGbG93SW47CiAgICBwICs9IGNyb3NzKHRhbmdlbnQsIHJhZGlhbCkgKiBjb3ModCAqIDAuOCkgKiAwLjMgKiB1Rmxvd0luOwogICAgcCAtPSByYWRpYWwgKiBzaW4odCAqIDEuNikgKiAwLjE1ICogdUZsb3dJbjsKCiAgICAvLyBUYWxraW5nOiByYWRpYWwgYnJlYXRoaW5nIOKAlCBjb2xvcnMgZXhwYW5kIG91dHdhcmQgYW5kIGNvbnRyYWN0IGJhY2sKICAgIHAgKz0gcmFkaWFsICogc2luKHQgKiAyLjApICogMC41NSAqIHVGbG93UHVsc2U7CiAgICBwICs9IHJhZGlhbCAqIHNpbih0ICogMy4zKSAqIDAuMiAqIHVGbG93UHVsc2U7CgogICAgLy8gV29ya2luZzogbGlzc2Fqb3VzIG9yYml0YWwgY2h1cm4KICAgIHAgKz0gdmVjMyhzaW4odCoxLjMpKjAuMzUsIGNvcyh0KjAuOSkqMC4zLCBzaW4odCoxLjcpKjAuMzUpICogdUZsb3dTd2lybDsKICAgIHAgKz0gdGFuZ2VudCAqIHNpbih0KjIuMCkgKiAwLjI1ICogdUZsb3dTd2lybDsKCiAgICBmbG9hdCB3YXJwQW10ID0gMC40ICogKDEuMCAtIGF1ZGlvQWN0aXZlICogMC41KTsKICAgIHZlYzMgd2FycDEgPSB2ZWMzKAogICAgICBzbm9pc2UocCArIHZlYzMoMC4wLCB0ICogMC4xMiwgMC4wKSksCiAgICAgIHNub2lzZShwICsgdmVjMyg1LjIsIHQgKiAwLjEwLCAxLjMpKSwKICAgICAgc25vaXNlKHAgKyB2ZWMzKDEuNywgMy40LCB0ICogMC4xNCkpCiAgICApOwogICAgcCArPSB3YXJwMSAqIHdhcnBBbXQ7CgogICAgdmVjMyB3YXJwMiA9IHZlYzMoCiAgICAgIHNub2lzZShwICogMC44ICsgdmVjMyh0ICogMC4wOCwgMC4wLCAzLjEpKSwKICAgICAgc25vaXNlKHAgKiAwLjggKyB2ZWMzKDguMywgdCAqIDAuMDcsIDAuMCkpLAogICAgICBzbm9pc2UocCAqIDAuOCArIHZlYzMoMC4wLCAyLjgsIHQgKiAwLjA5KSkKICAgICk7CiAgICB2ZWMzIGZjID0gcCArIHdhcnAyICogMC4xNTsKCiAgICBmbG9hdCBucyA9IDEuMCArIGF1ZGlvQWN0aXZlICogMC42OwogICAgZmxvYXQgbjEgPSBzbm9pc2UoZmMgKiAwLjcgKiBucykgKiAwLjUgKyAwLjU7CiAgICBmbG9hdCBuMiA9IHNub2lzZShmYyAqIDAuOSAqIG5zICsgdmVjMygzLjcsIDEuMiwgNC4xKSkgKiAwLjUgKyAwLjU7CiAgICBmbG9hdCBuMyA9IHNub2lzZShmYyAqIDAuNiAqIG5zICsgdmVjMyg3LjEsIDguMywgMi45KSkgKiAwLjUgKyAwLjU7CiAgICBmbG9hdCBuNCA9IHNub2lzZShmYyAqIDEuMSAqIG5zICsgdmVjMygyLjMsIDUuMSwgMC43KSkgKiAwLjUgKyAwLjU7CgogICAgdmVjMyBjb2xBID0gcGFsZXR0ZU1peCh1UGFsQTAsIHVQYWxBMSwgdVBhbEEyLCB1UGFsQTMsIHVQYWxBNCwgbjEsIG4yLCBuMywgbjQpOwogICAgdmVjMyBjb2xCID0gcGFsZXR0ZU1peCh1UGFsQjAsIHVQYWxCMSwgdVBhbEIyLCB1UGFsQjMsIHVQYWxCNCwgbjEsIG4yLCBuMywgbjQpOwogICAgdmVjMyBjb2wgPSBtaXgoY29sQSwgY29sQiwgdVBhbGV0dGVCbGVuZCk7CgogICAgZmxvYXQgZGlmZiA9IG1heChkb3QoTiwgTCksIDAuMCkgKiAwLjUgKyAwLjU7CiAgICB2ZWMzIEggPSBub3JtYWxpemUoTCArIFYpOwogICAgZmxvYXQgc3BlYyA9IHBvdyhtYXgoZG90KE4sIEgpLCAwLjApLCA0OC4wKSAqIDAuNDsKCiAgICB2ZWMzIGZDb2wgPSB1RnJlc25lbENvbG9yOwogICAgZmxvYXQgZlN0ciA9IHVGcmVzbmVsU3RyZW5ndGg7CiAgICBjb2wgPSBtaXgoY29sLCBmQ29sLCBwb3coMS4wIC0gbWF4KGRvdChOLCBWKSwgMC4wKSwgMi41KSAqIDAuMTggKiBmU3RyKTsKCiAgICB2ZWMzIGZpbiA9IGNvbCAqIGRpZmYgKyB2ZWMzKDEuMCkgKiBzcGVjICsgZkNvbCAqIHBvdygxLjAgLSBtYXgoZG90KE4sIFYpLCAwLjApLCAzLjApICogMC4zNSAqIGZTdHI7CiAgICBmaW4gKz0gZkNvbCAqIHBvdygxLjAgLSBtYXgoZG90KE4sIFYpLCAwLjApLCAzLjApICogMC4xMiAqIGZTdHI7CgogICAgZ2xfRnJhZ0NvbG9yID0gdmVjNChmaW4sIDEuMCk7CiAgfQpgOwoK", + "components/orb/noise.glsl.ts": "ZXhwb3J0IGNvbnN0IHNpbXBsZXgzRCA9IGAKICB2ZWM0IHBlcm11dGUodmVjNCB4KXtyZXR1cm4gbW9kKCgoeCozNC4wKSsxLjApKngsMjg5LjApO30KICB2ZWM0IHRheWxvckludlNxcnQodmVjNCByKXtyZXR1cm4gMS43OTI4NDI5MTQwMDE1OS0wLjg1MzczNDcyMDk1MzE0KnI7fQogIGZsb2F0IHNub2lzZSh2ZWMzIHYpewogICAgY29uc3QgdmVjMiBDPXZlYzIoMS4wLzYuMCwxLjAvMy4wKTsgY29uc3QgdmVjNCBEPXZlYzQoMC4wLDAuNSwxLjAsMi4wKTsKICAgIHZlYzMgaT1mbG9vcih2K2RvdCh2LEMueXl5KSk7IHZlYzMgeDA9di1pK2RvdChpLEMueHh4KTsKICAgIHZlYzMgZz1zdGVwKHgwLnl6eCx4MC54eXopOyB2ZWMzIGw9MS4wLWc7CiAgICB2ZWMzIGkxPW1pbihnLnh5eixsLnp4eSk7IHZlYzMgaTI9bWF4KGcueHl6LGwuenh5KTsKICAgIHZlYzMgeDE9eDAtaTErQy54eHg7IHZlYzMgeDI9eDAtaTIrQy55eXk7IHZlYzMgeDM9eDAtRC55eXk7CiAgICBpPW1vZChpLDI4OS4wKTsKICAgIHZlYzQgcD1wZXJtdXRlKHBlcm11dGUocGVybXV0ZShpLnordmVjNCgwLjAsaTEueixpMi56LDEuMCkpK2kueSt2ZWM0KDAuMCxpMS55LGkyLnksMS4wKSkraS54K3ZlYzQoMC4wLGkxLngsaTIueCwxLjApKTsKICAgIGZsb2F0IG5fPTEuMC83LjA7IHZlYzMgbnM9bl8qRC53eXotRC54eng7CiAgICB2ZWM0IGo9cC00OS4wKmZsb29yKHAqbnMueipucy56KTsKICAgIHZlYzQgeF89Zmxvb3Ioaipucy56KTsgdmVjNCB5Xz1mbG9vcihqLTcuMCp4Xyk7CiAgICB2ZWM0IHg9eF8qbnMueCtucy55eXl5OyB2ZWM0IHk9eV8qbnMueCtucy55eXl5OwogICAgdmVjNCBoPTEuMC1hYnMoeCktYWJzKHkpOwogICAgdmVjNCBiMD12ZWM0KHgueHkseS54eSk7IHZlYzQgYjE9dmVjNCh4Lnp3LHkuencpOwogICAgdmVjNCBzMD1mbG9vcihiMCkqMi4wKzEuMDsgdmVjNCBzMT1mbG9vcihiMSkqMi4wKzEuMDsKICAgIHZlYzQgc2g9LXN0ZXAoaCx2ZWM0KDAuMCkpOwogICAgdmVjNCBhMD1iMC54enl3K3MwLnh6eXcqc2gueHh5eTsgdmVjNCBhMT1iMS54enl3K3MxLnh6eXcqc2guenp3dzsKICAgIHZlYzMgcDA9dmVjMyhhMC54eSxoLngpOyB2ZWMzIHAxPXZlYzMoYTAuencsaC55KTsKICAgIHZlYzMgcDI9dmVjMyhhMS54eSxoLnopOyB2ZWMzIHAzPXZlYzMoYTEuencsaC53KTsKICAgIHZlYzQgbm9ybT10YXlsb3JJbnZTcXJ0KHZlYzQoZG90KHAwLHAwKSxkb3QocDEscDEpLGRvdChwMixwMiksZG90KHAzLHAzKSkpOwogICAgcDAqPW5vcm0ueDtwMSo9bm9ybS55O3AyKj1ub3JtLno7cDMqPW5vcm0udzsKICAgIHZlYzQgbT1tYXgoMC42LXZlYzQoZG90KHgwLHgwKSxkb3QoeDEseDEpLGRvdCh4Mix4MiksZG90KHgzLHgzKSksMC4wKTsKICAgIG09bSptOwogICAgcmV0dXJuIDQyLjAqZG90KG0qbSx2ZWM0KGRvdChwMCx4MCksZG90KHAxLHgxKSxkb3QocDIseDIpLGRvdChwMyx4MykpKTsKICB9CmA7Cg==", + "components/orb/types.ts": "ZXhwb3J0IHR5cGUgT3JiU3RhdGUgPSAiaWRsZSIgfCAiYXR0dW5lIiB8ICJwdWxzZSIgfCAic3VyZ2UiOwoKZXhwb3J0IHR5cGUgU3RhdGVDb25maWcgPSB7CglwYWxldHRlOiBbbnVtYmVyW10sIG51bWJlcltdLCBudW1iZXJbXSwgbnVtYmVyW10sIG51bWJlcltdXTsKCWZyZXNuZWxDb2xvcjogW251bWJlciwgbnVtYmVyLCBudW1iZXJdOwoJZnJlc25lbFN0cmVuZ3RoOiBudW1iZXI7Cglub2lzZVNwZWVkOiBudW1iZXI7CglmbG93RHJpZnQ6IG51bWJlcjsKCWZsb3dPdXQ6IG51bWJlcjsKCWZsb3dJbjogbnVtYmVyOwoJZmxvd1B1bHNlOiBudW1iZXI7CglmbG93U3dpcmw6IG51bWJlcjsKCWJhc2VQdWxzZTogbnVtYmVyOwp9Owo=", "components/pixelated-image/PixelatedImage.svelte": "PHNjcmlwdCBsYW5nPSJ0cyI+CglpbXBvcnQgeyBDYW52YXMgfSBmcm9tICJAdGhyZWx0ZS9jb3JlIjsKCWltcG9ydCBTY2VuZSBmcm9tICIuL1BpeGVsYXRlZEltYWdlU2NlbmUuc3ZlbHRlIjsKCWltcG9ydCB7IGNuIH0gZnJvbSAiLi4vdXRpbHMvY24iOwoJaW1wb3J0IHsgTm9Ub25lTWFwcGluZyB9IGZyb20gInRocmVlIjsKCWltcG9ydCB0eXBlIHsgQ29tcG9uZW50UHJvcHMgfSBmcm9tICJzdmVsdGUiOwoKCXR5cGUgU2NlbmVQcm9wcyA9IENvbXBvbmVudFByb3BzPHR5cGVvZiBTY2VuZT47CgoJaW50ZXJmYWNlIFByb3BzIHsKCQkvKioKCQkgKiBUaGUgaW1hZ2Ugc291cmNlIFVSTC4KCQkgKi8KCQlzcmM6IFNjZW5lUHJvcHNbImltYWdlIl07CgkJLyoqCgkJICogQWRkaXRpb25hbCBDU1MgY2xhc3NlcyBmb3IgdGhlIGNvbnRhaW5lci4KCQkgKi8KCQljbGFzcz86IHN0cmluZzsKCQkvKioKCQkgKiBJbml0aWFsIGdyaWQgc2l6ZSBmb3IgdGhlIHBpeGVsYXRpb24gZWZmZWN0LgoJCSAqIEBkZWZhdWx0IDYuMAoJCSAqLwoJCWluaXRpYWxHcmlkU2l6ZT86IFNjZW5lUHJvcHNbImluaXRpYWxHcmlkU2l6ZSJdOwoJCS8qKgoJCSAqIER1cmF0aW9uIG9mIGVhY2ggc3RlcCBpbiB0aGUgZGVwaXhlbGF0aW9uIGFuaW1hdGlvbi4KCQkgKiBAZGVmYXVsdCAwLjE1CgkJICovCgkJc3RlcER1cmF0aW9uPzogU2NlbmVQcm9wc1sic3RlcER1cmF0aW9uIl07CgkJW2tleTogc3RyaW5nXTogdW5rbm93bjsKCX0KCglsZXQgewoJCXNyYywKCQljbGFzczogY2xhc3NOYW1lID0gIiIsCgkJaW5pdGlhbEdyaWRTaXplID0gNi4wLAoJCXN0ZXBEdXJhdGlvbiA9IDAuMTUsCgkJLi4ucmVzdAoJfTogUHJvcHMgPSAkcHJvcHMoKTsKCgljb25zdCBkcHIgPSB0eXBlb2Ygd2luZG93ICE9PSAidW5kZWZpbmVkIiA/IHdpbmRvdy5kZXZpY2VQaXhlbFJhdGlvIDogMTsKPC9zY3JpcHQ+Cgo8ZGl2IGNsYXNzPXtjbigicmVsYXRpdmUgaC1mdWxsIHctZnVsbCBvdmVyZmxvdy1oaWRkZW4iLCBjbGFzc05hbWUpfSB7Li4ucmVzdH0+Cgk8ZGl2IGNsYXNzPSJhYnNvbHV0ZSBpbnNldC0wIHotMCI+CgkJPENhbnZhcyB7ZHByfSB0b25lTWFwcGluZz17Tm9Ub25lTWFwcGluZ30+CgkJCTxTY2VuZSBpbWFnZT17c3JjfSB7aW5pdGlhbEdyaWRTaXplfSB7c3RlcER1cmF0aW9ufSAvPgoJCTwvQ2FudmFzPgoJPC9kaXY+CjwvZGl2Pgo=", "components/pixelated-image/PixelatedImageScene.svelte": "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", "components/plasma-grid/PlasmaGrid.svelte": "PHNjcmlwdCBsYW5nPSJ0cyI+CglpbXBvcnQgeyBDYW52YXMgfSBmcm9tICJAdGhyZWx0ZS9jb3JlIjsKCWltcG9ydCBTY2VuZSBmcm9tICIuL1BsYXNtYUdyaWRTY2VuZS5zdmVsdGUiOwoJaW1wb3J0IHsgY24gfSBmcm9tICIuLi91dGlscy9jbiI7CglpbXBvcnQgeyBOb1RvbmVNYXBwaW5nIH0gZnJvbSAidGhyZWUiOwoJaW1wb3J0IHR5cGUgeyBDb21wb25lbnRQcm9wcyB9IGZyb20gInN2ZWx0ZSI7CgoJdHlwZSBTY2VuZVByb3BzID0gQ29tcG9uZW50UHJvcHM8dHlwZW9mIFNjZW5lPjsKCglpbnRlcmZhY2UgUHJvcHMgewoJCS8qKgoJCSAqIFRoZSBiYXNlIGJhY2tncm91bmQgY29sb3Igb2YgdGhlIGVmZmVjdC4KCQkgKiBAZGVmYXVsdCAiIzExMTExMyIKCQkgKi8KCQljb2xvcj86IFNjZW5lUHJvcHNbImNvbG9yIl07CgkJLyoqCgkJICogVGhlIGNvbG9yIHVzZWQgZm9yIHRoZSBwbGFzbWEgbm9pc2UgZ3JhZGllbnRzLgoJCSAqIEBkZWZhdWx0ICIjRkY2OTAwIgoJCSAqLwoJCWhpZ2hsaWdodENvbG9yPzogU2NlbmVQcm9wc1siaGlnaGxpZ2h0Q29sb3IiXTsKCQkvKioKCQkgKiBBZGRpdGlvbmFsIENTUyBjbGFzc2VzIGZvciB0aGUgY29udGFpbmVyLgoJCSAqLwoJCWNsYXNzPzogc3RyaW5nOwoJCVtrZXk6IHN0cmluZ106IHVua25vd247Cgl9CgoJbGV0IHsKCQljb2xvciwKCQloaWdobGlnaHRDb2xvciwKCQljbGFzczogY2xhc3NOYW1lID0gIiIsCgkJLi4ucmVzdAoJfTogUHJvcHMgPSAkcHJvcHMoKTsKCgljb25zdCBkcHIgPSB0eXBlb2Ygd2luZG93ICE9PSAidW5kZWZpbmVkIiA/IHdpbmRvdy5kZXZpY2VQaXhlbFJhdGlvIDogMTsKPC9zY3JpcHQ+Cgo8ZGl2IGNsYXNzPXtjbigicmVsYXRpdmUgaC1mdWxsIHctZnVsbCBvdmVyZmxvdy1oaWRkZW4iLCBjbGFzc05hbWUpfSB7Li4ucmVzdH0+Cgk8ZGl2IGNsYXNzPSJhYnNvbHV0ZSBpbnNldC0wIHotMCI+CgkJPENhbnZhcyB7ZHByfSB0b25lTWFwcGluZz17Tm9Ub25lTWFwcGluZ30+CgkJCTxTY2VuZSB7Y29sb3J9IHtoaWdobGlnaHRDb2xvcn0gLz4KCQk8L0NhbnZhcz4KCTwvZGl2Pgo8L2Rpdj4K", diff --git a/apps/web/static/registry/registry.json b/apps/web/static/registry/registry.json index 5040638..53fde9f 100644 --- a/apps/web/static/registry/registry.json +++ b/apps/web/static/registry/registry.json @@ -751,6 +751,43 @@ } ] }, + "orb": { + "slug": "orb", + "name": "Orb", + "description": "A 3D animated orb with state-driven flow patterns — idle drift, attune swirl, pulse breathing, surge churn — and smooth palette transitions between states.", + "category": "canvas", + "dependencies": { + "@threlte/core": "^8.3.1", + "three": "^0.182.0" + }, + "devDependencies": { + "@types/three": "^0.182.0" + }, + "internalDependencies": [], + "files": [ + { + "path": "components/orb/Orb.svelte", + "kind": "entry" + }, + { + "path": "components/orb/OrbScene.svelte" + }, + { + "path": "components/orb/orb.glsl.ts" + }, + { + "path": "components/orb/noise.glsl.ts" + }, + { + "path": "components/orb/types.ts", + "typeExports": ["OrbState"] + }, + { + "path": "utils/cn.ts", + "target": "utils" + } + ] + }, "pixelated-image": { "slug": "pixelated-image", "name": "Pixelated Image", diff --git a/bun.lock b/bun.lock index ea33fdf..91a405a 100644 --- a/bun.lock +++ b/bun.lock @@ -69,7 +69,7 @@ }, "packages/motion-core": { "name": "motion-core", - "version": "0.7.0", + "version": "0.10.0", "dependencies": { "clsx": "^2.1.1", "tailwind-merge": "^3.4.0", diff --git a/packages/motion-core/src/lib/components/index.ts b/packages/motion-core/src/lib/components/index.ts index 3569b20..eac6cb5 100644 --- a/packages/motion-core/src/lib/components/index.ts +++ b/packages/motion-core/src/lib/components/index.ts @@ -43,3 +43,5 @@ export { default as VideoPlayer } from "./video-player/VideoPlayer.svelte"; export { default as GodRays } from "./god-rays/GodRays.svelte"; export { default as SpecularBand } from "./specular-band/SpecularBand.svelte"; export { default as Halo } from "./halo/Halo.svelte"; +export { default as Orb } from "./orb/Orb.svelte"; +export type { OrbState } from "./orb/types"; diff --git a/packages/motion-core/src/lib/components/orb/Orb.svelte b/packages/motion-core/src/lib/components/orb/Orb.svelte new file mode 100644 index 0000000..4719055 --- /dev/null +++ b/packages/motion-core/src/lib/components/orb/Orb.svelte @@ -0,0 +1,60 @@ + + +
+
+ + + +
+
diff --git a/packages/motion-core/src/lib/components/orb/OrbScene.svelte b/packages/motion-core/src/lib/components/orb/OrbScene.svelte new file mode 100644 index 0000000..051487e --- /dev/null +++ b/packages/motion-core/src/lib/components/orb/OrbScene.svelte @@ -0,0 +1,290 @@ + + + + + + + + diff --git a/packages/motion-core/src/lib/components/orb/component.json b/packages/motion-core/src/lib/components/orb/component.json new file mode 100644 index 0000000..62f3609 --- /dev/null +++ b/packages/motion-core/src/lib/components/orb/component.json @@ -0,0 +1,37 @@ +{ + "name": "Orb", + "slug": "orb", + "description": "A 3D animated orb with state-driven flow patterns — idle drift, attune swirl, pulse breathing, surge churn — and smooth palette transitions between states.", + "category": "canvas", + "dependencies": { + "@threlte/core": "^8.3.1", + "three": "^0.182.0" + }, + "devDependencies": { + "@types/three": "^0.182.0" + }, + "internalDependencies": [], + "files": [ + { + "path": "Orb.svelte", + "kind": "entry" + }, + { + "path": "OrbScene.svelte" + }, + { + "path": "orb.glsl.ts" + }, + { + "path": "noise.glsl.ts" + }, + { + "path": "types.ts", + "typeExports": ["OrbState"] + }, + { + "path": "../../utils/cn.ts", + "target": "utils" + } + ] +} diff --git a/packages/motion-core/src/lib/components/orb/noise.glsl.ts b/packages/motion-core/src/lib/components/orb/noise.glsl.ts new file mode 100644 index 0000000..5aa43ae --- /dev/null +++ b/packages/motion-core/src/lib/components/orb/noise.glsl.ts @@ -0,0 +1,29 @@ +export const simplex3D = ` + vec4 permute(vec4 x){return mod(((x*34.0)+1.0)*x,289.0);} + vec4 taylorInvSqrt(vec4 r){return 1.79284291400159-0.85373472095314*r;} + float snoise(vec3 v){ + const vec2 C=vec2(1.0/6.0,1.0/3.0); const vec4 D=vec4(0.0,0.5,1.0,2.0); + vec3 i=floor(v+dot(v,C.yyy)); vec3 x0=v-i+dot(i,C.xxx); + vec3 g=step(x0.yzx,x0.xyz); vec3 l=1.0-g; + vec3 i1=min(g.xyz,l.zxy); vec3 i2=max(g.xyz,l.zxy); + vec3 x1=x0-i1+C.xxx; vec3 x2=x0-i2+C.yyy; vec3 x3=x0-D.yyy; + i=mod(i,289.0); + vec4 p=permute(permute(permute(i.z+vec4(0.0,i1.z,i2.z,1.0))+i.y+vec4(0.0,i1.y,i2.y,1.0))+i.x+vec4(0.0,i1.x,i2.x,1.0)); + float n_=1.0/7.0; vec3 ns=n_*D.wyz-D.xzx; + vec4 j=p-49.0*floor(p*ns.z*ns.z); + vec4 x_=floor(j*ns.z); vec4 y_=floor(j-7.0*x_); + vec4 x=x_*ns.x+ns.yyyy; vec4 y=y_*ns.x+ns.yyyy; + vec4 h=1.0-abs(x)-abs(y); + vec4 b0=vec4(x.xy,y.xy); vec4 b1=vec4(x.zw,y.zw); + vec4 s0=floor(b0)*2.0+1.0; vec4 s1=floor(b1)*2.0+1.0; + vec4 sh=-step(h,vec4(0.0)); + vec4 a0=b0.xzyw+s0.xzyw*sh.xxyy; vec4 a1=b1.xzyw+s1.xzyw*sh.zzww; + vec3 p0=vec3(a0.xy,h.x); vec3 p1=vec3(a0.zw,h.y); + vec3 p2=vec3(a1.xy,h.z); vec3 p3=vec3(a1.zw,h.w); + vec4 norm=taylorInvSqrt(vec4(dot(p0,p0),dot(p1,p1),dot(p2,p2),dot(p3,p3))); + p0*=norm.x;p1*=norm.y;p2*=norm.z;p3*=norm.w; + vec4 m=max(0.6-vec4(dot(x0,x0),dot(x1,x1),dot(x2,x2),dot(x3,x3)),0.0); + m=m*m; + return 42.0*dot(m*m,vec4(dot(p0,x0),dot(p1,x1),dot(p2,x2),dot(p3,x3))); + } +`; diff --git a/packages/motion-core/src/lib/components/orb/orb.glsl.ts b/packages/motion-core/src/lib/components/orb/orb.glsl.ts new file mode 100644 index 0000000..43cdab4 --- /dev/null +++ b/packages/motion-core/src/lib/components/orb/orb.glsl.ts @@ -0,0 +1,114 @@ +import { simplex3D } from "./noise.glsl"; + +export const orbVertex = ` + varying vec3 vNormal, vObjPos, vWorldPos; + void main(){ + vNormal = normalize(normalMatrix * normal); + vObjPos = position; + vWorldPos = (modelMatrix * vec4(position,1.0)).xyz; + gl_Position = projectionMatrix * modelViewMatrix * vec4(position,1.0); + } +`; + +export const orbFragment = ` + uniform float uTime; + uniform vec3 uLightPos; + uniform float uAmplitude; + uniform float uNoiseSpeed; + uniform vec3 uFresnelColor; + uniform float uFresnelStrength; + + uniform float uFlowDrift; + uniform float uFlowOut; + uniform float uFlowIn; + uniform float uFlowPulse; + uniform float uFlowSwirl; + + uniform vec3 uPalA0, uPalA1, uPalA2, uPalA3, uPalA4; + uniform vec3 uPalB0, uPalB1, uPalB2, uPalB3, uPalB4; + uniform float uPaletteBlend; + + varying vec3 vNormal, vObjPos, vWorldPos; + + ${simplex3D} + + vec3 paletteMix(vec3 c0, vec3 c1, vec3 c2, vec3 c3, vec3 c4, float n1, float n2, float n3, float n4){ + vec3 c = mix(c0, c1, smoothstep(.15, .65, n1)); + c = mix(c, c2, smoothstep(.2, .55, n2)); + c = mix(c, c3, smoothstep(.4, .75, n3) * .6); + c = mix(c, c4, smoothstep(.1, .4, n4) * .4); + return c; + } + + void main(){ + vec3 N = normalize(vNormal); + vec3 V = normalize(cameraPosition - vWorldPos); + vec3 L = normalize(uLightPos - vWorldPos); + + float t = uTime * uNoiseSpeed; + vec3 radial = normalize(vObjPos + vec3(0.001)); + vec3 tangent = normalize(cross(radial, vec3(0.0, 1.0, 0.001))); + + float audioActive = uFlowOut + uFlowIn + uFlowPulse; + + vec3 p = vObjPos * 1.2; + + // Idle: gentle meandering + p += vec3(sin(t*0.3)*0.15, sin(t*0.2)*0.2, cos(t*0.25)*0.15) * uFlowDrift; + + // Dictation: strong vertical slide + p += vec3(0.0, sin(t * 1.8) * 0.5 + sin(t * 2.9) * 0.15, 0.0) * uFlowOut; + p += vec3(sin(t * 0.4) * 0.08, 0.0, cos(t * 0.3) * 0.08) * uFlowOut; + + // Listening: tangential swirl — colors visibly rotate around the sphere + p += tangent * sin(t * 1.2) * 0.5 * uFlowIn; + p += cross(tangent, radial) * cos(t * 0.8) * 0.3 * uFlowIn; + p -= radial * sin(t * 1.6) * 0.15 * uFlowIn; + + // Talking: radial breathing — colors expand outward and contract back + p += radial * sin(t * 2.0) * 0.55 * uFlowPulse; + p += radial * sin(t * 3.3) * 0.2 * uFlowPulse; + + // Working: lissajous orbital churn + p += vec3(sin(t*1.3)*0.35, cos(t*0.9)*0.3, sin(t*1.7)*0.35) * uFlowSwirl; + p += tangent * sin(t*2.0) * 0.25 * uFlowSwirl; + + float warpAmt = 0.4 * (1.0 - audioActive * 0.5); + vec3 warp1 = vec3( + snoise(p + vec3(0.0, t * 0.12, 0.0)), + snoise(p + vec3(5.2, t * 0.10, 1.3)), + snoise(p + vec3(1.7, 3.4, t * 0.14)) + ); + p += warp1 * warpAmt; + + vec3 warp2 = vec3( + snoise(p * 0.8 + vec3(t * 0.08, 0.0, 3.1)), + snoise(p * 0.8 + vec3(8.3, t * 0.07, 0.0)), + snoise(p * 0.8 + vec3(0.0, 2.8, t * 0.09)) + ); + vec3 fc = p + warp2 * 0.15; + + float ns = 1.0 + audioActive * 0.6; + float n1 = snoise(fc * 0.7 * ns) * 0.5 + 0.5; + float n2 = snoise(fc * 0.9 * ns + vec3(3.7, 1.2, 4.1)) * 0.5 + 0.5; + float n3 = snoise(fc * 0.6 * ns + vec3(7.1, 8.3, 2.9)) * 0.5 + 0.5; + float n4 = snoise(fc * 1.1 * ns + vec3(2.3, 5.1, 0.7)) * 0.5 + 0.5; + + vec3 colA = paletteMix(uPalA0, uPalA1, uPalA2, uPalA3, uPalA4, n1, n2, n3, n4); + vec3 colB = paletteMix(uPalB0, uPalB1, uPalB2, uPalB3, uPalB4, n1, n2, n3, n4); + vec3 col = mix(colA, colB, uPaletteBlend); + + float diff = max(dot(N, L), 0.0) * 0.5 + 0.5; + vec3 H = normalize(L + V); + float spec = pow(max(dot(N, H), 0.0), 48.0) * 0.4; + + vec3 fCol = uFresnelColor; + float fStr = uFresnelStrength; + col = mix(col, fCol, pow(1.0 - max(dot(N, V), 0.0), 2.5) * 0.18 * fStr); + + vec3 fin = col * diff + vec3(1.0) * spec + fCol * pow(1.0 - max(dot(N, V), 0.0), 3.0) * 0.35 * fStr; + fin += fCol * pow(1.0 - max(dot(N, V), 0.0), 3.0) * 0.12 * fStr; + + gl_FragColor = vec4(fin, 1.0); + } +`; diff --git a/packages/motion-core/src/lib/components/orb/types.ts b/packages/motion-core/src/lib/components/orb/types.ts new file mode 100644 index 0000000..c75f183 --- /dev/null +++ b/packages/motion-core/src/lib/components/orb/types.ts @@ -0,0 +1,14 @@ +export type OrbState = "idle" | "attune" | "pulse" | "surge"; + +export type StateConfig = { + palette: [number[], number[], number[], number[], number[]]; + fresnelColor: [number, number, number]; + fresnelStrength: number; + noiseSpeed: number; + flowDrift: number; + flowOut: number; + flowIn: number; + flowPulse: number; + flowSwirl: number; + basePulse: number; +};