shaders 3.1.462 → 3.2.464

package/dist/core/Flip-tLanxfrx.js

@@ -0,0 +1,40 @@
+import { s as p, t as defineStd } from "./lower-z2vuXP8M.js";
+import { i as transformBoolean } from "./transformations-CoIwF5JU.js";
+import { s as flip } from "./warps-B_sbWWsN.js";
+const componentDefinition = defineStd({
+	name: "Flip",
+	role: "warp",
+	category: "Distortions",
+	description: "Mirror content horizontally, vertically, or both",
+	boundingBoxDeclaration: { aspectRatio: null },
+	props: {
+		flipX: {
+			default: false,
+			transform: transformBoolean,
+			description: "Mirror the content horizontally (left ↔ right)",
+			ui: {
+				type: "checkbox",
+				label: "Flip X",
+				group: "Effect"
+			}
+		},
+		flipY: {
+			default: false,
+			transform: transformBoolean,
+			description: "Mirror the content vertically (top ↔ bottom)",
+			ui: {
+				type: "checkbox",
+				label: "Flip Y",
+				group: "Effect"
+			}
+		}
+	},
+	map: flip({
+		flipX: p("flipX"),
+		flipY: p("flipY")
+	}),
+	edges: "none",
+	missingChildMessage: "You must pass a child component into the Flip shader."
+});
+var Flip_default = componentDefinition;
+export { componentDefinition as n, Flip_default as t };

package/dist/core/FloatingParticles-Bi1Llmwz.js

