shaders 3.0.452 → 3.1.454

package/dist/core/{ProgressiveBlur-Da5uOM1i.js → ProgressiveBlur-B1Ur87dm.js}

@@ -1,8 +1,8 @@
-import { $t as struct, Bt as smoothstep, Ct as dot, Jt as textureStorage2d, Lt as round, Nt as pow, P as unpremultiplyAlpha, Wt as data_exports, an as vec3f, at as textureLoad, b as vec4, bt as clamp, cn as f32, d as ZERO, in as vec2u, jt as mix, kt as max, ln as i32, m as call, nn as vec2f, qt as texture2d, rt as std_exports, sn as vec4f, st as textureStore, tt as src_default, un as u32, xt as cos, zt as sin } from "./edges-Dm0I-Ud7.js";
-import { n as createGuardedCompute } from "./compute-DYJOCqJI.js";
-import { a as createVariableGaussianBlurCompute, t as BLUR_MAP_FORMAT } from "./blur-BAqURXkj.js";
-import { c as transformPosition, r as transformAngle } from "./transformations-CsPUHppB.js";
-var DEG_TO_RAD = Math.PI / 180;
+import { At as max, Bt as sin, Gt as data_exports, Jt as texture2d, Rt as round, St as cos, Vt as smoothstep, Yt as textureStorage2d, an as vec2u, at as std_exports, cn as vec4f, dn as i32, en as struct, fn as u32, lt as textureStore, rn as vec2f, rt as src_default, st as textureLoad, un as f32, wt as dot, x as vec4, xt as clamp } from "./edges-CD7gCAto.js";
+import { t as DEG_TO_RAD$1 } from "./constants-DoOzbl5b.js";
+import { a as REMAP_WINDOW_FIELDS, i as MAP_SOURCE_DIM_FIELDS, m as remapWindowValues, o as applyRemapWindow, p as mapSourceScalar, s as blur_exports, t as BLUR_MAP_FORMAT, u as composeBlurredOverSharp, v as withVariableBlurCompute } from "./blur-CZuIxzX6.js";
+import { c as transformPosition, r as transformAngle } from "./transformations-B-zNWNdd.js";
+var DEG_TO_RAD = DEG_TO_RAD$1;
 const INTENSITY_TO_RADIUS = .36;
 const intensityToRadius = (intensity) => intensity * INTENSITY_TO_RADIUS;
 const progressiveBlurAmount = src_default.fn([
@@ -188,13 +188,8 @@ function progressiveFillMapParams() {
 		centerY: f32,
 		falloff: f32,
 		aspect: f32,
-		inputWidth: f32,
-		inputHeight: f32,
-		inputMin: f32,
-		inputMax: f32,
-		outputMin: f32,
-		outputMax: f32,
-		curve: f32
+		...MAP_SOURCE_DIM_FIELDS,
+		...REMAP_WINDOW_FIELDS
 	});
 }
 function buildProgressiveBlurFillGraph(computeWidth, computeHeight) {
@@ -413,6 +408,7 @@ function buildProgressiveBlurFillMapGraph(computeWidth, computeHeight, channel)
 		blurMap: { storageTexture: textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
 		params: { uniform: Params }
 	}), "layout");
