shaders 3.1.462 → 3.2.464

package/dist/core/ConicGradient-9gNpue0r.js

@@ -1,224 +0,0 @@
-import { Mt as vec2f, et as typegpu_default, ht as fract, m as call, ot as atan2, sn as f32 } from "./edges-CV-BHMpI.js";
-import { o as TAU$1 } from "./constants-BKlzQFdJ.js";
-import { r as geom_exports } from "./geom-BS390xIn.js";
-import { V as colorStopsPropConfig } from "./porters-j7yWJYy2.js";
-import { t as mixStopsOrColorsExpr } from "./noiseColor-DEQWYLVu.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-u-UZrXjj.js";
-var TAU = TAU$1;
-var INV_360 = 1 / 360;
-var { aspectCenteredDelta } = geom_exports;
-const conicFinalT = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	vec2f,
-	vec2f
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, rotation, repeat, uv, viewport) => {
-	"use gpu";
-	const delta = aspectCenteredDelta(uv, center, viewport);
-	const angle = atan2(delta.y, delta.x);
-	const normalized = __tsover_sub(.5, __tsover_div(angle, TAU));
-	const rotationFraction = __tsover_mul(rotation, INV_360);
-	return fract(__tsover_mul(__tsover_add(normalized, rotationFraction), repeat));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "center"
-			},
-			{
-				"type": "i",
-				"name": "rotation"
-			},
-			{
-				"type": "i",
-				"name": "repeat"
-			},
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"delta",
-				[
-					6,
-					"aspectCenteredDelta",
-					[
-						"uv",
-						"center",
-						"viewport"
-					]
-				]
-			],
-			[
-				13,
-				"angle",
-				[
-					6,
-					"std.atan2",
-					[[
-						7,
-						"delta",
-						"y"
-					], [
-						7,
-						"delta",
-						"x"
-					]]
-				]
-			],
-			[
-				13,
-				"normalized",
-				[
-					1,
-					[5, "0.5"],
-					"-",
-					[
-						1,
-						"angle",
-						"/",
-						"TAU"
-					]
-				]
-			],
-			[
-				13,
-				"rotationFraction",
-				[
-					1,
-					"rotation",
-					"*",
-					"INV_360"
-				]
-			],
-			[10, [
-				6,
-				"std.fract",
-				[[
-					1,
-					[
-						1,
-						"normalized",
-						"+",
-						"rotationFraction"
-					],
-					"*",
-					"repeat"
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"aspectCenteredDelta": () => aspectCenteredDelta,
-		"std.atan2": () => atan2,
-		"TAU": () => TAU,
-		"INV_360": () => INV_360,
-		"std.fract": () => fract
-	}
-}) && $.f)({}));
-const componentDefinition = {
-	name: "ConicGradient",
-	boundingBoxDeclaration: {
-		aspectRatio: null,
-		supportsResizeFit: true
-	},
-	category: "Textures",
-	description: "Colors sweep in a full circle around a center point, like a color wheel",
-	acceptsUVContext: true,
-	props: {
-		colorA: {
-			default: "#FF0080",
-			transform: transformColor,
-			description: "Starting color of the sweep",
-			ui: {
-				type: "color",
-				label: "Color A",
-				group: "Colors"
-			}
-		},
-		colorB: {
-			default: "#00BFFF",
-			transform: transformColor,
-			description: "Ending color of the sweep (wraps back to Color A)",
-			ui: {
-				type: "color",
-				label: "Color B",
-				group: "Colors"
-			}
-		},
-		stops: colorStopsPropConfig(),
-		center: {
-			default: {
-				x: .5,
-				y: .5
-			},
-			transform: transformPosition,
-			description: "Center point of the sweep",
-			ui: {
-				type: "position",
-				label: "Center",
-				group: "Position"
-			}
-		},
-		rotation: {
-			default: 0,
-			description: "Rotation offset in degrees — shifts where Color A begins",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 360,
-				step: 1,
-				label: "Rotation",
-				group: "Effect"
-			}
-		},
-		repeat: {
-			default: 1,
-			description: "Number of times the gradient repeats around the circle. Values above 1 create a starburst pattern.",
-			ui: {
-				type: ["range", "map"],
-				min: 1,
-				max: 24,
-				step: 1,
-				label: "Repeat",
-				group: "Effect"
-			}
-		},
-		colorSpace: {
-			default: "linear",
-			transform: transformColorSpace,
-			compileTime: true,
-			description: "Color space for color interpolation",
-			ui: {
-				type: "select",
-				options: colorSpaceOptions,
-				label: "Color Space",
-				group: "Colors"
-			}
-		}
-	},
-	fragment: (params) => {
-		const uv = params.uvContext ?? params.ctx.uv;
-		const viewport = params.effectiveViewportSize ?? params.ctx.viewportSize;
-		return mixStopsOrColorsExpr(params, call(conicFinalT, "conicFinalT", [
-			params.uniforms.center,
-			params.uniforms.rotation,
-			params.uniforms.repeat,
-			uv,
-			viewport
-		]));
-	}
-};
-var ConicGradient_default = componentDefinition;
-export { componentDefinition as n, conicFinalT as r, ConicGradient_default as t };