@@ -0,0 +1,315 @@
+import { $n as vec4f, _r as u32, ar as textureStorage2d, at as call, hr as f32, in as DEG_TO_RAD$1, mn as typegpu_default, or as arrayOf, rr as atomic, sn as PI, sr as struct, t as defineStd } from "./lower-z2vuXP8M.js";
+import { _ as integrator, g as force, m as drift, n as renderAgents, o as expDecay, t as agentSim, y as pointSlot } from "./agents-Ccxns43k.js";
+import { G as makeCpuValueGetter, K as readAgentFrame, V as SIZE_REF_RES, q as resolveRenderRes } from "./porters-B1UjrM1y.js";
+import { b as pointShapeOptions, g as makeUniformScatterInit, w as straightAlphaOver } from "./agents-DbHmHbkU.js";
+import { a as transformColor } from "./transformations-CoIwF5JU.js";
+var MAX_MOTES = 8192;
+var COUNT_MAX_MOBILE = 3e3;
+var RES = resolveRenderRes({
+	desktop: 1024,
+	mobile: 512
+});
+var STATE_FORMAT = "rgba16float";
+var DEG_TO_RAD = DEG_TO_RAD$1;
+var BASE_DRIFT = .12;
+var ORBIT_RAD = .035;
+var ORBIT_RATE = 1.4;
+var TWINKLE_FREQ = 2;
+var CURSOR_FORCE_K = 3.5;
+var CURSOR_DRAG = 1.1;
+var ANGLE_FLIP = PI;
+var SimParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	color: vec4f,
+	count: f32,
+	dt: f32,
+	time: f32,
+	aspect: f32,
+	domainX: f32,
+	driftBase: f32,
+	angleRad: f32,
+	speedVar: f32,
+	angleVarRad: f32,
+	randomness: f32,
+	twinkle: f32,
+	softness: f32,
+	bodyR: f32,
+	cursorX: f32,
+	cursorY: f32,
+	cursorRadSq: f32,
+	cursorForce: f32,
+	dragMul: f32
+}), "SimParams");
+var simLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
+	agents: {
+		storage: arrayOf(vec4f, MAX_MOTES),
+		access: "mutable"
+	},
+	accumE: {
+		storage: arrayOf(atomic(u32), RES * RES),
+		access: "mutable"
+	},
+	params: { uniform: SimParams },
+	outTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
+}), "simLayout");
+const floatingParticlesInitKernel = makeUniformScatterInit(simLayout, "floatingParticlesInit");
+const floatingParticlesUpdateKernel = integrator.drift2d(simLayout, {
+	drift: drift.variedHeading(simLayout),
+	gust: force.cursorGust(simLayout),
+	name: "floatingParticlesUpdate"
+});
+function floatingParticlesRender(shape) {
+	return renderAgents.pointWorld(simLayout, {
+		shape,
+		res: RES,
+		place: pointSlot.orbitalPlace(simLayout, {
+			radius: ORBIT_RAD,
+			rate: ORBIT_RATE
+		}),
+		brightness: pointSlot.twinkleBrightness(simLayout, { freq: TWINKLE_FREQ }),
+		bodyRadius: pointSlot.presenceRadius(simLayout),
+		names: {
+			splat: "floatingParticlesSplat",
+			resolve: "floatingParticlesResolve"
+		}
+	});
+}
+const makeFloatingParticlesSplatKernel = (shape) => floatingParticlesRender(shape).splat.kernel;
+const floatingParticlesSplatKernel = makeFloatingParticlesSplatKernel("dot");
+const floatingParticlesResolveKernel = floatingParticlesRender("dot").resolve.kernel;
+const particleOverChild = straightAlphaOver;
+const componentDefinition = defineStd({
+	name: "FloatingParticles",
+	role: "simulation",
+	species: "custom",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Textures",
+	description: "Drifting, twinkling motes — thousands of real simulated particles floating in a shared heading with per-particle wander and variance, and a cursor that stirs the field with a gust that settles back into the drift",
+	requiresRTT: false,
+	requiresChild: false,
+	usesPointer: true,
+	props: {
+		particleColor: {
+			default: "#ffffff",
+			transform: transformColor,
+			description: "Color of the particles",
+			ui: {
+				type: "color",
+				label: "Particle Color",
+				group: "Colors"
+			}
+		},
+		shape: {
+			default: "dot",
+			compileTime: true,
+			description: "What each particle is drawn as — a crisp dot or square (softness still feathers them), or a soft glow puff",
+			ui: {
+				type: "select",
+				options: pointShapeOptions,
+				label: "Shape",
+				group: "Effect"
+			}
+		},
+		count: {
+			default: 1200,
+			description: "Number of particles",
+			ui: {
+				type: "range",
+				min: 100,
+				max: MAX_MOTES,
+				step: 100,
+				label: "Count",
+				group: "Effect"
+			}
+		},
+		particleSize: {
+			default: 1.2,
+			description: "Size of the particles (each also varies slightly for depth)",
+			ui: {
+				type: ["range", "map"],
+				min: .3,
+				max: 4,
+				step: .05,
+				label: "Particle Size",
+				group: "Effect"
+			}
+		},
+		softness: {
+			default: .1,
+			description: "Edge softness of each particle — 0 is a crisp shape, 1 a soft glow puff",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Softness",
+				group: "Effect"
+			}
+		},
+		speed: {
+			default: .25,
+			description: "Speed of the shared drift",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		angle: {
+			default: 90,
+			description: "Drift heading in degrees (0 = left, 90 = up, 180 = right, 270 = down — the classic default floats upward)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Angle",
+				group: "Animation"
+			}
+		},
+		speedVariance: {
+			default: .3,
+			description: "Per-particle speed variance around the shared drift (0 = everything moves in lockstep)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .05,
+				label: "Speed Variance",
+				group: "Animation"
+			}
+		},
+		angleVariance: {
+			default: 30,
+			description: "Per-particle heading variance in degrees (0 = one shared direction, 180 = every which way)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 180,
+				step: 1,
+				label: "Angle Variance",
+				group: "Animation"
+			}
+		},
+		randomness: {
+			default: .25,
+			description: "Orbital wander — each particle circles lazily around its drift path instead of gliding straight",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .05,
+				label: "Randomness",
+				group: "Animation"
+			}
+		},
+		twinkle: {
+			default: .5,
+			description: "Intensity of the twinkle (0 = steady, 1 = full shimmer)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .05,
+				label: "Twinkle",
+				group: "Animation"
+			}
+		},
+		cursorStrength: {
+			default: 0,
+			description: "How strongly the cursor stirs the field — 0 (default) leaves the drift undisturbed",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Cursor Gust",
+				group: "Interaction"
+			}
+		}
+	},
+	...agentSim({
+		layout: simLayout,
+		params: SimParams,
+		maxAgents: MAX_MOTES,
+		countCap: {
+			desktop: MAX_MOTES,
+			mobile: COUNT_MAX_MOBILE
+		},
+		output: {
+			key: "outTex",
+			name: "particleTexture",
+			size: [RES, RES],
+			format: STATE_FORMAT
+		},
+		bake: ({ getCpuValue }) => {
+			const render = floatingParticlesRender(getCpuValue("shape") || "dot");
+			return {
+				pipelines: {
+					init: {
+						kernel: floatingParticlesInitKernel,
+						threads: "max"
+					},
+					update: {
+						kernel: floatingParticlesUpdateKernel,
+						threads: "agents"
+					},
+					splat: render.splat,
+					resolve: render.resolve
+				},
+				initStep: "init",
+				program: [
+					"update",
+					"splat",
+					"resolve"
+				]
+			};
+		},
+		frame: (sys, { getCpuValue }) => {
+			const g = makeCpuValueGetter(getCpuValue);
+			let localTime = 0;
+			return (frameParams) => {
+				const { dt, aspect, pointerX, pointerY } = readAgentFrame(frameParams);
+				localTime += dt;
+				const domainX = Math.max(aspect, .01);
+				const count = sys.resolveCount(g("count", 1200));
+				const cursorX = pointerX * aspect;
+				const cursorY = pointerY;
+				const cursorRadius = .22;
+				const col = getCpuValue("particleColor");
+				const bodyR = Math.min(Math.max(g("particleSize", 1.2), .3), 4) * 2 / SIZE_REF_RES;
+				sys.writeParams({
+					color: vec4f(col?.x ?? 1, col?.y ?? 1, col?.z ?? 1, col?.w ?? 1),
+					count,
+					dt,
+					time: localTime,
+					aspect,
+					domainX,
+					driftBase: Math.min(Math.max(g("speed", .25), 0), 1.5) * BASE_DRIFT / .25,
+					angleRad: g("angle", 90) * DEG_TO_RAD + ANGLE_FLIP,
+					speedVar: Math.min(Math.max(g("speedVariance", .3), 0), 1),
+					angleVarRad: Math.min(Math.max(g("angleVariance", 30), 0), 180) * DEG_TO_RAD,
+					randomness: Math.min(Math.max(g("randomness", .25), 0), 1),
+					twinkle: Math.min(Math.max(g("twinkle", .5), 0), 1),
+					softness: Math.min(Math.max(g("softness", .1), 0), 1),
+					bodyR,
+					cursorX,
+					cursorY,
+					cursorRadSq: cursorRadius * cursorRadius,
+					cursorForce: Math.min(Math.max(g("cursorStrength", 0), 0), 1) * CURSOR_FORCE_K,
+					dragMul: expDecay(CURSOR_DRAG, dt)
+				});
+				return sys.frame({ count });
+			};
+		},
+		fragment: {
+			output: "particleTexture",
+			fallback: "child",
+			compose: (field, { childNode }) => childNode ? call(particleOverChild, "particleOverChild", [field, childNode]) : field
+		}
+	})
+});
+var FloatingParticles_default = componentDefinition;
+export { floatingParticlesSplatKernel as a, particleOverChild as c, floatingParticlesResolveKernel as i, componentDefinition as n, floatingParticlesUpdateKernel as o, floatingParticlesInitKernel as r, makeFloatingParticlesSplatKernel as s, FloatingParticles_default as t };

