shaders 3.0.452 → 3.1.454

package/dist/core/tone-DPUvX6X0.js

@@ -0,0 +1,705 @@
+import { Gt as data_exports, Pt as pow, _t as abs, at as std_exports, on as vec3f, pn as __export, rt as src_default, un as f32, wt as dot, xt as clamp } from "./edges-CD7gCAto.js";
+var tone_exports = /* @__PURE__ */ __export({
+	luma601: () => luma601,
+	luma601Dot: () => luma601Dot,
+	luma709: () => luma709,
+	luma709Dot: () => luma709Dot,
+	pivotContrast: () => pivotContrast,
+	ridged: () => ridged,
+	signedToUnit: () => signedToUnit,
+	toneGlowInverted: () => toneGlowInverted,
+	toneRemap: () => toneRemap,
+	toneSignedInverted: () => toneSignedInverted,
+	toneUnitMultiplicative: () => toneUnitMultiplicative,
+	toneUnitPivotInverted: () => toneUnitPivotInverted
+});
+const luma709 = src_default.fn([vec3f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb) => {
+	"use gpu";
+	return __tsover_add(__tsover_add(__tsover_mul(rgb.x, .2126), __tsover_mul(rgb.y, .7152)), __tsover_mul(rgb.z, .0722));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "rgb"
+		}],
+		"body": [0, [[10, [
+			1,
+			[
+				1,
+				[
+					1,
+					[
+						7,
+						"rgb",
+						"x"
+					],
+					"*",
+					[5, "0.2126"]
+				],
+				"+",
+				[
+					1,
+					[
+						7,
+						"rgb",
+						"y"
+					],
+					"*",
+					[5, "0.7152"]
+				]
+			],
+			"+",
+			[
+				1,
+				[
+					7,
+					"rgb",
+					"z"
+				],
+				"*",
+				[5, "0.0722"]
+			]
+		]]]],
+		"externalNames": []
+	},
+	externals: () => ({})
+}) && $.f)({}));
+const luma601 = src_default.fn([vec3f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb) => {
+	"use gpu";
+	return __tsover_add(__tsover_add(__tsover_mul(rgb.x, .299), __tsover_mul(rgb.y, .587)), __tsover_mul(rgb.z, .114));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "rgb"
+		}],
+		"body": [0, [[10, [
+			1,
+			[
+				1,
+				[
+					1,
+					[
+						7,
+						"rgb",
+						"x"
+					],
+					"*",
+					[5, "0.299"]
+				],
+				"+",
+				[
+					1,
+					[
+						7,
+						"rgb",
+						"y"
+					],
+					"*",
+					[5, "0.587"]
+				]
+			],
+			"+",
+			[
+				1,
+				[
+					7,
+					"rgb",
+					"z"
+				],
+				"*",
+				[5, "0.114"]
+			]
+		]]]],
+		"externalNames": []
+	},
+	externals: () => ({})
+}) && $.f)({}));
+const luma709Dot = src_default.fn([vec3f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb) => {
+	"use gpu";
+	return dot(rgb, vec3f(.2126, .7152, .0722));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "rgb"
+		}],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"std",
+				"dot"
+			],
+			["rgb", [
+				6,
+				[
+					7,
+					"d",
+					"vec3f"
+				],
+				[
+					[5, "0.2126"],
+					[5, "0.7152"],
+					[5, "0.0722"]
+				]
+			]]
+		]]]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std: std_exports,
+		d: data_exports
+	})
+}) && $.f)({}));
+const luma601Dot = src_default.fn([vec3f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb) => {
+	"use gpu";
+	return dot(rgb, vec3f(.299, .587, .114));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "rgb"
+		}],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"std",
+				"dot"
+			],
+			["rgb", [
+				6,
+				[
+					7,
+					"d",
+					"vec3f"
+				],
+				[
+					[5, "0.299"],
+					[5, "0.587"],
+					[5, "0.114"]
+				]
+			]]
+		]]]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std: std_exports,
+		d: data_exports
+	})
+}) && $.f)({}));
+const pivotContrast = src_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, contrast, pivot) => {
+	"use gpu";
+	return clamp(__tsover_add(__tsover_mul(__tsover_sub(x, pivot), contrast), pivot), 0, 1);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "x"
+			},
+			{
+				"type": "i",
+				"name": "contrast"
+			},
+			{
+				"type": "i",
+				"name": "pivot"
+			}
+		],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"std",
+				"clamp"
+			],
+			[
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"x",
+							"-",
+							"pivot"
+						],
+						"*",
+						"contrast"
+					],
+					"+",
+					"pivot"
+				],
+				[5, "0"],
+				[5, "1"]
+			]
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const signedToUnit = src_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((v) => {
+	"use gpu";
+	return __tsover_add(__tsover_mul(v, .5), .5);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "v"
+		}],
+		"body": [0, [[10, [
+			1,
+			[
+				1,
+				"v",
+				"*",
+				[5, "0.5"]
+			],
+			"+",
+			[5, "0.5"]
+		]]]],
+		"externalNames": []
+	},
+	externals: () => ({})
+}) && $.f)({}));
+const ridged = src_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((v) => {
+	"use gpu";
+	return __tsover_sub(1, abs(v));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "v"
+		}],
+		"body": [0, [[10, [
+			1,
+			[5, "1"],
+			"-",
+			[
+				6,
+				[
+					7,
+					"std",
+					"abs"
+				],
+				["v"]
+			]
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const toneUnitPivotInverted = src_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((noise01, contrast, balance) => {
+	"use gpu";
+	const k = clamp(__tsover_add(__tsover_add(__tsover_mul(__tsover_sub(noise01, .5), __tsover_add(contrast, 1)), .5), balance), 0, 1);
+	return __tsover_sub(1, k);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "noise01"
+			},
+			{
+				"type": "i",
+				"name": "contrast"
+			},
+			{
+				"type": "i",
+				"name": "balance"
+			}
+		],
+		"body": [0, [[
+			13,
+			"k",
+			[
+				6,
+				[
+					7,
+					"std",
+					"clamp"
+				],
+				[
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"noise01",
+									"-",
+									[5, "0.5"]
+								],
+								"*",
+								[
+									1,
+									"contrast",
+									"+",
+									[5, "1"]
+								]
+							],
+							"+",
+							[5, "0.5"]
+						],
+						"+",
+						"balance"
+					],
+					[5, "0"],
+					[5, "1"]
+				]
+			]
+		], [10, [
+			1,
+			[5, "1"],
+			"-",
+			"k"
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const toneSignedInverted = src_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((v, contrast, balance) => {
+	"use gpu";
+	const adjusted = __tsover_add(__tsover_mul(v, __tsover_add(contrast, 1)), balance);
+	const k = clamp(__tsover_add(__tsover_mul(adjusted, .5), .5), 0, 1);
+	return __tsover_sub(1, k);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "v"
+			},
+			{
+				"type": "i",
+				"name": "contrast"
+			},
+			{
+				"type": "i",
+				"name": "balance"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"adjusted",
+				[
+					1,
+					[
+						1,
+						"v",
+						"*",
+						[
+							1,
+							"contrast",
+							"+",
+							[5, "1"]
+						]
+					],
+					"+",
+					"balance"
+				]
+			],
+			[
+				13,
+				"k",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								"adjusted",
+								"*",
+								[5, "0.5"]
+							],
+							"+",
+							[5, "0.5"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[10, [
+				1,
+				[5, "1"],
+				"-",
+				"k"
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const toneUnitMultiplicative = src_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((v, contrast, balance) => {
+	"use gpu";
+	const signed = __tsover_sub(__tsover_mul(v, 2), 1);
+	const adjusted = __tsover_add(__tsover_mul(signed, contrast), balance);
+	return clamp(__tsover_add(__tsover_mul(adjusted, .5), .5), 0, 1);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "v"
+			},
+			{
+				"type": "i",
+				"name": "contrast"
+			},
+			{
+				"type": "i",
+				"name": "balance"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"signed",
+				[
+					1,
+					[
+						1,
+						"v",
+						"*",
+						[5, "2"]
+					],
+					"-",
+					[5, "1"]
+				]
+			],
+			[
+				13,
+				"adjusted",
+				[
+					1,
+					[
+						1,
+						"signed",
+						"*",
+						"contrast"
+					],
+					"+",
+					"balance"
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"clamp"
+				],
+				[
+					[
+						1,
+						[
+							1,
+							"adjusted",
+							"*",
+							[5, "0.5"]
+						],
+						"+",
+						[5, "0.5"]
+					],
+					[5, "0"],
+					[5, "1"]
+				]
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const toneGlowInverted = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((v, glow, contrast, balance) => {
+	"use gpu";
+	const spread = pow(v, __tsover_div(5, glow));
+	const contrasted = clamp(__tsover_add(__tsover_mul(__tsover_sub(spread, .5), contrast), .5), 0, 1);
+	const balanceShift = __tsover_sub(__tsover_div(balance, 100), .5);
+	const balanced = clamp(__tsover_add(contrasted, balanceShift), 0, 1);
+	return __tsover_sub(1, balanced);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "v"
+			},
+			{
+				"type": "i",
+				"name": "glow"
+			},
+			{
+				"type": "i",
+				"name": "contrast"
+			},
+			{
+				"type": "i",
+				"name": "balance"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"spread",
+				[
+					6,
+					[
+						7,
+						"std",
+						"pow"
+					],
+					["v", [
+						1,
+						[5, "5"],
+						"/",
+						"glow"
+					]]
+				]
+			],
+			[
+				13,
+				"contrasted",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"spread",
+									"-",
+									[5, "0.5"]
+								],
+								"*",
+								"contrast"
+							],
+							"+",
+							[5, "0.5"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"balanceShift",
+				[
+					1,
+					[
+						1,
+						"balance",
+						"/",
+						[5, "100"]
+					],
+					"-",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"balanced",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							"contrasted",
+							"+",
+							"balanceShift"
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[10, [
+				1,
+				[5, "1"],
+				"-",
+				"balanced"
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+function toneRemap(options) {
+	const { domain, contrastMode, invert, glowGamma = false, balance = "plain" } = options;
+	if (glowGamma) {
+		if (domain === "unit" && contrastMode === "multiplicative" && invert && balance === "percentCentred") return toneGlowInverted;
+	} else if (balance === "plain") {
+		if (domain === "unit" && contrastMode === "additive" && invert) return toneUnitPivotInverted;
+		if (domain === "signed" && contrastMode === "additive" && invert) return toneSignedInverted;
+		if (domain === "unit" && contrastMode === "multiplicative" && !invert) return toneUnitMultiplicative;
+	}
+	throw new Error(`toneRemap: no variant for {domain: '${domain}', contrastMode: '${contrastMode}', invert: ${invert}, glowGamma: ${glowGamma}, balance: '${balance}'} — add its body to kit/tone.ts rather than approximating.`);
+}
+export { tone_exports as a, toneUnitPivotInverted as i, luma709Dot as n, toneRemap as r, luma601Dot as t };

package/dist/core/utilities/halfUvProps.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Reading a HALF-EXTENT size prop that may carry pixels.
+ *
+ * A shape's size props are half-extents in canvas-height units, and a user may switch one to
+ * absolute pixels — at which point the prop value becomes a `DimensionalValue` carrying the FULL
+ * pixel size (the same number the Design Editor's px chip shows), not the half. A `computeBounds` /
+ * `writeBounds` pair therefore has to normalize before it can do arithmetic, and it has to do so
+ * IDENTICALLY on both sides or a resize round-trip drifts.
+ *
+ * Trapezoid had this as a local closure shared between its two bounds callbacks. It lives here so
+ * the next `computeBounds` shape that grows px-capable size props can reuse the exact reading rule
+ * rather than re-deriving the ÷2 (which is the easy half to get wrong).
+ *
+ * NOT adopted by Ring or Blob: neither handles px size props at all today (both read
+ * `props.<size> as number`), so pointing them at this helper would ADD px support — a behaviour
+ * change, not an extraction. Left for whenever that support is wanted deliberately.
+ */
+/**
+ * Normalize a half-extent size prop to half-UV (canvas-height units).
+ *
+ * - `{value, unit: 'px'}` → the value is the FULL pixel size, so `value / (2 · canvasHeight)`.
+ * - any other `{value: number}` → already the half-UV value (this is Trapezoid's original rule: a
+ *   value object whose unit is anything but `'px'`, including missing, is read as UV).
+ * - a plain number → already the half-UV value.
+ * - anything else → `fallback` (the prop's default), never NaN.
+ *
+ * "Never NaN" is checked, not assumed: a non-finite numeric value (a dynamic prop resolving to NaN
+ * mid-frame) and a px read against a zero or non-finite `canvasHeight` (the frame before the canvas
+ * has been measured) both fall back rather than poisoning the bounds arithmetic downstream. The
+ * `fallback` itself is normalized at the boundary too (→ 0.5, a half-canvas half-extent), so the
+ * promise holds even for a caller that computes its fallback — every call site today passes a
+ * literal, making that branch unreachable, but the contract shouldn't depend on it.
+ */
+export declare function halfUvFromProp(value: unknown, canvasHeight: number, fallback: number): number;
+//# sourceMappingURL=halfUvProps.d.ts.map