shaders 3.1.462 → 3.2.464

package/dist/core/fields-Ch0s1PTq.js

@@ -1,1147 +0,0 @@
-import { Dt as sin, Ft as vec3f, Mt as vec2f, cn as i32, et as typegpu_default, ft as exp, lt as cos, mt as floor, rt as select, sn as f32 } from "./edges-CV-BHMpI.js";
-import { n as GOLDEN } from "./constants-BKlzQFdJ.js";
-import { t as aspectOf } from "./geom-BS390xIn.js";
-const aspectScaledDomain = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed) => {
-	"use gpu";
-	const aspect = aspectOf(viewport);
-	return vec2f(__tsover_mul(uv.x, aspect), uv.y).mul(exp(scale)).add(seed);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			},
-			{
-				"type": "i",
-				"name": "scale"
-			},
-			{
-				"type": "i",
-				"name": "seed"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"aspect",
-				[
-					6,
-					"aspectOf",
-					["viewport"]
-				]
-			],
-			[
-				13,
-				"aspectUV",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"uv",
-							"x"
-						],
-						"*",
-						"aspect"
-					], [
-						7,
-						"uv",
-						"y"
-					]]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					[
-						6,
-						[
-							7,
-							"aspectUV",
-							"mul"
-						],
-						[[
-							6,
-							"std.exp",
-							["scale"]
-						]]
-					],
-					"add"
-				],
-				["seed"]
-			]]
-		]]
-	},
-	externals: {
-		"aspectOf": () => aspectOf,
-		"d.vec2f": () => vec2f,
-		"std.exp": () => exp
-	}
-}) && $.f)({}));
-const pixelGridDomain = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, grain, seed) => {
-	"use gpu";
-	return floor(uv.mul(viewport).div(grain)).add(seed);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			},
-			{
-				"type": "i",
-				"name": "grain"
-			},
-			{
-				"type": "i",
-				"name": "seed"
-			}
-		],
-		"body": [0, [[10, [
-			6,
-			[
-				7,
-				[
-					6,
-					"std.floor",
-					[[
-						6,
-						[
-							7,
-							[
-								6,
-								[
-									7,
-									"uv",
-									"mul"
-								],
-								["viewport"]
-							],
-							"div"
-						],
-						["grain"]
-					]]
-				],
-				"add"
-			],
-			["seed"]
-		]]]]
-	},
-	externals: { "std.floor": () => floor }
-}) && $.f)({}));
-const timeAxisDomain = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32
-], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((pos, t, rate) => {
-	"use gpu";
-	return vec3f(pos.x, pos.y, __tsover_mul(t, rate));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "pos"
-			},
-			{
-				"type": "i",
-				"name": "t"
-			},
-			{
-				"type": "i",
-				"name": "rate"
-			}
-		],
-		"body": [0, [[10, [
-			6,
-			"d.vec3f",
-			[
-				[
-					7,
-					"pos",
-					"x"
-				],
-				[
-					7,
-					"pos",
-					"y"
-				],
-				[
-					1,
-					"t",
-					"*",
-					"rate"
-				]
-			]
-		]]]]
-	},
-	externals: { "d.vec3f": () => vec3f }
-}) && $.f)({}));
-var fieldFnIds = /* @__PURE__ */ new WeakMap();
-var nextFieldFnId = 0;
-function fieldFnId(fieldFn) {
-	const keyable = fieldFn;
-	const existing = fieldFnIds.get(keyable);
-	if (existing !== void 0) return existing;
-	const assigned = nextFieldFnId++;
-	fieldFnIds.set(keyable, assigned);
-	return assigned;
-}
-function fbmGated(fieldFn, options) {
-	const { maxOctaves, drift, stride = [17, 31], name = "fbmGated" } = options;
-	const key = `${fieldFnId(fieldFn)}|${name}|${maxOctaves}|${drift}|${stride[0]},${stride[1]}`;
-	const cached = fbmCache.get(key);
-	if (cached) return cached;
-	const N = maxOctaves;
-	const TIME_STRIDE = stride[0];
-	const SEED_STRIDE = stride[1];
-	const suffix = `${drift === "goldenAngle" ? "Golden" : "TimeSeed"}${N}`;
-	let built;
-	if (drift === "goldenAngle") {
-		const octaveField = fieldFn;
-		built = typegpu_default.fn([
-			vec2f,
-			f32,
-			f32,
-			f32,
-			f32,
-			vec2f,
-			f32
-		], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((base, baseFreq, lacunarity, persistence, animTime, seedOffset, octaveCount) => {
-			"use gpu";
-			const n = i32(octaveCount);
-			let freq = baseFreq;
-			let weight = f32(1);
-			let accumulated = f32(0);
-			let totalWeight = f32(0);
-			for (let i = 0; i < N; i++) {
-				const fi = f32(i);
-				const dirX = cos(__tsover_mul(fi, 2.3999632297286535));
-				const dirY = sin(__tsover_mul(fi, 2.3999632297286535));
-				const coord = vec2f(__tsover_add(__tsover_add(__tsover_mul(base.x, freq), __tsover_mul(animTime, dirX)), seedOffset.x), __tsover_add(__tsover_add(__tsover_mul(base.y, freq), __tsover_mul(animTime, dirY)), seedOffset.y));
-				const active = select(f32(0), f32(1), i < n);
-				accumulated = __tsover_add(accumulated, __tsover_mul(__tsover_mul(octaveField(coord), weight), active));
-				totalWeight = __tsover_add(totalWeight, __tsover_mul(weight, active));
-				freq = __tsover_mul(freq, lacunarity);
-				weight = __tsover_mul(weight, persistence);
-			}
-			return vec2f(accumulated, totalWeight);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [
-					{
-						"type": "i",
-						"name": "base"
-					},
-					{
-						"type": "i",
-						"name": "baseFreq"
-					},
-					{
-						"type": "i",
-						"name": "lacunarity"
-					},
-					{
-						"type": "i",
-						"name": "persistence"
-					},
-					{
-						"type": "i",
-						"name": "animTime"
-					},
-					{
-						"type": "i",
-						"name": "seedOffset"
-					},
-					{
-						"type": "i",
-						"name": "octaveCount"
-					}
-				],
-				"body": [0, [
-					[
-						13,
-						"n",
-						[
-							6,
-							"d.i32",
-							["octaveCount"]
-						]
-					],
-					[
-						12,
-						"freq",
-						"baseFreq"
-					],
-					[
-						12,
-						"weight",
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						]
-					],
-					[
-						12,
-						"accumulated",
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						]
-					],
-					[
-						12,
-						"totalWeight",
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						]
-					],
-					[
-						14,
-						[
-							12,
-							"i",
-							[5, "0"]
-						],
-						[
-							1,
-							"i",
-							"<",
-							"N"
-						],
-						[
-							102,
-							"++",
-							"i"
-						],
-						[0, [
-							[
-								13,
-								"fi",
-								[
-									6,
-									"d.f32",
-									["i"]
-								]
-							],
-							[
-								13,
-								"dirX",
-								[
-									6,
-									"std.cos",
-									[[
-										1,
-										"fi",
-										"*",
-										"GOLDEN"
-									]]
-								]
-							],
-							[
-								13,
-								"dirY",
-								[
-									6,
-									"std.sin",
-									[[
-										1,
-										"fi",
-										"*",
-										"GOLDEN"
-									]]
-								]
-							],
-							[
-								13,
-								"coord",
-								[
-									6,
-									"d.vec2f",
-									[[
-										1,
-										[
-											1,
-											[
-												1,
-												[
-													7,
-													"base",
-													"x"
-												],
-												"*",
-												"freq"
-											],
-											"+",
-											[
-												1,
-												"animTime",
-												"*",
-												"dirX"
-											]
-										],
-										"+",
-										[
-											7,
-											"seedOffset",
-											"x"
-										]
-									], [
-										1,
-										[
-											1,
-											[
-												1,
-												[
-													7,
-													"base",
-													"y"
-												],
-												"*",
-												"freq"
-											],
-											"+",
-											[
-												1,
-												"animTime",
-												"*",
-												"dirY"
-											]
-										],
-										"+",
-										[
-											7,
-											"seedOffset",
-											"y"
-										]
-									]]
-								]
-							],
-							[
-								13,
-								"active",
-								[
-									6,
-									"std.select",
-									[
-										[
-											6,
-											"d.f32",
-											[[5, "0"]]
-										],
-										[
-											6,
-											"d.f32",
-											[[5, "1"]]
-										],
-										[
-											1,
-											"i",
-											"<",
-											"n"
-										]
-									]
-								]
-							],
-							[
-								2,
-								"accumulated",
-								"=",
-								[
-									1,
-									"accumulated",
-									"+",
-									[
-										1,
-										[
-											1,
-											[
-												6,
-												"octaveField",
-												["coord"]
-											],
-											"*",
-											"weight"
-										],
-										"*",
-										"active"
-									]
-								]
-							],
-							[
-								2,
-								"totalWeight",
-								"=",
-								[
-									1,
-									"totalWeight",
-									"+",
-									[
-										1,
-										"weight",
-										"*",
-										"active"
-									]
-								]
-							],
-							[
-								2,
-								"freq",
-								"=",
-								[
-									1,
-									"freq",
-									"*",
-									"lacunarity"
-								]
-							],
-							[
-								2,
-								"weight",
-								"=",
-								[
-									1,
-									"weight",
-									"*",
-									"persistence"
-								]
-							]
-						]]
-					],
-					[10, [
-						6,
-						"d.vec2f",
-						["accumulated", "totalWeight"]
-					]]
-				]]
-			},
-			externals: {
-				"d.i32": () => i32,
-				"d.f32": () => f32,
-				"N": () => N,
-				"std.cos": () => cos,
-				"GOLDEN": () => 2.3999632297286535,
-				"std.sin": () => sin,
-				"d.vec2f": () => vec2f,
-				"std.select": () => select,
-				"octaveField": () => octaveField
-			}
-		}) && $.f)({})).$name(`${name}${suffix}`);
-	} else {
-		const octaveField = fieldFn;
-		built = typegpu_default.fn([
-			vec2f,
-			f32,
-			f32,
-			f32,
-			f32,
-			f32,
-			vec3f,
-			f32
-		], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((base, baseFreq, lacunarity, persistence, animTime, seed, extra, octaveCount) => {
-			"use gpu";
-			let freq = baseFreq;
-			let amp = f32(1);
-			let accumulated = f32(0);
-			let totalWeight = f32(0);
-			for (let o = 0; o < N; o++) {
-				const fo = f32(o);
-				const active = select(f32(0), f32(1), fo < octaveCount);
-				const raw = octaveField(vec2f(__tsover_mul(base.x, freq), __tsover_mul(base.y, freq)), __tsover_add(animTime, __tsover_mul(fo, TIME_STRIDE)), __tsover_add(seed, __tsover_mul(fo, SEED_STRIDE)), extra.x, extra.y, extra.z);
-				accumulated = __tsover_add(accumulated, __tsover_mul(__tsover_mul(raw, amp), active));
-				totalWeight = __tsover_add(totalWeight, __tsover_mul(amp, active));
-				amp = __tsover_mul(amp, persistence);
-				freq = __tsover_mul(freq, lacunarity);
-			}
-			return vec2f(accumulated, totalWeight);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [
-					{
-						"type": "i",
-						"name": "base"
-					},
-					{
-						"type": "i",
-						"name": "baseFreq"
-					},
-					{
-						"type": "i",
-						"name": "lacunarity"
-					},
-					{
-						"type": "i",
-						"name": "persistence"
-					},
-					{
-						"type": "i",
-						"name": "animTime"
-					},
-					{
-						"type": "i",
-						"name": "seed"
-					},
-					{
-						"type": "i",
-						"name": "extra"
-					},
-					{
-						"type": "i",
-						"name": "octaveCount"
-					}
-				],
-				"body": [0, [
-					[
-						12,
-						"freq",
-						"baseFreq"
-					],
-					[
-						12,
-						"amp",
-						[
-							6,
-							"d.f32",
-							[[5, "1"]]
-						]
-					],
-					[
-						12,
-						"accumulated",
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						]
-					],
-					[
-						12,
-						"totalWeight",
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						]
-					],
-					[
-						14,
-						[
-							12,
-							"o",
-							[5, "0"]
-						],
-						[
-							1,
-							"o",
-							"<",
-							"N"
-						],
-						[
-							102,
-							"++",
-							"o"
-						],
-						[0, [
-							[
-								13,
-								"fo",
-								[
-									6,
-									"d.f32",
-									["o"]
-								]
-							],
-							[
-								13,
-								"active",
-								[
-									6,
-									"std.select",
-									[
-										[
-											6,
-											"d.f32",
-											[[5, "0"]]
-										],
-										[
-											6,
-											"d.f32",
-											[[5, "1"]]
-										],
-										[
-											1,
-											"fo",
-											"<",
-											"octaveCount"
-										]
-									]
-								]
-							],
-							[
-								13,
-								"oUV",
-								[
-									6,
-									"d.vec2f",
-									[[
-										1,
-										[
-											7,
-											"base",
-											"x"
-										],
-										"*",
-										"freq"
-									], [
-										1,
-										[
-											7,
-											"base",
-											"y"
-										],
-										"*",
-										"freq"
-									]]
-								]
-							],
-							[
-								13,
-								"animT",
-								[
-									1,
-									"animTime",
-									"+",
-									[
-										1,
-										"fo",
-										"*",
-										"TIME_STRIDE"
-									]
-								]
-							],
-							[
-								13,
-								"seedOff",
-								[
-									1,
-									"seed",
-									"+",
-									[
-										1,
-										"fo",
-										"*",
-										"SEED_STRIDE"
-									]
-								]
-							],
-							[
-								13,
-								"raw",
-								[
-									6,
-									"octaveField",
-									[
-										"oUV",
-										"animT",
-										"seedOff",
-										[
-											7,
-											"extra",
-											"x"
-										],
-										[
-											7,
-											"extra",
-											"y"
-										],
-										[
-											7,
-											"extra",
-											"z"
-										]
-									]
-								]
-							],
-							[
-								2,
-								"accumulated",
-								"=",
-								[
-									1,
-									"accumulated",
-									"+",
-									[
-										1,
-										[
-											1,
-											"raw",
-											"*",
-											"amp"
-										],
-										"*",
-										"active"
-									]
-								]
-							],
-							[
-								2,
-								"totalWeight",
-								"=",
-								[
-									1,
-									"totalWeight",
-									"+",
-									[
-										1,
-										"amp",
-										"*",
-										"active"
-									]
-								]
-							],
-							[
-								2,
-								"amp",
-								"=",
-								[
-									1,
-									"amp",
-									"*",
-									"persistence"
-								]
-							],
-							[
-								2,
-								"freq",
-								"=",
-								[
-									1,
-									"freq",
-									"*",
-									"lacunarity"
-								]
-							]
-						]]
-					],
-					[10, [
-						6,
-						"d.vec2f",
-						["accumulated", "totalWeight"]
-					]]
-				]]
-			},
-			externals: {
-				"d.f32": () => f32,
-				"N": () => N,
-				"std.select": () => select,
-				"d.vec2f": () => vec2f,
-				"TIME_STRIDE": () => TIME_STRIDE,
-				"SEED_STRIDE": () => SEED_STRIDE,
-				"octaveField": () => octaveField
-			}
-		}) && $.f)({})).$name(`${name}${suffix}`);
-	}
-	fbmCache.set(key, built);
-	return built;
-}
-var fbmCache = /* @__PURE__ */ new Map();
-var IQ_WARP_OFFSETS = {
-	q: [[
-		.3,
-		-.2,
-		0
-	], [
-		5.2,
-		1.3,
-		.25
-	]],
-	r: [[
-		1.7,
-		9.2,
-		.15
-	], [
-		8.3,
-		2.8,
-		.13
-	]]
-};
-function domainWarp2(fieldFn, options = {}) {
-	const { offsets = IQ_WARP_OFFSETS, name = "domainWarp2" } = options;
-	const key = `${fieldFnId(fieldFn)}|${name}|${JSON.stringify(offsets)}`;
-	const cached = warpCache.get(key);
-	if (cached) return cached;
-	const warpField = fieldFn;
-	const [QX, QY, QZ] = offsets.q[0];
-	const [Q2X, Q2Y, Q2Z] = offsets.q[1];
-	const [RX, RY, RZ] = offsets.r[0];
-	const [R2X, R2Y, R2Z] = offsets.r[1];
-	const built = typegpu_default.fn([
-		vec3f,
-		f32,
-		f32
-	], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((pos, t, warpAmount) => {
-		"use gpu";
-		const qx = warpField(pos.add(vec3f(__tsover_mul(t, QX), __tsover_mul(t, QY), QZ)));
-		const qy = warpField(pos.add(vec3f(Q2X, Q2Y, __tsover_mul(t, Q2Z))));
-		const warped1 = pos.add(vec3f(qx, qy, 0).mul(warpAmount));
-		const rx = warpField(warped1.add(vec3f(RX, RY, __tsover_mul(t, RZ))));
-		const ry = warpField(warped1.add(vec3f(R2X, R2Y, __tsover_mul(t, R2Z))));
-		return pos.add(vec3f(rx, ry, 0).mul(warpAmount));
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [
-				{
-					"type": "i",
-					"name": "pos"
-				},
-				{
-					"type": "i",
-					"name": "t"
-				},
-				{
-					"type": "i",
-					"name": "warpAmount"
-				}
-			],
-			"body": [0, [
-				[
-					13,
-					"qx",
-					[
-						6,
-						"warpField",
-						[[
-							6,
-							[
-								7,
-								"pos",
-								"add"
-							],
-							[[
-								6,
-								"d.vec3f",
-								[
-									[
-										1,
-										"t",
-										"*",
-										"QX"
-									],
-									[
-										1,
-										"t",
-										"*",
-										"QY"
-									],
-									"QZ"
-								]
-							]]
-						]]
-					]
-				],
-				[
-					13,
-					"qy",
-					[
-						6,
-						"warpField",
-						[[
-							6,
-							[
-								7,
-								"pos",
-								"add"
-							],
-							[[
-								6,
-								"d.vec3f",
-								[
-									"Q2X",
-									"Q2Y",
-									[
-										1,
-										"t",
-										"*",
-										"Q2Z"
-									]
-								]
-							]]
-						]]
-					]
-				],
-				[
-					13,
-					"warped1",
-					[
-						6,
-						[
-							7,
-							"pos",
-							"add"
-						],
-						[[
-							6,
-							[
-								7,
-								[
-									6,
-									"d.vec3f",
-									[
-										"qx",
-										"qy",
-										[5, "0"]
-									]
-								],
-								"mul"
-							],
-							["warpAmount"]
-						]]
-					]
-				],
-				[
-					13,
-					"rx",
-					[
-						6,
-						"warpField",
-						[[
-							6,
-							[
-								7,
-								"warped1",
-								"add"
-							],
-							[[
-								6,
-								"d.vec3f",
-								[
-									"RX",
-									"RY",
-									[
-										1,
-										"t",
-										"*",
-										"RZ"
-									]
-								]
-							]]
-						]]
-					]
-				],
-				[
-					13,
-					"ry",
-					[
-						6,
-						"warpField",
-						[[
-							6,
-							[
-								7,
-								"warped1",
-								"add"
-							],
-							[[
-								6,
-								"d.vec3f",
-								[
-									"R2X",
-									"R2Y",
-									[
-										1,
-										"t",
-										"*",
-										"R2Z"
-									]
-								]
-							]]
-						]]
-					]
-				],
-				[10, [
-					6,
-					[
-						7,
-						"pos",
-						"add"
-					],
-					[[
-						6,
-						[
-							7,
-							[
-								6,
-								"d.vec3f",
-								[
-									"rx",
-									"ry",
-									[5, "0"]
-								]
-							],
-							"mul"
-						],
-						["warpAmount"]
-					]]
-				]]
-			]]
-		},
-		externals: {
-			"warpField": () => warpField,
-			"d.vec3f": () => vec3f,
-			"QX": () => QX,
-			"QY": () => QY,
-			"QZ": () => QZ,
-			"Q2X": () => Q2X,
-			"Q2Y": () => Q2Y,
-			"Q2Z": () => Q2Z,
-			"RX": () => RX,
-			"RY": () => RY,
-			"RZ": () => RZ,
-			"R2X": () => R2X,
-			"R2Y": () => R2Y,
-			"R2Z": () => R2Z
-		}
-	}) && $.f)({})).$name(name);
-	warpCache.set(key, built);
-	return built;
-}
-var warpCache = /* @__PURE__ */ new Map();
-export { timeAxisDomain as a, pixelGridDomain as i, domainWarp2 as n, fbmGated as r, aspectScaledDomain as t };