package/dist/core/FlowField-DDFjV4AF.js

@@ -0,0 +1,110 @@
+import { s as p, t as defineStd } from "./lower-z2vuXP8M.js";
+import { s as transformEdges } from "./transformations-CoIwF5JU.js";
+import { c as flowNoise } from "./warps-B_sbWWsN.js";
+const componentDefinition = defineStd({
+	name: "FlowField",
+	role: "warp",
+	category: "Distortions",
+	description: "Fluid-like distortion with constant smooth motion",
+	boundingBoxDeclaration: { aspectRatio: null },
+	animatedTime: { speed: "speed" },
+	extraAnimatedTimes: { evolution: "evolutionSpeed" },
+	props: {
+		strength: {
+			default: .15,
+			description: "Intensity of the flow distortion",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: .5,
+				step: .01,
+				label: "Strength",
+				group: "Effect"
+			}
+		},
+		detail: {
+			default: 2,
+			description: "Scale of the flow patterns",
+			ui: {
+				type: ["range", "map"],
+				min: .5,
+				max: 5,
+				step: .1,
+				label: "Detail",
+				group: "Effect"
+			}
+		},
+		speed: {
+			default: 0,
+			description: "Speed of the flow",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 20,
+				step: .1,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		evolutionSpeed: {
+			default: 0,
+			description: "How fast the flow field pattern reshapes over time",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 20,
+				step: .1,
+				label: "Evolution Speed",
+				group: "Animation"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Random seed for flow pattern variation",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Effect"
+			}
+		},
+		edges: {
+			default: "mirror",
+			description: "How to handle edges when distortion pushes content out of bounds",
+			transform: transformEdges,
+			compileTime: true,
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Stretch",
+						value: "stretch"
+					},
+					{
+						label: "Transparent",
+						value: "transparent"
+					},
+					{
+						label: "Mirror",
+						value: "mirror"
+					},
+					{
+						label: "Wrap",
+						value: "wrap"
+					}
+				],
+				label: "Edges",
+				group: "Effect"
+			}
+		}
+	},
+	map: flowNoise({
+		strength: p("strength"),
+		detail: p("detail"),
+		seed: p("seed")
+	})
+});
+var FlowField_default = componentDefinition;
+export { componentDefinition as n, FlowField_default as t };

package/dist/core/Flower-CQgB1K5v.js

