shaders 3.1.462 → 3.2.464

package/dist/core/{lightfields-C49QCtGR.js → lightfields-BjzpZvFy.js}

@@ -1,5 +1,5 @@
-import { Dt as sin, Ft as vec3f, Mt as vec2f, Ot as smoothstep, _t as max, ct as clamp, et as typegpu_default, ft as exp, gt as length, it as abs, kt as sqrt, lt as cos, mt as floor, ot as atan2, rt as select, sn as f32, xt as pow, yt as mix } from "./edges-CV-BHMpI.js";
-import { o as TAU } from "./constants-BKlzQFdJ.js";
+import { $n as vec4f, Cn as atan2, En as cos, Gn as sqrt, In as mix, Jn as vec2f, Nn as length, Pn as max, Rn as pow, Tn as clamp, Un as sin, Wn as smoothstep, Xt as aspectOf, Zn as vec3f, bn as select, hr as f32, jn as floor, kn as exp, ln as TAU, mn as typegpu_default, xn as abs } from "./lower-z2vuXP8M.js";
+import { t as luma601Dot } from "./tone-BA0D_veZ.js";
 const radialGaussianFalloff = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dist, sharpness) => {
 	"use gpu";
 	return exp(-__tsover_mul(__tsover_mul(dist, dist), sharpness));
@@ -1087,6 +1087,906 @@ const taperedSegmentGlow = typegpu_default.fn([
 		"d.vec2f": () => vec2f
 	}
 }) && $.f)({}));