+	const channelScalar = mapSourceScalar(channel);
 	return {
 		layout,
 		kernel: src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
@@ -423,12 +419,8 @@ function buildProgressiveBlurFillMapGraph(computeWidth, computeHeight, channel)
 			const blurAmount = progressiveBlurAmount(p.angle, p.centerX, p.centerY, p.falloff, vec2f(u, v), p.aspect);
 			const srcX = clamp(i32(round(__tsover_mul(u, p.inputWidth))), 0, i32(__tsover_sub(p.inputWidth, 1)));
 			const srcY = clamp(i32(round(__tsover_mul(v, p.inputHeight))), 0, i32(__tsover_sub(p.inputHeight, 1)));
-			const sample = textureLoad(layout.$.source, vec2u(u32(srcX), u32(srcY)), 0);
-			const raw = channel === "alpha" ? sample.w : channel === "alphaInverted" ? __tsover_sub(1, sample.w) : channel === "luminanceInverted" ? __tsover_sub(1, dot(sample.xyz, vec3f(.2126, .7152, .0722))) : dot(sample.xyz, vec3f(.2126, .7152, .0722));
-			const inputRange = max(__tsover_sub(p.inputMax, p.inputMin), 1e-4);
-			const eased = pow(clamp(__tsover_div(__tsover_sub(raw, p.inputMin), inputRange), 0, 1), pow(2, __tsover_mul(-p.curve, 2)));
-			const maxRadius = __tsover_mul(mix(p.outputMin, p.outputMax, eased), .36);
-			const radius = __tsover_mul(blurAmount, maxRadius);
+			const remapped = applyRemapWindow(channelScalar(textureLoad(layout.$.source, vec2u(u32(srcX), u32(srcY)), 0)), p.inputMin, p.inputMax, p.outputMin, p.outputMax, p.curve);
+			const radius = __tsover_mul(blurAmount, __tsover_mul(remapped, .36));
 			textureStore(layout.$.blurMap, vec2u(cx, cy), vec4f(radius, 0, 0, 1));
 		}), {
 			v: 1,
@@ -714,229 +706,46 @@ function buildProgressiveBlurFillMapGraph(computeWidth, computeHeight, channel)
 					],
 					[
 						13,
-						"raw",
+						"remapped",
 						[
-							105,
-							[
-								1,
-								"channel",
-								"===",
-								[103, "alpha"]
-							],
+							6,
 							[
 								7,
-								"sample",
-								"w"
+								"blur",
+								"applyRemapWindow"
 							],
 							[
-								105,
 								[
-									1,
-									"channel",
-									"===",
-									[103, "alphaInverted"]
+									6,
+									"channelScalar",
+									["sample"]
 								],
 								[
-									1,
-									[5, "1"],
-									"-",
-									[
-										7,
-										"sample",
-										"w"
-									]
+									7,
+									"p",
+									"inputMin"
 								],
-								[
-									105,
-									[
-										1,
-										"channel",
-										"===",
-										[103, "luminanceInverted"]
-									],
-									[
-										1,
-										[5, "1"],
-										"-",
-										[
-											6,
-											[
-												7,
-												"std",
-												"dot"
-											],
-											[[
-												7,
-												"sample",
-												"xyz"
-											], [
-												6,
-												[
-													7,
-													"d",
-													"vec3f"
-												],
-												[
-													[5, "0.2126"],
-													[5, "0.7152"],
-													[5, "0.0722"]
-												]
-											]]
-										]
-									],
-									[
-										6,
-										[
-											7,
-											"std",
-											"dot"
-										],
-										[[
-											7,
-											"sample",
-											"xyz"
-										], [
-											6,
-											[
-												7,
-												"d",
-												"vec3f"
-											],
-											[
-												[5, "0.2126"],
-												[5, "0.7152"],
-												[5, "0.0722"]
-											]
-										]]
-									]
-								]
-							]
-						]
-					],
-					[
-						13,
-						"inputRange",
-						[
-							6,
-							[
-								7,
-								"std",
-								"max"
-							],
-							[[
-								1,
 								[
 									7,
 									"p",
 									"inputMax"
 								],
-								"-",
 								[
 									7,
 									"p",
-									"inputMin"
-								]
-							], [5, "0.0001"]]
-						]
-					],
-					[
-						13,
-						"normalised",
-						[
-							6,
-							[
-								7,
-								"std",
-								"clamp"
-							],
-							[
-								[
-									1,
-									[
-										1,
-										"raw",
-										"-",
-										[
-											7,
-											"p",
-											"inputMin"
-										]
-									],
-									"/",
-									"inputRange"
+									"outputMin"
 								],
-								[5, "0"],
-								[5, "1"]
-							]
-						]
-					],
-					[
-						13,
-						"exponent",
-						[
-							6,
-							[
-								7,
-								"std",
-								"pow"
-							],
-							[[5, "2"], [
-								1,
-								[
-									4,
-									"-",
-									[
-										7,
-										"p",
-										"curve"
-									]
-								],
-								"*",
-								[5, "2"]
-							]]
-						]
-					],
-					[
-						13,
-						"eased",
-						[
-							6,
-							[
-								7,
-								"std",
-								"pow"
-							],
-							["normalised", "exponent"]
-						]
-					],
-					[
-						13,
-						"maxRadius",
-						[
-							1,
-							[
-								6,
 								[
 									7,
-									"std",
-									"mix"
+									"p",
+									"outputMax"
 								],
 								[
-									[
-										7,
-										"p",
-										"outputMin"
-									],
-									[
-										7,
-										"p",
-										"outputMax"
-									],
-									"eased"
+									7,
+									"p",
+									"curve"
 								]
-							],
-							"*",
-							"INTENSITY_TO_RADIUS"
+							]
 						]
 					],
 					[
@@ -946,7 +755,12 @@ function buildProgressiveBlurFillMapGraph(computeWidth, computeHeight, channel)
 							1,
 							"blurAmount",
 							"*",
-							"maxRadius"
+							[
+								1,
+								"remapped",
+								"*",
+								"INTENSITY_TO_RADIUS"
+							]
 						]
 					],
 					[
@@ -999,7 +813,8 @@ function buildProgressiveBlurFillMapGraph(computeWidth, computeHeight, channel)
 					"computeHeight",
 					"progressiveBlurAmount",
 					"std",
-					"channel",
+					"blur",
+					"channelScalar",
 					"INTENSITY_TO_RADIUS"
 				]
 			},
