shaders 2.5.135 → 3.0.437

package/dist/core/Frost-IvGmzNqf.js

@@ -0,0 +1,2672 @@
+import { At as call, It as vec4, Pt as floatE, R as std, T as sdf_exports, d as sdf3d_exports, et as mxNoiseFloat2, n as tgpu, nt as mxWorleyNoiseFloat2Pub, 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 } = 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 frostComposite = tgpu.fn([
+	d.vec4f,
+	d.vec4f,
+	d.vec4f,
+	d.vec2f,
+	d.vec2f,
+	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, iceColor, p0, p1, p2, p3) => {
+	"use gpu";
+	const scale = p0.x;
+	const edgeSoftness = p0.y;
+	const density = p0.z;
+	const absorption = p0.w;
+	const scatter = p1.x;
+	const frostAmount = p1.y;
+	const frostDepth = p1.z;
+	const frostScaleP = p1.w;
+	const frostRoughness = p2.x;
+	const sparkleAmt = p2.y;
+	const gloss = p2.z;
+	const fresnelAmt = p2.w;
+	const lightAngle = p3.x;
+	const ambientAmt = p3.y;
+	const animTime = p3.z;
+	const volumetric = p3.w;
+	const sharp = std.max(__tsover_mul(edgeSoftness, .5), .001);
+	const pxH = __tsover_div(1, viewportSize.y);
+	const sdfRaw = surf0.x;
+	const sdf = __tsover_div(sdfRaw, scale);
+	if (sdf > __tsover_mul(pxH, 2)) return d.vec4f(0, 0, 0, 0);
+	const EPS = .01;
+	const gradX = __tsover_div(__tsover_sub(surfX.x, sdfRaw), EPS);
+	const gradY = __tsover_div(__tsover_sub(surfY.x, sdfRaw), EPS);
+	const rb1 = std.clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharp), 32), 0, 1);
+	const pdx = std.select(__tsover_sub(sdfUV.x, .5), surf0.y, volumetric > .5);
+	const pdy = std.select(__tsover_sub(sdfUV.y, .5), surf0.z, volumetric > .5);
+	const thicknessRange = std.max(d.f32(.3), .01);
+	const depthNorm = std.clamp(__tsover_div(__tsover_mul(sdf, -1), thicknessRange), 0, 1);
+	const ddx = std.clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -4, 4);
+	const ddy = std.clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -4, 4);
+	const nVol = std.normalize(d.vec3f(ddx, ddy, -1));
+	const bevelSlope = __tsover_mul(std.sqrt(std.max(__tsover_sub(1, __tsover_mul(depthNorm, depthNorm)), d.f32(0))), 1.8);
+	const nFlat = std.normalize(d.vec3f(__tsover_mul(gradX, bevelSlope), __tsover_mul(gradY, bevelSlope), -1));
+	const nBase = std.select(nFlat, nVol, volumetric > .5);
+	const steepness = std.select(d.f32(0), std.clamp(__tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy)), 0, 2), volumetric > .5);
+	const steepAtten = __tsover_div(1, __tsover_add(1, __tsover_mul(steepness, 2)));
+	const thickVol = std.clamp(__tsover_mul(__tsover_mul(sdf, -1), 2), 0, 1.2);
+	const thickFlat = __tsover_mul(std.clamp(__tsover_mul(sdf, -1), 0, .5), 2);
+	const thicknessRaw = std.select(thickFlat, thickVol, volumetric > .5);
+	const thickness = __tsover_mul(thicknessRaw, density);
+	const depthT = std.clamp(__tsover_mul(thickness, 1.2), 0, 1);
+	const absorb = d.vec3f(1.6, .85, .45).mul(absorption);
+	const transmit = d.vec3f(std.exp(__tsover_mul(__tsover_mul(thickness, absorb.x), -1)), std.exp(__tsover_mul(__tsover_mul(thickness, absorb.y), -1)), std.exp(__tsover_mul(__tsover_mul(thickness, absorb.z), -1)));
+	const scatteredRgb = std.mix(d.vec3f(1, 1, 1), iceColor, d.vec3f(depthT)).mul(transmit);
+	const frostDepthU = std.max(__tsover_mul(frostDepth, .3), .01);
+	const edgeMask = __tsover_sub(1, std.smoothstep(0, frostDepthU, __tsover_mul(sdf, -1)));
+	const frostField = __tsover_mul(edgeMask, frostAmount);
+	const frostScale = __tsover_mul(frostScaleP, 60);
+	const feps = .004;
+	let frostPerturbX = d.f32(0);
+	let frostPerturbY = d.f32(0);
+	let crackLines = d.f32(0);
+	if (frostField > 0) {
+		const fn0 = mxNoiseFloat2(d.vec2f(__tsover_mul(pdx, frostScale), __tsover_mul(pdy, frostScale)));
+		const fnx = __tsover_div(__tsover_sub(mxNoiseFloat2(d.vec2f(__tsover_mul(__tsover_add(pdx, feps), frostScale), __tsover_mul(pdy, frostScale))), fn0), feps);
+		const fny = __tsover_div(__tsover_sub(mxNoiseFloat2(d.vec2f(__tsover_mul(pdx, frostScale), __tsover_mul(__tsover_add(pdy, feps), frostScale))), fn0), feps);
+		const frostNormalAmp = __tsover_mul(__tsover_mul(frostField, frostRoughness), steepAtten);
+		frostPerturbX = __tsover_mul(__tsover_mul(fnx, frostNormalAmp), .03);
+		frostPerturbY = __tsover_mul(__tsover_mul(fny, frostNormalAmp), .03);
+		const wScale = __tsover_mul(frostScaleP, 40);
+		const wc = mxWorleyNoiseFloat2Pub(d.vec2f(__tsover_mul(pdx, wScale), __tsover_mul(pdy, wScale)), 1);
+		crackLines = __tsover_mul(std.smoothstep(.25, 0, wc), frostField);
+	}
+	const n = std.normalize(nBase.add(d.vec3f(frostPerturbX, frostPerturbY, 0)));
+	const lx = std.cos(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const ly = std.sin(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const L = std.normalize(d.vec3f(lx, ly, -.6));
+	const H = std.normalize(L.add(d.vec3f(0, 0, -1)));
+	const ndl = std.dot(n, L);
+	const ndh = std.clamp(std.dot(n, H), 0, 1);
+	const wrap = __tsover_add(__tsover_mul(ndl, .5), .5);
+	const sssDiffuse = std.pow(wrap, d.f32(.7));
+	const backLight = std.clamp(__tsover_add(__tsover_mul(std.dot(L, d.vec3f(0, 0, 1)), .5), .5), 0, 1);
+	const forwardGlow = transmit.mul(backLight).mul(scatter).mul(__tsover_sub(1, __tsover_mul(depthT, .4)));
+	const sssRgb = scatteredRgb.mul(__tsover_add(__tsover_mul(sssDiffuse, .6), .5)).add(forwardGlow.mul(.5));
+	let sparkleGlint = d.f32(0);
+	if (frostField > 0) {
+		const glintField = __tsover_add(__tsover_mul(mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(pdx, 190), 13.7), __tsover_sub(__tsover_mul(pdy, 190), 4.3))), .5), .5);
+		const twinkle = __tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(animTime, 3), __tsover_mul(glintField, 40))), .5), .5);
+		sparkleGlint = __tsover_mul(__tsover_mul(__tsover_mul(std.smoothstep(.72, .96, __tsover_mul(glintField, twinkle)), __tsover_add(__tsover_mul(std.pow(ndh, d.f32(6)), .6), .4)), frostField), sparkleAmt);
+	}
+	const frostRgb = d.vec3f(.95, .98, 1).mul(__tsover_add(__tsover_mul(crackLines, .4), __tsover_mul(sparkleGlint, 4)));
+	const cosView = std.clamp(__tsover_mul(n.z, -1), 0, 1);
+	const grazing = __tsover_sub(1, cosView);
+	const fres = __tsover_mul(std.pow(grazing, d.f32(3)), fresnelAmt);
+	const fresnelRgb = d.vec3f(.85, .93, 1).mul(__tsover_mul(fres, 1.5));
+	const broadSpec = __tsover_mul(__tsover_mul(std.pow(ndh, d.f32(16)), .4), gloss);
+	const ambient = d.vec3f(.4, .46, .55).mul(ambientAmt);
+	const iceRgb = sssRgb.add(ambient).add(d.vec3f(broadSpec, broadSpec, broadSpec)).add(fresnelRgb).add(frostRgb);
+	const transition = std.smoothstep(0, 1, rb1);
+	return d.vec4f(iceRgb.x, iceRgb.y, iceRgb.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": "iceColor"
+			},
+			{
+				"type": "i",
+				"name": "p0"
+			},
+			{
+				"type": "i",
+				"name": "p1"
+			},
+			{
+				"type": "i",
+				"name": "p2"
+			},
+			{
+				"type": "i",
+				"name": "p3"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"scale",
+				[
+					7,
+					"p0",
+					"x"
+				]
+			],
+			[
+				13,
+				"edgeSoftness",
+				[
+					7,
+					"p0",
+					"y"
+				]
+			],
+			[
+				13,
+				"density",
+				[
+					7,
+					"p0",
+					"z"
+				]
+			],
+			[
+				13,
+				"absorption",
+				[
+					7,
+					"p0",
+					"w"
+				]
+			],
+			[
+				13,
+				"scatter",
+				[
+					7,
+					"p1",
+					"x"
+				]
+			],
+			[
+				13,
+				"frostAmount",
+				[
+					7,
+					"p1",
+					"y"
+				]
+			],
+			[
+				13,
+				"frostDepth",
+				[
+					7,
+					"p1",
+					"z"
+				]
+			],
+			[
+				13,
+				"frostScaleP",
+				[
+					7,
+					"p1",
+					"w"
+				]
+			],
+			[
+				13,
+				"frostRoughness",
+				[
+					7,
+					"p2",
+					"x"
+				]
+			],
+			[
+				13,
+				"sparkleAmt",
+				[
+					7,
+					"p2",
+					"y"
+				]
+			],
+			[
+				13,
+				"gloss",
+				[
+					7,
+					"p2",
+					"z"
+				]
+			],
+			[
+				13,
+				"fresnelAmt",
+				[
+					7,
+					"p2",
+					"w"
+				]
+			],
+			[
+				13,
+				"lightAngle",
+				[
+					7,
+					"p3",
+					"x"
+				]
+			],
+			[
+				13,
+				"ambientAmt",
+				[
+					7,
+					"p3",
+					"y"
+				]
+			],
+			[
+				13,
+				"animTime",
+				[
+					7,
+					"p3",
+					"z"
+				]
+			],
+			[
+				13,
+				"volumetric",
+				[
+					7,
+					"p3",
+					"w"
+				]
+			],
+			[
+				13,
+				"sharp",
+				[
+					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",
+					"/",
+					"scale"
+				]
+			],
+			[
+				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,
+				"gradX",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"surfX",
+							"x"
+						],
+						"-",
+						"sdfRaw"
+					],
+					"/",
+					"EPS"
+				]
+			],
+			[
+				13,
+				"gradY",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"surfY",
+							"x"
+						],
+						"-",
+						"sdfRaw"
+					],
+					"/",
+					"EPS"
+				]
+			],
+			[
+				13,
+				"rb1",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"sdf",
+									"*",
+									[
+										4,
+										"-",
+										[5, "1"]
+									]
+								],
+								"/",
+								"sharp"
+							],
+							"*",
+							[5, "32"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"pdx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"sdfUV",
+								"x"
+							],
+							"-",
+							[5, "0.5"]
+						],
+						[
+							7,
+							"surf0",
+							"y"
+						],
+						[
+							1,
+							"volumetric",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"pdy",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"sdfUV",
+								"y"
+							],
+							"-",
+							[5, "0.5"]
+						],
+						[
+							7,
+							"surf0",
+							"z"
+						],
+						[
+							1,
+							"volumetric",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"thicknessRange",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "0.3"]]
+					], [5, "0.01"]]
+				]
+			],
+			[
+				13,
+				"depthNorm",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								"sdf",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							"/",
+							"thicknessRange"
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"ddx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"surfX",
+									"w"
+								],
+								"-",
+								[
+									7,
+									"surf0",
+									"w"
+								]
+							],
+							"/",
+							"EPS"
+						],
+						[
+							4,
+							"-",
+							[5, "4"]
+						],
+						[5, "4"]
+					]
+				]
+			],
+			[
+				13,
+				"ddy",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"surfY",
+									"w"
+								],
+								"-",
+								[
+									7,
+									"surf0",
+									"w"
+								]
+							],
+							"/",
+							"EPS"
+						],
+						[
+							4,
+							"-",
+							[5, "4"]
+						],
+						[5, "4"]
+					]
+				]
+			],
+			[
+				13,
+				"nVol",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							"ddx",
+							"ddy",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"bevelSlope",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"sqrt"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							[[
+								1,
+								[5, "1"],
+								"-",
+								[
+									1,
+									"depthNorm",
+									"*",
+									"depthNorm"
+								]
+							], [
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							]]
+						]]
+					],
+					"*",
+					[5, "1.8"]
+				]
+			],
+			[
+				13,
+				"nFlat",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								1,
+								"gradX",
+								"*",
+								"bevelSlope"
+							],
+							[
+								1,
+								"gradY",
+								"*",
+								"bevelSlope"
+							],
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"nBase",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"nFlat",
+						"nVol",
+						[
+							1,
+							"volumetric",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"steepness",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								[
+									1,
+									[
+										1,
+										"ddx",
+										"*",
+										"ddx"
+									],
+									"+",
+									[
+										1,
+										"ddy",
+										"*",
+										"ddy"
+									]
+								],
+								[5, "0"],
+								[5, "2"]
+							]
+						],
+						[
+							1,
+							"volumetric",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"steepAtten",
+				[
+					1,
+					[5, "1"],
+					"/",
+					[
+						1,
+						[5, "1"],
+						"+",
+						[
+							1,
+							"steepness",
+							"*",
+							[5, "2"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"thickVol",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								"sdf",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							"*",
+							[5, "2"]
+						],
+						[5, "0"],
+						[5, "1.2"]
+					]
+				]
+			],
+			[
+				13,
+				"thickFlat",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								"sdf",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							[5, "0"],
+							[5, "0.5"]
+						]
+					],
+					"*",
+					[5, "2"]
+				]
+			],
+			[
+				13,
+				"thicknessRaw",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"thickFlat",
+						"thickVol",
+						[
+							1,
+							"volumetric",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"thickness",
+				[
+					1,
+					"thicknessRaw",
+					"*",
+					"density"
+				]
+			],
+			[
+				13,
+				"depthT",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							"thickness",
+							"*",
+							[5, "1.2"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"absorb",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[
+								[5, "1.6"],
+								[5, "0.85"],
+								[5, "0.45"]
+							]
+						],
+						"mul"
+					],
+					["absorption"]
+				]
+			],
+			[
+				13,
+				"transmit",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"exp"
+							],
+							[[
+								1,
+								[
+									1,
+									"thickness",
+									"*",
+									[
+										7,
+										"absorb",
+										"x"
+									]
+								],
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							]]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"exp"
+							],
+							[[
+								1,
+								[
+									1,
+									"thickness",
+									"*",
+									[
+										7,
+										"absorb",
+										"y"
+									]
+								],
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							]]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"exp"
+							],
+							[[
+								1,
+								[
+									1,
+									"thickness",
+									"*",
+									[
+										7,
+										"absorb",
+										"z"
+									]
+								],
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"scatteredRgb",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec3f"
+									],
+									[
+										[5, "1"],
+										[5, "1"],
+										[5, "1"]
+									]
+								],
+								"iceColor",
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec3f"
+									],
+									["depthT"]
+								]
+							]
+						],
+						"mul"
+					],
+					["transmit"]
+				]
+			],
+			[
+				13,
+				"frostDepthU",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						"frostDepth",
+						"*",
+						[5, "0.3"]
+					], [5, "0.01"]]
+				]
+			],
+			[
+				13,
+				"edgeMask",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						[
+							7,
+							"std",
+							"smoothstep"
+						],
+						[
+							[5, "0"],
+							"frostDepthU",
+							[
+								1,
+								"sdf",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"frostField",
+				[
+					1,
+					"edgeMask",
+					"*",
+					"frostAmount"
+				]
+			],
+			[
+				13,
+				"frostScale",
+				[
+					1,
+					"frostScaleP",
+					"*",
+					[5, "60"]
+				]
+			],
+			[
+				13,
+				"feps",
+				[5, "0.004"]
+			],
+			[
+				12,
+				"frostPerturbX",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				]
+			],
+			[
+				12,
+				"frostPerturbY",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				]
+			],
+			[
+				12,
+				"crackLines",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				]
+			],
+			[
+				11,
+				[
+					1,
+					"frostField",
+					">",
+					[5, "0"]
+				],
+				[0, [
+					[
+						13,
+						"fn0",
+						[
+							6,
+							[
+								7,
+								"noise",
+								"mxNoiseFloat2"
+							],
+							[[
+								6,
+								[
+									7,
+									"d",
+									"vec2f"
+								],
+								[[
+									1,
+									"pdx",
+									"*",
+									"frostScale"
+								], [
+									1,
+									"pdy",
+									"*",
+									"frostScale"
+								]]
+							]]
+						]
+					],
+					[
+						13,
+						"fnx",
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"noise",
+										"mxNoiseFloat2"
+									],
+									[[
+										6,
+										[
+											7,
+											"d",
+											"vec2f"
+										],
+										[[
+											1,
+											[
+												1,
+												"pdx",
+												"+",
+												"feps"
+											],
+											"*",
+											"frostScale"
+										], [
+											1,
+											"pdy",
+											"*",
+											"frostScale"
+										]]
+									]]
+								],
+								"-",
+								"fn0"
+							],
+							"/",
+							"feps"
+						]
+					],
+					[
+						13,
+						"fny",
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"noise",
+										"mxNoiseFloat2"
+									],
+									[[
+										6,
+										[
+											7,
+											"d",
+											"vec2f"
+										],
+										[[
+											1,
+											"pdx",
+											"*",
+											"frostScale"
+										], [
+											1,
+											[
+												1,
+												"pdy",
+												"+",
+												"feps"
+											],
+											"*",
+											"frostScale"
+										]]
+									]]
+								],
+								"-",
+								"fn0"
+							],
+							"/",
+							"feps"
+						]
+					],
+					[
+						13,
+						"frostNormalAmp",
+						[
+							1,
+							[
+								1,
+								"frostField",
+								"*",
+								"frostRoughness"
+							],
+							"*",
+							"steepAtten"
+						]
+					],
+					[
+						2,
+						"frostPerturbX",
+						"=",
+						[
+							1,
+							[
+								1,
+								"fnx",
+								"*",
+								"frostNormalAmp"
+							],
+							"*",
+							[5, "0.03"]
+						]
+					],
+					[
+						2,
+						"frostPerturbY",
+						"=",
+						[
+							1,
+							[
+								1,
+								"fny",
+								"*",
+								"frostNormalAmp"
+							],
+							"*",
+							[5, "0.03"]
+						]
+					],
+					[
+						13,
+						"wScale",
+						[
+							1,
+							"frostScaleP",
+							"*",
+							[5, "40"]
+						]
+					],
+					[
+						13,
+						"wc",
+						[
+							6,
+							[
+								7,
+								"noise",
+								"mxWorleyNoiseFloat2Pub"
+							],
+							[[
+								6,
+								[
+									7,
+									"d",
+									"vec2f"
+								],
+								[[
+									1,
+									"pdx",
+									"*",
+									"wScale"
+								], [
+									1,
+									"pdy",
+									"*",
+									"wScale"
+								]]
+							], [5, "1"]]
+						]
+					],
+					[
+						2,
+						"crackLines",
+						"=",
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"smoothstep"
+								],
+								[
+									[5, "0.25"],
+									[5, "0"],
+									"wc"
+								]
+							],
+							"*",
+							"frostField"
+						]
+					]
+				]]
+			],
+			[
+				13,
+				"n",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"nBase",
+							"add"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[
+								"frostPerturbX",
+								"frostPerturbY",
+								[5, "0"]
+							]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"lx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"cos"
+					],
+					[[
+						1,
+						"lightAngle",
+						"*",
+						"DEG_TO_RAD"
+					]]
+				]
+			],
+			[
+				13,
+				"ly",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					[[
+						1,
+						"lightAngle",
+						"*",
+						"DEG_TO_RAD"
+					]]
+				]
+			],
+			[
+				13,
+				"L",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							"lx",
+							"ly",
+							[
+								4,
+								"-",
+								[5, "0.6"]
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"H",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"L",
+							"add"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[
+								[5, "0"],
+								[5, "0"],
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"ndl",
+				[
+					6,
+					[
+						7,
+						"std",
+						"dot"
+					],
+					["n", "L"]
+				]
+			],
+			[
+				13,
+				"ndh",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"dot"
+							],
+							["n", "H"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"wrap",
+				[
+					1,
+					[
+						1,
+						"ndl",
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"sssDiffuse",
+				[
+					6,
+					[
+						7,
+						"std",
+						"pow"
+					],
+					["wrap", [
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "0.7"]]
+					]]
+				]
+			],
+			[
+				13,
+				"backLight",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"std",
+										"dot"
+									],
+									["L", [
+										6,
+										[
+											7,
+											"d",
+											"vec3f"
+										],
+										[
+											[5, "0"],
+											[5, "0"],
+											[5, "1"]
+										]
+									]]
+								],
+								"*",
+								[5, "0.5"]
+							],
+							"+",
+							[5, "0.5"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"forwardGlow",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										"transmit",
+										"mul"
+									],
+									["backLight"]
+								],
+								"mul"
+							],
+							["scatter"]
+						],
+						"mul"
+					],
+					[[
+						1,
+						[5, "1"],
+						"-",
+						[
+							1,
+							"depthT",
+							"*",
+							[5, "0.4"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"sssRgb",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"scatteredRgb",
+								"mul"
+							],
+							[[
+								1,
+								[
+									1,
+									"sssDiffuse",
+									"*",
+									[5, "0.6"]
+								],
+								"+",
+								[5, "0.5"]
+							]]
+						],
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							"forwardGlow",
+							"mul"
+						],
+						[[5, "0.5"]]
+					]]
+				]
+			],
+			[
+				12,
+				"sparkleGlint",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				]
+			],
+			[
+				11,
+				[
+					1,
+					"frostField",
+					">",
+					[5, "0"]
+				],
+				[0, [
+					[
+						13,
+						"glintField",
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"noise",
+										"mxNoiseFloat2"
+									],
+									[[
+										6,
+										[
+											7,
+											"d",
+											"vec2f"
+										],
+										[[
+											1,
+											[
+												1,
+												"pdx",
+												"*",
+												[5, "190"]
+											],
+											"+",
+											[5, "13.7"]
+										], [
+											1,
+											[
+												1,
+												"pdy",
+												"*",
+												[5, "190"]
+											],
+											"-",
+											[5, "4.3"]
+										]]
+									]]
+								],
+								"*",
+								[5, "0.5"]
+							],
+							"+",
+							[5, "0.5"]
+						]
+					],
+					[
+						13,
+						"twinkle",
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"std",
+										"sin"
+									],
+									[[
+										1,
+										[
+											1,
+											"animTime",
+											"*",
+											[5, "3"]
+										],
+										"+",
+										[
+											1,
+											"glintField",
+											"*",
+											[5, "40"]
+										]
+									]]
+								],
+								"*",
+								[5, "0.5"]
+							],
+							"+",
+							[5, "0.5"]
+						]
+					],
+					[
+						2,
+						"sparkleGlint",
+						"=",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[
+										6,
+										[
+											7,
+											"std",
+											"smoothstep"
+										],
+										[
+											[5, "0.72"],
+											[5, "0.96"],
+											[
+												1,
+												"glintField",
+												"*",
+												"twinkle"
+											]
+										]
+									],
+									"*",
+									[
+										1,
+										[
+											1,
+											[
+												6,
+												[
+													7,
+													"std",
+													"pow"
+												],
+												["ndh", [
+													6,
+													[
+														7,
+														"d",
+														"f32"
+													],
+													[[5, "6"]]
+												]]
+											],
+											"*",
+											[5, "0.6"]
+										],
+										"+",
+										[5, "0.4"]
+									]
+								],
+								"*",
+								"frostField"
+							],
+							"*",
+							"sparkleAmt"
+						]
+					]
+				]]
+			],
+			[
+				13,
+				"frostRgb",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[
+								[5, "0.95"],
+								[5, "0.98"],
+								[5, "1"]
+							]
+						],
+						"mul"
+					],
+					[[
+						1,
+						[
+							1,
+							"crackLines",
+							"*",
+							[5, "0.4"]
+						],
+						"+",
+						[
+							1,
+							"sparkleGlint",
+							"*",
+							[5, "4"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"cosView",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"n",
+								"z"
+							],
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"grazing",
+				[
+					1,
+					[5, "1"],
+					"-",
+					"cosView"
+				]
+			],
+			[
+				13,
+				"fres",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"pow"
+						],
+						["grazing", [
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "3"]]
+						]]
+					],
+					"*",
+					"fresnelAmt"
+				]
+			],
+			[
+				13,
+				"fresnelRgb",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[
+								[5, "0.85"],
+								[5, "0.93"],
+								[5, "1"]
+							]
+						],
+						"mul"
+					],
+					[[
+						1,
+						"fres",
+						"*",
+						[5, "1.5"]
+					]]
+				]
+			],
+			[
+				13,
+				"broadSpec",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"pow"
+							],
+							["ndh", [
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "16"]]
+							]]
+						],
+						"*",
+						[5, "0.4"]
+					],
+					"*",
+					"gloss"
+				]
+			],
+			[
+				13,
+				"ambient",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[
+								[5, "0.4"],
+								[5, "0.46"],
+								[5, "0.55"]
+							]
+						],
+						"mul"
+					],
+					["ambientAmt"]
+				]
+			],
+			[
+				13,
+				"iceRgb",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										[
+											6,
+											[
+												7,
+												"sssRgb",
+												"add"
+											],
+											["ambient"]
+										],
+										"add"
+									],
+									[[
+										6,
+										[
+											7,
+											"d",
+											"vec3f"
+										],
+										[
+											"broadSpec",
+											"broadSpec",
+											"broadSpec"
+										]
+									]]
+								],
+								"add"
+							],
+							["fresnelRgb"]
+						],
+						"add"
+					],
+					["frostRgb"]
+				]
+			],
+			[
+				13,
+				"transition",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						[5, "0"],
+						[5, "1"],
+						"rb1"
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				[
+					[
+						7,
+						"iceRgb",
+						"x"
+					],
+					[
+						7,
+						"iceRgb",
+						"y"
+					],
+					[
+						7,
+						"iceRgb",
+						"z"
+					],
+					"transition"
+				]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"d",
+			"noise",
+			"DEG_TO_RAD"
+		]
+	},
+	externals: () => ({
+		std,
+		d,
+		noise: noise_exports,
+		DEG_TO_RAD
+	})
+}) && $.f)({}));
+const componentDefinition = {
+	name: "Frost",
+	boundingBoxDeclaration: shapeEffectBoundingBoxDeclaration,
+	category: "Shape Effects",
+	description: "Photoreal frozen ice — thickness-driven subsurface scattering that reads as a solid block, with fine frost crystals creeping in from the 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 ice shape",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position",
+				units: ["%", "px"]
+			}
+		},
+		scale: {
+			default: 1,
+			description: "Scale of the ice shape (1 = default size)",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 3,
+				step: .01,
+				label: "Scale",
+				group: "Position"
+			}
+		},
+		rotation: {
+			default: 0,
+			description: "Rotation of the ice shape in degrees",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Rotation",
+				group: "Position"
+			}
+		},
+		iceColor: {
+			default: "#0597fc",
+			transform: transformColor,
+			description: "Ice tint — the colour deep ice saturates toward (thin edges stay near white)",
+			ui: {
+				type: "color",
+				label: "Ice Color",
+				group: "Ice"
+			}
+		},
+		ambient: {
+			default: 0,
+			description: "Cool ambient fill so shadowed ice never goes black",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Ambient",
+				group: "Ice"
+			}
+		},
+		edgeSoftness: {
+			default: .05,
+			description: "Softness of the shape boundary edge",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Edge Softness",
+				group: "Ice"
+			}
+		},
+		density: {
+			default: 5,
+			description: "Optical depth multiplier — how thick and deep the ice reads",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 10,
+				step: .01,
+				label: "Density",
+				group: "Subsurface"
+			}
+		},
+		absorption: {
+			default: 1,
+			description: "Beer–Lambert absorption strength — higher drives a deeper blue-teal core",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Absorption",
+				group: "Subsurface"
+			}
+		},
+		scatter: {
+			default: .5,
+			description: "Forward back-lit glow transmitted through thin ice",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Scatter",
+				group: "Subsurface"
+			}
+		},
+		frostAmount: {
+			default: .8,
+			description: "Overall density of the rim frost crystals",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Frost",
+				group: "Frost"
+			}
+		},
+		frostDepth: {
+			default: .4,
+			description: "How far the frost creeps inward from the rim",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Frost Depth",
+				group: "Frost"
+			}
+		},
+		frostScale: {
+			default: 1,
+			description: "Crystal size — higher = finer, busier frost",
+			ui: {
+				type: "range",
+				min: .3,
+				max: 4,
+				step: .01,
+				label: "Frost Scale",
+				group: "Frost"
+			}
+		},
+		frostRoughness: {
+			default: 3,
+			description: "Feathery roughness of the frost crystal surface",
+			ui: {
+				type: "range",
+				min: 1,
+				max: 5,
+				step: .01,
+				label: "Frost Roughness",
+				group: "Frost"
+			}
+		},
+		sparkle: {
+			default: .5,
+			description: "Tiny bright crystal glints catching the light at the rim",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Sparkle",
+				group: "Frost"
+			}
+		},
+		gloss: {
+			default: .6,
+			description: "Surface sheen — the broad soft icy specular",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Gloss",
+				group: "Surface"
+			}
+		},
+		fresnel: {
+			default: .02,
+			description: "Cold rim glow on grazing surfaces",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Fresnel",
+				group: "Surface"
+			}
+		},
+		lightAngle: {
+			default: 300,
+			description: "Key light direction in degrees",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Light Angle",
+				group: "Surface"
+			}
+		},
+		speed: {
+			default: .3,
+			description: "Sparkle twinkle speed. 0 freezes the sparkle.",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		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 p0 = vec4(uniforms.scale, uniforms.edgeSoftness, uniforms.density, uniforms.absorption);
+		const p1 = vec4(uniforms.scatter, uniforms.frostAmount, uniforms.frostDepth, uniforms.frostScale);
+		const p2 = vec4(uniforms.frostRoughness, uniforms.sparkle, uniforms.gloss, uniforms.fresnel);
+		const p3 = vec4(uniforms.lightAngle, uniforms.ambient, t, volFlag);
+		return call(frostComposite, "frostComposite", [
+			surf0,
+			surfX,
+			surfY,
+			sdfUV,
+			ctx.viewportSize,
+			uniforms.iceColor.member("rgb"),
+			p0,
+			p1,
+			p2,
+			p3
+		]);
+	}
+};
+var Frost_default = componentDefinition;
+export { componentDefinition as n, frostComposite as r, Frost_default as t };