shaders 2.5.135 → 3.0.437

package/dist/core/LiquidMetal-PGUaQGV-.js

@@ -0,0 +1,2561 @@
+import { At as call, It as vec4, Pt as floatE, R as std, T as sdf_exports, at as perlin12d, d as sdf3d_exports, n as tgpu, on as d, rt as noise_exports } from "./coords-BlwgBpJf.js";
+import { n as glass_exports } from "./glass-DdgMBWkF.js";
+import { a as transformColor, c as transformPosition } from "./transformations-fqzznt4g.js";
+import { t as animatedTime } from "./porters-CoaznI7i.js";
+import { t as shapeEffectBoundingBoxDeclaration } from "./shapeEffectBounds-BlxxsYMN.js";
+var { sdfSpaceUV, offsetUV } = glass_exports;
+var { createSvgSdfSampler, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
+var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS, is3dShapeType, isVolumetricShapeType, isMobileGpuViewport } = sdf3d_exports;
+var DEG_TO_RAD = .017453292519943295;
+var DEFAULT_SHAPE_CONFIG = JSON.stringify({
+	type: "circleSDF",
+	radius: .35
+});
+function resolveShapeType(shapeType, shape) {
+	if (shapeType) return shapeType;
+	if (shape && typeof shape === "object") return shape.type || "circleSDF";
+	if (typeof shape === "string") try {
+		return JSON.parse(shape).type || "circleSDF";
+	} catch {
+		return "circleSDF";
+	}
+	return "circleSDF";
+}
+const liquidStudio = tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32
+], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rx, ry, envC, envS, keyRad, drift, envStr) => {
+	"use gpu";
+	const ex = __tsover_sub(__tsover_mul(rx, envC), __tsover_mul(ry, envS));
+	const ey = __tsover_add(__tsover_mul(rx, envS), __tsover_mul(ry, envC));
+	const p = d.vec2f(ex, ey);
+	const sky = std.smoothstep(-.7, .85, ey);
+	let lum = __tsover_mul(__tsover_mul(sky, sky), .4);
+	const r0 = __tsover_mul(keyRad, 1.05);
+	const box0 = std.smoothstep(r0, __tsover_mul(r0, .2), std.length(p.sub(d.vec2f(__tsover_add(0, drift), .55))));
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(box0, 1.75), envStr));
+	const r1 = __tsover_mul(keyRad, 1.25);
+	const box1 = std.smoothstep(r1, __tsover_mul(r1, .2), std.length(p.sub(d.vec2f(__tsover_add(-.45, drift), -.4))));
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(box1, 1.15), envStr));
+	const r2 = __tsover_mul(keyRad, 1.15);
+	const box2 = std.smoothstep(r2, __tsover_mul(r2, .2), std.length(p.sub(d.vec2f(__tsover_add(.55, drift), .1))));
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(box2, 1.1), envStr));
+	return lum;
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "rx"
+			},
+			{
+				"type": "i",
+				"name": "ry"
+			},
+			{
+				"type": "i",
+				"name": "envC"
+			},
+			{
+				"type": "i",
+				"name": "envS"
+			},
+			{
+				"type": "i",
+				"name": "keyRad"
+			},
+			{
+				"type": "i",
+				"name": "drift"
+			},
+			{
+				"type": "i",
+				"name": "envStr"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"ex",
+				[
+					1,
+					[
+						1,
+						"rx",
+						"*",
+						"envC"
+					],
+					"-",
+					[
+						1,
+						"ry",
+						"*",
+						"envS"
+					]
+				]
+			],
+			[
+				13,
+				"ey",
+				[
+					1,
+					[
+						1,
+						"rx",
+						"*",
+						"envS"
+					],
+					"+",
+					[
+						1,
+						"ry",
+						"*",
+						"envC"
+					]
+				]
+			],
+			[
+				13,
+				"p",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					["ex", "ey"]
+				]
+			],
+			[
+				13,
+				"sky",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						[
+							4,
+							"-",
+							[5, "0.7"]
+						],
+						[5, "0.85"],
+						"ey"
+					]
+				]
+			],
+			[
+				12,
+				"lum",
+				[
+					1,
+					[
+						1,
+						"sky",
+						"*",
+						"sky"
+					],
+					"*",
+					[5, "0.4"]
+				]
+			],
+			[
+				13,
+				"r0",
+				[
+					1,
+					"keyRad",
+					"*",
+					[5, "1.05"]
+				]
+			],
+			[
+				13,
+				"box0",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						"r0",
+						[
+							1,
+							"r0",
+							"*",
+							[5, "0.2"]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"length"
+							],
+							[[
+								6,
+								[
+									7,
+									"p",
+									"sub"
+								],
+								[[
+									6,
+									[
+										7,
+										"d",
+										"vec2f"
+									],
+									[[
+										1,
+										[5, "0"],
+										"+",
+										"drift"
+									], [5, "0.55"]]
+								]]
+							]]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"lum",
+				"=",
+				[
+					1,
+					"lum",
+					"+",
+					[
+						1,
+						[
+							1,
+							"box0",
+							"*",
+							[5, "1.75"]
+						],
+						"*",
+						"envStr"
+					]
+				]
+			],
+			[
+				13,
+				"r1",
+				[
+					1,
+					"keyRad",
+					"*",
+					[5, "1.25"]
+				]
+			],
+			[
+				13,
+				"box1",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						"r1",
+						[
+							1,
+							"r1",
+							"*",
+							[5, "0.2"]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"length"
+							],
+							[[
+								6,
+								[
+									7,
+									"p",
+									"sub"
+								],
+								[[
+									6,
+									[
+										7,
+										"d",
+										"vec2f"
+									],
+									[[
+										1,
+										[
+											4,
+											"-",
+											[5, "0.45"]
+										],
+										"+",
+										"drift"
+									], [
+										4,
+										"-",
+										[5, "0.4"]
+									]]
+								]]
+							]]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"lum",
+				"=",
+				[
+					1,
+					"lum",
+					"+",
+					[
+						1,
+						[
+							1,
+							"box1",
+							"*",
+							[5, "1.15"]
+						],
+						"*",
+						"envStr"
+					]
+				]
+			],
+			[
+				13,
+				"r2",
+				[
+					1,
+					"keyRad",
+					"*",
+					[5, "1.15"]
+				]
+			],
+			[
+				13,
+				"box2",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						"r2",
+						[
+							1,
+							"r2",
+							"*",
+							[5, "0.2"]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"length"
+							],
+							[[
+								6,
+								[
+									7,
+									"p",
+									"sub"
+								],
+								[[
+									6,
+									[
+										7,
+										"d",
+										"vec2f"
+									],
+									[[
+										1,
+										[5, "0.55"],
+										"+",
+										"drift"
+									], [5, "0.1"]]
+								]]
+							]]
+						]
+					]
+				]
+			],
+			[
+				2,
+				"lum",
+				"=",
+				[
+					1,
+					"lum",
+					"+",
+					[
+						1,
+						[
+							1,
+							"box2",
+							"*",
+							[5, "1.1"]
+						],
+						"*",
+						"envStr"
+					]
+				]
+			],
+			[10, "lum"]
+		]],
+		"externalNames": ["d", "std"]
+	},
+	externals: () => ({
+		d,
+		std
+	})
+}) && $.f)({}));
+const liquidMetalComposite = tgpu.fn([
+	d.vec4f,
+	d.vec4f,
+	d.vec4f,
+	d.vec2f,
+	d.vec2f,
+	d.vec3f,
+	d.vec3f,
+	d.vec4f,
+	d.vec4f,
+	d.vec4f,
+	d.vec4f
+], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, viewportSize, lightColor, darkColor, p0, p1, p2, p3) => {
+	"use gpu";
+	const scl = p0.x;
+	const edgeSoftness = p0.y;
+	const ripple = p0.z;
+	const warp = p0.w;
+	const turbulence = p1.x;
+	const environment = p1.y;
+	const envRotation = p1.z;
+	const sharpness = p1.w;
+	const dispersion = p2.x;
+	const lightAngle = p2.y;
+	const animTime = p2.z;
+	const volumetric = p2.w;
+	const mobile = p3.x;
+	const sharpEdge = std.max(__tsover_mul(edgeSoftness, .5), .001);
+	const pxH = __tsover_div(1, viewportSize.y);
+	const sdfRaw = surf0.x;
+	const sdf = __tsover_div(sdfRaw, scl);
+	if (sdf > __tsover_mul(pxH, 2)) return d.vec4f(0, 0, 0, 0);
+	const EPS = .01;
+	const ddx = std.clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -5, 5);
+	const ddy = std.clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -5, 5);
+	const nVol = std.normalize(d.vec3f(ddx, ddy, -1));
+	const gradX = __tsover_div(__tsover_sub(surfX.x, sdfRaw), EPS);
+	const gradY = __tsover_div(__tsover_sub(surfY.x, sdfRaw), EPS);
+	const rimT = std.clamp(__tsover_div(__tsover_mul(sdf, -1), .05), 0, 1);
+	const rimBevel = __tsover_mul(__tsover_sub(1, rimT), 1.6);
+	const nFlat = std.normalize(d.vec3f(__tsover_mul(gradX, rimBevel), __tsover_mul(gradY, rimBevel), -1));
+	const nGeo = std.select(nFlat, nVol, volumetric > .5);
+	const fx = std.select(__tsover_sub(sdfUV.x, .5), surf0.y, volumetric > .5);
+	const fy = std.select(__tsover_sub(sdfUV.y, .5), surf0.z, volumetric > .5);
+	const freq = __tsover_mul(ripple, 2.6);
+	const flowT = __tsover_mul(animTime, .12);
+	const q = d.vec2f(__tsover_mul(fx, freq), __tsover_mul(fy, freq));
+	const wAmt = __tsover_mul(warp, .9);
+	const warpInput = q.mul(.6);
+	const wx = __tsover_mul(std.sin(__tsover_add(__tsover_add(__tsover_mul(warpInput.x, 1.7), __tsover_mul(flowT, .7)), 1.7)), std.cos(__tsover_add(__tsover_add(__tsover_mul(warpInput.y, 1.3), __tsover_mul(flowT, .5)), 2.3)));
+	const wy = __tsover_mul(std.cos(__tsover_add(__tsover_add(__tsover_mul(warpInput.x, 1.4), __tsover_mul(flowT, .9)), 8.7)), std.sin(__tsover_add(__tsover_add(__tsover_mul(warpInput.y, 1.6), __tsover_mul(flowT, .6)), 5.1)));
+	const qw = q.add(d.vec2f(wx, wy).mul(wAmt));
+	const gMax = d.f32(4);
+	const nd = perlin12d(qw);
+	const reliefGrad = .62;
+	const hx = std.clamp(__tsover_mul(nd.y, reliefGrad), __tsover_mul(gMax, -1), gMax);
+	const hy = std.clamp(__tsover_mul(nd.z, reliefGrad), __tsover_mul(gMax, -1), gMax);
+	const relief = __tsover_mul(turbulence, .5);
+	const n = std.normalize(d.vec3f(__tsover_sub(nGeo.x, __tsover_mul(hx, relief)), __tsover_sub(nGeo.y, __tsover_mul(hy, relief)), nGeo.z));
+	const R = std.reflect(d.vec3f(0, 0, 1), n);
+	const envStr = environment;
+	const sharp = std.clamp(sharpness, 0, 1);
+	const keyRad = std.mix(.5, .18, sharp);
+	const drift = __tsover_mul(std.sin(__tsover_mul(animTime, .07)), .05);
+	const lx = std.cos(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const ly = std.sin(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const envC = std.cos(__tsover_mul(envRotation, DEG_TO_RAD));
+	const envS = std.sin(__tsover_mul(envRotation, DEG_TO_RAD));
+	const L = std.normalize(d.vec3f(lx, ly, -.7));
+	const Hh = std.normalize(L.add(d.vec3f(0, 0, -1)));
+	const ndh = std.clamp(__tsover_add(__tsover_add(__tsover_mul(n.x, Hh.x), __tsover_mul(n.y, Hh.y)), __tsover_mul(n.z, Hh.z)), 0, 1);
+	const spec = __tsover_mul(std.pow(ndh, std.mix(d.f32(60), d.f32(900), sharp)), std.mix(.4, 1.4, sharp));
+	const lumG = __tsover_add(liquidStudio(R.x, R.y, envC, envS, keyRad, drift, envStr), spec);
+	const grazeD = __tsover_sub(1, std.clamp(__tsover_mul(n.z, -1), 0, 1));
+	const dth = __tsover_mul(__tsover_mul(dispersion, .09), __tsover_add(.4, __tsover_mul(grazeD, 1.3)));
+	const lumBoffset = __tsover_add(liquidStudio(__tsover_add(R.x, __tsover_mul(R.y, dth)), __tsover_sub(R.y, __tsover_mul(R.x, dth)), envC, envS, keyRad, drift, envStr), spec);
+	const lumB = std.select(lumBoffset, lumG, mobile > .5);
+	const lumRdesktop = __tsover_sub(__tsover_mul(lumG, 2), lumBoffset);
+	const lumR = std.select(lumRdesktop, lumG, mobile > .5);
+	const rgb = d.vec3f(std.mix(darkColor.x, lightColor.x, std.clamp(lumR, 0, 1.8)), std.mix(darkColor.y, lightColor.y, std.clamp(lumG, 0, 1.8)), std.mix(darkColor.z, lightColor.z, std.clamp(lumB, 0, 1.8)));
+	const transition = std.smoothstep(0, 1, std.clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharpEdge), 32), 0, 1));
+	return d.vec4f(rgb.x, rgb.y, rgb.z, transition);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "surf0"
+			},
+			{
+				"type": "i",
+				"name": "surfX"
+			},
+			{
+				"type": "i",
+				"name": "surfY"
+			},
+			{
+				"type": "i",
+				"name": "sdfUV"
+			},
+			{
+				"type": "i",
+				"name": "viewportSize"
+			},
+			{
+				"type": "i",
+				"name": "lightColor"
+			},
+			{
+				"type": "i",
+				"name": "darkColor"
+			},
+			{
+				"type": "i",
+				"name": "p0"
+			},
+			{
+				"type": "i",
+				"name": "p1"
+			},
+			{
+				"type": "i",
+				"name": "p2"
+			},
+			{
+				"type": "i",
+				"name": "p3"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"scl",
+				[
+					7,
+					"p0",
+					"x"
+				]
+			],
+			[
+				13,
+				"edgeSoftness",
+				[
+					7,
+					"p0",
+					"y"
+				]
+			],
+			[
+				13,
+				"ripple",
+				[
+					7,
+					"p0",
+					"z"
+				]
+			],
+			[
+				13,
+				"warp",
+				[
+					7,
+					"p0",
+					"w"
+				]
+			],
+			[
+				13,
+				"turbulence",
+				[
+					7,
+					"p1",
+					"x"
+				]
+			],
+			[
+				13,
+				"environment",
+				[
+					7,
+					"p1",
+					"y"
+				]
+			],
+			[
+				13,
+				"envRotation",
+				[
+					7,
+					"p1",
+					"z"
+				]
+			],
+			[
+				13,
+				"sharpness",
+				[
+					7,
+					"p1",
+					"w"
+				]
+			],
+			[
+				13,
+				"dispersion",
+				[
+					7,
+					"p2",
+					"x"
+				]
+			],
+			[
+				13,
+				"lightAngle",
+				[
+					7,
+					"p2",
+					"y"
+				]
+			],
+			[
+				13,
+				"animTime",
+				[
+					7,
+					"p2",
+					"z"
+				]
+			],
+			[
+				13,
+				"volumetric",
+				[
+					7,
+					"p2",
+					"w"
+				]
+			],
+			[
+				13,
+				"mobile",
+				[
+					7,
+					"p3",
+					"x"
+				]
+			],
+			[
+				13,
+				"sharpEdge",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						"edgeSoftness",
+						"*",
+						[5, "0.5"]
+					], [5, "0.001"]]
+				]
+			],
+			[
+				13,
+				"pxH",
+				[
+					1,
+					[5, "1"],
+					"/",
+					[
+						7,
+						"viewportSize",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"sdfRaw",
+				[
+					7,
+					"surf0",
+					"x"
+				]
+			],
+			[
+				13,
+				"sdf",
+				[
+					1,
+					"sdfRaw",
+					"/",
+					"scl"
+				]
+			],
+			[
+				11,
+				[
+					1,
+					"sdf",
+					">",
+					[
+						1,
+						"pxH",
+						"*",
+						[5, "2"]
+					]
+				],
+				[10, [
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[5, "0"],
+						[5, "0"],
+						[5, "0"],
+						[5, "0"]
+					]
+				]]
+			],
+			[
+				13,
+				"EPS",
+				[5, "0.01"]
+			],
+			[
+				13,
+				"ddx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"surfX",
+									"w"
+								],
+								"-",
+								[
+									7,
+									"surf0",
+									"w"
+								]
+							],
+							"/",
+							"EPS"
+						],
+						[
+							4,
+							"-",
+							[5, "5"]
+						],
+						[5, "5"]
+					]
+				]
+			],
+			[
+				13,
+				"ddy",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"surfY",
+									"w"
+								],
+								"-",
+								[
+									7,
+									"surf0",
+									"w"
+								]
+							],
+							"/",
+							"EPS"
+						],
+						[
+							4,
+							"-",
+							[5, "5"]
+						],
+						[5, "5"]
+					]
+				]
+			],
+			[
+				13,
+				"nVol",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							"ddx",
+							"ddy",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"gradX",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"surfX",
+							"x"
+						],
+						"-",
+						"sdfRaw"
+					],
+					"/",
+					"EPS"
+				]
+			],
+			[
+				13,
+				"gradY",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"surfY",
+							"x"
+						],
+						"-",
+						"sdfRaw"
+					],
+					"/",
+					"EPS"
+				]
+			],
+			[
+				13,
+				"rimT",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								"sdf",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							"/",
+							[5, "0.05"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"rimBevel",
+				[
+					1,
+					[
+						1,
+						[5, "1"],
+						"-",
+						"rimT"
+					],
+					"*",
+					[5, "1.6"]
+				]
+			],
+			[
+				13,
+				"nFlat",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								1,
+								"gradX",
+								"*",
+								"rimBevel"
+							],
+							[
+								1,
+								"gradY",
+								"*",
+								"rimBevel"
+							],
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"nGeo",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"nFlat",
+						"nVol",
+						[
+							1,
+							"volumetric",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"fx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"sdfUV",
+								"x"
+							],
+							"-",
+							[5, "0.5"]
+						],
+						[
+							7,
+							"surf0",
+							"y"
+						],
+						[
+							1,
+							"volumetric",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"fy",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"sdfUV",
+								"y"
+							],
+							"-",
+							[5, "0.5"]
+						],
+						[
+							7,
+							"surf0",
+							"z"
+						],
+						[
+							1,
+							"volumetric",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"freq",
+				[
+					1,
+					"ripple",
+					"*",
+					[5, "2.6"]
+				]
+			],
+			[
+				13,
+				"flowT",
+				[
+					1,
+					"animTime",
+					"*",
+					[5, "0.12"]
+				]
+			],
+			[
+				13,
+				"q",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						"fx",
+						"*",
+						"freq"
+					], [
+						1,
+						"fy",
+						"*",
+						"freq"
+					]]
+				]
+			],
+			[
+				13,
+				"wAmt",
+				[
+					1,
+					"warp",
+					"*",
+					[5, "0.9"]
+				]
+			],
+			[
+				13,
+				"warpInput",
+				[
+					6,
+					[
+						7,
+						"q",
+						"mul"
+					],
+					[[5, "0.6"]]
+				]
+			],
+			[
+				13,
+				"wx",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"sin"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"warpInput",
+										"x"
+									],
+									"*",
+									[5, "1.7"]
+								],
+								"+",
+								[
+									1,
+									"flowT",
+									"*",
+									[5, "0.7"]
+								]
+							],
+							"+",
+							[5, "1.7"]
+						]]
+					],
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"cos"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"warpInput",
+										"y"
+									],
+									"*",
+									[5, "1.3"]
+								],
+								"+",
+								[
+									1,
+									"flowT",
+									"*",
+									[5, "0.5"]
+								]
+							],
+							"+",
+							[5, "2.3"]
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"wy",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"cos"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"warpInput",
+										"x"
+									],
+									"*",
+									[5, "1.4"]
+								],
+								"+",
+								[
+									1,
+									"flowT",
+									"*",
+									[5, "0.9"]
+								]
+							],
+							"+",
+							[5, "8.7"]
+						]]
+					],
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"sin"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"warpInput",
+										"y"
+									],
+									"*",
+									[5, "1.6"]
+								],
+								"+",
+								[
+									1,
+									"flowT",
+									"*",
+									[5, "0.6"]
+								]
+							],
+							"+",
+							[5, "5.1"]
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"qw",
+				[
+					6,
+					[
+						7,
+						"q",
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2f"
+								],
+								["wx", "wy"]
+							],
+							"mul"
+						],
+						["wAmt"]
+					]]
+				]
+			],
+			[
+				13,
+				"gMax",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "4"]]
+				]
+			],
+			[
+				13,
+				"nd",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"perlin12d"
+					],
+					["qw"]
+				]
+			],
+			[
+				13,
+				"reliefGrad",
+				[5, "0.62"]
+			],
+			[
+				13,
+				"hx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"nd",
+								"y"
+							],
+							"*",
+							"reliefGrad"
+						],
+						[
+							1,
+							"gMax",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						"gMax"
+					]
+				]
+			],
+			[
+				13,
+				"hy",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"nd",
+								"z"
+							],
+							"*",
+							"reliefGrad"
+						],
+						[
+							1,
+							"gMax",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						"gMax"
+					]
+				]
+			],
+			[
+				13,
+				"relief",
+				[
+					1,
+					"turbulence",
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"n",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								1,
+								[
+									7,
+									"nGeo",
+									"x"
+								],
+								"-",
+								[
+									1,
+									"hx",
+									"*",
+									"relief"
+								]
+							],
+							[
+								1,
+								[
+									7,
+									"nGeo",
+									"y"
+								],
+								"-",
+								[
+									1,
+									"hy",
+									"*",
+									"relief"
+								]
+							],
+							[
+								7,
+								"nGeo",
+								"z"
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"R",
+				[
+					6,
+					[
+						7,
+						"std",
+						"reflect"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[5, "0"],
+							[5, "0"],
+							[5, "1"]
+						]
+					], "n"]
+				]
+			],
+			[
+				13,
+				"envStr",
+				"environment"
+			],
+			[
+				13,
+				"sharp",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						"sharpness",
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"keyRad",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[5, "0.5"],
+						[5, "0.18"],
+						"sharp"
+					]
+				]
+			],
+			[
+				13,
+				"drift",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"sin"
+						],
+						[[
+							1,
+							"animTime",
+							"*",
+							[5, "0.07"]
+						]]
+					],
+					"*",
+					[5, "0.05"]
+				]
+			],
+			[
+				13,
+				"lx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"cos"
+					],
+					[[
+						1,
+						"lightAngle",
+						"*",
+						"DEG_TO_RAD"
+					]]
+				]
+			],
+			[
+				13,
+				"ly",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					[[
+						1,
+						"lightAngle",
+						"*",
+						"DEG_TO_RAD"
+					]]
+				]
+			],
+			[
+				13,
+				"envC",
+				[
+					6,
+					[
+						7,
+						"std",
+						"cos"
+					],
+					[[
+						1,
+						"envRotation",
+						"*",
+						"DEG_TO_RAD"
+					]]
+				]
+			],
+			[
+				13,
+				"envS",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					[[
+						1,
+						"envRotation",
+						"*",
+						"DEG_TO_RAD"
+					]]
+				]
+			],
+			[
+				13,
+				"L",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							"lx",
+							"ly",
+							[
+								4,
+								"-",
+								[5, "0.7"]
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"Hh",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"L",
+							"add"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[
+								[5, "0"],
+								[5, "0"],
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"ndh",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"n",
+										"x"
+									],
+									"*",
+									[
+										7,
+										"Hh",
+										"x"
+									]
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										"n",
+										"y"
+									],
+									"*",
+									[
+										7,
+										"Hh",
+										"y"
+									]
+								]
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									"n",
+									"z"
+								],
+								"*",
+								[
+									7,
+									"Hh",
+									"z"
+								]
+							]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"spec",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"pow"
+						],
+						["ndh", [
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "60"]]
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "900"]]
+								],
+								"sharp"
+							]
+						]]
+					],
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							[5, "0.4"],
+							[5, "1.4"],
+							"sharp"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"lumG",
+				[
+					1,
+					[
+						6,
+						"liquidStudio",
+						[
+							[
+								7,
+								"R",
+								"x"
+							],
+							[
+								7,
+								"R",
+								"y"
+							],
+							"envC",
+							"envS",
+							"keyRad",
+							"drift",
+							"envStr"
+						]
+					],
+					"+",
+					"spec"
+				]
+			],
+			[
+				13,
+				"grazeD",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								[
+									7,
+									"n",
+									"z"
+								],
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							[5, "0"],
+							[5, "1"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"dth",
+				[
+					1,
+					[
+						1,
+						"dispersion",
+						"*",
+						[5, "0.09"]
+					],
+					"*",
+					[
+						1,
+						[5, "0.4"],
+						"+",
+						[
+							1,
+							"grazeD",
+							"*",
+							[5, "1.3"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"lumBoffset",
+				[
+					1,
+					[
+						6,
+						"liquidStudio",
+						[
+							[
+								1,
+								[
+									7,
+									"R",
+									"x"
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										"R",
+										"y"
+									],
+									"*",
+									"dth"
+								]
+							],
+							[
+								1,
+								[
+									7,
+									"R",
+									"y"
+								],
+								"-",
+								[
+									1,
+									[
+										7,
+										"R",
+										"x"
+									],
+									"*",
+									"dth"
+								]
+							],
+							"envC",
+							"envS",
+							"keyRad",
+							"drift",
+							"envStr"
+						]
+					],
+					"+",
+					"spec"
+				]
+			],
+			[
+				13,
+				"lumB",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"lumBoffset",
+						"lumG",
+						[
+							1,
+							"mobile",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"lumRdesktop",
+				[
+					1,
+					[
+						1,
+						"lumG",
+						"*",
+						[5, "2"]
+					],
+					"-",
+					"lumBoffset"
+				]
+			],
+			[
+				13,
+				"lumR",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"lumRdesktop",
+						"lumG",
+						[
+							1,
+							"mobile",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"rgb",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									7,
+									"darkColor",
+									"x"
+								],
+								[
+									7,
+									"lightColor",
+									"x"
+								],
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										"lumR",
+										[5, "0"],
+										[5, "1.8"]
+									]
+								]
+							]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									7,
+									"darkColor",
+									"y"
+								],
+								[
+									7,
+									"lightColor",
+									"y"
+								],
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										"lumG",
+										[5, "0"],
+										[5, "1.8"]
+									]
+								]
+							]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									7,
+									"darkColor",
+									"z"
+								],
+								[
+									7,
+									"lightColor",
+									"z"
+								],
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										"lumB",
+										[5, "0"],
+										[5, "1.8"]
+									]
+								]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"transition",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						[5, "0"],
+						[5, "1"],
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								[
+									1,
+									[
+										1,
+										[
+											1,
+											"sdf",
+											"*",
+											[
+												4,
+												"-",
+												[5, "1"]
+											]
+										],
+										"/",
+										"sharpEdge"
+									],
+									"*",
+									[5, "32"]
+								],
+								[5, "0"],
+								[5, "1"]
+							]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				[
+					[
+						7,
+						"rgb",
+						"x"
+					],
+					[
+						7,
+						"rgb",
+						"y"
+					],
+					[
+						7,
+						"rgb",
+						"z"
+					],
+					"transition"
+				]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"d",
+			"noise",
+			"DEG_TO_RAD",
+			"liquidStudio"
+		]
+	},
+	externals: () => ({
+		std,
+		d,
+		noise: noise_exports,
+		DEG_TO_RAD,
+		liquidStudio
+	})
+}) && $.f)({}));
+const componentDefinition = {
+	name: "LiquidMetal",
+	boundingBoxDeclaration: shapeEffectBoundingBoxDeclaration,
+	category: "Shape Effects",
+	description: "Flowing liquid chrome — a molten reflective surface that wraps the shape, sweeping a procedural studio reflection across animated folds with crisp speculars and prismatic edges",
+	animatedTime: { speed: "speed" },
+	extraFields: {
+		...VOLUMETRIC_FIELD_EXTRA_FIELDS,
+		...ANALYTIC_SDF_EXTRA_FIELDS
+	},
+	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"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "Center position of the metal shape",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position",
+				units: ["%", "px"]
+			}
+		},
+		scale: {
+			default: 1,
+			description: "Scale of the metal shape (1 = default size)",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 3,
+				step: .01,
+				label: "Scale",
+				group: "Position"
+			}
+		},
+		rotation: {
+			default: 0,
+			description: "Rotation of the metal shape in degrees",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Rotation",
+				group: "Position"
+			}
+		},
+		lightColor: {
+			default: "#eef0f6",
+			transform: transformColor,
+			description: "The bright tone of the chrome highlights",
+			ui: {
+				type: "color",
+				label: "Light Color",
+				group: "Metal"
+			}
+		},
+		darkColor: {
+			default: "#141414",
+			transform: transformColor,
+			description: "The dark tone the reflection falls to in shadow — recolor for tinted metal (gold, steel, copper…)",
+			ui: {
+				type: "color",
+				label: "Dark Color",
+				group: "Metal"
+			}
+		},
+		turbulence: {
+			default: 1,
+			description: "How molten the surface is — the depth of the flowing folds that bend the reflection",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1.5,
+				step: .01,
+				label: "Turbulence",
+				group: "Liquid"
+			}
+		},
+		ripple: {
+			default: 4,
+			description: "Scale of the molten folds — higher = smaller, busier ripples",
+			ui: {
+				type: "range",
+				min: .5,
+				max: 8,
+				step: .01,
+				label: "Ripple Scale",
+				group: "Liquid"
+			}
+		},
+		warp: {
+			default: 1.5,
+			description: "Swirl of the flow — domain-warps the folds into liquid curls",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1.5,
+				step: .01,
+				label: "Swirl",
+				group: "Liquid"
+			}
+		},
+		speed: {
+			default: .5,
+			description: "Speed of the molten flow and the slowly drifting reflection. 0 pauses.",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 4,
+				step: .01,
+				label: "Speed",
+				group: "Liquid"
+			}
+		},
+		environment: {
+			default: 1.5,
+			description: "Strength of the reflected studio lighting — the softboxes seen across the metal",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Environment",
+				group: "Surface"
+			}
+		},
+		envRotation: {
+			default: 0,
+			description: "Rotates the whole reflected studio — spins where the bright reflections fall",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Env Rotation",
+				group: "Surface"
+			}
+		},
+		sharpness: {
+			default: .6,
+			description: "Tightness of the specular highlights — 1 = razor chrome glints, 0 = soft satin",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Sharpness",
+				group: "Surface"
+			}
+		},
+		dispersion: {
+			default: .25,
+			description: "Prismatic color fringing along the reflection edges",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Dispersion",
+				group: "Surface"
+			}
+		},
+		lightAngle: {
+			default: 265,
+			description: "Direction of the key light for the specular glints, in degrees",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Light Angle",
+				group: "Surface"
+			}
+		},
+		edgeSoftness: {
+			default: .05,
+			description: "Softness of the shape boundary edge",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Edge Softness",
+				group: "Surface"
+			}
+		},
+		shape: {
+			default: DEFAULT_SHAPE_CONFIG,
+			description: "Serialized shape configuration (JSON)",
+			ui: {
+				type: "shape",
+				label: "Shape",
+				group: "Shape"
+			}
+		},
+		shapeSdfUrl: {
+			default: "",
+			compileTime: true,
+			description: "URL to a pre-generated SDF .bin file"
+		},
+		shapeType: {
+			default: "",
+			compileTime: true,
+			description: "Active SDF shape type"
+		}
+	},
+	compute: (params) => {
+		const vf = createVolumetricFieldComputeNode(params, () => params.getCpuValue("shape"), "raw");
+		return vf ? {
+			outputs: vf.outputs,
+			getComputeNodes: (fp) => vf.getComputeNodes(fp)
+		} : null;
+	},
+	fragment: (params) => {
+		const { computeOutputs, uniforms, propValues, ctx, getCpuValue } = params;
+		let sampler;
+		let gradSampler;
+		let volumetric = false;
+		const fieldTex = computeOutputs?.volumetricFieldTexture;
+		if (fieldTex) {
+			const s = buildVolumetricFieldSampler(fieldTex, {
+				originX: uniforms._vfOriginX,
+				originY: uniforms._vfOriginY,
+				spanX: uniforms._vfSpanX,
+				spanY: uniforms._vfSpanY,
+				activeResF: uniforms._vfActiveRes,
+				rBound: uniforms._vfRBound
+			});
+			sampler = s.volumetricFieldSampler;
+			gradSampler = s.volumetricFieldSamplerFast;
+			volumetric = true;
+		} else {
+			const shapeSdfUrl = propValues.shapeSdfUrl || "";
+			const shapeType = propValues.shapeType || "";
+			if (shapeSdfUrl) {
+				sampler = createSvgSdfSampler(params, shapeSdfUrl);
+				gradSampler = sampler;
+				volumetric = isVolumetricShapeType(shapeType);
+			} else {
+				const st = resolveShapeType(shapeType, getCpuValue("shape"));
+				sampler = createAnalyticSdfSampler(st, driveAnalyticSubProps(params, () => getCpuValue("shape")), "raw");
+				gradSampler = sampler;
+				volumetric = is3dShapeType(st);
+			}
+		}
+		const sdfUV = call(sdfSpaceUV, "sdfSpaceUV", [
+			uniforms.center,
+			uniforms.scale,
+			uniforms.rotation,
+			ctx.uv,
+			ctx.aspect
+		]);
+		const surf0 = sampler(sdfUV);
+		const surfX = gradSampler(call(offsetUV, "offsetUV", [
+			sdfUV,
+			floatE(.01),
+			floatE(0)
+		]));
+		const surfY = gradSampler(call(offsetUV, "offsetUV", [
+			sdfUV,
+			floatE(0),
+			floatE(.01)
+		]));
+		const t = animatedTime(params);
+		const volFlag = floatE(volumetric ? 1 : 0);
+		const mobileFlag = floatE(isMobileGpuViewport() ? 1 : 0);
+		const p0 = vec4(uniforms.scale, uniforms.edgeSoftness, uniforms.ripple, uniforms.warp);
+		const p1 = vec4(uniforms.turbulence, uniforms.environment, uniforms.envRotation, uniforms.sharpness);
+		const p2 = vec4(uniforms.dispersion, uniforms.lightAngle, t, volFlag);
+		const p3 = vec4(mobileFlag, floatE(0), floatE(0), floatE(0));
+		return call(liquidMetalComposite, "liquidMetalComposite", [
+			surf0,
+			surfX,
+			surfY,
+			sdfUV,
+			ctx.viewportSize,
+			uniforms.lightColor.member("rgb"),
+			uniforms.darkColor.member("rgb"),
+			p0,
+			p1,
+			p2,
+			p3
+		]);
+	}
+};
+var LiquidMetal_default = componentDefinition;
+export { liquidStudio as i, componentDefinition as n, liquidMetalComposite as r, LiquidMetal_default as t };