shaders 3.1.462 → 3.2.464

package/dist/core/WaveDistortion-Btt0BlER.js

@@ -1,981 +0,0 @@
-import { At as step, Dt as sin, Mt as vec2f, et as typegpu_default, ht as fract, it as abs, lt as cos, m as call, sn as f32 } from "./edges-CV-BHMpI.js";
-import { o as TAU$1, t as DEG_TO_RAD$1 } from "./constants-BKlzQFdJ.js";
-import { E as uvRemapShader, t as animatedTime } from "./porters-j7yWJYy2.js";
-import { n as edgesPropConfig } from "./propConfigs-CvzF7Ot8.js";
-var DEG_TO_RAD = DEG_TO_RAD$1;
-var TAU = TAU$1;
-const wavePhase = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, t) => {
-	"use gpu";
-	const centeredUV = uv.sub(vec2f(.5, .5));
-	const aspectCorrectedUV = vec2f(__tsover_mul(centeredUV.x, aspect), centeredUV.y);
-	const angleRad = __tsover_mul(angle, DEG_TO_RAD);
-	const cosA = cos(angleRad);
-	const sinA = sin(angleRad);
-	const rotatedY = __tsover_add(__tsover_mul(aspectCorrectedUV.x, sinA), __tsover_mul(aspectCorrectedUV.y, cosA));
-	return __tsover_add(__tsover_mul(__tsover_mul(__tsover_add(rotatedY, .5), frequency), TAU), t);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			},
-			{
-				"type": "i",
-				"name": "angle"
-			},
-			{
-				"type": "i",
-				"name": "frequency"
-			},
-			{
-				"type": "i",
-				"name": "t"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"centeredUV",
-				[
-					6,
-					[
-						7,
-						"uv",
-						"sub"
-					],
-					[[
-						6,
-						"d.vec2f",
-						[[5, "0.5"], [5, "0.5"]]
-					]]
-				]
-			],
-			[
-				13,
-				"aspectCorrectedUV",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"centeredUV",
-							"x"
-						],
-						"*",
-						"aspect"
-					], [
-						7,
-						"centeredUV",
-						"y"
-					]]
-				]
-			],
-			[
-				13,
-				"angleRad",
-				[
-					1,
-					"angle",
-					"*",
-					"DEG_TO_RAD"
-				]
-			],
-			[
-				13,
-				"cosA",
-				[
-					6,
-					"std.cos",
-					["angleRad"]
-				]
-			],
-			[
-				13,
-				"sinA",
-				[
-					6,
-					"std.sin",
-					["angleRad"]
-				]
-			],
-			[
-				13,
-				"rotatedY",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"aspectCorrectedUV",
-							"x"
-						],
-						"*",
-						"sinA"
-					],
-					"+",
-					[
-						1,
-						[
-							7,
-							"aspectCorrectedUV",
-							"y"
-						],
-						"*",
-						"cosA"
-					]
-				]
-			],
-			[10, [
-				1,
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"rotatedY",
-							"+",
-							[5, "0.5"]
-						],
-						"*",
-						"frequency"
-					],
-					"*",
-					"TAU"
-				],
-				"+",
-				"t"
-			]]
-		]]
-	},
-	externals: {
-		"d.vec2f": () => vec2f,
-		"DEG_TO_RAD": () => DEG_TO_RAD,
-		"std.cos": () => cos,
-		"std.sin": () => sin,
-		"TAU": () => TAU
-	}
-}) && $.f)({}));
-const waveApply = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, strength, wave) => {
-	"use gpu";
-	const angleRad = __tsover_mul(angle, DEG_TO_RAD);
-	const cosA = cos(angleRad);
-	const sinA = sin(angleRad);
-	const displacement = __tsover_mul(__tsover_mul(wave, strength), .5);
-	const displacementX = __tsover_div(__tsover_mul(displacement, cosA), aspect);
-	const displacementY = __tsover_mul(displacement, sinA);
-	return vec2f(__tsover_add(uv.x, displacementX), __tsover_add(uv.y, displacementY));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			},
-			{
-				"type": "i",
-				"name": "angle"
-			},
-			{
-				"type": "i",
-				"name": "strength"
-			},
-			{
-				"type": "i",
-				"name": "wave"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"angleRad",
-				[
-					1,
-					"angle",
-					"*",
-					"DEG_TO_RAD"
-				]
-			],
-			[
-				13,
-				"cosA",
-				[
-					6,
-					"std.cos",
-					["angleRad"]
-				]
-			],
-			[
-				13,
-				"sinA",
-				[
-					6,
-					"std.sin",
-					["angleRad"]
-				]
-			],
-			[
-				13,
-				"displacement",
-				[
-					1,
-					[
-						1,
-						"wave",
-						"*",
-						"strength"
-					],
-					"*",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"displacementX",
-				[
-					1,
-					[
-						1,
-						"displacement",
-						"*",
-						"cosA"
-					],
-					"/",
-					"aspect"
-				]
-			],
-			[
-				13,
-				"displacementY",
-				[
-					1,
-					"displacement",
-					"*",
-					"sinA"
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				[[
-					1,
-					[
-						7,
-						"uv",
-						"x"
-					],
-					"+",
-					"displacementX"
-				], [
-					1,
-					[
-						7,
-						"uv",
-						"y"
-					],
-					"+",
-					"displacementY"
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"DEG_TO_RAD": () => DEG_TO_RAD,
-		"std.cos": () => cos,
-		"std.sin": () => sin,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const waveDistortSine = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, strength, t) => {
-	"use gpu";
-	return waveApply(uv, aspect, angle, strength, sin(wavePhase(uv, aspect, angle, frequency, t)));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			},
-			{
-				"type": "i",
-				"name": "angle"
-			},
-			{
-				"type": "i",
-				"name": "frequency"
-			},
-			{
-				"type": "i",
-				"name": "strength"
-			},
-			{
-				"type": "i",
-				"name": "t"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"phase",
-				[
-					6,
-					"wavePhase",
-					[
-						"uv",
-						"aspect",
-						"angle",
-						"frequency",
-						"t"
-					]
-				]
-			],
-			[
-				13,
-				"wave",
-				[
-					6,
-					"std.sin",
-					["phase"]
-				]
-			],
-			[10, [
-				6,
-				"waveApply",
-				[
-					"uv",
-					"aspect",
-					"angle",
-					"strength",
-					"wave"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"wavePhase": () => wavePhase,
-		"std.sin": () => sin,
-		"waveApply": () => waveApply
-	}
-}) && $.f)({}));
-const waveDistortTriangle = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, strength, t) => {
-	"use gpu";
-	const phase = wavePhase(uv, aspect, angle, frequency, t);
-	const normalizedPhase = fract(__tsover_div(phase, TAU));
-	return waveApply(uv, aspect, angle, strength, __tsover_sub(__tsover_mul(abs(__tsover_sub(__tsover_mul(normalizedPhase, 2), 1)), 2), 1));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			},
-			{
-				"type": "i",
-				"name": "angle"
-			},
-			{
-				"type": "i",
-				"name": "frequency"
-			},
-			{
-				"type": "i",
-				"name": "strength"
-			},
-			{
-				"type": "i",
-				"name": "t"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"phase",
-				[
-					6,
-					"wavePhase",
-					[
-						"uv",
-						"aspect",
-						"angle",
-						"frequency",
-						"t"
-					]
-				]
-			],
-			[
-				13,
-				"normalizedPhase",
-				[
-					6,
-					"std.fract",
-					[[
-						1,
-						"phase",
-						"/",
-						"TAU"
-					]]
-				]
-			],
-			[
-				13,
-				"wave",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"std.abs",
-							[[
-								1,
-								[
-									1,
-									"normalizedPhase",
-									"*",
-									[5, "2"]
-								],
-								"-",
-								[5, "1"]
-							]]
-						],
-						"*",
-						[5, "2"]
-					],
-					"-",
-					[5, "1"]
-				]
-			],
-			[10, [
-				6,
-				"waveApply",
-				[
-					"uv",
-					"aspect",
-					"angle",
-					"strength",
-					"wave"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"wavePhase": () => wavePhase,
-		"std.fract": () => fract,
-		"TAU": () => TAU,
-		"std.abs": () => abs,
-		"waveApply": () => waveApply
-	}
-}) && $.f)({}));
-const waveDistortSquare = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, strength, t) => {
-	"use gpu";
-	const phase = wavePhase(uv, aspect, angle, frequency, t);
-	const normalizedPhase = fract(__tsover_div(phase, TAU));
-	return waveApply(uv, aspect, angle, strength, __tsover_sub(__tsover_mul(step(.5, normalizedPhase), 2), 1));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			},
-			{
-				"type": "i",
-				"name": "angle"
-			},
-			{
-				"type": "i",
-				"name": "frequency"
-			},
-			{
-				"type": "i",
-				"name": "strength"
-			},
-			{
-				"type": "i",
-				"name": "t"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"phase",
-				[
-					6,
-					"wavePhase",
-					[
-						"uv",
-						"aspect",
-						"angle",
-						"frequency",
-						"t"
-					]
-				]
-			],
-			[
-				13,
-				"normalizedPhase",
-				[
-					6,
-					"std.fract",
-					[[
-						1,
-						"phase",
-						"/",
-						"TAU"
-					]]
-				]
-			],
-			[
-				13,
-				"wave",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"std.step",
-							[[5, "0.5"], "normalizedPhase"]
-						],
-						"*",
-						[5, "2"]
-					],
-					"-",
-					[5, "1"]
-				]
-			],
-			[10, [
-				6,
-				"waveApply",
-				[
-					"uv",
-					"aspect",
-					"angle",
-					"strength",
-					"wave"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"wavePhase": () => wavePhase,
-		"std.fract": () => fract,
-		"TAU": () => TAU,
-		"std.step": () => step,
-		"waveApply": () => waveApply
-	}
-}) && $.f)({}));
-const waveDistortSawtooth = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, strength, t) => {
-	"use gpu";
-	const phase = wavePhase(uv, aspect, angle, frequency, t);
-	const normalizedPhase = fract(__tsover_div(phase, TAU));
-	return waveApply(uv, aspect, angle, strength, __tsover_sub(__tsover_mul(normalizedPhase, 2), 1));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			},
-			{
-				"type": "i",
-				"name": "angle"
-			},
-			{
-				"type": "i",
-				"name": "frequency"
-			},
-			{
-				"type": "i",
-				"name": "strength"
-			},
-			{
-				"type": "i",
-				"name": "t"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"phase",
-				[
-					6,
-					"wavePhase",
-					[
-						"uv",
-						"aspect",
-						"angle",
-						"frequency",
-						"t"
-					]
-				]
-			],
-			[
-				13,
-				"normalizedPhase",
-				[
-					6,
-					"std.fract",
-					[[
-						1,
-						"phase",
-						"/",
-						"TAU"
-					]]
-				]
-			],
-			[
-				13,
-				"wave",
-				[
-					1,
-					[
-						1,
-						"normalizedPhase",
-						"*",
-						[5, "2"]
-					],
-					"-",
-					[5, "1"]
-				]
-			],
-			[10, [
-				6,
-				"waveApply",
-				[
-					"uv",
-					"aspect",
-					"angle",
-					"strength",
-					"wave"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"wavePhase": () => wavePhase,
-		"std.fract": () => fract,
-		"TAU": () => TAU,
-		"waveApply": () => waveApply
-	}
-}) && $.f)({}));
-const waveDistortBounce = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, frequency, strength, t) => {
-	"use gpu";
-	return waveApply(uv, aspect, angle, strength, abs(sin(wavePhase(uv, aspect, angle, frequency, t))));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			},
-			{
-				"type": "i",
-				"name": "angle"
-			},
-			{
-				"type": "i",
-				"name": "frequency"
-			},
-			{
-				"type": "i",
-				"name": "strength"
-			},
-			{
-				"type": "i",
-				"name": "t"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"phase",
-				[
-					6,
-					"wavePhase",
-					[
-						"uv",
-						"aspect",
-						"angle",
-						"frequency",
-						"t"
-					]
-				]
-			],
-			[
-				13,
-				"wave",
-				[
-					6,
-					"std.abs",
-					[[
-						6,
-						"std.sin",
-						["phase"]
-					]]
-				]
-			],
-			[10, [
-				6,
-				"waveApply",
-				[
-					"uv",
-					"aspect",
-					"angle",
-					"strength",
-					"wave"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"wavePhase": () => wavePhase,
-		"std.abs": () => abs,
-		"std.sin": () => sin,
-		"waveApply": () => waveApply
-	}
-}) && $.f)({}));
-var WAVE_MODES = {
-	sine: 0,
-	triangle: 1,
-	square: 2,
-	sawtooth: 3,
-	bounce: 4
-};
-function waveTypeMode(raw) {
-	if (typeof raw === "number") return raw;
-	return WAVE_MODES[raw] ?? 0;
-}
-function waveBodyFor(waveType) {
-	switch (waveType) {
-		case 1: return {
-			fn: waveDistortTriangle,
-			hint: "waveDistortTriangle"
-		};
-		case 2: return {
-			fn: waveDistortSquare,
-			hint: "waveDistortSquare"
-		};
-		case 3: return {
-			fn: waveDistortSawtooth,
-			hint: "waveDistortSawtooth"
-		};
-		case 4: return {
-			fn: waveDistortBounce,
-			hint: "waveDistortBounce"
-		};
-		default: return {
-			fn: waveDistortSine,
-			hint: "waveDistortSine"
-		};
-	}
-}
-const componentDefinition = {
-	name: "WaveDistortion",
-	category: "Distortions",
-	description: "Wave-based distortion with multiple waveform types",
-	requiresRTT: true,
-	requiresChild: true,
-	boundingBoxDeclaration: { aspectRatio: null },
-	animatedTime: { speed: "speed" },
-	props: {
-		strength: {
-			default: .3,
-			description: "Distortion intensity",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Strength",
-				group: "Effect"
-			}
-		},
-		frequency: {
-			default: 1,
-			description: "Number of bends/waves",
-			ui: {
-				type: ["range", "map"],
-				min: .1,
-				max: 10,
-				step: .1,
-				label: "Frequency",
-				group: "Effect"
-			}
-		},
-		speed: {
-			default: 1,
-			description: "Animation speed",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 5,
-				step: .1,
-				label: "Speed",
-				group: "Animation"
-			}
-		},
-		angle: {
-			default: 0,
-			description: "Direction of wave distortion in degrees",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 360,
-				step: 1,
-				label: "Angle",
-				group: "Effect"
-			}
-		},
-		waveType: {
-			default: "sine",
-			description: "Shape of the distortion wave",
-			compileTime: true,
-			transform: (value) => {
-				return {
-					"sine": 0,
-					"triangle": 1,
-					"square": 2,
-					"sawtooth": 3,
-					"bounce": 4
-				}[value] ?? 0;
-			},
-			ui: {
-				type: "select",
-				options: [
-					{
-						label: "Sine",
-						value: "sine"
-					},
-					{
-						label: "Triangle",
-						value: "triangle"
-					},
-					{
-						label: "Square",
-						value: "square"
-					},
-					{
-						label: "Sawtooth",
-						value: "sawtooth"
-					},
-					{
-						label: "Bounce",
-						value: "bounce"
-					}
-				],
-				label: "Wave Type",
-				group: "Effect"
-			}
-		},
-		edges: edgesPropConfig("stretch", "How to handle edges when distortion pushes content out of bounds")
-	},
-	...uvRemapShader((params) => {
-		const { fn, hint } = waveBodyFor(waveTypeMode(params.propValues.waveType));
-		const t = animatedTime(params).mul(.5);
-		const u = params.uniforms;
-		return { map: (uv, aspect) => call(fn, hint, [
-			uv,
-			aspect,
-			u.angle,
-			u.frequency,
-			u.strength,
-			t
-		]) };
-	}, { requireChildMessage: "You must pass a child component into the WaveDistortion shader." })
-};
-var WaveDistortion_default = componentDefinition;
-export { waveDistortSawtooth as a, waveDistortTriangle as c, waveDistortBounce as i, wavePhase as l, componentDefinition as n, waveDistortSine as o, waveApply as r, waveDistortSquare as s, WaveDistortion_default as t };