shaders 3.1.462 → 3.2.464

package/dist/core/ColorWheel-CsWS484T.js

@@ -1,511 +0,0 @@
-import { At as step, Dt as sin, H as mixColorsLinear, Lt as vec4f, Mt as vec2f, U as mixColorsVariants, ct as clamp, et as typegpu_default, ht as fract, it as abs, lt as cos, m as call, mt as floor, sn as f32, yt as mix } from "./edges-CV-BHMpI.js";
-import { t as DEG_TO_RAD$1 } from "./constants-BKlzQFdJ.js";
-import { r as geom_exports } from "./geom-BS390xIn.js";
-import { t as animatedTime } from "./porters-j7yWJYy2.js";
-import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-u-UZrXjj.js";
-var DEG_TO_RAD = DEG_TO_RAD$1;
-var { aspectOf, canvasCentredDelta, directionalProjection } = geom_exports;
-const colorWheelT = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, angle, scale, animTime) => {
-	"use gpu";
-	const angleRad = __tsover_mul(angle, DEG_TO_RAD);
-	const aspect = aspectOf(viewport);
-	const projectedCoord = __tsover_add(directionalProjection(canvasCentredDelta(uv, aspect), cos(angleRad), sin(angleRad)), __tsover_mul(aspect, .5));
-	return fract(__tsover_add(__tsover_mul(__tsover_mul(projectedCoord, scale), .2), animTime));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "viewport"
-			},
-			{
-				"type": "i",
-				"name": "angle"
-			},
-			{
-				"type": "i",
-				"name": "scale"
-			},
-			{
-				"type": "i",
-				"name": "animTime"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"angleRad",
-				[
-					1,
-					"angle",
-					"*",
-					"DEG_TO_RAD"
-				]
-			],
-			[
-				13,
-				"aspect",
-				[
-					6,
-					"aspectOf",
-					["viewport"]
-				]
-			],
-			[
-				13,
-				"projectedCoord",
-				[
-					1,
-					[
-						6,
-						"directionalProjection",
-						[
-							[
-								6,
-								"canvasCentredDelta",
-								["uv", "aspect"]
-							],
-							[
-								6,
-								"std.cos",
-								["angleRad"]
-							],
-							[
-								6,
-								"std.sin",
-								["angleRad"]
-							]
-						]
-					],
-					"+",
-					[
-						1,
-						"aspect",
-						"*",
-						[5, "0.5"]
-					]
-				]
-			],
-			[10, [
-				6,
-				"std.fract",
-				[[
-					1,
-					[
-						1,
-						[
-							1,
-							"projectedCoord",
-							"*",
-							"scale"
-						],
-						"*",
-						[5, "0.2"]
-					],
-					"+",
-					"animTime"
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"DEG_TO_RAD": () => DEG_TO_RAD,
-		"aspectOf": () => aspectOf,
-		"directionalProjection": () => directionalProjection,
-		"canvasCentredDelta": () => canvasCentredDelta,
-		"std.cos": () => cos,
-		"std.sin": () => sin,
-		"std.fract": () => fract
-	}
-}) && $.f)({}));
-const colorWheelRainbow = typegpu_default.fn([f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
-	"use gpu";
-	const h6 = __tsover_mul(t, 6);
-	return vec4f(clamp(__tsover_sub(abs(__tsover_sub(h6, 3)), 1), 0, 1), clamp(__tsover_sub(2, abs(__tsover_sub(h6, 2))), 0, 1), clamp(__tsover_sub(2, abs(__tsover_sub(h6, 4))), 0, 1), 1);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "t"
-		}],
-		"body": [0, [
-			[
-				13,
-				"h6",
-				[
-					1,
-					"t",
-					"*",
-					[5, "6"]
-				]
-			],
-			[
-				13,
-				"r",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								6,
-								"std.abs",
-								[[
-									1,
-									"h6",
-									"-",
-									[5, "3"]
-								]]
-							],
-							"-",
-							[5, "1"]
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"g",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[5, "2"],
-							"-",
-							[
-								6,
-								"std.abs",
-								[[
-									1,
-									"h6",
-									"-",
-									[5, "2"]
-								]]
-							]
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"b",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[5, "2"],
-							"-",
-							[
-								6,
-								"std.abs",
-								[[
-									1,
-									"h6",
-									"-",
-									[5, "4"]
-								]]
-							]
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[10, [
-				6,
-				"d.vec4f",
-				[
-					"r",
-					"g",
-					"b",
-					[5, "1"]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"std.clamp": () => clamp,
-		"std.abs": () => abs,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({}));
-const colorWheelPhase = typegpu_default.fn([f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t) => {
-	"use gpu";
-	const t3 = __tsover_mul(t, 3);
-	return vec2f(fract(t3), floor(t3));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "t"
-		}],
-		"body": [0, [[
-			13,
-			"t3",
-			[
-				1,
-				"t",
-				"*",
-				[5, "3"]
-			]
-		], [10, [
-			6,
-			"d.vec2f",
-			[[
-				6,
-				"std.fract",
-				["t3"]
-			], [
-				6,
-				"std.floor",
-				["t3"]
-			]]
-		]]]]
-	},
-	externals: {
-		"d.vec2f": () => vec2f,
-		"std.fract": () => fract,
-		"std.floor": () => floor
-	}
-}) && $.f)({}));
-const colorWheelSelect = typegpu_default.fn([
-	vec4f,
-	vec4f,
-	vec4f,
-	f32
-], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((c01, c12, c20, floorT3) => {
-	"use gpu";
-	return mix(mix(c20, c12, step(floorT3, 1.5)), c01, step(floorT3, .5));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "c01"
-			},
-			{
-				"type": "i",
-				"name": "c12"
-			},
-			{
-				"type": "i",
-				"name": "c20"
-			},
-			{
-				"type": "i",
-				"name": "floorT3"
-			}
-		],
-		"body": [0, [[
-			13,
-			"seg1",
-			[
-				6,
-				"std.mix",
-				[
-					"c20",
-					"c12",
-					[
-						6,
-						"std.step",
-						["floorT3", [5, "1.5"]]
-					]
-				]
-			]
-		], [10, [
-			6,
-			"std.mix",
-			[
-				"seg1",
-				"c01",
-				[
-					6,
-					"std.step",
-					["floorT3", [5, "0.5"]]
-				]
-			]
-		]]]]
-	},
-	externals: {
-		"std.mix": () => mix,
-		"std.step": () => step
-	}
-}) && $.f)({}));
-const componentDefinition = {
-	name: "ColorWheel",
-	boundingBoxDeclaration: {
-		aspectRatio: null,
-		supportsResizeFit: true
-	},
-	category: "Textures",
-	description: "A directional gradient that smoothly cycles through rainbow colors or a custom set of three colors",
-	acceptsUVContext: true,
-	animatedTime: { speed: "speed" },
-	props: {
-		mode: {
-			default: "rainbow",
-			compileTime: true,
-			description: "Rainbow cycles through the full spectrum; Custom loops through your three chosen colors",
-			ui: {
-				type: "select",
-				options: [{
-					label: "Rainbow",
-					value: "rainbow"
-				}, {
-					label: "Custom",
-					value: "custom"
-				}],
-				label: "Mode",
-				group: "Colors"
-			}
-		},
-		colorA: {
-			default: "#ff0000",
-			transform: transformColor,
-			description: "First color in the cycle",
-			ui: {
-				type: "color",
-				label: "Color 1",
-				group: "Colors",
-				condition: { mode: "custom" }
-			}
-		},
-		colorB: {
-			default: "#00ff88",
-			transform: transformColor,
-			description: "Second color in the cycle",
-			ui: {
-				type: "color",
-				label: "Color 2",
-				group: "Colors",
-				condition: { mode: "custom" }
-			}
-		},
-		colorC: {
-			default: "#0066ff",
-			transform: transformColor,
-			description: "Third color in the cycle",
-			ui: {
-				type: "color",
-				label: "Color 3",
-				group: "Colors",
-				condition: { mode: "custom" }
-			}
-		},
-		scale: {
-			default: 1,
-			description: "Number of color cycles across the viewport",
-			ui: {
-				type: ["range", "map"],
-				min: .1,
-				max: 10,
-				step: .1,
-				label: "Scale",
-				group: "Effect"
-			}
-		},
-		angle: {
-			default: 0,
-			transform: transformAngle,
-			description: "Direction the gradient flows",
-			ui: {
-				type: ["range", "map"],
-				min: -180,
-				max: 180,
-				step: 1,
-				label: "Angle",
-				group: "Effect"
-			}
-		},
-		speed: {
-			default: .05,
-			description: "Speed at which the gradient cycles",
-			ui: {
-				type: "range",
-				min: -1,
-				max: 1,
-				step: .01,
-				label: "Speed",
-				group: "Animation"
-			}
-		},
-		colorSpace: {
-			default: "oklch",
-			transform: transformColorSpace,
-			compileTime: true,
-			description: "Color space for blending between custom colors",
-			ui: {
-				type: "select",
-				options: colorSpaceOptions,
-				label: "Color Space",
-				group: "Colors",
-				condition: { mode: "custom" }
-			}
-		}
-	},
-	fragment: (params) => {
-		const { uniforms, propValues } = params;
-		const uv = params.uvContext ?? params.ctx.uv;
-		const viewport = params.effectiveViewportSize ?? params.ctx.viewportSize;
-		const animTime = animatedTime(params);
-		const t = call(colorWheelT, "colorWheelT", [
-			uv,
-			viewport,
-			uniforms.angle,
-			uniforms.scale,
-			animTime
-		]);
-		if ((propValues.mode ?? "rainbow") === "rainbow") return call(colorWheelRainbow, "colorWheelRainbow", [t]);
-		const phase = call(colorWheelPhase, "colorWheelPhase", [t]);
-		const si = phase.member("x");
-		const floorT3 = phase.member("y");
-		const variant = mixColorsVariants[propValues.colorSpace ?? 0] ?? mixColorsLinear;
-		return call(colorWheelSelect, "colorWheelSelect", [
-			call(variant, "mixColors", [
-				uniforms.colorA,
-				uniforms.colorB,
-				si
-			]),
-			call(variant, "mixColors", [
-				uniforms.colorB,
-				uniforms.colorC,
-				si
-			]),
-			call(variant, "mixColors", [
-				uniforms.colorC,
-				uniforms.colorA,
-				si
-			]),
-			floorT3
-		]);
-	}
-};
-var ColorWheel_default = componentDefinition;
-export { colorWheelT as a, colorWheelSelect as i, colorWheelPhase as n, componentDefinition as o, colorWheelRainbow as r, ColorWheel_default as t };