+const streakBand = typegpu_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((u, center, width) => {
+	"use gpu";
+	return exp(__tsover_div(__tsover_mul(__tsover_mul(__tsover_sub(u, center), __tsover_sub(u, center)), -1), __tsover_mul(width, width)));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "u"
+			},
+			{
+				"type": "i",
+				"name": "center"
+			},
+			{
+				"type": "i",
+				"name": "width"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			"std.exp",
+			[[
+				1,
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"u",
+							"-",
+							"center"
+						],
+						"*",
+						[
+							1,
+							"u",
+							"-",
+							"center"
+						]
+					],
+					"*",
+					[
+						4,
+						"-",
+						[5, "1"]
+					]
+				],
+				"/",
+				[
+					1,
+					"width",
+					"*",
+					"width"
+				]
+			]]
+		]]]]
+	},
+	externals: { "std.exp": () => exp }
+}) && $.f)({}));
+const heatRamp3 = typegpu_default.fn([
+	f32,
+	vec3f,
+	vec3f,
+	vec3f
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((heat, hot, mid, fringe) => {
+	"use gpu";
+	const toMid = smoothstep(0, .5, heat);
+	const toHot = smoothstep(.55, 1.15, heat);
+	return mix(mix(fringe, mid, vec3f(toMid)), hot, vec3f(toHot)).mul(clamp(heat, 0, 1.6));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "heat"
+			},
+			{
+				"type": "i",
+				"name": "hot"
+			},
+			{
+				"type": "i",
+				"name": "mid"
+			},
+			{
+				"type": "i",
+				"name": "fringe"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"toMid",
+				[
+					6,
+					"std.smoothstep",
+					[
+						[5, "0"],
+						[5, "0.5"],
+						"heat"
+					]
+				]
+			],
+			[
+				13,
+				"toHot",
+				[
+					6,
+					"std.smoothstep",
+					[
+						[5, "0.55"],
+						[5, "1.15"],
+						"heat"
+					]
+				]
+			],
+			[
+				13,
+				"rgb",
+				[
+					6,
+					"std.mix",
+					[
+						[
+							6,
+							"std.mix",
+							[
+								"fringe",
+								"mid",
+								[
+									6,
+									"d.vec3f",
+									["toMid"]
+								]
+							]
+						],
+						"hot",
+						[
+							6,
+							"d.vec3f",
+							["toHot"]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"rgb",
+					"mul"
+				],
+				[[
+					6,
+					"std.clamp",
+					[
+						"heat",
+						[5, "0"],
+						[5, "1.6"]
+					]
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"std.smoothstep": () => smoothstep,
+		"std.mix": () => mix,
+		"d.vec3f": () => vec3f,
+		"std.clamp": () => clamp
+	}
+}) && $.f)({}));
+const chromaticHeatTaps = typegpu_default.fn([
+	f32,
+	vec3f,
+	vec3f,
+	vec3f
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((heat, hot, mid, fringe) => {
+	"use gpu";
+	const rampR = heatRamp3(__tsover_mul(heat, 1.08), hot, mid, fringe);
+	const rampG = heatRamp3(heat, hot, mid, fringe);
+	const rampB = heatRamp3(__tsover_mul(heat, .88), hot, mid, fringe);
+	return vec3f(rampR.x, rampG.y, rampB.z);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "heat"
+			},
+			{
+				"type": "i",
+				"name": "hot"
+			},
+			{
+				"type": "i",
+				"name": "mid"
+			},
+			{
+				"type": "i",
+				"name": "fringe"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"rampR",
+				[
+					6,
+					"heatRamp3",
+					[
+						[
+							1,
+							"heat",
+							"*",
+							[5, "1.08"]
+						],
+						"hot",
+						"mid",
+						"fringe"
+					]
+				]
+			],
+			[
+				13,
+				"rampG",
+				[
+					6,
+					"heatRamp3",
+					[
+						"heat",
+						"hot",
+						"mid",
+						"fringe"
+					]
+				]
+			],
+			[
+				13,
+				"rampB",
+				[
+					6,
+					"heatRamp3",
+					[
+						[
+							1,
+							"heat",
+							"*",
+							[5, "0.88"]
+						],
+						"hot",
+						"mid",
+						"fringe"
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec3f",
+				[
+					[
+						7,
+						"rampR",
+						"x"
+					],
+					[
+						7,
+						"rampG",
+						"y"
+					],
+					[
+						7,
+						"rampB",
+						"z"
+					]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"heatRamp3": () => heatRamp3,
+		"d.vec3f": () => vec3f
+	}
+}) && $.f)({}));
+const radialFeatherMask = typegpu_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dist, radius, feather) => {
+	"use gpu";
+	const falloffStart = __tsover_mul(radius, __tsover_sub(1, feather));
+	return __tsover_sub(1, smoothstep(falloffStart, radius, dist));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dist"
+			},
+			{
+				"type": "i",
+				"name": "radius"
+			},
+			{
+				"type": "i",
+				"name": "feather"
+			}
+		],
+		"body": [0, [[
+			13,
+			"falloffStart",
+			[
+				1,
+				"radius",
+				"*",
+				[
+					1,
+					[5, "1"],
+					"-",
+					"feather"
+				]
+			]
+		], [10, [
+			1,
+			[5, "1"],
+			"-",
+			[
+				6,
+				"std.smoothstep",
+				[
+					"falloffStart",
+					"radius",
+					"dist"
+				]
+			]
+		]]]]
+	},
+	externals: { "std.smoothstep": () => smoothstep }
+}) && $.f)({}));
+const softRayLobes = typegpu_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((angle, count, phase, softness) => {
+	"use gpu";
+	return angularSineLobes(angle, count, phase, __tsover_mul(__tsover_div(1, __tsover_add(softness, .05)), .3));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "angle"
+			},
+			{
+				"type": "i",
+				"name": "count"
+			},
+			{
+				"type": "i",
+				"name": "phase"
+			},
+			{
+				"type": "i",
+				"name": "softness"
+			}
+		],
+		"body": [0, [[
+			13,
+			"sharpness",
+			[
+				1,
+				[
+					1,
+					[5, "1"],
+					"/",
+					[
+						1,
+						"softness",
+						"+",
+						[5, "0.05"]
+					]
+				],
+				"*",
+				[5, "0.3"]
+			]
+		], [10, [
+			6,
+			"angularSineLobes",
+			[
+				"angle",
+				"count",
+				"phase",
+				"sharpness"
+			]
+		]]]]
+	},
+	externals: { "angularSineLobes": () => angularSineLobes }
+}) && $.f)({}));
+const radialBurstFrame = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	vec2f
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, center) => {
+	"use gpu";
+	const aspect = aspectOf(viewport);
+	const cx = center.x;
+	const cy = __tsover_sub(1, center.y);
+	const dx = __tsover_sub(__tsover_mul(uv.x, aspect), __tsover_mul(cx, aspect));
+	const dy = __tsover_sub(uv.y, cy);
+	return vec2f(sqrt(__tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy))), atan2(dy, dx));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "center"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"aspect",
+				[
+					6,
+					"geom.aspectOf",
+					["viewport"]
+				]
+			],
+			[
+				13,
+				"cx",
+				[
+					7,
+					"center",
+					"x"
+				]
+			],
+			[
+				13,
+				"cy",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						7,
+						"center",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"dx",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"uv",
+							"x"
+						],
+						"*",
+						"aspect"
+					],
+					"-",
+					[
+						1,
+						"cx",
+						"*",
+						"aspect"
+					]
+				]
+			],
+			[
+				13,
+				"dy",
+				[
+					1,
+					[
+						7,
+						"uv",
+						"y"
+					],
+					"-",
+					"cy"
+				]
+			],
+			[
+				13,
+				"dist",
+				[
+					6,
+					"std.sqrt",
+					[[
+						1,
+						[
+							1,
+							"dx",
+							"*",
+							"dx"
+						],
+						"+",
+						[
+							1,
+							"dy",
+							"*",
+							"dy"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"angle",
+				[
+					6,
+					"std.atan2",
+					["dy", "dx"]
+				]
+			],
+			[10, [
+				6,
+				"d.vec2f",
+				["dist", "angle"]
+			]]
+		]]
+	},
+	externals: {
+		"geom.aspectOf": () => aspectOf,
+		"std.sqrt": () => sqrt,
+		"std.atan2": () => atan2,
+		"d.vec2f": () => vec2f
+	}
+}) && $.f)({}));
+const vignetteMask = typegpu_default.fn([
+	vec2f,
+	vec2f,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, strength) => {
+	"use gpu";
+	const aspect = aspectOf(viewport);
+	const vigX = __tsover_mul(__tsover_sub(uv.x, .5), aspect);
+	const vigY = __tsover_sub(uv.y, .5);
+	const vigD2 = __tsover_add(__tsover_mul(vigX, vigX), __tsover_mul(vigY, vigY));
+	return clamp(__tsover_sub(1, __tsover_mul(vigD2, strength)), 0, 1);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "strength"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"aspect",
+				[
+					6,
+					"geom.aspectOf",
+					["viewport"]
+				]
+			],
+			[
+				13,
+				"vigX",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"uv",
+							"x"
+						],
+						"-",
+						[5, "0.5"]
+					],
+					"*",
+					"aspect"
+				]
+			],
+			[
+				13,
+				"vigY",
+				[
+					1,
+					[
+						7,
+						"uv",
+						"y"
+					],
+					"-",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"vigD2",
+				[
+					1,
+					[
+						1,
+						"vigX",
+						"*",
+						"vigX"
+					],
+					"+",
+					[
+						1,
+						"vigY",
+						"*",
+						"vigY"
+					]
+				]
+			],
+			[10, [
+				6,
+				"std.clamp",
+				[
+					[
+						1,
+						[5, "1"],
+						"-",
+						[
+							1,
+							"vigD2",
+							"*",
+							"strength"
+						]
+					],
+					[5, "0"],
+					[5, "1"]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"geom.aspectOf": () => aspectOf,
+		"std.clamp": () => clamp
+	}
+}) && $.f)({}));
+const screenGlowComposite = typegpu_default.fn([vec4f, vec3f], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, leakRgb) => {
+	"use gpu";
+	const base = color.xyz;
+	const outRgb = clamp(vec3f(1, 1, 1).sub(vec3f(1, 1, 1).sub(clamp(base, vec3f(0), vec3f(1))).mul(vec3f(1, 1, 1).sub(clamp(leakRgb, vec3f(0), vec3f(1))))).add(leakRgb.mul(.16)), vec3f(0), vec3f(1));
+	const leakLuma = clamp(luma601Dot(leakRgb), 0, 1);
+	return vec4f(outRgb, clamp(__tsover_add(color.w, __tsover_mul(leakLuma, .85)), 0, 1));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "color"
+		}, {
+			"type": "i",
+			"name": "leakRgb"
+		}],
+		"body": [0, [
+			[
+				13,
+				"base",
+				[
+					7,
+					"color",
+					"xyz"
+				]
+			],
+			[
+				13,
+				"screened",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							"d.vec3f",
+							[
+								[5, "1"],
+								[5, "1"],
+								[5, "1"]
+							]
+						],
+						"sub"
+					],
+					[[
+						6,
+						[
+							7,
+							[
+								6,
+								[
+									7,
+									[
+										6,
+										"d.vec3f",
+										[
+											[5, "1"],
+											[5, "1"],
+											[5, "1"]
+										]
+									],
+									"sub"
+								],
+								[[
+									6,
+									"std.clamp",
+									[
+										"base",
+										[
+											6,
+											"d.vec3f",
+											[[5, "0"]]
+										],
+										[
+											6,
+											"d.vec3f",
+											[[5, "1"]]
+										]
+									]
+								]]
+							],
+							"mul"
+						],
+						[[
+							6,
+							[
+								7,
+								[
+									6,
+									"d.vec3f",
+									[
+										[5, "1"],
+										[5, "1"],
+										[5, "1"]
+									]
+								],
+								"sub"
+							],
+							[[
+								6,
+								"std.clamp",
+								[
+									"leakRgb",
+									[
+										6,
+										"d.vec3f",
+										[[5, "0"]]
+									],
+									[
+										6,
+										"d.vec3f",
+										[[5, "1"]]
+									]
+								]
+							]]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"lifted",
+				[
+					6,
+					[
+						7,
+						"screened",
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							"leakRgb",
+							"mul"
+						],
+						[[5, "0.16"]]
+					]]
+				]
+			],
+			[
+				13,
+				"outRgb",
+				[
+					6,
+					"std.clamp",
+					[
+						"lifted",
+						[
+							6,
+							"d.vec3f",
+							[[5, "0"]]
+						],
+						[
+							6,
+							"d.vec3f",
+							[[5, "1"]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"leakLuma",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							6,
+							"tone.luma601Dot",
+							["leakRgb"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"outA",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							1,
+							[
+								7,
+								"color",
+								"w"
+							],
+							"+",
+							[
+								1,
+								"leakLuma",
+								"*",
+								[5, "0.85"]
+							]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[10, [
+				6,
+				"d.vec4f",
+				["outRgb", "outA"]
+			]]
+		]]
+	},
+	externals: {
+		"d.vec3f": () => vec3f,
+		"std.clamp": () => clamp,
+		"tone.luma601Dot": () => luma601Dot,
+		"d.vec4f": () => vec4f
+	}
+}) && $.f)({}));
 const beamLocalFrame = typegpu_default.fn([
 	vec2f,
 	f32,
@@ -1352,4 +2252,4 @@ const beamLocalFrame = typegpu_default.fn([
 		"d.f32": () => f32
 	}
 }) && $.f)({}));
-export { chromaticRingBand as a, radialGaussianGlow as c, beamLocalFrame as i, seamlessAngularField as l, angularSineLobes as n, pointToSegment as o, anisotropicGaussianSpot as r, radialGaussianFalloff as s, angularCosineSpikes as t, taperedSegmentGlow as u };
+export { chromaticRingBand as a, radialFeatherMask as c, screenGlowComposite as d, seamlessAngularField as f, vignetteMask as g, taperedSegmentGlow as h, chromaticHeatTaps as i, radialGaussianFalloff as l, streakBand as m, anisotropicGaussianSpot as n, pointToSegment as o, softRayLobes as p, beamLocalFrame as r, radialBurstFrame as s, angularCosineSpikes as t, radialGaussianGlow as u };