shaders 3.1.463 → 3.2.464

package/dist/core/Repeater-DTpCf9Lm.js

@@ -0,0 +1,762 @@
+import { Cr as __export, Tt as unpremultiplyAlpha, at as call, ct as expr, ft as Expr, nt as ZERO, pt as formatFloat$1, s as p, t as defineStd } from "./lower-z2vuXP8M.js";
+import { i as transformBoolean } from "./transformations-CoIwF5JU.js";
+import { n as crosses } from "./slots-BqeQDVxy.js";
+var instanceParts_exports = /* @__PURE__ */ __export({
+	accumulateInstances: () => accumulateInstances,
+	formatFloat: () => formatFloat$1,
+	gridPlacement: () => gridPlacement,
+	instanceHueShift: () => instanceHueShift,
+	instanceVariation: () => instanceVariation,
+	linePlacement: () => linePlacement,
+	placementField: () => placementField,
+	radialPlacement: () => radialPlacement,
+	sourceRect: () => sourceRect
+});
+var PI = Math.PI;
+function sourceRect(f, src, crop) {
+	const { p: p$1, L } = f;
+	return [
+		`let ${p$1}_cropL = ${crop.left};`,
+		`let ${p$1}_cropR = ${crop.right};`,
+		`let ${p$1}_cropT = ${crop.top};`,
+		`let ${p$1}_cropB = ${crop.bottom};`,
+		`let ${p$1}_srcCx = (${src.cx}) + (${p$1}_cropL - ${p$1}_cropR) * (${src.hw});`,
+		`let ${p$1}_srcCy = (${src.cy}) + (${p$1}_cropT - ${p$1}_cropB) * (${src.hh});`,
+		`let ${p$1}_srcHw = max((${src.hw}) * (1.0 - ${p$1}_cropL - ${p$1}_cropR), ${L(1e-6)});`,
+		`let ${p$1}_srcHh = max((${src.hh}) * (1.0 - ${p$1}_cropT - ${p$1}_cropB), ${L(1e-6)});`,
+		`let ${p$1}_srcHwSq = ${p$1}_srcHw * ${p$1}_aspect;`,
+		`let ${p$1}_srcHhSq = ${p$1}_srcHh;`
+	];
+}
+function placementField(f, own) {
+	const { p: p$1, L } = f;
+	return [
+		`let ${p$1}_fieldCenterSq = vec2f((${own.cx}) * ${p$1}_aspect, ${own.cy});`,
+		`let ${p$1}_fieldHwSq = max((${own.hw}) * ${p$1}_aspect, ${L(1e-6)});`,
+		`let ${p$1}_fieldHh = max(${own.hh}, ${L(1e-6)});`
+	];
+}
+function gridPlacement(slots, flipMode) {
+	return {
+		requested: () => `(${slots.columns} * ${slots.rows})`,
+		body: (f) => {
+			const { p: p$1, L } = f;
+			const out = [
+				`let ${p$1}_cols = ${slots.columns};`,
+				`let ${p$1}_rows = ${slots.rows};`,
+				`let ${p$1}_col = ${p$1}_j - ${p$1}_cols * floor(${p$1}_j / ${p$1}_cols);`,
+				`let ${p$1}_row = floor(${p$1}_j / ${p$1}_cols);`,
+				`let ${p$1}_gapXSq = ${slots.gapX} * ${p$1}_aspect;`,
+				`let ${p$1}_gapY = ${slots.gapY};`,
+				`let ${p$1}_fieldW = ${p$1}_fieldHwSq * 2.0;`,
+				`let ${p$1}_fieldH = ${p$1}_fieldHh * 2.0;`,
+				`let ${p$1}_pitchX = (${p$1}_fieldW - ${p$1}_gapXSq * (${p$1}_cols - 1.0)) / ${p$1}_cols;`,
+				`let ${p$1}_pitchY = (${p$1}_fieldH - ${p$1}_gapY * (${p$1}_rows - 1.0)) / ${p$1}_rows;`,
+				`let ${p$1}_periodX = ${p$1}_pitchX + ${p$1}_gapXSq;`,
+				`let ${p$1}_periodY = ${p$1}_pitchY + ${p$1}_gapY;`,
+				`${p$1}_cellFitInv = max(${p$1}_srcHwSq * 2.0 / max(${p$1}_pitchX, ${L(1e-5)}), ${p$1}_srcHhSq * 2.0 / max(${p$1}_pitchY, ${L(1e-5)}));`,
+				`let ${p$1}_rowMod2 = ${p$1}_row - 2.0 * floor(${p$1}_row / 2.0);`,
+				`let ${p$1}_staggerOff = ${p$1}_rowMod2 * ${slots.stagger} * ${p$1}_periodX;`,
+				`let ${p$1}_cxArg = ${p$1}_col * ${p$1}_periodX + ${p$1}_staggerOff + ${p$1}_phase * ${p$1}_periodX;`,
+				`let ${p$1}_cxMod = ${p$1}_periodX * ${p$1}_cols;`,
+				`let ${p$1}_cellX = ${p$1}_cxArg - ${p$1}_cxMod * floor(${p$1}_cxArg / ${p$1}_cxMod);`,
+				`let ${p$1}_cyArg = ${p$1}_row * ${p$1}_periodY + ${p$1}_phase * ${p$1}_periodY;`,
+				`let ${p$1}_cyMod = ${p$1}_periodY * ${p$1}_rows;`,
+				`let ${p$1}_cellY = ${p$1}_cyArg - ${p$1}_cyMod * floor(${p$1}_cyArg / ${p$1}_cyMod);`,
+				`${p$1}_pos = vec2f(${p$1}_fieldCenterSq.x - ${p$1}_fieldW * 0.5 + ${p$1}_pitchX * 0.5 + ${p$1}_cellX, ${p$1}_fieldCenterSq.y - ${p$1}_fieldH * 0.5 + ${p$1}_pitchY * 0.5 + ${p$1}_cellY);`
+			];
+			if (flipMode === 1 || flipMode === 3) out.push(`${p$1}_flipX = 1.0 - (${p$1}_col - 2.0 * floor(${p$1}_col / 2.0)) * 2.0;`);
+			if (flipMode === 2 || flipMode === 3) out.push(`${p$1}_flipY = 1.0 - (${p$1}_row - 2.0 * floor(${p$1}_row / 2.0)) * 2.0;`);
+			return out;
+		}
+	};
+}
+function radialPlacement(anchorSq, slots) {
+	return {
+		requested: () => slots.count,
+		body: (f) => {
+			const { p: p$1, L } = f;
+			return [
+				`let ${p$1}_cSq = ${anchorSq};`,
+				`let ${p$1}_sweep = ${slots.sweep} * ${L(PI / 180)};`,
+				`let ${p$1}_start = ${slots.startAngle} * ${L(PI / 180)};`,
+				`let ${p$1}_ang = ${p$1}_start + ${p$1}_sweep * (${p$1}_j / ${p$1}_totalN) + ${p$1}_phase * ${p$1}_sweep;`,
+				`${p$1}_pos = ${p$1}_cSq + vec2f(cos(${p$1}_ang), sin(${p$1}_ang)) * ${slots.radius};`,
+				`${p$1}_layoutRot = select(0.0, ${p$1}_ang + ${L(PI / 2)}, ${slots.faceCenter} > 0.0);`
+			];
+		}
+	};
+}
+function linePlacement(anchorSq, slots) {
+	return {
+		requested: () => slots.count,
+		body: (f) => {
+			const { p: p$1, L } = f;
+			return [
+				`let ${p$1}_cSq = ${anchorSq};`,
+				`let ${p$1}_dirRad = ${slots.direction} * ${L(PI / 180)};`,
+				`let ${p$1}_dir = vec2f(cos(${p$1}_dirRad), sin(${p$1}_dirRad));`,
+				`let ${p$1}_tArg = ${p$1}_j + ${p$1}_phase;`,
+				`let ${p$1}_t = ${p$1}_tArg - ${p$1}_totalN * floor(${p$1}_tArg / ${p$1}_totalN);`,
+				`${p$1}_pos = ${p$1}_cSq + ${p$1}_dir * ${slots.spacing} * ${p$1}_t;`
+			];
+		}
+	};
+}
+function instanceVariation(f, slots) {
+	const { p: p$1, L } = f;
+	const hash = (off) => `fract(sin((${p$1}_hashBase + ${L(off)}) * 78.233) * 43758.5453)`;
+	return [
+		`let ${p$1}_hashBase = ${p$1}_j + ${p$1}_seed * 7.0;`,
+		`let ${p$1}_h1 = ${hash(.123)};`,
+		`let ${p$1}_h2 = ${hash(5.456)};`,
+		`let ${p$1}_h3 = ${hash(9.789)};`,
+		`let ${p$1}_h4 = ${hash(13.21)};`,
+		`let ${p$1}_h5 = ${hash(17.65)};`,
+		`let ${p$1}_scale = max(pow(${slots.scale}, ${p$1}_j) * (1.0 + ${slots.jitterScale} * (${p$1}_h3 - 0.5)), ${L(1e-4)});`,
+		`let ${p$1}_rot = ${p$1}_layoutRot + ${slots.rotation} * ${p$1}_j + ${slots.jitterRotation} * (${p$1}_h4 - 0.5) * ${L(PI * 2)};`,
+		`let ${p$1}_instOpacity = pow(${slots.opacity}, ${p$1}_j) * (1.0 - ${slots.jitterOpacity} * ${p$1}_h5);`,
+		`${p$1}_pos = ${p$1}_pos + vec2f((${p$1}_h1 - 0.5) * ${p$1}_fieldHwSq, (${p$1}_h2 - 0.5) * ${p$1}_fieldHh) * ${slots.jitterPosition};`
+	];
+}
+function instanceHueShift(f, hueShift) {
+	const { p: p$1, L } = f;
+	return [
+		`let ${p$1}_hueAngle = ${hueShift} * ${p$1}_j;`,
+		`let ${p$1}_cosH = cos(${p$1}_hueAngle);`,
+		`let ${p$1}_sinH = sin(${p$1}_hueAngle);`,
+		`let ${p$1}_kOMC = (1.0 - ${p$1}_cosH) * ${L(1 / 3)};`,
+		`let ${p$1}_sOS3 = ${p$1}_sinH / 1.7320508075688772;`,
+		`let ${p$1}_mA = ${p$1}_cosH + ${p$1}_kOMC;`,
+		`let ${p$1}_mB = ${p$1}_kOMC - ${p$1}_sOS3;`,
+		`let ${p$1}_mC = ${p$1}_kOMC + ${p$1}_sOS3;`,
+		`${p$1}_rgb = vec3f(${p$1}_src.r * ${p$1}_mA + ${p$1}_src.g * ${p$1}_mB + ${p$1}_src.b * ${p$1}_mC, ${p$1}_src.r * ${p$1}_mC + ${p$1}_src.g * ${p$1}_mA + ${p$1}_src.b * ${p$1}_mB, ${p$1}_src.r * ${p$1}_mB + ${p$1}_src.g * ${p$1}_mC + ${p$1}_src.b * ${p$1}_mA);`
+	];
+}
+function accumulateInstances(f, slots) {
+	const { p: p$1 } = f;
+	const out = [];
+	out.push(`let ${p$1}_totalN = min(max(${slots.placement.requested()}, 1.0), 64.0);`);
+	out.push(`var ${p$1}_accum = vec4f(0.0, 0.0, 0.0, 0.0);`);
+	out.push(`var ${p$1}_cellFitInv = 1.0;`);
+	const body = [];
+	body.push(`let ${p$1}_fi = f32(${p$1}_i);`);
+	body.push(slots.zBack ? `let ${p$1}_j = ${p$1}_totalN - 1.0 - ${p$1}_fi;` : `let ${p$1}_j = ${p$1}_fi;`);
+	body.push(`var ${p$1}_pos = vec2f(0.0, 0.0);`);
+	body.push(`var ${p$1}_layoutRot = 0.0;`);
+	body.push(`var ${p$1}_flipX = 1.0;`);
+	body.push(`var ${p$1}_flipY = 1.0;`);
+	body.push(...slots.placement.body(f));
+	body.push(...slots.variation);
+	body.push(`let ${p$1}_negRot = -${p$1}_rot;`);
+	body.push(`let ${p$1}_cosA = cos(${p$1}_negRot);`);
+	body.push(`let ${p$1}_sinA = sin(${p$1}_negRot);`);
+	body.push(`let ${p$1}_d0 = ${p$1}_pix - ${p$1}_pos;`);
+	body.push(`let ${p$1}_dr = vec2f(${p$1}_d0.x * ${p$1}_cosA - ${p$1}_d0.y * ${p$1}_sinA, ${p$1}_d0.x * ${p$1}_sinA + ${p$1}_d0.y * ${p$1}_cosA);`);
+	body.push(`let ${p$1}_dl = ${p$1}_dr / ${p$1}_scale;`);
+	body.push(`let ${p$1}_localU = ${p$1}_dl.x * ${p$1}_flipX * ${p$1}_cellFitInv / (${p$1}_srcHwSq * 2.0) + 0.5;`);
+	body.push(`let ${p$1}_localV = ${p$1}_dl.y * ${p$1}_flipY * ${p$1}_cellFitInv / (${p$1}_srcHhSq * 2.0) + 0.5;`);
+	const sample = [];
+	sample.push(`let ${p$1}_sampleUV = vec2f(${p$1}_srcCx - ${p$1}_srcHw + ${p$1}_localU * ${p$1}_srcHw * 2.0, ${p$1}_srcCy - ${p$1}_srcHh + ${p$1}_localV * ${p$1}_srcHh * 2.0);`);
+	sample.push(`let ${p$1}_src = textureSampleLevel(tex.$.${slots.texKey}, samp.$.linearClamp, ${p$1}_sampleUV, 0.0);`);
+	sample.push(`var ${p$1}_rgb = ${p$1}_src.rgb;`);
+	sample.push(...slots.hue);
+	sample.push(`let ${p$1}_a = ${p$1}_src.a * ${p$1}_instOpacity;`);
+	sample.push(`let ${p$1}_premul = ${p$1}_rgb * ${p$1}_a;`);
+	sample.push(`${p$1}_accum = vec4f(${p$1}_premul + ${p$1}_accum.rgb * (1.0 - ${p$1}_a), ${p$1}_a + ${p$1}_accum.a * (1.0 - ${p$1}_a));`);
+	body.push(`if (${p$1}_localU >= 0.0 && ${p$1}_localU <= 1.0 && ${p$1}_localV >= 0.0 && ${p$1}_localV <= 1.0) {`);
+	for (const s of sample) body.push(`  ${s}`);
+	body.push(`}`);
+	out.push(`for (var ${p$1}_i = 0u; ${p$1}_i < u32(${p$1}_totalN); ${p$1}_i++) {`);
+	for (const b of body) out.push(`  ${b}`);
+	out.push(`}`);
+	return out;
+}
+var { formatFloat } = instanceParts_exports;
+const grid = (slots) => ({
+	kind: "grid",
+	slots
+});
+const radial = (slots) => ({
+	kind: "radial",
+	slots
+});
+const line = (slots) => ({
+	kind: "line",
+	slots
+});
+const byMode = (mode, members) => ({
+	mode,
+	members
+});
+var MODE_MAP = {
+	grid: 0,
+	radial: 1,
+	linear: 2
+};
+var FLIP_MAP = {
+	"none": 0,
+	"alternate-flip-x": 1,
+	"alternate-flip-y": 2,
+	"both": 3
+};
+function repeatInstances(recipe) {
+	return (params) => {
+		const { uniforms, childNode, ctx, propValues, childBoundsParams, ownBoundsParams, convertToTexture } = params;
+		if (!childNode) return ZERO;
+		const texKey = convertToTexture(childNode).key;
+		const structural = (ref, map) => {
+			const v = propValues[ref.name];
+			return typeof v === "number" ? v : map[v] ?? 0;
+		};
+		const spec = "members" in recipe.placement ? [
+			recipe.placement.members.grid,
+			recipe.placement.members.radial,
+			recipe.placement.members.linear
+		][structural(recipe.placement.mode, MODE_MAP)] ?? recipe.placement.members.grid : recipe.placement;
+		const zBack = recipe.order ? propValues[recipe.order.name] === "backward" || propValues[recipe.order.name] === 1 : false;
+		const hueActive = recipe.hueShift ? (propValues[recipe.hueShift.name] ?? 0) !== 0 : false;
+		return new Expr((ec) => {
+			const f = {
+				p: ec.freshLocal("rep"),
+				L: formatFloat
+			};
+			const { p: p$1, L } = f;
+			const R = (ref) => {
+				const accessor = uniforms[ref.name];
+				if (!accessor) throw new Error(`std: repeatInstances binds unknown prop '${ref.name}'`);
+				return accessor._emit(ec);
+			};
+			const stmts = [];
+			stmts.push(`let ${p$1}_uv = ${ctx.uv._emit(ec)};`);
+			stmts.push(`let ${p$1}_aspect = ${ctx.aspect._emit(ec)};`);
+			stmts.push(`let ${p$1}_pix = vec2f(${p$1}_uv.x * ${p$1}_aspect, ${p$1}_uv.y);`);
+			const src = {
+				cx: childBoundsParams ? childBoundsParams.centerX._emit(ec) : L(.5),
+				cy: childBoundsParams ? childBoundsParams.centerY._emit(ec) : L(.5),
+				hw: childBoundsParams ? childBoundsParams.halfWidth._emit(ec) : L(.5),
+				hh: childBoundsParams ? childBoundsParams.halfHeight._emit(ec) : L(.5)
+			};
+			stmts.push(...sourceRect(f, src, {
+				left: R(recipe.source.crop.left),
+				right: R(recipe.source.crop.right),
+				top: R(recipe.source.crop.top),
+				bottom: R(recipe.source.crop.bottom)
+			}));
+			stmts.push(...placementField(f, {
+				cx: ownBoundsParams ? ownBoundsParams.centerX._emit(ec) : L(.5),
+				cy: ownBoundsParams ? ownBoundsParams.centerY._emit(ec) : L(.5),
+				hw: ownBoundsParams ? ownBoundsParams.halfWidth._emit(ec) : L(.5),
+				hh: ownBoundsParams ? ownBoundsParams.halfHeight._emit(ec) : L(.5)
+			}));
+			stmts.push(`let ${p$1}_phase = ${R(recipe.variation.phase)};`);
+			stmts.push(`let ${p$1}_seed = ${R(recipe.variation.seed)};`);
+			const anchorSq = childBoundsParams ? `vec2f((${childBoundsParams.centerX._emit(ec)}) * ${p$1}_aspect, ${childBoundsParams.centerY._emit(ec)})` : `${p$1}_fieldCenterSq`;
+			const placement = spec.kind === "grid" ? gridPlacement({
+				columns: R(spec.slots.columns),
+				rows: R(spec.slots.rows),
+				gapX: R(spec.slots.gapX),
+				gapY: R(spec.slots.gapY),
+				stagger: R(spec.slots.stagger)
+			}, structural(spec.slots.flip, FLIP_MAP)) : spec.kind === "radial" ? radialPlacement(anchorSq, {
+				count: R(spec.slots.count),
+				sweep: R(spec.slots.sweep),
+				startAngle: R(spec.slots.startAngle),
+				radius: R(spec.slots.radius),
+				faceCenter: R(spec.slots.faceCenter)
+			}) : linePlacement(anchorSq, {
+				count: R(spec.slots.count),
+				direction: R(spec.slots.direction),
+				spacing: R(spec.slots.spacing)
+			});
+			stmts.push(...accumulateInstances(f, {
+				placement,
+				variation: instanceVariation(f, {
+					scale: R(recipe.variation.scale),
+					rotation: R(recipe.variation.rotation),
+					opacity: R(recipe.variation.opacity),
+					jitterPosition: R(recipe.variation.jitter.position),
+					jitterRotation: R(recipe.variation.jitter.rotation),
+					jitterScale: R(recipe.variation.jitter.scale),
+					jitterOpacity: R(recipe.variation.jitter.opacity)
+				}),
+				hue: hueActive && recipe.hueShift ? instanceHueShift(f, R(recipe.hueShift)) : [],
+				zBack,
+				texKey
+			}));
+			for (const s of stmts) ec.statement(s);
+			return call(unpremultiplyAlpha, "unpremultiplyAlpha", [expr(`${p$1}_accum`)])._emit(ec);
+		});
+	};
+}
+const componentDefinition = defineStd({
+	name: "Repeater",
+	role: "structural",
+	species: "custom",
+	category: "Distortions",
+	description: "Repeat the child content in grid, radial or linear layouts with per-instance variation",
+	requiresRTT: true,
+	requiresChild: true,
+	wantsBoundsParams: true,
+	boundingBoxDeclaration: { aspectRatio: null },
+	props: {
+		mode: {
+			default: "grid",
+			transform: (value) => ({
+				grid: 0,
+				radial: 1,
+				linear: 2
+			})[value] ?? 0,
+			compileTime: true,
+			description: "Layout used to place the repeated instances",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Grid",
+						value: "grid"
+					},
+					{
+						label: "Radial",
+						value: "radial"
+					},
+					{
+						label: "Linear",
+						value: "linear"
+					}
+				],
+				label: "Mode",
+				group: "Layout"
+			}
+		},
+		cropLeft: {
+			default: 0,
+			description: "Crop inset from the left edge of the source element (fraction of its width)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: .49,
+				step: .005,
+				label: "Crop Left",
+				group: "Source"
+			}
+		},
+		cropRight: {
+			default: 0,
+			description: "Crop inset from the right edge of the source element (fraction of its width)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: .49,
+				step: .005,
+				label: "Crop Right",
+				group: "Source"
+			}
+		},
+		cropTop: {
+			default: 0,
+			description: "Crop inset from the top edge of the source element (fraction of its height)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: .49,
+				step: .005,
+				label: "Crop Top",
+				group: "Source"
+			}
+		},
+		cropBottom: {
+			default: 0,
+			description: "Crop inset from the bottom edge of the source element (fraction of its height)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: .49,
+				step: .005,
+				label: "Crop Bottom",
+				group: "Source"
+			}
+		},
+		columns: {
+			default: 3,
+			description: "Number of grid columns",
+			ui: {
+				type: ["range", "map"],
+				min: 1,
+				max: 12,
+				step: 1,
+				label: "Columns",
+				group: "Layout",
+				condition: { mode: "grid" }
+			}
+		},
+		rows: {
+			default: 3,
+			description: "Number of grid rows",
+			ui: {
+				type: ["range", "map"],
+				min: 1,
+				max: 12,
+				step: 1,
+				label: "Rows",
+				group: "Layout",
+				condition: { mode: "grid" }
+			}
+		},
+		gapX: {
+			default: .05,
+			description: "Horizontal gap between grid cells",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: .5,
+				step: .005,
+				label: "Gap X",
+				group: "Layout",
+				condition: { mode: "grid" },
+				dimensional: "canvas-width"
+			}
+		},
+		gapY: {
+			default: .05,
+			description: "Vertical gap between grid cells",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: .5,
+				step: .005,
+				label: "Gap Y",
+				group: "Layout",
+				condition: { mode: "grid" },
+				dimensional: "canvas-height"
+			}
+		},
+		stagger: {
+			default: 0,
+			description: "Horizontal offset applied to every other row (brick layout)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Stagger",
+				group: "Layout",
+				condition: { mode: "grid" }
+			}
+		},
+		flip: {
+			default: "none",
+			transform: (value) => ({
+				"none": 0,
+				"alternate-flip-x": 1,
+				"alternate-flip-y": 2,
+				"both": 3
+			})[value] ?? 0,
+			compileTime: true,
+			description: "Mirror alternating columns/rows for seamless tiling patterns",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "None",
+						value: "none"
+					},
+					{
+						label: "Alternate Flip X",
+						value: "alternate-flip-x"
+					},
+					{
+						label: "Alternate Flip Y",
+						value: "alternate-flip-y"
+					},
+					{
+						label: "Both",
+						value: "both"
+					}
+				],
+				label: "Flip",
+				group: "Layout",
+				condition: { mode: "grid" }
+			}
+		},
+		count: {
+			default: 8,
+			description: "Number of repeated instances",
+			ui: {
+				type: ["range", "map"],
+				min: 1,
+				max: 64,
+				step: 1,
+				label: "Count",
+				group: "Layout",
+				condition: { mode: ["radial", "linear"] }
+			}
+		},
+		radius: {
+			default: .3,
+			description: "Orbit radius of the radial layout",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .005,
+				label: "Radius",
+				group: "Layout",
+				condition: { mode: "radial" },
+				dimensional: "canvas-height"
+			}
+		},
+		startAngle: {
+			default: 0,
+			description: "Angle of the first instance on the orbit",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Start Angle",
+				group: "Layout",
+				condition: { mode: "radial" }
+			}
+		},
+		sweep: {
+			default: 360,
+			description: "Angular span the instances are distributed across",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Sweep",
+				group: "Layout",
+				condition: { mode: "radial" }
+			}
+		},
+		faceCenter: {
+			default: false,
+			transform: transformBoolean,
+			description: "Rotate each instance to face the orbit center",
+			ui: {
+				type: "checkbox",
+				label: "Face Center",
+				group: "Layout",
+				condition: { mode: "radial" }
+			}
+		},
+		direction: {
+			default: 0,
+			description: "Direction of the linear layout in degrees (0 = rightward)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Direction",
+				group: "Layout",
+				condition: { mode: "linear" }
+			}
+		},
+		spacing: {
+			default: .2,
+			description: "Distance between consecutive instances",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .005,
+				label: "Spacing",
+				group: "Layout",
+				condition: { mode: "linear" },
+				dimensional: "canvas-height"
+			}
+		},
+		instanceScale: {
+			default: 1,
+			description: "Progressive scale multiplier applied per instance (compounds with each copy)",
+			ui: {
+				type: ["range", "map"],
+				min: .5,
+				max: 2,
+				step: .005,
+				label: "Scale",
+				group: "Instances"
+			}
+		},
+		instanceRotation: {
+			default: 0,
+			transform: (value) => value * Math.PI / 180,
+			description: "Additional rotation in degrees applied per instance (accumulates with each copy)",
+			ui: {
+				type: ["range", "map"],
+				min: -180,
+				max: 180,
+				step: 1,
+				label: "Rotation",
+				group: "Instances"
+			}
+		},
+		instanceOpacity: {
+			default: 1,
+			description: "Progressive opacity falloff applied per instance (compounds with each copy)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .005,
+				label: "Opacity",
+				group: "Instances"
+			}
+		},
+		hueShift: {
+			default: 0,
+			transform: (value) => value * Math.PI / 180,
+			recompile: crosses(0),
+			description: "Hue rotation in degrees added per instance",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Hue Shift",
+				group: "Instances"
+			}
+		},
+		phase: {
+			default: 0,
+			description: "Seamless layout animation phase (0-1 wraps to the identical layout)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .001,
+				label: "Phase",
+				group: "Instances"
+			}
+		},
+		zOrder: {
+			default: "forward",
+			transform: (value) => value === "backward" ? 1 : 0,
+			compileTime: true,
+			description: "Stacking order of overlapping instances",
+			ui: {
+				type: "select",
+				options: [{
+					label: "Forward",
+					value: "forward"
+				}, {
+					label: "Backward",
+					value: "backward"
+				}],
+				label: "Z-Order",
+				group: "Instances"
+			}
+		},
+		jitterPosition: {
+			default: 0,
+			description: "Random per-instance position offset",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .005,
+				label: "Position",
+				group: "Jitter"
+			}
+		},
+		jitterRotation: {
+			default: 0,
+			description: "Random per-instance rotation",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .005,
+				label: "Rotation",
+				group: "Jitter"
+			}
+		},
+		jitterScale: {
+			default: 0,
+			description: "Random per-instance scale variation",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .005,
+				label: "Scale",
+				group: "Jitter"
+			}
+		},
+		jitterOpacity: {
+			default: 0,
+			description: "Random per-instance opacity variation",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .005,
+				label: "Opacity",
+				group: "Jitter"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Random seed for the jitter values",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Jitter"
+			}
+		}
+	},
+	gpu: { fragment: repeatInstances({
+		source: { crop: {
+			left: p("cropLeft"),
+			right: p("cropRight"),
+			top: p("cropTop"),
+			bottom: p("cropBottom")
+		} },
+		placement: byMode(p("mode"), {
+			grid: grid({
+				columns: p("columns"),
+				rows: p("rows"),
+				gapX: p("gapX"),
+				gapY: p("gapY"),
+				stagger: p("stagger"),
+				flip: p("flip")
+			}),
+			radial: radial({
+				count: p("count"),
+				radius: p("radius"),
+				startAngle: p("startAngle"),
+				sweep: p("sweep"),
+				faceCenter: p("faceCenter")
+			}),
+			linear: line({
+				count: p("count"),
+				direction: p("direction"),
+				spacing: p("spacing")
+			})
+		}),
+		variation: {
+			scale: p("instanceScale"),
+			rotation: p("instanceRotation"),
+			opacity: p("instanceOpacity"),
+			jitter: {
+				position: p("jitterPosition"),
+				rotation: p("jitterRotation"),
+				scale: p("jitterScale"),
+				opacity: p("jitterOpacity")
+			},
+			seed: p("seed"),
+			phase: p("phase")
+		},
+		hueShift: p("hueShift"),
+		order: p("zOrder")
+	}) }
+});
+var Repeater_default = componentDefinition;
+export { componentDefinition as n, Repeater_default as t };