@@ -1010,7 +825,8 @@ function buildProgressiveBlurFillMapGraph(computeWidth, computeHeight, channel)
 				computeHeight,
 				progressiveBlurAmount,
 				std: std_exports,
-				channel,
+				blur: blur_exports,
+				channelScalar,
 				INTENSITY_TO_RADIUS: .36
 			})
 		}) && $.f)({})).$name("progressiveBlurFillBlurMapVariable"),
@@ -1077,165 +893,37 @@ const componentDefinition = {
 		}
 	},
 	compute: (params) => {
-		const { childNode, gpu, convertToTexture, registerComputeTexture, getCpuValue, getMapInfo, onCleanup, onResize, dimensions } = params;
-		if (!childNode) return null;
-		const root = gpu?.root;
-		if (!root) return null;
-		const childTexture = convertToTexture(childNode);
-		let curWidth = Math.max(1, Math.round(dimensions.width));
-		let curHeight = Math.max(1, Math.round(dimensions.height));
-		const variable = createVariableGaussianBlurCompute(root, null, curWidth, curHeight, onCleanup);
-		const blurredTexture = registerComputeTexture(variable.outputTexture);
-		const readGeometry = () => {
+		const { getCpuValue, getMapInfo } = params;
+		const readGeometry = (dims) => {
 			const center = getCpuValue("center");
 			return {
 				angle: getCpuValue("angle") ?? 0,
 				centerX: typeof center?.x === "number" ? center.x : 0,
 				centerY: typeof center?.y === "number" ? center.y : .5,
 				falloff: getCpuValue("falloff") ?? 1,
-				aspect: curWidth / curHeight
+				aspect: dims.width / dims.height
 			};
 		};
 		const mapInfo = getMapInfo("intensity");
-		if (mapInfo) {
-			const graph$1 = buildProgressiveBlurFillMapGraph(variable.computeWidth, variable.computeHeight, mapInfo.channel);
-			const fillParams$1 = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph$1.Params), "fillParams");
-			let fillPass$1 = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-				"use gpu";
-				graph$1.kernel(cx, cy);
-			}), {
-				v: 1,
-				name: void 0,
-				ast: {
-					"params": [{
-						"type": "i",
-						"name": "cx"
-					}, {
-						"type": "i",
-						"name": "cy"
-					}],
-					"body": [0, [[
-						6,
-						[
-							7,
-							"graph",
-							"kernel"
-						],
-						["cx", "cy"]
-					]]],
-					"externalNames": ["graph"]
-				},
-				externals: () => ({ graph: graph$1 })
-			}) && $.f)({}), { size: [variable.computeWidth, variable.computeHeight] });
-			onResize(({ width, height }) => {
-				curWidth = Math.max(1, Math.round(width));
-				curHeight = Math.max(1, Math.round(height));
-				variable.setInputDimensions(curWidth, curHeight);
-			});
-			return {
-				outputs: {
-					childTexture,
-					blurredTexture
-				},
-				bindInputs: (resolve) => {
-					const src = resolve(childTexture.key);
-					if (src) variable.setInputTexture(src.texture);
-					const mapSrc = resolve(mapInfo.sourceTexture.key);
-					if (mapSrc) {
-						const bg = root.createBindGroup(graph$1.layout, {
-							source: mapSrc.texture,
-							blurMap: variable.blurMapTexture,
-							params: fillParams$1.buffer
-						});
-						fillPass$1 = fillPass$1.with(bg);
-					}
-				},
-				getComputeNodes: () => {
-					const g = readGeometry();
-					const w = mapInfo.window();
-					fillParams$1.write({
-						...g,
-						inputWidth: curWidth,
-						inputHeight: curHeight,
-						inputMin: w.inputMin,
-						inputMax: w.inputMax,
-						outputMin: w.outputMin,
-						outputMax: w.outputMax,
-						curve: w.curve
-					});
-					return [fillPass$1, ...variable.computeSteps];
-				}
-			};
-		}
-		const graph = buildProgressiveBlurFillGraph(variable.computeWidth, variable.computeHeight);
-		const fillParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(graph.Params), "fillParams");
-		const fillBindGroup = root.createBindGroup(graph.layout, {
-			blurMap: variable.blurMapTexture,
-			params: fillParams.buffer
-		});
-		const fillPass = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			graph.kernel(cx, cy);
-		}), {
-			v: 1,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					6,
-					[
-						7,
-						"graph",
-						"kernel"
-					],
-					["cx", "cy"]
-				]]],
-				"externalNames": ["graph"]
-			},
-			externals: () => ({ graph })
-		}) && $.f)({}), {
-			size: [variable.computeWidth, variable.computeHeight],
-			bindGroup: fillBindGroup
+		if (mapInfo) return withVariableBlurCompute(params, {
+			source: mapInfo,
+			buildFill: (cw, ch) => buildProgressiveBlurFillMapGraph(cw, ch, mapInfo.channel),
+			fillValues: (dims, window) => ({
+				...readGeometry(dims),
+				inputWidth: dims.width,
+				inputHeight: dims.height,
+				...remapWindowValues(window)
+			})
 		});
-		onResize(({ width, height }) => {
-			curWidth = Math.max(1, Math.round(width));
-			curHeight = Math.max(1, Math.round(height));
-			variable.setInputDimensions(curWidth, curHeight);
+		return withVariableBlurCompute(params, {
+			buildFill: buildProgressiveBlurFillGraph,
+			fillValues: (dims) => ({
+				...readGeometry(dims),
+				maxRadius: intensityToRadius(getCpuValue("intensity") ?? 0)
+			})
 		});
-		return {
-			outputs: {
-				childTexture,
-				blurredTexture
-			},
-			bindInputs: (resolve) => {
-				const src = resolve(childTexture.key);
-				if (src) variable.setInputTexture(src.texture);
-			},
-			getComputeNodes: () => {
-				const g = readGeometry();
-				const intensity = getCpuValue("intensity") ?? 0;
-				fillParams.write({
-					...g,
-					maxRadius: intensityToRadius(intensity)
-				});
-				return [fillPass, ...variable.computeSteps];
-			}
-		};
 	},
-	fragment: ({ childNode, computeOutputs, ctx, convertToTexture }) => {
-		if (!childNode) return ZERO;
-		const blurred = computeOutputs?.blurredTexture;
-		const sharp = computeOutputs?.childTexture;
-		if (!blurred || !sharp) return call(unpremultiplyAlpha, "unpremultiplyAlpha", [convertToTexture(childNode).sample(ctx.uv)]);
-		const sharpSample = sharp.sample(ctx.uv);
-		return call(unpremultiplyAlpha, "unpremultiplyAlpha", [vec4(blurred.sample(ctx.uv).member("rgb"), sharpSample.member("a"))]);
-	}
+	fragment: (params) => composeBlurredOverSharp(params, (blurred, sharp) => vec4(blurred.member("rgb"), sharp.member("a")))
 };
 var ProgressiveBlur_default = componentDefinition;
 export { componentDefinition as a, buildProgressiveBlurFillMapGraph as i, ProgressiveBlur_default as n, intensityToRadius as o, buildProgressiveBlurFillGraph as r, progressiveBlurAmount as s, INTENSITY_TO_RADIUS as t };