shaders 3.1.462 → 3.2.464

package/dist/core/TiltShift-AvLZaRdU.js

@@ -1,888 +0,0 @@
-import { Dt as sin, Gt as textureStorage2d, Lt as vec4f, Mt as vec2f, Ot as smoothstep, Pt as vec2u, Tt as round, Wt as texture2d, cn as i32, ct as clamp, dt as dot, et as typegpu_default, it as abs, ln as u32, lt as cos, m as call, qt as struct, sn as f32, y as mixExpr } from "./edges-CV-BHMpI.js";
-import { I as textureLoad, R as textureStore } from "./device-DKcu50_C.js";
-import { t as DEG_TO_RAD$1 } from "./constants-BKlzQFdJ.js";
-import { _ as withVariableBlurCompute, a as REMAP_WINDOW_FIELDS, f as mapSourceScalar, i as MAP_SOURCE_DIM_FIELDS, l as composeBlurredOverSharp, o as applyRemapWindow, p as remapWindowValues, t as BLUR_MAP_FORMAT } from "./blur-CXouokcq.js";
-import { c as transformPosition, r as transformAngle } from "./transformations-u-UZrXjj.js";
-var DEG_TO_RAD = DEG_TO_RAD$1;
-const INTENSITY_TO_RADIUS = .36;
-const intensityToRadius = (intensity) => intensity * INTENSITY_TO_RADIUS;
-const tiltShiftBlurAmount = typegpu_default.fn([
-	f32,
-	vec2f,
-	f32,
-	f32,
-	vec2f,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((angleDeg, center, width, falloff, uv, aspect) => {
-	"use gpu";
-	const angleRad = __tsover_mul(angleDeg, DEG_TO_RAD);
-	const perpVector = vec2f(__tsover_mul(sin(angleRad), -1), cos(angleRad));
-	const centerPos = vec2f(center.x, __tsover_sub(1, center.y));
-	const centeredUV = uv.sub(centerPos);
-	const distFromLine = abs(dot(vec2f(__tsover_mul(centeredUV.x, aspect), centeredUV.y), perpVector));
-	const focusWidth = __tsover_mul(width, .5);
-	return smoothstep(focusWidth, __tsover_add(focusWidth, falloff), distFromLine);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "angleDeg"
-			},
-			{
-				"type": "i",
-				"name": "center"
-			},
-			{
-				"type": "i",
-				"name": "width"
-			},
-			{
-				"type": "i",
-				"name": "falloff"
-			},
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"angleRad",
-				[
-					1,
-					"angleDeg",
-					"*",
-					"DEG_TO_RAD"
-				]
-			],
-			[
-				13,
-				"perpVector",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							6,
-							"std.sin",
-							["angleRad"]
-						],
-						"*",
-						[
-							4,
-							"-",
-							[5, "1"]
-						]
-					], [
-						6,
-						"std.cos",
-						["angleRad"]
-					]]
-				]
-			],
-			[
-				13,
-				"centerPos",
-				[
-					6,
-					"d.vec2f",
-					[[
-						7,
-						"center",
-						"x"
-					], [
-						1,
-						[5, "1"],
-						"-",
-						[
-							7,
-							"center",
-							"y"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"centeredUV",
-				[
-					6,
-					[
-						7,
-						"uv",
-						"sub"
-					],
-					["centerPos"]
-				]
-			],
-			[
-				13,
-				"aspectCorrectedUV",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"centeredUV",
-							"x"
-						],
-						"*",
-						"aspect"
-					], [
-						7,
-						"centeredUV",
-						"y"
-					]]
-				]
-			],
-			[
-				13,
-				"distFromLine",
-				[
-					6,
-					"std.abs",
-					[[
-						6,
-						"std.dot",
-						["aspectCorrectedUV", "perpVector"]
-					]]
-				]
-			],
-			[
-				13,
-				"focusWidth",
-				[
-					1,
-					"width",
-					"*",
-					[5, "0.5"]
-				]
-			],
-			[10, [
-				6,
-				"std.smoothstep",
-				[
-					"focusWidth",
-					[
-						1,
-						"focusWidth",
-						"+",
-						"falloff"
-					],
-					"distFromLine"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"DEG_TO_RAD": () => DEG_TO_RAD,
-		"d.vec2f": () => vec2f,
-		"std.sin": () => sin,
-		"std.cos": () => cos,
-		"std.abs": () => abs,
-		"std.dot": () => dot,
-		"std.smoothstep": () => smoothstep
-	}
-}) && $.f)({})).$name("tiltShiftBlurAmount");
-function tiltShiftFillParams() {
-	return struct({
-		angle: f32,
-		centerX: f32,
-		centerY: f32,
-		width: f32,
-		falloff: f32,
-		aspect: f32,
-		maxRadius: f32
-	});
-}
-function tiltShiftFillMapParams() {
-	return struct({
-		angle: f32,
-		centerX: f32,
-		centerY: f32,
-		width: f32,
-		falloff: f32,
-		aspect: f32,
-		...MAP_SOURCE_DIM_FIELDS,
-		...REMAP_WINDOW_FIELDS
-	});
-}
-function buildTiltShiftFillGraph(computeWidth, computeHeight) {
-	const Params = tiltShiftFillParams();
-	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-		blurMap: { storageTexture: textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
-		params: { uniform: Params }
-	}), "layout");
-	return {
-		layout,
-		kernel: typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			const p = layout.$.params;
-			const u = __tsover_div(__tsover_add(f32(cx), .5), computeWidth);
-			const v = __tsover_div(__tsover_add(f32(cy), .5), computeHeight);
-			const blurAmount = tiltShiftBlurAmount(p.angle, vec2f(p.centerX, p.centerY), p.width, p.falloff, vec2f(u, v), p.aspect);
-			const radius = __tsover_mul(blurAmount, p.maxRadius);
-			textureStore(layout.$.blurMap, vec2u(cx, cy), vec4f(radius, 0, 0, 1));
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [
-					[
-						13,
-						"p",
-						[
-							7,
-							[
-								7,
-								"layout",
-								"$"
-							],
-							"params"
-						]
-					],
-					[
-						13,
-						"u",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["cx"]
-								],
-								"+",
-								[5, "0.5"]
-							],
-							"/",
-							"computeWidth"
-						]
-					],
-					[
-						13,
-						"v",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["cy"]
-								],
-								"+",
-								[5, "0.5"]
-							],
-							"/",
-							"computeHeight"
-						]
-					],
-					[
-						13,
-						"blurAmount",
-						[
-							6,
-							"tiltShiftBlurAmount",
-							[
-								[
-									7,
-									"p",
-									"angle"
-								],
-								[
-									6,
-									"d.vec2f",
-									[[
-										7,
-										"p",
-										"centerX"
-									], [
-										7,
-										"p",
-										"centerY"
-									]]
-								],
-								[
-									7,
-									"p",
-									"width"
-								],
-								[
-									7,
-									"p",
-									"falloff"
-								],
-								[
-									6,
-									"d.vec2f",
-									["u", "v"]
-								],
-								[
-									7,
-									"p",
-									"aspect"
-								]
-							]
-						]
-					],
-					[
-						13,
-						"radius",
-						[
-							1,
-							"blurAmount",
-							"*",
-							[
-								7,
-								"p",
-								"maxRadius"
-							]
-						]
-					],
-					[
-						6,
-						"std.textureStore",
-						[
-							[
-								7,
-								[
-									7,
-									"layout",
-									"$"
-								],
-								"blurMap"
-							],
-							[
-								6,
-								"d.vec2u",
-								["cx", "cy"]
-							],
-							[
-								6,
-								"d.vec4f",
-								[
-									"radius",
-									[5, "0"],
-									[5, "0"],
-									[5, "1"]
-								]
-							]
-						]
-					]
-				]]
-			},
-			externals: {
-				"layout": () => layout,
-				"d.f32": () => f32,
-				"computeWidth": () => computeWidth,
-				"computeHeight": () => computeHeight,
-				"tiltShiftBlurAmount": () => tiltShiftBlurAmount,
-				"d.vec2f": () => vec2f,
-				"std.textureStore": () => textureStore,
-				"d.vec2u": () => vec2u,
-				"d.vec4f": () => vec4f
-			}
-		}) && $.f)({})).$name("tiltShiftFillBlurMap"),
-		Params
-	};
-}
-function buildTiltShiftFillMapGraph(computeWidth, computeHeight, channel) {
-	const Params = tiltShiftFillMapParams();
-	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-		source: { texture: texture2d(f32) },
-		blurMap: { storageTexture: textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
-		params: { uniform: Params }
-	}), "layout");
-	const channelScalar = mapSourceScalar(channel);
-	return {
-		layout,
-		kernel: typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			const p = layout.$.params;
-			const u = __tsover_div(__tsover_add(f32(cx), .5), computeWidth);
-			const v = __tsover_div(__tsover_add(f32(cy), .5), computeHeight);
-			const blurAmount = tiltShiftBlurAmount(p.angle, vec2f(p.centerX, p.centerY), p.width, 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 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: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [
-					[
-						13,
-						"p",
-						[
-							7,
-							[
-								7,
-								"layout",
-								"$"
-							],
-							"params"
-						]
-					],
-					[
-						13,
-						"u",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["cx"]
-								],
-								"+",
-								[5, "0.5"]
-							],
-							"/",
-							"computeWidth"
-						]
-					],
-					[
-						13,
-						"v",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["cy"]
-								],
-								"+",
-								[5, "0.5"]
-							],
-							"/",
-							"computeHeight"
-						]
-					],
-					[
-						13,
-						"blurAmount",
-						[
-							6,
-							"tiltShiftBlurAmount",
-							[
-								[
-									7,
-									"p",
-									"angle"
-								],
-								[
-									6,
-									"d.vec2f",
-									[[
-										7,
-										"p",
-										"centerX"
-									], [
-										7,
-										"p",
-										"centerY"
-									]]
-								],
-								[
-									7,
-									"p",
-									"width"
-								],
-								[
-									7,
-									"p",
-									"falloff"
-								],
-								[
-									6,
-									"d.vec2f",
-									["u", "v"]
-								],
-								[
-									7,
-									"p",
-									"aspect"
-								]
-							]
-						]
-					],
-					[
-						13,
-						"srcX",
-						[
-							6,
-							"std.clamp",
-							[
-								[
-									6,
-									"d.i32",
-									[[
-										6,
-										"std.round",
-										[[
-											1,
-											"u",
-											"*",
-											[
-												7,
-												"p",
-												"inputWidth"
-											]
-										]]
-									]]
-								],
-								[5, "0"],
-								[
-									6,
-									"d.i32",
-									[[
-										1,
-										[
-											7,
-											"p",
-											"inputWidth"
-										],
-										"-",
-										[5, "1"]
-									]]
-								]
-							]
-						]
-					],
-					[
-						13,
-						"srcY",
-						[
-							6,
-							"std.clamp",
-							[
-								[
-									6,
-									"d.i32",
-									[[
-										6,
-										"std.round",
-										[[
-											1,
-											"v",
-											"*",
-											[
-												7,
-												"p",
-												"inputHeight"
-											]
-										]]
-									]]
-								],
-								[5, "0"],
-								[
-									6,
-									"d.i32",
-									[[
-										1,
-										[
-											7,
-											"p",
-											"inputHeight"
-										],
-										"-",
-										[5, "1"]
-									]]
-								]
-							]
-						]
-					],
-					[
-						13,
-						"sample",
-						[
-							6,
-							"std.textureLoad",
-							[
-								[
-									7,
-									[
-										7,
-										"layout",
-										"$"
-									],
-									"source"
-								],
-								[
-									6,
-									"d.vec2u",
-									[[
-										6,
-										"d.u32",
-										["srcX"]
-									], [
-										6,
-										"d.u32",
-										["srcY"]
-									]]
-								],
-								[5, "0"]
-							]
-						]
-					],
-					[
-						13,
-						"remapped",
-						[
-							6,
-							"blur.applyRemapWindow",
-							[
-								[
-									6,
-									"channelScalar",
-									["sample"]
-								],
-								[
-									7,
-									"p",
-									"inputMin"
-								],
-								[
-									7,
-									"p",
-									"inputMax"
-								],
-								[
-									7,
-									"p",
-									"outputMin"
-								],
-								[
-									7,
-									"p",
-									"outputMax"
-								],
-								[
-									7,
-									"p",
-									"curve"
-								]
-							]
-						]
-					],
-					[
-						13,
-						"radius",
-						[
-							1,
-							"blurAmount",
-							"*",
-							[
-								1,
-								"remapped",
-								"*",
-								"INTENSITY_TO_RADIUS"
-							]
-						]
-					],
-					[
-						6,
-						"std.textureStore",
-						[
-							[
-								7,
-								[
-									7,
-									"layout",
-									"$"
-								],
-								"blurMap"
-							],
-							[
-								6,
-								"d.vec2u",
-								["cx", "cy"]
-							],
-							[
-								6,
-								"d.vec4f",
-								[
-									"radius",
-									[5, "0"],
-									[5, "0"],
-									[5, "1"]
-								]
-							]
-						]
-					]
-				]]
-			},
-			externals: {
-				"layout": () => layout,
-				"d.f32": () => f32,
-				"computeWidth": () => computeWidth,
-				"computeHeight": () => computeHeight,
-				"tiltShiftBlurAmount": () => tiltShiftBlurAmount,
-				"d.vec2f": () => vec2f,
-				"std.clamp": () => clamp,
-				"d.i32": () => i32,
-				"std.round": () => round,
-				"std.textureLoad": () => textureLoad,
-				"d.vec2u": () => vec2u,
-				"d.u32": () => u32,
-				"blur.applyRemapWindow": () => applyRemapWindow,
-				"channelScalar": () => channelScalar,
-				"INTENSITY_TO_RADIUS": () => .36,
-				"std.textureStore": () => textureStore,
-				"d.vec4f": () => vec4f
-			}
-		}) && $.f)({})).$name("tiltShiftFillBlurMapVariable"),
-		Params
-	};
-}
-const componentDefinition = {
-	name: "TiltShift",
-	boundingBoxDeclaration: { aspectRatio: null },
-	category: "Blurs",
-	description: "Selective focus blur mimicking tilt-shift photography",
-	requiresRTT: true,
-	requiresChild: true,
-	props: {
-		intensity: {
-			default: 50,
-			description: "Maximum blur intensity at edges",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 100,
-				step: 1,
-				label: "Intensity",
-				group: "Effect"
-			}
-		},
-		width: {
-			default: .3,
-			description: "Width of the sharp focus area",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .1,
-				label: "Width",
-				group: "Effect"
-			}
-		},
-		falloff: {
-			default: .3,
-			description: "Distance over which blur transitions to full strength",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .1,
-				label: "Falloff",
-				group: "Effect"
-			}
-		},
-		angle: {
-			default: 0,
-			transform: transformAngle,
-			description: "Rotation angle of the focus line (in degrees)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 360,
-				step: 1,
-				label: "Angle",
-				group: "Effect"
-			}
-		},
-		center: {
-			default: {
-				x: .5,
-				y: .5
-			},
-			transform: transformPosition,
-			description: "Center point of the focus line",
-			ui: {
-				type: "position",
-				label: "Center",
-				group: "Position"
-			}
-		}
-	},
-	compute: (params) => {
-		const { getCpuValue, getMapInfo } = params;
-		const readGeometry = (dims) => {
-			const center = getCpuValue("center");
-			return {
-				angle: getCpuValue("angle") ?? 0,
-				centerX: typeof center?.x === "number" ? center.x : .5,
-				centerY: typeof center?.y === "number" ? center.y : .5,
-				width: getCpuValue("width") ?? .3,
-				falloff: getCpuValue("falloff") ?? .3,
-				aspect: dims.width / dims.height
-			};
-		};
-		const mapInfo = getMapInfo("intensity");
-		if (mapInfo) return withVariableBlurCompute(params, {
-			halfKernel: 14,
-			source: mapInfo,
-			buildFill: (cw, ch) => buildTiltShiftFillMapGraph(cw, ch, mapInfo.channel),
-			fillValues: (dims, window) => ({
-				...readGeometry(dims),
-				inputWidth: dims.width,
-				inputHeight: dims.height,
-				...remapWindowValues(window)
-			})
-		});
-		return withVariableBlurCompute(params, {
-			halfKernel: 14,
-			buildFill: buildTiltShiftFillGraph,
-			fillValues: (dims) => ({
-				...readGeometry(dims),
-				maxRadius: intensityToRadius(getCpuValue("intensity") ?? 0)
-			})
-		});
-	},
-	fragment: (params) => composeBlurredOverSharp(params, (blurred, sharp) => {
-		const { uniforms, ctx } = params;
-		return mixExpr(sharp, blurred, call(tiltShiftBlurAmount, "tiltShiftBlurAmount", [
-			uniforms.angle,
-			uniforms.center,
-			uniforms.width,
-			uniforms.falloff,
-			ctx.uv,
-			ctx.aspect
-		]));
-	})
-};
-var TiltShift_default = componentDefinition;
-export { componentDefinition as a, buildTiltShiftFillMapGraph as i, TiltShift_default as n, intensityToRadius as o, buildTiltShiftFillGraph as r, tiltShiftBlurAmount as s, INTENSITY_TO_RADIUS as t };