shaders 2.5.135 → 3.0.436

package/dist/core/Blob-wBvtPxKh.js

@@ -0,0 +1,1653 @@
+import { At as call, Qt as mixColorsVariants, R as std, Zt as mixColorsLinear, gt as mixColorStopsRuntime, n as tgpu, on as d } from "./coords-BxHv8WrA.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-fqzznt4g.js";
+import { m as colorStopsPropConfig, t as animatedTime } from "./porters-7vtm6PTd.js";
+const blobOrganicRadius = tgpu.fn([
+	d.vec2f,
+	d.f32,
+	d.f32,
+	d.f32
+], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, size, deformation, animTime) => {
+	"use gpu";
+	const ns = d.f32(4);
+	const at = animTime;
+	const noise1 = __tsover_mul(__tsover_mul(__tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(uv.x, __tsover_mul(ns, .8)), __tsover_mul(at, .8))), std.sin(__tsover_add(__tsover_mul(uv.y, __tsover_mul(ns, .7)), __tsover_mul(at, .6)))), std.sin(__tsover_sub(__tsover_mul(uv.x, __tsover_mul(ns, 1.2)), __tsover_add(__tsover_mul(uv.y, __tsover_mul(ns, .9)), __tsover_mul(at, .4))))), .15), deformation);
+	const noise2 = __tsover_mul(__tsover_mul(__tsover_mul(std.sin(__tsover_sub(__tsover_mul(uv.x, __tsover_mul(ns, 1.4)), __tsover_mul(at, .5))), std.sin(__tsover_add(__tsover_mul(uv.y, __tsover_mul(ns, 1.1)), __tsover_mul(at, .7)))), .12), deformation);
+	const noise3 = __tsover_mul(__tsover_mul(__tsover_add(std.sin(__tsover_add(__tsover_mul(uv.x, __tsover_mul(ns, 1.8)), __tsover_add(__tsover_mul(uv.y, __tsover_mul(ns, 1.6)), __tsover_mul(at, .3)))), std.sin(__tsover_sub(__tsover_mul(uv.x, __tsover_mul(ns, .6)), __tsover_mul(at, .9)))), .1), deformation);
+	const noise4 = __tsover_mul(__tsover_mul(__tsover_mul(std.sin(__tsover_add(__tsover_mul(uv.x, __tsover_mul(ns, 2.2)), __tsover_mul(at, .2))), std.sin(__tsover_sub(__tsover_mul(uv.y, __tsover_mul(ns, 1.9)), __tsover_mul(at, .8)))), .04), deformation);
+	return __tsover_add(size, __tsover_add(__tsover_add(__tsover_add(noise1, noise2), noise3), noise4));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "size"
+			},
+			{
+				"type": "i",
+				"name": "deformation"
+			},
+			{
+				"type": "i",
+				"name": "animTime"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"ns",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "4"]]
+				]
+			],
+			[
+				13,
+				"at",
+				"animTime"
+			],
+			[
+				13,
+				"noise1",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"std",
+										"sin"
+									],
+									[[
+										1,
+										[
+											1,
+											[
+												7,
+												"uv",
+												"x"
+											],
+											"*",
+											[
+												1,
+												"ns",
+												"*",
+												[5, "0.8"]
+											]
+										],
+										"+",
+										[
+											1,
+											"at",
+											"*",
+											[5, "0.8"]
+										]
+									]]
+								],
+								"*",
+								[
+									6,
+									[
+										7,
+										"std",
+										"sin"
+									],
+									[[
+										1,
+										[
+											1,
+											[
+												7,
+												"uv",
+												"y"
+											],
+											"*",
+											[
+												1,
+												"ns",
+												"*",
+												[5, "0.7"]
+											]
+										],
+										"+",
+										[
+											1,
+											"at",
+											"*",
+											[5, "0.6"]
+										]
+									]]
+								]
+							],
+							"+",
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										1,
+										[
+											7,
+											"uv",
+											"x"
+										],
+										"*",
+										[
+											1,
+											"ns",
+											"*",
+											[5, "1.2"]
+										]
+									],
+									"-",
+									[
+										1,
+										[
+											1,
+											[
+												7,
+												"uv",
+												"y"
+											],
+											"*",
+											[
+												1,
+												"ns",
+												"*",
+												[5, "0.9"]
+											]
+										],
+										"+",
+										[
+											1,
+											"at",
+											"*",
+											[5, "0.4"]
+										]
+									]
+								]]
+							]
+						],
+						"*",
+						[5, "0.15"]
+					],
+					"*",
+					"deformation"
+				]
+			],
+			[
+				13,
+				"noise2",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										1,
+										[
+											7,
+											"uv",
+											"x"
+										],
+										"*",
+										[
+											1,
+											"ns",
+											"*",
+											[5, "1.4"]
+										]
+									],
+									"-",
+									[
+										1,
+										"at",
+										"*",
+										[5, "0.5"]
+									]
+								]]
+							],
+							"*",
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										1,
+										[
+											7,
+											"uv",
+											"y"
+										],
+										"*",
+										[
+											1,
+											"ns",
+											"*",
+											[5, "1.1"]
+										]
+									],
+									"+",
+									[
+										1,
+										"at",
+										"*",
+										[5, "0.7"]
+									]
+								]]
+							]
+						],
+						"*",
+						[5, "0.12"]
+					],
+					"*",
+					"deformation"
+				]
+			],
+			[
+				13,
+				"noise3",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										1,
+										[
+											7,
+											"uv",
+											"x"
+										],
+										"*",
+										[
+											1,
+											"ns",
+											"*",
+											[5, "1.8"]
+										]
+									],
+									"+",
+									[
+										1,
+										[
+											1,
+											[
+												7,
+												"uv",
+												"y"
+											],
+											"*",
+											[
+												1,
+												"ns",
+												"*",
+												[5, "1.6"]
+											]
+										],
+										"+",
+										[
+											1,
+											"at",
+											"*",
+											[5, "0.3"]
+										]
+									]
+								]]
+							],
+							"+",
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										1,
+										[
+											7,
+											"uv",
+											"x"
+										],
+										"*",
+										[
+											1,
+											"ns",
+											"*",
+											[5, "0.6"]
+										]
+									],
+									"-",
+									[
+										1,
+										"at",
+										"*",
+										[5, "0.9"]
+									]
+								]]
+							]
+						],
+						"*",
+						[5, "0.1"]
+					],
+					"*",
+					"deformation"
+				]
+			],
+			[
+				13,
+				"noise4",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										1,
+										[
+											7,
+											"uv",
+											"x"
+										],
+										"*",
+										[
+											1,
+											"ns",
+											"*",
+											[5, "2.2"]
+										]
+									],
+									"+",
+									[
+										1,
+										"at",
+										"*",
+										[5, "0.2"]
+									]
+								]]
+							],
+							"*",
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										1,
+										[
+											7,
+											"uv",
+											"y"
+										],
+										"*",
+										[
+											1,
+											"ns",
+											"*",
+											[5, "1.9"]
+										]
+									],
+									"-",
+									[
+										1,
+										"at",
+										"*",
+										[5, "0.8"]
+									]
+								]]
+							]
+						],
+						"*",
+						[5, "0.04"]
+					],
+					"*",
+					"deformation"
+				]
+			],
+			[10, [
+				1,
+				"size",
+				"+",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"noise1",
+							"+",
+							"noise2"
+						],
+						"+",
+						"noise3"
+					],
+					"+",
+					"noise4"
+				]
+			]]
+		]],
+		"externalNames": ["d", "std"]
+	},
+	externals: () => ({
+		d,
+		std
+	})
+}) && $.f)({}));
+const blobField = tgpu.fn([
+	d.vec2f,
+	d.vec2f,
+	d.vec2f,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32
+], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((baseUV, viewport, center, size, deformation, softness, highlightIntensity, normLx, normLy, normLz, animTime) => {
+	"use gpu";
+	const edgeWidth = __tsover_mul(softness, .3);
+	const edgeCurve = __tsover_add(__tsover_mul(softness, 2), .5);
+	const aspect = __tsover_div(viewport.x, viewport.y);
+	const uv = d.vec2f(__tsover_sub(__tsover_mul(baseUV.x, aspect), __tsover_mul(center.x, aspect)), __tsover_sub(baseUV.y, __tsover_sub(1, center.y)));
+	const dist = std.length(uv);
+	const organicRadius = blobOrganicRadius(uv, size, deformation, animTime);
+	const linearMask = __tsover_sub(1, std.smoothstep(__tsover_sub(organicRadius, edgeWidth), __tsover_add(organicRadius, edgeWidth), dist));
+	const blobMask = std.pow(linearMask, edgeCurve);
+	const normalTilt = std.smoothstep(0, organicRadius, dist);
+	const fakeZ = __tsover_sub(1, __tsover_mul(normalTilt, .1));
+	const tilted = __tsover_add(normalTilt, .2);
+	const surfaceNormal = std.normalize(d.vec3f(__tsover_mul(uv.x, tilted), __tsover_mul(uv.y, tilted), fakeZ));
+	const lightDir = d.vec3f(normLx, normLy, normLz);
+	const viewDir = d.vec3f(0, 0, 1);
+	const reflectDir = std.reflect(lightDir.mul(-1), surfaceNormal);
+	const specDot = std.max(0, std.dot(reflectDir, viewDir));
+	const specular = std.pow(specDot, 32);
+	const curvatureBoost = __tsover_add(__tsover_mul(normalTilt, .5), .5);
+	const finalHighlight = __tsover_mul(__tsover_mul(__tsover_mul(specular, curvatureBoost), highlightIntensity), blobMask);
+	const posX = __tsover_mul(uv.x, 3);
+	const posY = __tsover_mul(uv.y, 3);
+	const colorNoise1 = __tsover_add(__tsover_mul(__tsover_add(__tsover_mul(std.sin(__tsover_add(posX, __tsover_mul(animTime, .4))), std.sin(__tsover_add(posY, __tsover_mul(animTime, .3)))), std.sin(__tsover_add(__tsover_add(__tsover_mul(posX, .7), __tsover_mul(posY, .8)), __tsover_mul(animTime, .2)))), .5), .5);
+	const colorNoise2 = __tsover_add(__tsover_mul(__tsover_add(__tsover_mul(std.sin(__tsover_sub(__tsover_mul(posX, 1.3), __tsover_mul(animTime, .5))), std.sin(__tsover_add(__tsover_mul(posY, 1.1), __tsover_mul(animTime, .6)))), std.sin(__tsover_sub(__tsover_mul(posX, .5), __tsover_sub(__tsover_mul(posY, .6), __tsover_mul(animTime, .3))))), .5), .5);
+	const combinedNoise = __tsover_add(__tsover_mul(colorNoise1, .6), __tsover_mul(colorNoise2, .4));
+	const mixFactor = std.smoothstep(.1, .9, combinedNoise);
+	return d.vec3f(mixFactor, finalHighlight, blobMask);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "baseUV"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "center"
+			},
+			{
+				"type": "i",
+				"name": "size"
+			},
+			{
+				"type": "i",
+				"name": "deformation"
+			},
+			{
+				"type": "i",
+				"name": "softness"
+			},
+			{
+				"type": "i",
+				"name": "highlightIntensity"
+			},
+			{
+				"type": "i",
+				"name": "normLx"
+			},
+			{
+				"type": "i",
+				"name": "normLy"
+			},
+			{
+				"type": "i",
+				"name": "normLz"
+			},
+			{
+				"type": "i",
+				"name": "animTime"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"edgeWidth",
+				[
+					1,
+					"softness",
+					"*",
+					[5, "0.3"]
+				]
+			],
+			[
+				13,
+				"edgeCurve",
+				[
+					1,
+					[
+						1,
+						"softness",
+						"*",
+						[5, "2"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"aspect",
+				[
+					1,
+					[
+						7,
+						"viewport",
+						"x"
+					],
+					"/",
+					[
+						7,
+						"viewport",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"uv",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"baseUV",
+								"x"
+							],
+							"*",
+							"aspect"
+						],
+						"-",
+						[
+							1,
+							[
+								7,
+								"center",
+								"x"
+							],
+							"*",
+							"aspect"
+						]
+					], [
+						1,
+						[
+							7,
+							"baseUV",
+							"y"
+						],
+						"-",
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								7,
+								"center",
+								"y"
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"dist",
+				[
+					6,
+					[
+						7,
+						"std",
+						"length"
+					],
+					["uv"]
+				]
+			],
+			[
+				13,
+				"organicRadius",
+				[
+					6,
+					"blobOrganicRadius",
+					[
+						"uv",
+						"size",
+						"deformation",
+						"animTime"
+					]
+				]
+			],
+			[
+				13,
+				"linearMask",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						[
+							7,
+							"std",
+							"smoothstep"
+						],
+						[
+							[
+								1,
+								"organicRadius",
+								"-",
+								"edgeWidth"
+							],
+							[
+								1,
+								"organicRadius",
+								"+",
+								"edgeWidth"
+							],
+							"dist"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"blobMask",
+				[
+					6,
+					[
+						7,
+						"std",
+						"pow"
+					],
+					["linearMask", "edgeCurve"]
+				]
+			],
+			[
+				13,
+				"normalTilt",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						[5, "0"],
+						"organicRadius",
+						"dist"
+					]
+				]
+			],
+			[
+				13,
+				"fakeZ",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						1,
+						"normalTilt",
+						"*",
+						[5, "0.1"]
+					]
+				]
+			],
+			[
+				13,
+				"tilted",
+				[
+					1,
+					"normalTilt",
+					"+",
+					[5, "0.2"]
+				]
+			],
+			[
+				13,
+				"surfaceNormal",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								1,
+								[
+									7,
+									"uv",
+									"x"
+								],
+								"*",
+								"tilted"
+							],
+							[
+								1,
+								[
+									7,
+									"uv",
+									"y"
+								],
+								"*",
+								"tilted"
+							],
+							"fakeZ"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"lightDir",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						"normLx",
+						"normLy",
+						"normLz"
+					]
+				]
+			],
+			[
+				13,
+				"viewDir",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						[5, "0"],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"reflectDir",
+				[
+					6,
+					[
+						7,
+						"std",
+						"reflect"
+					],
+					[[
+						6,
+						[
+							7,
+							"lightDir",
+							"mul"
+						],
+						[[
+							4,
+							"-",
+							[5, "1"]
+						]]
+					], "surfaceNormal"]
+				]
+			],
+			[
+				13,
+				"specDot",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[5, "0"], [
+						6,
+						[
+							7,
+							"std",
+							"dot"
+						],
+						["reflectDir", "viewDir"]
+					]]
+				]
+			],
+			[
+				13,
+				"specular",
+				[
+					6,
+					[
+						7,
+						"std",
+						"pow"
+					],
+					["specDot", [5, "32"]]
+				]
+			],
+			[
+				13,
+				"curvatureBoost",
+				[
+					1,
+					[
+						1,
+						"normalTilt",
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"finalHighlight",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"specular",
+							"*",
+							"curvatureBoost"
+						],
+						"*",
+						"highlightIntensity"
+					],
+					"*",
+					"blobMask"
+				]
+			],
+			[
+				13,
+				"posX",
+				[
+					1,
+					[
+						7,
+						"uv",
+						"x"
+					],
+					"*",
+					[5, "3"]
+				]
+			],
+			[
+				13,
+				"posY",
+				[
+					1,
+					[
+						7,
+						"uv",
+						"y"
+					],
+					"*",
+					[5, "3"]
+				]
+			],
+			[
+				13,
+				"colorNoise1",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"std",
+										"sin"
+									],
+									[[
+										1,
+										"posX",
+										"+",
+										[
+											1,
+											"animTime",
+											"*",
+											[5, "0.4"]
+										]
+									]]
+								],
+								"*",
+								[
+									6,
+									[
+										7,
+										"std",
+										"sin"
+									],
+									[[
+										1,
+										"posY",
+										"+",
+										[
+											1,
+											"animTime",
+											"*",
+											[5, "0.3"]
+										]
+									]]
+								]
+							],
+							"+",
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										1,
+										[
+											1,
+											"posX",
+											"*",
+											[5, "0.7"]
+										],
+										"+",
+										[
+											1,
+											"posY",
+											"*",
+											[5, "0.8"]
+										]
+									],
+									"+",
+									[
+										1,
+										"animTime",
+										"*",
+										[5, "0.2"]
+									]
+								]]
+							]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"colorNoise2",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"std",
+										"sin"
+									],
+									[[
+										1,
+										[
+											1,
+											"posX",
+											"*",
+											[5, "1.3"]
+										],
+										"-",
+										[
+											1,
+											"animTime",
+											"*",
+											[5, "0.5"]
+										]
+									]]
+								],
+								"*",
+								[
+									6,
+									[
+										7,
+										"std",
+										"sin"
+									],
+									[[
+										1,
+										[
+											1,
+											"posY",
+											"*",
+											[5, "1.1"]
+										],
+										"+",
+										[
+											1,
+											"animTime",
+											"*",
+											[5, "0.6"]
+										]
+									]]
+								]
+							],
+							"+",
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										1,
+										"posX",
+										"*",
+										[5, "0.5"]
+									],
+									"-",
+									[
+										1,
+										[
+											1,
+											"posY",
+											"*",
+											[5, "0.6"]
+										],
+										"-",
+										[
+											1,
+											"animTime",
+											"*",
+											[5, "0.3"]
+										]
+									]
+								]]
+							]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"combinedNoise",
+				[
+					1,
+					[
+						1,
+						"colorNoise1",
+						"*",
+						[5, "0.6"]
+					],
+					"+",
+					[
+						1,
+						"colorNoise2",
+						"*",
+						[5, "0.4"]
+					]
+				]
+			],
+			[
+				13,
+				"mixFactor",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						[5, "0.1"],
+						[5, "0.9"],
+						"combinedNoise"
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec3f"
+				],
+				[
+					"mixFactor",
+					"finalHighlight",
+					"blobMask"
+				]
+			]]
+		]],
+		"externalNames": [
+			"d",
+			"std",
+			"blobOrganicRadius"
+		]
+	},
+	externals: () => ({
+		d,
+		std,
+		blobOrganicRadius
+	})
+}) && $.f)({}));
+const blobCompose = tgpu.fn([
+	d.vec4f,
+	d.vec4f,
+	d.f32,
+	d.f32,
+	d.f32
+], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((colorMix, highlightColor, finalHighlight, avgAlpha, blobMask) => {
+	"use gpu";
+	const highlightContribution = highlightColor.xyz.mul(finalHighlight);
+	const rgb = colorMix.xyz.add(highlightContribution);
+	return d.vec4f(rgb, __tsover_mul(avgAlpha, blobMask));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "colorMix"
+			},
+			{
+				"type": "i",
+				"name": "highlightColor"
+			},
+			{
+				"type": "i",
+				"name": "finalHighlight"
+			},
+			{
+				"type": "i",
+				"name": "avgAlpha"
+			},
+			{
+				"type": "i",
+				"name": "blobMask"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"highlightContribution",
+				[
+					6,
+					[
+						7,
+						[
+							7,
+							"highlightColor",
+							"xyz"
+						],
+						"mul"
+					],
+					["finalHighlight"]
+				]
+			],
+			[
+				13,
+				"rgb",
+				[
+					6,
+					[
+						7,
+						[
+							7,
+							"colorMix",
+							"xyz"
+						],
+						"add"
+					],
+					["highlightContribution"]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				["rgb", [
+					1,
+					"avgAlpha",
+					"*",
+					"blobMask"
+				]]
+			]]
+		]],
+		"externalNames": ["d"]
+	},
+	externals: () => ({ d })
+}) && $.f)({}));
+const componentDefinition = {
+	name: "Blob",
+	category: "Textures",
+	description: "Organic animated blob with 3D lighting and gradients",
+	acceptsUVContext: true,
+	animatedTime: { speed: "speed" },
+	extraFields: {
+		normLx: {
+			schema: d.f32,
+			initial: 0
+		},
+		normLy: {
+			schema: d.f32,
+			initial: 0
+		},
+		normLz: {
+			schema: d.f32,
+			initial: 1
+		}
+	},
+	boundingBoxDeclaration: {
+		propBindings: {
+			x: {
+				prop: "center",
+				as: "position-x"
+			},
+			y: {
+				prop: "center",
+				as: "position-y"
+			}
+		},
+		computeBounds(props, cw, ch) {
+			const size = props.size ?? .5;
+			const cx = props.center?.x ?? .5;
+			const cy = props.center?.y ?? .5;
+			const diameter = size * 2 * ch;
+			return {
+				centerXPx: cx * cw,
+				centerYPx: cy * ch,
+				widthPx: diameter,
+				heightPx: diameter,
+				rotationDeg: 0
+			};
+		},
+		writeBounds(bounds, currentProps, cw, ch) {
+			const newSize = Math.max(0, bounds.widthPx / (2 * ch));
+			return {
+				center: {
+					...currentProps.center ?? {
+						x: .5,
+						y: .5
+					},
+					x: bounds.centerXPx / cw,
+					y: bounds.centerYPx / ch
+				},
+				size: newSize
+			};
+		},
+		softnessBinding: {
+			prop: "softness",
+			toPx: (v, _, ch) => v * .3 * ch,
+			fromPx: (px, _, ch) => Math.max(0, Math.min(1, px / (.3 * ch)))
+		}
+	},
+	props: {
+		origin: {
+			default: "center",
+			description: "Reference edge the center position is measured from (center default). Lets you pin the shape relative to a corner or the canvas centre.",
+			ui: {
+				type: "origin",
+				label: "Origin",
+				group: "Position"
+			}
+		},
+		colorA: {
+			default: "#ff6b35",
+			transform: transformColor,
+			description: "Primary color of the blob",
+			ui: {
+				type: "color",
+				label: "Color A",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#e91e63",
+			transform: transformColor,
+			description: "Secondary color of the blob",
+			ui: {
+				type: "color",
+				label: "Color B",
+				group: "Colors"
+			}
+		},
+		stops: colorStopsPropConfig(),
+		size: {
+			default: .5,
+			description: "Size of the blob",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Size",
+				group: "Effect"
+			}
+		},
+		deformation: {
+			default: .5,
+			description: "How organic and blobby the shape is (0 = circle, 1 = very blobby)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .1,
+				label: "Deformation",
+				group: "Effect"
+			}
+		},
+		softness: {
+			default: .5,
+			description: "Softness of the blob edges (combines edge width and transition curve)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .1,
+				label: "Softness",
+				group: "Effect"
+			}
+		},
+		highlightIntensity: {
+			default: .5,
+			description: "Intensity of specular highlight effect",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .1,
+				label: "Highlight Intensity",
+				group: "Highlight"
+			}
+		},
+		highlightX: {
+			default: .3,
+			description: "Light direction X component",
+			ui: {
+				type: "range",
+				min: -1,
+				max: 1,
+				step: .1,
+				label: "Highlight X",
+				group: "Highlight"
+			}
+		},
+		highlightY: {
+			default: -.3,
+			description: "Light direction Y component",
+			ui: {
+				type: "range",
+				min: -1,
+				max: 1,
+				step: .1,
+				label: "Highlight Y",
+				group: "Highlight"
+			}
+		},
+		highlightZ: {
+			default: .4,
+			description: "Light direction Z component",
+			ui: {
+				type: "range",
+				min: -1,
+				max: 1,
+				step: .1,
+				label: "Highlight Z",
+				group: "Highlight"
+			}
+		},
+		highlightColor: {
+			default: "#ffe11a",
+			transform: transformColor,
+			description: "Color of the specular highlight",
+			ui: {
+				type: "color",
+				label: "Highlight Color",
+				group: "Highlight"
+			}
+		},
+		speed: {
+			default: .5,
+			description: "Animation speed",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 2,
+				step: .1,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		seed: {
+			default: 1,
+			description: "Adjusts the starting state, useful for variation",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Effect"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "The center point of the blob",
+			ui: {
+				type: "position",
+				label: "Center Position",
+				group: "Position",
+				units: ["%", "px"]
+			}
+		},
+		colorSpace: {
+			default: "linear",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Color space for color interpolation",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Colors"
+			}
+		}
+	},
+	fragment: (params) => {
+		const { uniforms, ctx, propValues } = params;
+		const uv = params.uvContext ?? ctx.uv;
+		const viewport = ctx.viewportSize;
+		const animTime = animatedTime(params, "seed");
+		params.onBeforeRender(() => {
+			const lx = params.getCpuValue("highlightX");
+			const ly = params.getCpuValue("highlightY");
+			const lz = params.getCpuValue("highlightZ");
+			const len = Math.sqrt(lx * lx + ly * ly + lz * lz);
+			if (len > 0) {
+				params.setExtraField("normLx", lx / len);
+				params.setExtraField("normLy", ly / len);
+				params.setExtraField("normLz", lz / len);
+			} else {
+				params.setExtraField("normLx", 0);
+				params.setExtraField("normLy", 0);
+				params.setExtraField("normLz", 0);
+			}
+		});
+		const field = call(blobField, "blobField", [
+			uv,
+			viewport,
+			uniforms.center,
+			uniforms.size,
+			uniforms.deformation,
+			uniforms.softness,
+			uniforms.highlightIntensity,
+			uniforms.normLx,
+			uniforms.normLy,
+			uniforms.normLz,
+			animTime
+		]);
+		const mixFactor = field.member("x");
+		const finalHighlight = field.member("y");
+		const blobMask = field.member("z");
+		const colorSpaceMode = propValues.colorSpace ?? 0;
+		const stopCount = propValues.stopCount ?? 0;
+		let colorMix;
+		if (stopCount > 1) colorMix = mixColorStopsRuntime(mixFactor, {
+			colorsArray: uniforms.colorsArray,
+			positionsArray: uniforms.positionsArray,
+			convertedColorsArray: uniforms.convertedColorsArray,
+			stopCount: uniforms.stopCount
+		}, colorSpaceMode);
+		else colorMix = call(mixColorsVariants[colorSpaceMode] ?? mixColorsLinear, "mixColors", [
+			uniforms.colorA,
+			uniforms.colorB,
+			mixFactor
+		]);
+		const avgAlpha = uniforms.colorA.member("a").add(uniforms.colorB.member("a")).mul(.5);
+		return call(blobCompose, "blobCompose", [
+			colorMix,
+			uniforms.highlightColor,
+			finalHighlight,
+			avgAlpha,
+			blobMask
+		]);
+	}
+};
+var Blob_default = componentDefinition;
+export { componentDefinition as a, blobOrganicRadius as i, blobCompose as n, blobField as r, Blob_default as t };