shaders 2.5.135 → 3.0.437

package/dist/core/BrushedMetal-CvIXubZz.js

@@ -0,0 +1,3028 @@
+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, 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
+});
+var BLUR_K = [
+	-4,
+	-3,
+	-2,
+	-1,
+	0,
+	1,
+	2,
+	3,
+	4
+];
+var BLUR_W = (() => {
+	const sigma = 2.1;
+	const raw = BLUR_K.map((k) => Math.exp(-(k * k) / (2 * sigma * sigma)));
+	const sum = raw.reduce((a, b) => a + b, 0);
+	return raw.map((w) => w / sum);
+})();
+var BRUSH_BLUR_W = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.const(d.arrayOf(d.f32, 9), BLUR_W), "BRUSH_BLUR_W");
+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 brushedStudio = 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), .38);
+	const r0 = __tsover_mul(keyRad, 1);
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(std.smoothstep(r0, __tsover_mul(r0, .2), std.length(p.sub(d.vec2f(__tsover_add(0, drift), .55)))), 1.7), envStr));
+	const r1 = __tsover_mul(keyRad, 1.15);
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(std.smoothstep(r1, __tsover_mul(r1, .2), std.length(p.sub(d.vec2f(__tsover_add(-.55, drift), .18)))), 1.05), envStr));
+	const r2 = __tsover_mul(keyRad, 1);
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(std.smoothstep(r2, __tsover_mul(r2, .2), std.length(p.sub(d.vec2f(__tsover_add(.55, drift), .1)))), 1), envStr));
+	const r3 = __tsover_mul(keyRad, 1.3);
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(std.smoothstep(r3, __tsover_mul(r3, .2), std.length(p.sub(d.vec2f(__tsover_add(.2, drift), -.5)))), .7), envStr));
+	const r4 = __tsover_mul(keyRad, 1.1);
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(std.smoothstep(r4, __tsover_mul(r4, .2), std.length(p.sub(d.vec2f(__tsover_add(-.35, drift), -.25)))), .85), 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.38"]
+				]
+			],
+			[
+				13,
+				"r0",
+				[
+					1,
+					"keyRad",
+					"*",
+					[5, "1"]
+				]
+			],
+			[
+				2,
+				"lum",
+				"=",
+				[
+					1,
+					"lum",
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								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"]]
+											]]
+										]]
+									]
+								]
+							],
+							"*",
+							[5, "1.7"]
+						],
+						"*",
+						"envStr"
+					]
+				]
+			],
+			[
+				13,
+				"r1",
+				[
+					1,
+					"keyRad",
+					"*",
+					[5, "1.15"]
+				]
+			],
+			[
+				2,
+				"lum",
+				"=",
+				[
+					1,
+					"lum",
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								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.55"]
+													],
+													"+",
+													"drift"
+												], [5, "0.18"]]
+											]]
+										]]
+									]
+								]
+							],
+							"*",
+							[5, "1.05"]
+						],
+						"*",
+						"envStr"
+					]
+				]
+			],
+			[
+				13,
+				"r2",
+				[
+					1,
+					"keyRad",
+					"*",
+					[5, "1"]
+				]
+			],
+			[
+				2,
+				"lum",
+				"=",
+				[
+					1,
+					"lum",
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								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"]]
+											]]
+										]]
+									]
+								]
+							],
+							"*",
+							[5, "1"]
+						],
+						"*",
+						"envStr"
+					]
+				]
+			],
+			[
+				13,
+				"r3",
+				[
+					1,
+					"keyRad",
+					"*",
+					[5, "1.3"]
+				]
+			],
+			[
+				2,
+				"lum",
+				"=",
+				[
+					1,
+					"lum",
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"smoothstep"
+								],
+								[
+									"r3",
+									[
+										1,
+										"r3",
+										"*",
+										[5, "0.2"]
+									],
+									[
+										6,
+										[
+											7,
+											"std",
+											"length"
+										],
+										[[
+											6,
+											[
+												7,
+												"p",
+												"sub"
+											],
+											[[
+												6,
+												[
+													7,
+													"d",
+													"vec2f"
+												],
+												[[
+													1,
+													[5, "0.2"],
+													"+",
+													"drift"
+												], [
+													4,
+													"-",
+													[5, "0.5"]
+												]]
+											]]
+										]]
+									]
+								]
+							],
+							"*",
+							[5, "0.7"]
+						],
+						"*",
+						"envStr"
+					]
+				]
+			],
+			[
+				13,
+				"r4",
+				[
+					1,
+					"keyRad",
+					"*",
+					[5, "1.1"]
+				]
+			],
+			[
+				2,
+				"lum",
+				"=",
+				[
+					1,
+					"lum",
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"smoothstep"
+								],
+								[
+									"r4",
+									[
+										1,
+										"r4",
+										"*",
+										[5, "0.2"]
+									],
+									[
+										6,
+										[
+											7,
+											"std",
+											"length"
+										],
+										[[
+											6,
+											[
+												7,
+												"p",
+												"sub"
+											],
+											[[
+												6,
+												[
+													7,
+													"d",
+													"vec2f"
+												],
+												[[
+													1,
+													[
+														4,
+														"-",
+														[5, "0.35"]
+													],
+													"+",
+													"drift"
+												], [
+													4,
+													"-",
+													[5, "0.25"]
+												]]
+											]]
+										]]
+									]
+								]
+							],
+							"*",
+							[5, "0.85"]
+						],
+						"*",
+						"envStr"
+					]
+				]
+			],
+			[10, "lum"]
+		]],
+		"externalNames": ["d", "std"]
+	},
+	externals: () => ({
+		d,
+		std
+	})
+}) && $.f)({}));
+const brushedMetalComposite = tgpu.fn([
+	d.vec4f,
+	d.vec4f,
+	d.vec4f,
+	d.vec2f,
+	d.vec2f,
+	d.vec2f,
+	d.vec3f,
+	d.vec3f,
+	d.vec4f,
+	d.vec4f,
+	d.vec4f
+], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, uv, viewportSize, lightColor, darkColor, p0, p1, p2) => {
+	"use gpu";
+	const scl = p0.x;
+	const edgeSoftness = p0.y;
+	const brushAngle = p0.z;
+	const anisotropy = p0.w;
+	const grain = p1.x;
+	const grainScale = p1.y;
+	const roughness = p1.z;
+	const environment = p1.w;
+	const envRotation = p2.x;
+	const lightAngle = p2.y;
+	const animTime = p2.z;
+	const volumetric = p2.w;
+	const aspect = __tsover_div(viewportSize.x, viewportSize.y);
+	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 lx = std.cos(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const ly = std.sin(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const btx = std.cos(__tsover_mul(brushAngle, DEG_TO_RAD));
+	const bty = std.sin(__tsover_mul(brushAngle, DEG_TO_RAD));
+	const envC = std.cos(__tsover_mul(envRotation, DEG_TO_RAD));
+	const envS = std.sin(__tsover_mul(envRotation, DEG_TO_RAD));
+	const EPS = .01;
+	const gradX = __tsover_div(__tsover_sub(surfX.x, sdfRaw), EPS);
+	const gradY = __tsover_div(__tsover_sub(surfY.x, sdfRaw), EPS);
+	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 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 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 bix = __tsover_mul(bty, -1);
+	const biy = btx;
+	const along = __tsover_add(__tsover_mul(pdx, btx), __tsover_mul(pdy, bty));
+	const across = __tsover_add(__tsover_mul(pdx, bix), __tsover_mul(pdy, biy));
+	const dens = __tsover_mul(grainScale, 150);
+	const driftA = __tsover_mul(std.sin(__tsover_mul(animTime, .05)), .35);
+	const aniso = anisotropy;
+	const sheen0 = mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(along, 1.3), driftA), __tsover_mul(across, 6.5)));
+	const line0 = __tsover_add(mxNoiseFloat2(d.vec2f(__tsover_mul(along, 4.5), __tsover_mul(across, dens))), __tsover_mul(mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(along, 8), 3.1), __tsover_add(__tsover_mul(__tsover_mul(across, dens), 2.3), 7.7))), .5));
+	const sheenAmt = __tsover_add(__tsover_mul(aniso, .5), .08);
+	const lineAmt = __tsover_mul(grain, .16);
+	const pAcross = __tsover_add(__tsover_mul(sheen0, sheenAmt), __tsover_mul(line0, lineAmt));
+	const pAlong = __tsover_mul(mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(__tsover_add(along, 11.7), 1.3), driftA), __tsover_mul(across, 6.5))), __tsover_mul(sheenAmt, .12));
+	const n = std.normalize(d.vec3f(__tsover_add(__tsover_add(nGeo.x, __tsover_mul(bix, pAcross)), __tsover_mul(btx, pAlong)), __tsover_add(__tsover_add(nGeo.y, __tsover_mul(biy, pAcross)), __tsover_mul(bty, pAlong)), nGeo.z));
+	const fov = .6;
+	const viewI = std.normalize(d.vec3f(__tsover_mul(__tsover_mul(__tsover_sub(uv.x, .5), aspect), fov), __tsover_mul(__tsover_sub(uv.y, .5), fov), 1));
+	const cosView = std.clamp(__tsover_mul(std.dot(n, viewI), -1), 0, 1);
+	const grazing = __tsover_sub(1, cosView);
+	const R = std.reflect(viewI, n);
+	const envStr = environment;
+	const rough = std.clamp(roughness, 0, 1);
+	const keyRad = std.mix(.42, .16, __tsover_sub(1, rough));
+	const drift = __tsover_mul(std.sin(__tsover_mul(animTime, .07)), .05);
+	const smear = __tsover_mul(__tsover_mul(aniso, __tsover_add(__tsover_mul(rough, .6), .25)), .42);
+	const step = __tsover_div(smear, 4);
+	let envLum = d.f32(0);
+	for (let i = 0; i < 9; i++) {
+		const off = __tsover_mul(step, __tsover_sub(d.f32(i), 4));
+		envLum = __tsover_add(envLum, __tsover_mul(brushedStudio(__tsover_add(R.x, __tsover_mul(btx, off)), __tsover_add(R.y, __tsover_mul(bty, off)), envC, envS, keyRad, drift, envStr), BRUSH_BLUR_W.$[i]));
+	}
+	const t0 = d.vec3f(btx, bty, 0);
+	const T3 = std.normalize(t0.sub(n.mul(std.dot(n, t0))));
+	const B3 = d.vec3f(__tsover_sub(__tsover_mul(n.y, T3.z), __tsover_mul(n.z, T3.y)), __tsover_sub(__tsover_mul(n.z, T3.x), __tsover_mul(n.x, T3.z)), __tsover_sub(__tsover_mul(n.x, T3.y), __tsover_mul(n.y, T3.x)));
+	const L = std.normalize(d.vec3f(lx, ly, -.7));
+	const H = std.normalize(L.sub(viewI));
+	const hT = std.dot(H, T3);
+	const hB = std.dot(H, B3);
+	const hN = std.clamp(std.abs(std.dot(H, n)), 1e-4, 1);
+	const baseA = std.mix(.05, .45, rough);
+	const aAlong = __tsover_mul(baseA, __tsover_add(1, __tsover_mul(aniso, 7)));
+	const aAcross = std.max(__tsover_mul(baseA, __tsover_sub(1, __tsover_mul(aniso, .55))), .02);
+	const expo = __tsover_div(__tsover_add(__tsover_mul(__tsover_div(hT, aAlong), __tsover_div(hT, aAlong)), __tsover_mul(__tsover_div(hB, aAcross), __tsover_div(hB, aAcross))), __tsover_mul(__tsover_add(hN, 1), .5));
+	const spec = __tsover_mul(std.exp(__tsover_mul(expo, -1)), std.mix(.45, 1.1, __tsover_sub(1, rough)));
+	const fres = __tsover_add(1, __tsover_mul(std.pow(grazing, d.f32(3)), .6));
+	const lit = std.clamp(__tsover_mul(__tsover_add(envLum, spec), fres), 0, 1.7);
+	const rgb = std.mix(darkColor, lightColor, d.vec3f(lit));
+	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": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewportSize"
+			},
+			{
+				"type": "i",
+				"name": "lightColor"
+			},
+			{
+				"type": "i",
+				"name": "darkColor"
+			},
+			{
+				"type": "i",
+				"name": "p0"
+			},
+			{
+				"type": "i",
+				"name": "p1"
+			},
+			{
+				"type": "i",
+				"name": "p2"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"scl",
+				[
+					7,
+					"p0",
+					"x"
+				]
+			],
+			[
+				13,
+				"edgeSoftness",
+				[
+					7,
+					"p0",
+					"y"
+				]
+			],
+			[
+				13,
+				"brushAngle",
+				[
+					7,
+					"p0",
+					"z"
+				]
+			],
+			[
+				13,
+				"anisotropy",
+				[
+					7,
+					"p0",
+					"w"
+				]
+			],
+			[
+				13,
+				"grain",
+				[
+					7,
+					"p1",
+					"x"
+				]
+			],
+			[
+				13,
+				"grainScale",
+				[
+					7,
+					"p1",
+					"y"
+				]
+			],
+			[
+				13,
+				"roughness",
+				[
+					7,
+					"p1",
+					"z"
+				]
+			],
+			[
+				13,
+				"environment",
+				[
+					7,
+					"p1",
+					"w"
+				]
+			],
+			[
+				13,
+				"envRotation",
+				[
+					7,
+					"p2",
+					"x"
+				]
+			],
+			[
+				13,
+				"lightAngle",
+				[
+					7,
+					"p2",
+					"y"
+				]
+			],
+			[
+				13,
+				"animTime",
+				[
+					7,
+					"p2",
+					"z"
+				]
+			],
+			[
+				13,
+				"volumetric",
+				[
+					7,
+					"p2",
+					"w"
+				]
+			],
+			[
+				13,
+				"aspect",
+				[
+					1,
+					[
+						7,
+						"viewportSize",
+						"x"
+					],
+					"/",
+					[
+						7,
+						"viewportSize",
+						"y"
+					]
+				]
+			],
+			[
+				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,
+				"lx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"cos"
+					],
+					[[
+						1,
+						"lightAngle",
+						"*",
+						"DEG_TO_RAD"
+					]]
+				]
+			],
+			[
+				13,
+				"ly",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					[[
+						1,
+						"lightAngle",
+						"*",
+						"DEG_TO_RAD"
+					]]
+				]
+			],
+			[
+				13,
+				"btx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"cos"
+					],
+					[[
+						1,
+						"brushAngle",
+						"*",
+						"DEG_TO_RAD"
+					]]
+				]
+			],
+			[
+				13,
+				"bty",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					[[
+						1,
+						"brushAngle",
+						"*",
+						"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,
+				"EPS",
+				[5, "0.01"]
+			],
+			[
+				13,
+				"gradX",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"surfX",
+							"x"
+						],
+						"-",
+						"sdfRaw"
+					],
+					"/",
+					"EPS"
+				]
+			],
+			[
+				13,
+				"gradY",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"surfY",
+							"x"
+						],
+						"-",
+						"sdfRaw"
+					],
+					"/",
+					"EPS"
+				]
+			],
+			[
+				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,
+				"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,
+				"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,
+				"bix",
+				[
+					1,
+					"bty",
+					"*",
+					[
+						4,
+						"-",
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"biy",
+				"btx"
+			],
+			[
+				13,
+				"along",
+				[
+					1,
+					[
+						1,
+						"pdx",
+						"*",
+						"btx"
+					],
+					"+",
+					[
+						1,
+						"pdy",
+						"*",
+						"bty"
+					]
+				]
+			],
+			[
+				13,
+				"across",
+				[
+					1,
+					[
+						1,
+						"pdx",
+						"*",
+						"bix"
+					],
+					"+",
+					[
+						1,
+						"pdy",
+						"*",
+						"biy"
+					]
+				]
+			],
+			[
+				13,
+				"dens",
+				[
+					1,
+					"grainScale",
+					"*",
+					[5, "150"]
+				]
+			],
+			[
+				13,
+				"driftA",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"sin"
+						],
+						[[
+							1,
+							"animTime",
+							"*",
+							[5, "0.05"]
+						]]
+					],
+					"*",
+					[5, "0.35"]
+				]
+			],
+			[
+				13,
+				"aniso",
+				"anisotropy"
+			],
+			[
+				13,
+				"sheen0",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"mxNoiseFloat2"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							[
+								1,
+								"along",
+								"*",
+								[5, "1.3"]
+							],
+							"+",
+							"driftA"
+						], [
+							1,
+							"across",
+							"*",
+							[5, "6.5"]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"line0",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"noise",
+							"mxNoiseFloat2"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[
+								1,
+								"along",
+								"*",
+								[5, "4.5"]
+							], [
+								1,
+								"across",
+								"*",
+								"dens"
+							]]
+						]]
+					],
+					"+",
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"noise",
+								"mxNoiseFloat2"
+							],
+							[[
+								6,
+								[
+									7,
+									"d",
+									"vec2f"
+								],
+								[[
+									1,
+									[
+										1,
+										"along",
+										"*",
+										[5, "8"]
+									],
+									"+",
+									[5, "3.1"]
+								], [
+									1,
+									[
+										1,
+										[
+											1,
+											"across",
+											"*",
+											"dens"
+										],
+										"*",
+										[5, "2.3"]
+									],
+									"+",
+									[5, "7.7"]
+								]]
+							]]
+						],
+						"*",
+						[5, "0.5"]
+					]
+				]
+			],
+			[
+				13,
+				"sheenAmt",
+				[
+					1,
+					[
+						1,
+						"aniso",
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.08"]
+				]
+			],
+			[
+				13,
+				"lineAmt",
+				[
+					1,
+					"grain",
+					"*",
+					[5, "0.16"]
+				]
+			],
+			[
+				13,
+				"pAcross",
+				[
+					1,
+					[
+						1,
+						"sheen0",
+						"*",
+						"sheenAmt"
+					],
+					"+",
+					[
+						1,
+						"line0",
+						"*",
+						"lineAmt"
+					]
+				]
+			],
+			[
+				13,
+				"pAlong",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"noise",
+							"mxNoiseFloat2"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[
+								1,
+								[
+									1,
+									[
+										1,
+										"along",
+										"+",
+										[5, "11.7"]
+									],
+									"*",
+									[5, "1.3"]
+								],
+								"+",
+								"driftA"
+							], [
+								1,
+								"across",
+								"*",
+								[5, "6.5"]
+							]]
+						]]
+					],
+					"*",
+					[
+						1,
+						"sheenAmt",
+						"*",
+						[5, "0.12"]
+					]
+				]
+			],
+			[
+				13,
+				"n",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"nGeo",
+										"x"
+									],
+									"+",
+									[
+										1,
+										"bix",
+										"*",
+										"pAcross"
+									]
+								],
+								"+",
+								[
+									1,
+									"btx",
+									"*",
+									"pAlong"
+								]
+							],
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"nGeo",
+										"y"
+									],
+									"+",
+									[
+										1,
+										"biy",
+										"*",
+										"pAcross"
+									]
+								],
+								"+",
+								[
+									1,
+									"bty",
+									"*",
+									"pAlong"
+								]
+							],
+							[
+								7,
+								"nGeo",
+								"z"
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"fov",
+				[5, "0.6"]
+			],
+			[
+				13,
+				"viewI",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											7,
+											"uv",
+											"x"
+										],
+										"-",
+										[5, "0.5"]
+									],
+									"*",
+									"aspect"
+								],
+								"*",
+								"fov"
+							],
+							[
+								1,
+								[
+									1,
+									[
+										7,
+										"uv",
+										"y"
+									],
+									"-",
+									[5, "0.5"]
+								],
+								"*",
+								"fov"
+							],
+							[5, "1"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"cosView",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"dot"
+								],
+								["n", "viewI"]
+							],
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"grazing",
+				[
+					1,
+					[5, "1"],
+					"-",
+					"cosView"
+				]
+			],
+			[
+				13,
+				"R",
+				[
+					6,
+					[
+						7,
+						"std",
+						"reflect"
+					],
+					["viewI", "n"]
+				]
+			],
+			[
+				13,
+				"envStr",
+				"environment"
+			],
+			[
+				13,
+				"rough",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						"roughness",
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"keyRad",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[5, "0.42"],
+						[5, "0.16"],
+						[
+							1,
+							[5, "1"],
+							"-",
+							"rough"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"drift",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"sin"
+						],
+						[[
+							1,
+							"animTime",
+							"*",
+							[5, "0.07"]
+						]]
+					],
+					"*",
+					[5, "0.05"]
+				]
+			],
+			[
+				13,
+				"smear",
+				[
+					1,
+					[
+						1,
+						"aniso",
+						"*",
+						[
+							1,
+							[
+								1,
+								"rough",
+								"*",
+								[5, "0.6"]
+							],
+							"+",
+							[5, "0.25"]
+						]
+					],
+					"*",
+					[5, "0.42"]
+				]
+			],
+			[
+				13,
+				"step",
+				[
+					1,
+					"smear",
+					"/",
+					[5, "4"]
+				]
+			],
+			[
+				12,
+				"envLum",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				]
+			],
+			[
+				14,
+				[
+					12,
+					"i",
+					[5, "0"]
+				],
+				[
+					1,
+					"i",
+					"<",
+					[5, "9"]
+				],
+				[
+					102,
+					"++",
+					"i"
+				],
+				[0, [[
+					13,
+					"off",
+					[
+						1,
+						"step",
+						"*",
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["i"]
+							],
+							"-",
+							[5, "4"]
+						]
+					]
+				], [
+					2,
+					"envLum",
+					"=",
+					[
+						1,
+						"envLum",
+						"+",
+						[
+							1,
+							[
+								6,
+								"brushedStudio",
+								[
+									[
+										1,
+										[
+											7,
+											"R",
+											"x"
+										],
+										"+",
+										[
+											1,
+											"btx",
+											"*",
+											"off"
+										]
+									],
+									[
+										1,
+										[
+											7,
+											"R",
+											"y"
+										],
+										"+",
+										[
+											1,
+											"bty",
+											"*",
+											"off"
+										]
+									],
+									"envC",
+									"envS",
+									"keyRad",
+									"drift",
+									"envStr"
+								]
+							],
+							"*",
+							[
+								8,
+								[
+									7,
+									"BRUSH_BLUR_W",
+									"$"
+								],
+								"i"
+							]
+						]
+					]
+				]]]
+			],
+			[
+				13,
+				"t0",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						"btx",
+						"bty",
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"T3",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"t0",
+							"sub"
+						],
+						[[
+							6,
+							[
+								7,
+								"n",
+								"mul"
+							],
+							[[
+								6,
+								[
+									7,
+									"std",
+									"dot"
+								],
+								["n", "t0"]
+							]]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"B3",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"n",
+									"y"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"z"
+								]
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"n",
+									"z"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"y"
+								]
+							]
+						],
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"n",
+									"z"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"x"
+								]
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"n",
+									"x"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"z"
+								]
+							]
+						],
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"n",
+									"x"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"y"
+								]
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"n",
+									"y"
+								],
+								"*",
+								[
+									7,
+									"T3",
+									"x"
+								]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"L",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							"lx",
+							"ly",
+							[
+								4,
+								"-",
+								[5, "0.7"]
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"H",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"L",
+							"sub"
+						],
+						["viewI"]
+					]]
+				]
+			],
+			[
+				13,
+				"hT",
+				[
+					6,
+					[
+						7,
+						"std",
+						"dot"
+					],
+					["H", "T3"]
+				]
+			],
+			[
+				13,
+				"hB",
+				[
+					6,
+					[
+						7,
+						"std",
+						"dot"
+					],
+					["H", "B3"]
+				]
+			],
+			[
+				13,
+				"hN",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"abs"
+							],
+							[[
+								6,
+								[
+									7,
+									"std",
+									"dot"
+								],
+								["H", "n"]
+							]]
+						],
+						[5, "0.0001"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"baseA",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[5, "0.05"],
+						[5, "0.45"],
+						"rough"
+					]
+				]
+			],
+			[
+				13,
+				"aAlong",
+				[
+					1,
+					"baseA",
+					"*",
+					[
+						1,
+						[5, "1"],
+						"+",
+						[
+							1,
+							"aniso",
+							"*",
+							[5, "7"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"aAcross",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						"baseA",
+						"*",
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								1,
+								"aniso",
+								"*",
+								[5, "0.55"]
+							]
+						]
+					], [5, "0.02"]]
+				]
+			],
+			[
+				13,
+				"expo",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"hT",
+								"/",
+								"aAlong"
+							],
+							"*",
+							[
+								1,
+								"hT",
+								"/",
+								"aAlong"
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								1,
+								"hB",
+								"/",
+								"aAcross"
+							],
+							"*",
+							[
+								1,
+								"hB",
+								"/",
+								"aAcross"
+							]
+						]
+					],
+					"/",
+					[
+						1,
+						[
+							1,
+							"hN",
+							"+",
+							[5, "1"]
+						],
+						"*",
+						[5, "0.5"]
+					]
+				]
+			],
+			[
+				13,
+				"spec",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"exp"
+						],
+						[[
+							1,
+							"expo",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]]
+					],
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							[5, "0.45"],
+							[5, "1.1"],
+							[
+								1,
+								[5, "1"],
+								"-",
+								"rough"
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"fres",
+				[
+					1,
+					[5, "1"],
+					"+",
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"pow"
+							],
+							["grazing", [
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "3"]]
+							]]
+						],
+						"*",
+						[5, "0.6"]
+					]
+				]
+			],
+			[
+				13,
+				"lit",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								"envLum",
+								"+",
+								"spec"
+							],
+							"*",
+							"fres"
+						],
+						[5, "0"],
+						[5, "1.7"]
+					]
+				]
+			],
+			[
+				13,
+				"rgb",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						"darkColor",
+						"lightColor",
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							["lit"]
+						]
+					]
+				]
+			],
+			[
+				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",
+			"DEG_TO_RAD",
+			"noise",
+			"brushedStudio",
+			"BRUSH_BLUR_W"
+		]
+	},
+	externals: () => ({
+		std,
+		d,
+		DEG_TO_RAD,
+		noise: noise_exports,
+		brushedStudio,
+		BRUSH_BLUR_W
+	})
+}) && $.f)({}));
+const componentDefinition = {
+	name: "BrushedMetal",
+	boundingBoxDeclaration: shapeEffectBoundingBoxDeclaration,
+	category: "Shape Effects",
+	description: "Photorealistic brushed metal — a satin anodised surface combed with fine directional grain that smears the reflected studio and key light into the long anisotropic streaks of real brushed aluminium, steel, gold or copper",
+	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: "#e9ebef",
+			transform: transformColor,
+			description: "The bright tone of the polished grain — recolor for gold (#ffe8b0), copper (#ffc8a0) or steel",
+			ui: {
+				type: "color",
+				label: "Light Color",
+				group: "Metal"
+			}
+		},
+		darkColor: {
+			default: "#26282d",
+			transform: transformColor,
+			description: "The dark tone the brushed grain falls to in shadow. Tint it warm for gold/bronze, cool for steel.",
+			ui: {
+				type: "color",
+				label: "Dark Color",
+				group: "Metal"
+			}
+		},
+		brushAngle: {
+			default: 0,
+			description: "Direction the surface is brushed, in degrees — the grain and every reflection streak run along this axis",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Brush Angle",
+				group: "Brush"
+			}
+		},
+		anisotropy: {
+			default: .4,
+			description: "How directional the brushing is — 1 = long smeared streaks along the grain, 0 = isotropic satin with no direction",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Anisotropy",
+				group: "Brush"
+			}
+		},
+		grain: {
+			default: .4,
+			description: "Depth of the individual brush scratches — the fine satin texture combed into the metal",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Grain",
+				group: "Brush"
+			}
+		},
+		grainScale: {
+			default: 2,
+			description: "Density of the brush lines — higher = finer, tighter scratches",
+			ui: {
+				type: "range",
+				min: .25,
+				max: 4,
+				step: .01,
+				label: "Grain Scale",
+				group: "Brush"
+			}
+		},
+		roughness: {
+			default: .5,
+			description: "Overall satin softness — 0 = near-polished with crisp reflections, 1 = soft matte brushed finish",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Roughness",
+				group: "Surface"
+			}
+		},
+		environment: {
+			default: 1.4,
+			description: "Strength of the reflected studio lighting — the softboxes seen smeared 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"
+			}
+		},
+		lightAngle: {
+			default: 215,
+			description: "Direction of the key light for the anisotropic specular streak, in degrees",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Light Angle",
+				group: "Surface"
+			}
+		},
+		speed: {
+			default: .4,
+			description: "Speed of the slowly drifting reflection — the studio gently orbits the surface. 0 pauses.",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 4,
+				step: .01,
+				label: "Speed",
+				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 p0 = vec4(uniforms.scale, uniforms.edgeSoftness, uniforms.brushAngle, uniforms.anisotropy);
+		const p1 = vec4(uniforms.grain, uniforms.grainScale, uniforms.roughness, uniforms.environment);
+		const p2 = vec4(uniforms.envRotation, uniforms.lightAngle, t, volFlag);
+		return call(brushedMetalComposite, "brushedMetalComposite", [
+			surf0,
+			surfX,
+			surfY,
+			sdfUV,
+			ctx.uv,
+			ctx.viewportSize,
+			uniforms.lightColor.member("rgb"),
+			uniforms.darkColor.member("rgb"),
+			p0,
+			p1,
+			p2
+		]);
+	}
+};
+var BrushedMetal_default = componentDefinition;
+export { componentDefinition as i, brushedMetalComposite as n, brushedStudio as r, BrushedMetal_default as t };