shaders 2.5.135 → 3.0.436

package/dist/core/Holographic-DMNxCZ-k.js

@@ -0,0 +1,2471 @@
+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-BxHv8WrA.js";
+import { n as glass_exports } from "./glass-Cywh_vHD.js";
+import { c as transformPosition } from "./transformations-fqzznt4g.js";
+import { t as animatedTime } from "./porters-7vtm6PTd.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 DEFAULT_SHAPE_CONFIG = JSON.stringify({
+	type: "circleSDF",
+	radius: .35
+});
+var TWO_PI = 6.283185307179586;
+var THIRD = 1 / 3;
+var TWOTHIRD = 2 / 3;
+var LIGHT_X = Math.cos(300 * Math.PI / 180);
+var LIGHT_Y = Math.sin(300 * Math.PI / 180);
+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 holoRainbow = tgpu.fn([d.f32], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
+	"use gpu";
+	const r = __tsover_add(__tsover_mul(std.cos(__tsover_mul(t, TWO_PI)), .5), .5);
+	const g = __tsover_add(__tsover_mul(std.cos(__tsover_mul(__tsover_add(t, THIRD), TWO_PI)), .5), .5);
+	const b = __tsover_add(__tsover_mul(std.cos(__tsover_mul(__tsover_add(t, TWOTHIRD), TWO_PI)), .5), .5);
+	return d.vec3f(r, g, b);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "t"
+		}],
+		"body": [0, [
+			[
+				13,
+				"r",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"cos"
+							],
+							[[
+								1,
+								"t",
+								"*",
+								"TWO_PI"
+							]]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"g",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"cos"
+							],
+							[[
+								1,
+								[
+									1,
+									"t",
+									"+",
+									"THIRD"
+								],
+								"*",
+								"TWO_PI"
+							]]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"b",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"cos"
+							],
+							[[
+								1,
+								[
+									1,
+									"t",
+									"+",
+									"TWOTHIRD"
+								],
+								"*",
+								"TWO_PI"
+							]]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec3f"
+				],
+				[
+					"r",
+					"g",
+					"b"
+				]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"TWO_PI",
+			"THIRD",
+			"TWOTHIRD",
+			"d"
+		]
+	},
+	externals: () => ({
+		std,
+		TWO_PI,
+		THIRD,
+		TWOTHIRD,
+		d
+	})
+}) && $.f)({}));
+const holographicComposite = tgpu.fn([
+	d.vec4f,
+	d.vec4f,
+	d.vec4f,
+	d.vec2f,
+	d.vec2f,
+	d.vec4f,
+	d.vec4f,
+	d.vec4f
+], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sC, sR, sU, sdfUV, viewportSize, p0, p1, p2) => {
+	"use gpu";
+	const scl = p0.x;
+	const edgeSoftness = p0.y;
+	const crinkleScale = p0.z;
+	const crinkle = p0.w;
+	const foilScale = p1.x;
+	const hueShift = p1.y;
+	const saturation = p1.z;
+	const roughness = p1.w;
+	const sparkle = p2.x;
+	const animTime = p2.y;
+	const volumetric = p2.z;
+	const sharp = std.max(__tsover_mul(edgeSoftness, .5), .001);
+	const pxH = __tsover_div(1, viewportSize.y);
+	const sdfRaw = sC.x;
+	const sdf = __tsover_div(sdfRaw, scl);
+	if (sdf > __tsover_mul(pxH, 2)) return d.vec4f(0, 0, 0, 0);
+	const EPS = .008;
+	const gradX = __tsover_div(__tsover_sub(sR.x, sC.x), EPS);
+	const gradY = __tsover_div(__tsover_sub(sU.x, sC.x), 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), sC.y, volumetric > .5);
+	const pdy = std.select(__tsover_sub(sdfUV.y, .5), sC.z, volumetric > .5);
+	const qdx = __tsover_sub(sdfUV.x, .5);
+	const qdy = __tsover_sub(sdfUV.y, .5);
+	const baseNxVol = std.clamp(__tsover_div(__tsover_sub(sR.w, sC.w), EPS), -1.5, 1.5);
+	const baseNyVol = std.clamp(__tsover_div(__tsover_sub(sU.w, sC.w), EPS), -1.5, 1.5);
+	const steepnessVol = std.clamp(__tsover_add(__tsover_mul(baseNxVol, baseNxVol), __tsover_mul(baseNyVol, baseNyVol)), 0, 2);
+	const edgeT = std.clamp(__tsover_div(__tsover_mul(sdf, -1), .06), 0, 1);
+	const domeSlope = __tsover_mul(__tsover_sub(1, edgeT), .35);
+	const baseNxFlat = __tsover_mul(gradX, domeSlope);
+	const baseNyFlat = __tsover_mul(gradY, domeSlope);
+	const baseNx = std.select(baseNxFlat, baseNxVol, volumetric > .5);
+	const baseNy = std.select(baseNyFlat, baseNyVol, volumetric > .5);
+	const steepness = std.select(d.f32(0), steepnessVol, volumetric > .5);
+	const crScale = __tsover_mul(crinkleScale, 1.35);
+	const steepAtten = __tsover_div(1, __tsover_add(1, __tsover_mul(steepness, 2)));
+	const crAmp = __tsover_mul(__tsover_mul(crinkle, .8), steepAtten);
+	const neps = .02;
+	const w0 = mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(pdx, crScale), 2.7), __tsover_add(__tsover_mul(pdy, crScale), 11.3)));
+	const wxTap = mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(__tsover_add(pdx, neps), crScale), 2.7), __tsover_add(__tsover_mul(pdy, crScale), 11.3)));
+	const wyTap = mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(pdx, crScale), 2.7), __tsover_add(__tsover_mul(__tsover_add(pdy, neps), crScale), 11.3)));
+	const wx = __tsover_div(__tsover_sub(wxTap, w0), neps);
+	const wy = __tsover_div(__tsover_sub(wyTap, w0), neps);
+	const n = std.normalize(d.vec3f(__tsover_add(baseNx, __tsover_mul(__tsover_mul(wx, crAmp), .4)), __tsover_add(baseNy, __tsover_mul(__tsover_mul(wy, crAmp), .4)), -1));
+	const fScale = __tsover_mul(foilScale, 2.2);
+	const drift = __tsover_mul(animTime, .06);
+	const blotch = __tsover_add(mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(pdx, fScale), __tsover_mul(drift, LIGHT_X)), __tsover_add(__tsover_mul(pdy, fScale), __tsover_mul(drift, LIGHT_Y)))), __tsover_mul(mxNoiseFloat2(d.vec2f(__tsover_sub(__tsover_add(__tsover_mul(__tsover_mul(pdx, fScale), 2.1), 5.2), __tsover_mul(__tsover_mul(drift, LIGHT_X), 1.6)), __tsover_sub(__tsover_add(__tsover_mul(__tsover_mul(pdy, fScale), 2.1), 9.4), __tsover_mul(__tsover_mul(drift, LIGHT_Y), 1.6)))), .4));
+	const normalTilt = __tsover_add(__tsover_mul(n.x, LIGHT_X), __tsover_mul(n.y, LIGHT_Y));
+	const ramp = __tsover_mul(__tsover_add(__tsover_mul(pdx, LIGHT_X), __tsover_mul(pdy, LIGHT_Y)), .8);
+	const hue = __tsover_add(__tsover_add(__tsover_add(__tsover_add(__tsover_mul(blotch, .45), ramp), __tsover_mul(normalTilt, 1.4)), __tsover_mul(animTime, .18)), __tsover_div(hueShift, 360));
+	const saturationC = std.clamp(saturation, 0, 1);
+	const spectral = holoRainbow(hue);
+	const silver = d.vec3f(.72, .73, .76);
+	const foilTint = std.mix(silver, spectral, d.vec3f(__tsover_mul(saturationC, .85)));
+	const roughnessC = std.clamp(roughness, 0, 1);
+	const L = std.normalize(d.vec3f(LIGHT_X, LIGHT_Y, -.9));
+	const H = std.normalize(L.add(d.vec3f(0, 0, -1)));
+	const ndl = std.clamp(__tsover_add(__tsover_mul(std.dot(n, L), .5), .5), 0, 1);
+	const ndh = std.clamp(std.dot(n, H), 0, 1);
+	const sheen = __tsover_mul(__tsover_mul(std.pow(ndh, d.f32(7)), .45), __tsover_sub(1, __tsover_mul(roughnessC, .35)));
+	const specCore = __tsover_mul(__tsover_mul(std.pow(ndh, std.mix(d.f32(42), d.f32(12), roughnessC)), .85), __tsover_sub(1, __tsover_mul(roughnessC, .55)));
+	const specRgb = foilTint.mul(sheen).add(std.mix(foilTint, d.vec3f(1, 1, 1), d.vec3f(.6)).mul(specCore));
+	const flakeN = mxNoiseFloat2(d.vec2f(__tsover_mul(pdx, 190), __tsover_mul(pdy, 190)));
+	const flakePhase = mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(pdx, 190), 47.3), __tsover_sub(__tsover_mul(pdy, 190), 31.1)));
+	const twinkle = __tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(animTime, 2.2), __tsover_mul(flakePhase, 12.6))), .5), .5);
+	const flakeMask = __tsover_mul(__tsover_mul(std.smoothstep(.52, .62, __tsover_add(__tsover_mul(flakeN, .75), __tsover_mul(twinkle, .3))), std.clamp(sparkle, 0, 1)), steepAtten);
+	const flakeRgb = holoRainbow(__tsover_add(__tsover_add(hue, .33), __tsover_mul(flakePhase, .5))).mul(__tsover_add(.85, __tsover_mul(twinkle, .55))).mul(__tsover_add(__tsover_mul(ndl, .6), .7));
+	const grain = mxNoiseFloat2(d.vec2f(__tsover_mul(qdx, 420), __tsover_mul(qdy, 420)));
+	const grainMul = __tsover_add(1, __tsover_mul(__tsover_mul(grain, roughnessC), .28));
+	const foilBase = foilTint.mul(__tsover_add(__tsover_mul(ndl, .5), .62)).add(specRgb);
+	const foilRgb = std.mix(foilBase, flakeRgb, d.vec3f(flakeMask)).mul(grainMul);
+	const transition = std.smoothstep(0, 1, rb1);
+	return d.vec4f(foilRgb.x, foilRgb.y, foilRgb.z, transition);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "sC"
+			},
+			{
+				"type": "i",
+				"name": "sR"
+			},
+			{
+				"type": "i",
+				"name": "sU"
+			},
+			{
+				"type": "i",
+				"name": "sdfUV"
+			},
+			{
+				"type": "i",
+				"name": "viewportSize"
+			},
+			{
+				"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,
+				"crinkleScale",
+				[
+					7,
+					"p0",
+					"z"
+				]
+			],
+			[
+				13,
+				"crinkle",
+				[
+					7,
+					"p0",
+					"w"
+				]
+			],
+			[
+				13,
+				"foilScale",
+				[
+					7,
+					"p1",
+					"x"
+				]
+			],
+			[
+				13,
+				"hueShift",
+				[
+					7,
+					"p1",
+					"y"
+				]
+			],
+			[
+				13,
+				"saturation",
+				[
+					7,
+					"p1",
+					"z"
+				]
+			],
+			[
+				13,
+				"roughness",
+				[
+					7,
+					"p1",
+					"w"
+				]
+			],
+			[
+				13,
+				"sparkle",
+				[
+					7,
+					"p2",
+					"x"
+				]
+			],
+			[
+				13,
+				"animTime",
+				[
+					7,
+					"p2",
+					"y"
+				]
+			],
+			[
+				13,
+				"volumetric",
+				[
+					7,
+					"p2",
+					"z"
+				]
+			],
+			[
+				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,
+					"sC",
+					"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.008"]
+			],
+			[
+				13,
+				"gradX",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"sR",
+							"x"
+						],
+						"-",
+						[
+							7,
+							"sC",
+							"x"
+						]
+					],
+					"/",
+					"EPS"
+				]
+			],
+			[
+				13,
+				"gradY",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"sU",
+							"x"
+						],
+						"-",
+						[
+							7,
+							"sC",
+							"x"
+						]
+					],
+					"/",
+					"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,
+							"sC",
+							"y"
+						],
+						[
+							1,
+							"volumetric",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"pdy",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"sdfUV",
+								"y"
+							],
+							"-",
+							[5, "0.5"]
+						],
+						[
+							7,
+							"sC",
+							"z"
+						],
+						[
+							1,
+							"volumetric",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"qdx",
+				[
+					1,
+					[
+						7,
+						"sdfUV",
+						"x"
+					],
+					"-",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"qdy",
+				[
+					1,
+					[
+						7,
+						"sdfUV",
+						"y"
+					],
+					"-",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"baseNxVol",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"sR",
+									"w"
+								],
+								"-",
+								[
+									7,
+									"sC",
+									"w"
+								]
+							],
+							"/",
+							"EPS"
+						],
+						[
+							4,
+							"-",
+							[5, "1.5"]
+						],
+						[5, "1.5"]
+					]
+				]
+			],
+			[
+				13,
+				"baseNyVol",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"sU",
+									"w"
+								],
+								"-",
+								[
+									7,
+									"sC",
+									"w"
+								]
+							],
+							"/",
+							"EPS"
+						],
+						[
+							4,
+							"-",
+							[5, "1.5"]
+						],
+						[5, "1.5"]
+					]
+				]
+			],
+			[
+				13,
+				"steepnessVol",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								"baseNxVol",
+								"*",
+								"baseNxVol"
+							],
+							"+",
+							[
+								1,
+								"baseNyVol",
+								"*",
+								"baseNyVol"
+							]
+						],
+						[5, "0"],
+						[5, "2"]
+					]
+				]
+			],
+			[
+				13,
+				"edgeT",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								"sdf",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							"/",
+							[5, "0.06"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"domeSlope",
+				[
+					1,
+					[
+						1,
+						[5, "1"],
+						"-",
+						"edgeT"
+					],
+					"*",
+					[5, "0.35"]
+				]
+			],
+			[
+				13,
+				"baseNxFlat",
+				[
+					1,
+					"gradX",
+					"*",
+					"domeSlope"
+				]
+			],
+			[
+				13,
+				"baseNyFlat",
+				[
+					1,
+					"gradY",
+					"*",
+					"domeSlope"
+				]
+			],
+			[
+				13,
+				"baseNx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"baseNxFlat",
+						"baseNxVol",
+						[
+							1,
+							"volumetric",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"baseNy",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"baseNyFlat",
+						"baseNyVol",
+						[
+							1,
+							"volumetric",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"steepness",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						"steepnessVol",
+						[
+							1,
+							"volumetric",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"crScale",
+				[
+					1,
+					"crinkleScale",
+					"*",
+					[5, "1.35"]
+				]
+			],
+			[
+				13,
+				"steepAtten",
+				[
+					1,
+					[5, "1"],
+					"/",
+					[
+						1,
+						[5, "1"],
+						"+",
+						[
+							1,
+							"steepness",
+							"*",
+							[5, "2"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"crAmp",
+				[
+					1,
+					[
+						1,
+						"crinkle",
+						"*",
+						[5, "0.8"]
+					],
+					"*",
+					"steepAtten"
+				]
+			],
+			[
+				13,
+				"neps",
+				[5, "0.02"]
+			],
+			[
+				13,
+				"w0",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"mxNoiseFloat2"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							[
+								1,
+								"pdx",
+								"*",
+								"crScale"
+							],
+							"+",
+							[5, "2.7"]
+						], [
+							1,
+							[
+								1,
+								"pdy",
+								"*",
+								"crScale"
+							],
+							"+",
+							[5, "11.3"]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"wxTap",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"mxNoiseFloat2"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									"pdx",
+									"+",
+									"neps"
+								],
+								"*",
+								"crScale"
+							],
+							"+",
+							[5, "2.7"]
+						], [
+							1,
+							[
+								1,
+								"pdy",
+								"*",
+								"crScale"
+							],
+							"+",
+							[5, "11.3"]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"wyTap",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"mxNoiseFloat2"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							[
+								1,
+								"pdx",
+								"*",
+								"crScale"
+							],
+							"+",
+							[5, "2.7"]
+						], [
+							1,
+							[
+								1,
+								[
+									1,
+									"pdy",
+									"+",
+									"neps"
+								],
+								"*",
+								"crScale"
+							],
+							"+",
+							[5, "11.3"]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"wx",
+				[
+					1,
+					[
+						1,
+						"wxTap",
+						"-",
+						"w0"
+					],
+					"/",
+					"neps"
+				]
+			],
+			[
+				13,
+				"wy",
+				[
+					1,
+					[
+						1,
+						"wyTap",
+						"-",
+						"w0"
+					],
+					"/",
+					"neps"
+				]
+			],
+			[
+				13,
+				"n",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								1,
+								"baseNx",
+								"+",
+								[
+									1,
+									[
+										1,
+										"wx",
+										"*",
+										"crAmp"
+									],
+									"*",
+									[5, "0.4"]
+								]
+							],
+							[
+								1,
+								"baseNy",
+								"+",
+								[
+									1,
+									[
+										1,
+										"wy",
+										"*",
+										"crAmp"
+									],
+									"*",
+									[5, "0.4"]
+								]
+							],
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"fScale",
+				[
+					1,
+					"foilScale",
+					"*",
+					[5, "2.2"]
+				]
+			],
+			[
+				13,
+				"drift",
+				[
+					1,
+					"animTime",
+					"*",
+					[5, "0.06"]
+				]
+			],
+			[
+				13,
+				"blotch",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"noise",
+							"mxNoiseFloat2"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[
+								1,
+								[
+									1,
+									"pdx",
+									"*",
+									"fScale"
+								],
+								"+",
+								[
+									1,
+									"drift",
+									"*",
+									"LIGHT_X"
+								]
+							], [
+								1,
+								[
+									1,
+									"pdy",
+									"*",
+									"fScale"
+								],
+								"+",
+								[
+									1,
+									"drift",
+									"*",
+									"LIGHT_Y"
+								]
+							]]
+						]]
+					],
+					"+",
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"noise",
+								"mxNoiseFloat2"
+							],
+							[[
+								6,
+								[
+									7,
+									"d",
+									"vec2f"
+								],
+								[[
+									1,
+									[
+										1,
+										[
+											1,
+											[
+												1,
+												"pdx",
+												"*",
+												"fScale"
+											],
+											"*",
+											[5, "2.1"]
+										],
+										"+",
+										[5, "5.2"]
+									],
+									"-",
+									[
+										1,
+										[
+											1,
+											"drift",
+											"*",
+											"LIGHT_X"
+										],
+										"*",
+										[5, "1.6"]
+									]
+								], [
+									1,
+									[
+										1,
+										[
+											1,
+											[
+												1,
+												"pdy",
+												"*",
+												"fScale"
+											],
+											"*",
+											[5, "2.1"]
+										],
+										"+",
+										[5, "9.4"]
+									],
+									"-",
+									[
+										1,
+										[
+											1,
+											"drift",
+											"*",
+											"LIGHT_Y"
+										],
+										"*",
+										[5, "1.6"]
+									]
+								]]
+							]]
+						],
+						"*",
+						[5, "0.4"]
+					]
+				]
+			],
+			[
+				13,
+				"normalTilt",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"n",
+							"x"
+						],
+						"*",
+						"LIGHT_X"
+					],
+					"+",
+					[
+						1,
+						[
+							7,
+							"n",
+							"y"
+						],
+						"*",
+						"LIGHT_Y"
+					]
+				]
+			],
+			[
+				13,
+				"ramp",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"pdx",
+							"*",
+							"LIGHT_X"
+						],
+						"+",
+						[
+							1,
+							"pdy",
+							"*",
+							"LIGHT_Y"
+						]
+					],
+					"*",
+					[5, "0.8"]
+				]
+			],
+			[
+				13,
+				"hue",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"blotch",
+									"*",
+									[5, "0.45"]
+								],
+								"+",
+								"ramp"
+							],
+							"+",
+							[
+								1,
+								"normalTilt",
+								"*",
+								[5, "1.4"]
+							]
+						],
+						"+",
+						[
+							1,
+							"animTime",
+							"*",
+							[5, "0.18"]
+						]
+					],
+					"+",
+					[
+						1,
+						"hueShift",
+						"/",
+						[5, "360"]
+					]
+				]
+			],
+			[
+				13,
+				"saturationC",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						"saturation",
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"spectral",
+				[
+					6,
+					"holoRainbow",
+					["hue"]
+				]
+			],
+			[
+				13,
+				"silver",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						[5, "0.72"],
+						[5, "0.73"],
+						[5, "0.76"]
+					]
+				]
+			],
+			[
+				13,
+				"foilTint",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						"silver",
+						"spectral",
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[[
+								1,
+								"saturationC",
+								"*",
+								[5, "0.85"]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"roughnessC",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						"roughness",
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"L",
+				[
+					6,
+					[
+						7,
+						"std",
+						"normalize"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							"LIGHT_X",
+							"LIGHT_Y",
+							[
+								4,
+								"-",
+								[5, "0.9"]
+							]
+						]
+					]]
+				]
+			],
+			[
+				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",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"std",
+										"dot"
+									],
+									["n", "L"]
+								],
+								"*",
+								[5, "0.5"]
+							],
+							"+",
+							[5, "0.5"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"ndh",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"dot"
+							],
+							["n", "H"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"sheen",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"pow"
+							],
+							["ndh", [
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "7"]]
+							]]
+						],
+						"*",
+						[5, "0.45"]
+					],
+					"*",
+					[
+						1,
+						[5, "1"],
+						"-",
+						[
+							1,
+							"roughnessC",
+							"*",
+							[5, "0.35"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"specCore",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"pow"
+							],
+							["ndh", [
+								6,
+								[
+									7,
+									"std",
+									"mix"
+								],
+								[
+									[
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										[[5, "42"]]
+									],
+									[
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										[[5, "12"]]
+									],
+									"roughnessC"
+								]
+							]]
+						],
+						"*",
+						[5, "0.85"]
+					],
+					"*",
+					[
+						1,
+						[5, "1"],
+						"-",
+						[
+							1,
+							"roughnessC",
+							"*",
+							[5, "0.55"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"specRgb",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"foilTint",
+								"mul"
+							],
+							["sheen"]
+						],
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							[
+								6,
+								[
+									7,
+									"std",
+									"mix"
+								],
+								[
+									"foilTint",
+									[
+										6,
+										[
+											7,
+											"d",
+											"vec3f"
+										],
+										[
+											[5, "1"],
+											[5, "1"],
+											[5, "1"]
+										]
+									],
+									[
+										6,
+										[
+											7,
+											"d",
+											"vec3f"
+										],
+										[[5, "0.6"]]
+									]
+								]
+							],
+							"mul"
+						],
+						["specCore"]
+					]]
+				]
+			],
+			[
+				13,
+				"flakeN",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"mxNoiseFloat2"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							"pdx",
+							"*",
+							[5, "190"]
+						], [
+							1,
+							"pdy",
+							"*",
+							[5, "190"]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"flakePhase",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"mxNoiseFloat2"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							[
+								1,
+								"pdx",
+								"*",
+								[5, "190"]
+							],
+							"+",
+							[5, "47.3"]
+						], [
+							1,
+							[
+								1,
+								"pdy",
+								"*",
+								[5, "190"]
+							],
+							"-",
+							[5, "31.1"]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"twinkle",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"sin"
+							],
+							[[
+								1,
+								[
+									1,
+									"animTime",
+									"*",
+									[5, "2.2"]
+								],
+								"+",
+								[
+									1,
+									"flakePhase",
+									"*",
+									[5, "12.6"]
+								]
+							]]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"flakeMask",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"smoothstep"
+							],
+							[
+								[5, "0.52"],
+								[5, "0.62"],
+								[
+									1,
+									[
+										1,
+										"flakeN",
+										"*",
+										[5, "0.75"]
+									],
+									"+",
+									[
+										1,
+										"twinkle",
+										"*",
+										[5, "0.3"]
+									]
+								]
+							]
+						],
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								"sparkle",
+								[5, "0"],
+								[5, "1"]
+							]
+						]
+					],
+					"*",
+					"steepAtten"
+				]
+			],
+			[
+				13,
+				"flakeRgb",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								[
+									6,
+									"holoRainbow",
+									[[
+										1,
+										[
+											1,
+											"hue",
+											"+",
+											[5, "0.33"]
+										],
+										"+",
+										[
+											1,
+											"flakePhase",
+											"*",
+											[5, "0.5"]
+										]
+									]]
+								],
+								"mul"
+							],
+							[[
+								1,
+								[5, "0.85"],
+								"+",
+								[
+									1,
+									"twinkle",
+									"*",
+									[5, "0.55"]
+								]
+							]]
+						],
+						"mul"
+					],
+					[[
+						1,
+						[
+							1,
+							"ndl",
+							"*",
+							[5, "0.6"]
+						],
+						"+",
+						[5, "0.7"]
+					]]
+				]
+			],
+			[
+				13,
+				"grain",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"mxNoiseFloat2"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							"qdx",
+							"*",
+							[5, "420"]
+						], [
+							1,
+							"qdy",
+							"*",
+							[5, "420"]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"grainMul",
+				[
+					1,
+					[5, "1"],
+					"+",
+					[
+						1,
+						[
+							1,
+							"grain",
+							"*",
+							"roughnessC"
+						],
+						"*",
+						[5, "0.28"]
+					]
+				]
+			],
+			[
+				13,
+				"foilBase",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"foilTint",
+								"mul"
+							],
+							[[
+								1,
+								[
+									1,
+									"ndl",
+									"*",
+									[5, "0.5"]
+								],
+								"+",
+								[5, "0.62"]
+							]]
+						],
+						"add"
+					],
+					["specRgb"]
+				]
+			],
+			[
+				13,
+				"foilRgb",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								"foilBase",
+								"flakeRgb",
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec3f"
+									],
+									["flakeMask"]
+								]
+							]
+						],
+						"mul"
+					],
+					["grainMul"]
+				]
+			],
+			[
+				13,
+				"transition",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						[5, "0"],
+						[5, "1"],
+						"rb1"
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				[
+					[
+						7,
+						"foilRgb",
+						"x"
+					],
+					[
+						7,
+						"foilRgb",
+						"y"
+					],
+					[
+						7,
+						"foilRgb",
+						"z"
+					],
+					"transition"
+				]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"d",
+			"noise",
+			"LIGHT_X",
+			"LIGHT_Y",
+			"holoRainbow"
+		]
+	},
+	externals: () => ({
+		std,
+		d,
+		noise: noise_exports,
+		LIGHT_X,
+		LIGHT_Y,
+		holoRainbow
+	})
+}) && $.f)({}));
+const componentDefinition = {
+	name: "Holographic",
+	boundingBoxDeclaration: shapeEffectBoundingBoxDeclaration,
+	category: "Shape Effects",
+	description: "Iridescent holographic foil sticker with animated rainbow sheen and glitter flakes",
+	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 foil shape",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position",
+				units: ["%", "px"]
+			}
+		},
+		scale: {
+			default: 1,
+			description: "Scale of the foil shape (1 = default size)",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 3,
+				step: .01,
+				label: "Scale",
+				group: "Position"
+			}
+		},
+		rotation: {
+			default: 0,
+			description: "Rotation of the foil shape in degrees",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Rotation",
+				group: "Position"
+			}
+		},
+		hueShift: {
+			default: 0,
+			description: "Rotates the rainbow spectrum across the foil",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Hue Shift",
+				group: "Foil"
+			}
+		},
+		foilScale: {
+			default: 1.5,
+			description: "Size of the iridescent color patches — higher = smaller, busier patches",
+			ui: {
+				type: "range",
+				min: .3,
+				max: 6,
+				step: .01,
+				label: "Foil Scale",
+				group: "Foil"
+			}
+		},
+		saturation: {
+			default: .75,
+			description: "Rainbow saturation — 0 = plain silver foil, 1 = fully spectral",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Saturation",
+				group: "Foil"
+			}
+		},
+		roughness: {
+			default: .25,
+			description: "Matte laminate grain — softens the gloss with fine paper-like noise",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Roughness",
+				group: "Foil"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "Animation speed — the spectrum drifts across the foil as if the sticker is tilting in your hand. 0 pauses.",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		crinkle: {
+			default: .5,
+			description: "Laminate wrinkles — perturbs the surface so the sheen and rainbow swirl locally instead of lying flat",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Crinkle",
+				group: "Foil"
+			}
+		},
+		crinkleScale: {
+			default: 1,
+			description: "Size of the laminate wrinkles — higher = smaller, denser wrinkles",
+			ui: {
+				type: "range",
+				min: .3,
+				max: 6,
+				step: .01,
+				label: "Crinkle Scale",
+				group: "Foil"
+			}
+		},
+		sparkle: {
+			default: .4,
+			description: "Glitter flakes embedded in the foil — tiny facets that refract a shifted hue and twinkle as the spectrum drifts",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Sparkle",
+				group: "Foil"
+			}
+		},
+		edgeSoftness: {
+			default: .05,
+			description: "Softness of the shape boundary edge",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Edge Softness",
+				group: "Foil"
+			}
+		},
+		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 sC = sampler(sdfUV);
+		const sR = gradSampler(call(offsetUV, "offsetUV", [
+			sdfUV,
+			floatE(.008),
+			floatE(0)
+		]));
+		const sU = gradSampler(call(offsetUV, "offsetUV", [
+			sdfUV,
+			floatE(0),
+			floatE(.008)
+		]));
+		const t = animatedTime(params);
+		const volFlag = floatE(volumetric ? 1 : 0);
+		const p0 = vec4(uniforms.scale, uniforms.edgeSoftness, uniforms.crinkleScale, uniforms.crinkle);
+		const p1 = vec4(uniforms.foilScale, uniforms.hueShift, uniforms.saturation, uniforms.roughness);
+		const p2 = vec4(uniforms.sparkle, t, volFlag, floatE(0));
+		return call(holographicComposite, "holographicComposite", [
+			sC,
+			sR,
+			sU,
+			sdfUV,
+			ctx.viewportSize,
+			p0,
+			p1,
+			p2
+		]);
+	}
+};
+var Holographic_default = componentDefinition;
+export { holographicComposite as i, componentDefinition as n, holoRainbow as r, Holographic_default as t };