package/dist/core/ContourLines-BTO4gDYR.js

@@ -1,495 +0,0 @@
-import { Ft as vec3f, Lt as vec4f, Ot as smoothstep, _t as max, b as vec4, d as ZERO, et as typegpu_default, ht as fract, it as abs, m as call, rt as select, sn as f32, v as floatE, xt as pow, yt as mix } from "./edges-CV-BHMpI.js";
-import { r as fwidth } from "./derivative-CR__I1Rp.js";
-import { n as luma709Dot } from "./tone-Bm6RiwOF.js";
-import { a as transformColor, i as transformBoolean } from "./transformations-u-UZrXjj.js";
-var transformSource = (value) => value === "alpha" ? 1 : 0;
-var transformColorMode = (value) => value === "custom" ? 1 : 0;
-var sourceModeOf = (raw) => typeof raw === "number" ? raw : raw === "alpha" ? 1 : 0;
-var colorModeOf = (raw) => typeof raw === "number" ? raw : raw === "custom" ? 1 : 0;
-const contourLuma = luma709Dot;
-const contourLineMask = typegpu_default.fn([
-	f32,
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sourceValue, levels, lineWidth, softness, gamma, invert) => {
-	"use gpu";
-	const sv = pow(select(sourceValue, __tsover_sub(1, sourceValue), invert > .5), gamma);
-	const scaledValue = __tsover_add(__tsover_mul(sv, levels), .5);
-	const fw = max(fwidth(scaledValue), 1e-4);
-	const distFromBoundary = abs(__tsover_sub(fract(__tsover_add(scaledValue, .5)), .5));
-	const normalizedDist = __tsover_div(distFromBoundary, fw);
-	const transitionFactor = __tsover_add(__tsover_mul(softness, .99), .01);
-	const innerEdge = __tsover_mul(lineWidth, __tsover_sub(1, transitionFactor));
-	return __tsover_sub(1, smoothstep(innerEdge, lineWidth, normalizedDist));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "sourceValue"
-			},
-			{
-				"type": "i",
-				"name": "levels"
-			},
-			{
-				"type": "i",
-				"name": "lineWidth"
-			},
-			{
-				"type": "i",
-				"name": "softness"
-			},
-			{
-				"type": "i",
-				"name": "gamma"
-			},
-			{
-				"type": "i",
-				"name": "invert"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"invertedValue",
-				[
-					6,
-					"std.select",
-					[
-						"sourceValue",
-						[
-							1,
-							[5, "1"],
-							"-",
-							"sourceValue"
-						],
-						[
-							1,
-							"invert",
-							">",
-							[5, "0.5"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"sv",
-				[
-					6,
-					"std.pow",
-					["invertedValue", "gamma"]
-				]
-			],
-			[
-				13,
-				"scaledValue",
-				[
-					1,
-					[
-						1,
-						"sv",
-						"*",
-						"levels"
-					],
-					"+",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"fw",
-				[
-					6,
-					"std.max",
-					[[
-						6,
-						"std.fwidth",
-						["scaledValue"]
-					], [5, "0.0001"]]
-				]
-			],
-			[
-				13,
-				"distFromBoundary",
-				[
-					6,
-					"std.abs",
-					[[
-						1,
-						[
-							6,
-							"std.fract",
-							[[
-								1,
-								"scaledValue",
-								"+",
-								[5, "0.5"]
-							]]
-						],
-						"-",
-						[5, "0.5"]
-					]]
-				]
-			],
-			[
-				13,
-				"normalizedDist",
-				[
-					1,
-					"distFromBoundary",
-					"/",
-					"fw"
-				]
-			],
-			[
-				13,
-				"transitionFactor",
-				[
-					1,
-					[
-						1,
-						"softness",
-						"*",
-						[5, "0.99"]
-					],
-					"+",
-					[5, "0.01"]
-				]
-			],
-			[
-				13,
-				"innerEdge",
-				[
-					1,
-					"lineWidth",
-					"*",
-					[
-						1,
-						[5, "1"],
-						"-",
-						"transitionFactor"
-					]
-				]
-			],
-			[10, [
-				1,
-				[5, "1"],
-				"-",
-				[
-					6,
-					"std.smoothstep",
-					[
-						"innerEdge",
-						"lineWidth",
-						"normalizedDist"
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.select": () => select,
-		"std.pow": () => pow,
-		"std.max": () => max,
-		"std.fwidth": () => fwidth,
-		"std.abs": () => abs,
-		"std.fract": () => fract,
-		"std.smoothstep": () => smoothstep
-	}
-}) && $.f)({}));
-const contourCompose = typegpu_default.fn([
-	vec4f,
-	vec4f,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((bg, line, mask) => {
-	"use gpu";
-	const rgb = mix(vec3f(bg.x, bg.y, bg.z), vec3f(line.x, line.y, line.z), vec3f(mask));
-	const alpha = mix(bg.w, line.w, mask);
-	return vec4f(rgb.x, rgb.y, rgb.z, alpha);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "bg"
-			},
-			{
-				"type": "i",
-				"name": "line"
-			},
-			{
-				"type": "i",
-				"name": "mask"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"rgb",
-				[
-					6,
-					"std.mix",
-					[
-						[
-							6,
-							"d.vec3f",
-							[
-								[
-									7,
-									"bg",
-									"x"
-								],
-								[
-									7,
-									"bg",
-									"y"
-								],
-								[
-									7,
-									"bg",
-									"z"
-								]
-							]
-						],
-						[
-							6,
-							"d.vec3f",
-							[
-								[
-									7,
-									"line",
-									"x"
-								],
-								[
-									7,
-									"line",
-									"y"
-								],
-								[
-									7,
-									"line",
-									"z"
-								]
-							]
-						],
-						[
-							6,
-							"d.vec3f",
-							["mask"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"alpha",
-				[
-					6,
-					"std.mix",
-					[
-						[
-							7,
-							"bg",
-							"w"
-						],
-						[
-							7,
-							"line",
-							"w"
-						],
-						"mask"
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					[
-						7,
-						"rgb",
-						"x"
-					],
-					[
-						7,
-						"rgb",
-						"y"
-					],
-					[
-						7,
-						"rgb",
-						"z"
-					],
-					"alpha"
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.mix": () => mix,
-		"d.vec3f": () => vec3f,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const componentDefinition = {
-	name: "ContourLines",
-	boundingBoxDeclaration: { aspectRatio: null },
-	category: "Stylize",
-	description: "Draw topographical contour lines based on luminance or alpha",
-	requiresChild: true,
-	blendWithChildren: false,
-	props: {
-		levels: {
-			default: 5,
-			description: "Number of contour levels",
-			ui: {
-				type: ["range", "map"],
-				min: 2,
-				max: 30,
-				step: 1,
-				label: "Levels",
-				group: "Effect"
-			}
-		},
-		lineWidth: {
-			default: 2,
-			description: "Width of the contour lines in pixels",
-			ui: {
-				type: ["range", "map"],
-				min: .5,
-				max: 5,
-				step: .1,
-				label: "Line Width",
-				group: "Effect"
-			}
-		},
-		softness: {
-			default: 0,
-			description: "Edge softness of the lines (0 = sharp, 1 = soft)",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Softness",
-				group: "Effect"
-			}
-		},
-		gamma: {
-			default: .5,
-			description: "Contour distribution. <1 clusters in bright, >1 clusters in dark",
-			ui: {
-				type: ["range", "map"],
-				min: .1,
-				max: 2,
-				step: .01,
-				label: "Gamma",
-				group: "Effect"
-			}
-		},
-		invert: {
-			default: false,
-			description: "Invert the source values",
-			transform: transformBoolean,
-			ui: {
-				type: "checkbox",
-				label: "Invert",
-				group: "Effect"
-			}
-		},
-		source: {
-			default: "luminance",
-			description: "Use luminance or alpha channel for contours",
-			transform: transformSource,
-			compileTime: true,
-			ui: {
-				type: "select",
-				options: [{
-					label: "Luminance",
-					value: "luminance"
-				}, {
-					label: "Alpha",
-					value: "alpha"
-				}],
-				label: "Source",
-				group: "Effect"
-			}
-		},
-		colorMode: {
-			default: "source",
-			description: "Use source image colors or custom colors",
-			transform: transformColorMode,
-			compileTime: true,
-			ui: {
-				type: "select",
-				options: [{
-					label: "Source",
-					value: "source"
-				}, {
-					label: "Custom",
-					value: "custom"
-				}],
-				label: "Color Mode",
-				group: "Colors"
-			}
-		},
-		lineColor: {
-			default: "#000000",
-			description: "Color of the contour lines (custom mode)",
-			transform: transformColor,
-			ui: {
-				type: "color",
-				label: "Line Color",
-				group: "Colors",
-				condition: { colorMode: "custom" }
-			}
-		},
-		backgroundColor: {
-			default: "transparent",
-			description: "Background color (custom mode)",
-			transform: transformColor,
-			ui: {
-				type: "color",
-				label: "Background Color",
-				group: "Colors",
-				condition: { colorMode: "custom" }
-			}
-		}
-	},
-	fragment: ({ childNode, uniforms, propValues }) => {
-		if (!childNode) return ZERO;
-		const lineMask = call(contourLineMask, "contourLineMask", [
-			sourceModeOf(propValues.source) === 1 ? childNode.member("a") : call(contourLuma, "luma709", [childNode.member("rgb")]),
-			uniforms.levels,
-			uniforms.lineWidth,
-			uniforms.softness,
-			uniforms.gamma,
-			uniforms.invert
-		]);
-		let bg;
-		let line;
-		if (colorModeOf(propValues.colorMode) === 1) {
-			bg = uniforms.backgroundColor;
-			line = uniforms.lineColor;
-		} else {
-			bg = ZERO;
-			line = vec4(childNode.member("rgb"), floatE(1));
-		}
-		return call(contourCompose, "contourCompose", [
-			bg,
-			line,
-			lineMask
-		]);
-	}
-};
-var ContourLines_default = componentDefinition;
-export { contourLuma as a, contourLineMask as i, componentDefinition as n, contourCompose as r, ContourLines_default as t };