@@ -0,0 +1,56 @@
+import { t as defineStd } from "./lower-z2vuXP8M.js";
+import { s as flower } from "./shape-BMO1cLTt.js";
+const componentDefinition = defineStd({
+	role: "shape",
+	name: "Flower",
+	description: "Petal shape with N lobes and adjustable inner-to-outer radius ratio",
+	shape: {
+		distance: ({ x, y }, u) => flower(x, y, u("radius"), u("sides"), u("innerRatio")),
+		colorDescription: "Fill color of the flower",
+		centerDescription: "Center position of the flower",
+		bounds: { size: {
+			width: "radius",
+			height: "radius"
+		} },
+		shapeProps: {
+			radius: {
+				default: .4,
+				description: "Outer petal tip radius in UV space",
+				ui: {
+					type: "range",
+					min: 0,
+					max: 1,
+					step: .01,
+					label: "Radius",
+					group: "Shape"
+				}
+			},
+			sides: {
+				default: 5,
+				description: "Number of petals",
+				ui: {
+					type: "range",
+					min: 3,
+					max: 12,
+					step: 1,
+					label: "Petals",
+					group: "Shape"
+				}
+			},
+			innerRatio: {
+				default: .4,
+				description: "Inner valley radius as a ratio of outer radius — lower values make deeper notches",
+				ui: {
+					type: "range",
+					min: .1,
+					max: .95,
+					step: .01,
+					label: "Inner Ratio",
+					group: "Shape"
+				}
+			}
+		}
+	}
+});
+var Flower_default = componentDefinition;
+export { componentDefinition as n, Flower_default as t };

package/dist/core/FlowingGradient-DExZwWd-.js

@@ -0,0 +1,154 @@
+import { Zn as vec3f, it as asLocal, s as p, t as defineStd } from "./lower-z2vuXP8M.js";
+import { a as foldLighting, i as flowingFactors, u as quadBlend } from "./scenic-CJSExiX2.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CoIwF5JU.js";
+const componentDefinition = defineStd({
+	name: "FlowingGradient",
+	role: "generator",
+	boundingBoxDeclaration: {
+		aspectRatio: null,
+		supportsResizeFit: true
+	},
+	category: "Textures",
+	description: "Liquid silk gradient with organic flowing color bands",
+	acceptsUVContext: true,
+	animatedTime: { speed: "speed" },
+	extraFields: {
+		convA: {
+			schema: vec3f,
+			initial: [
+				0,
+				0,
+				0
+			]
+		},
+		convB: {
+			schema: vec3f,
+			initial: [
+				0,
+				0,
+				0
+			]
+		},
+		convC: {
+			schema: vec3f,
+			initial: [
+				0,
+				0,
+				0
+			]
+		},
+		convD: {
+			schema: vec3f,
+			initial: [
+				0,
+				0,
+				0
+			]
+		}
+	},
+	props: {
+		colorA: {
+			default: "#0a0015",
+			transform: transformColor,
+			description: "Deep background color",
+			ui: {
+				type: "color",
+				label: "Color A",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#6b17e6",
+			transform: transformColor,
+			description: "Primary accent color",
+			ui: {
+				type: "color",
+				label: "Color B",
+				group: "Colors"
+			}
+		},
+		colorC: {
+			default: "#ff4d6a",
+			transform: transformColor,
+			description: "Secondary accent color",
+			ui: {
+				type: "color",
+				label: "Color C",
+				group: "Colors"
+			}
+		},
+		colorD: {
+			default: "#ff6b35",
+			transform: transformColor,
+			description: "Tertiary accent color",
+			ui: {
+				type: "color",
+				label: "Color D",
+				group: "Colors"
+			}
+		},
+		colorSpace: {
+			default: "oklch",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Color space for color interpolation",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Colors"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "Animation speed",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 10,
+				step: .1,
+				label: "Speed",
+				group: "Effect"
+			}
+		},
+		distortion: {
+			default: .5,
+			description: "Organic distortion intensity",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 2,
+				step: .1,
+				label: "Distortion",
+				group: "Effect"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Random seed for variation",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Effect"
+			}
+		}
+	},
+	paint: (params) => {
+		const f = asLocal(flowingFactors({
+			distortion: p("distortion"),
+			seed: p("seed")
+		})(params), "flowFactors");
+		return foldLighting(quadBlend({
+			a: p("colorA"),
+			b: p("colorB"),
+			c: p("colorC"),
+			d: p("colorD"),
+			space: p("colorSpace")
+		})(f.member("x"), f.member("y"), params), f.member("z"));
+	}
+});
+var FlowingGradient_default = componentDefinition;
+export { componentDefinition as n, FlowingGradient_default as t };