shaders 3.2.475 → 4.0.0

package/dist/core/noise-G7a5U0ar.js

@@ -1,546 +0,0 @@
-import { $t as timeAxisDomain, En as perlin12d, Gn as typegpu_default, Gt as aspectScaledDomain, It as mixColorsLinear, Mn as wavelet12, Nn as wool12, On as scratches12, Or as vec2f, Ot as unpremultiplyAlpha, Xt as pixelGridDomain, ar as clamp, at as ZERO, ct as call, fn as blue12, ft as floatE, gn as gabor12, hn as erosion12, kn as stone12, mt as vec4, n as paintFrame, o as uniformOf, pt as mixExpr, qr as f32, st as asLocal } from "./lower-DtoDQ7hV.js";
-import { i as signedToUnit, o as toneSignedInverted } from "./tone-CsRho9qb.js";
-import { _ as worleyHash$1, a as fbmNormalize, b as worleyNormalize, c as rawAspectScaledDomain, d as toneLift, f as transformWorleyDistance$1, g as worleyDistNum, h as worleyCells, i as curlMagnitude, l as ribbonsField, m as voronoiCells, n as cellBorders$1, o as fractalSum, p as transformWorleyMode$1, r as cellFill$1, t as aspectPlane, u as rotatedCenteredDomain, v as worleyModeNum, x as worleyTone, y as worleyModeScale } from "./noisePaints-B_axPpuv.js";
-import { Tt as backConvertToP3, t as animatedTime } from "./porters-CQwDd2t4.js";
-import { O as noiseToneKColor, b as stops, f as rampOver, n as colorSpaceModeOf } from "./fields-CXwmEUsd.js";
-import { N as sin, n as add, w as mul } from "./math-7PlusTFx.js";
-const reliefPos = typegpu_default.fn([
-	vec2f,
-	f32,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, scale, seed) => {
-	"use gpu";
-	const aspectUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
-	const freq = __tsover_mul(scale, 4);
-	return aspectUV.mul(freq).add(seed);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "aspect"
-			},
-			{
-				"type": "i",
-				"name": "scale"
-			},
-			{
-				"type": "i",
-				"name": "seed"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"aspectUV",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"uv",
-							"x"
-						],
-						"*",
-						"aspect"
-					], [
-						7,
-						"uv",
-						"y"
-					]]
-				]
-			],
-			[
-				13,
-				"freq",
-				[
-					1,
-					"scale",
-					"*",
-					[5, "4"]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					[
-						6,
-						[
-							7,
-							"aspectUV",
-							"mul"
-						],
-						["freq"]
-					],
-					"add"
-				],
-				["seed"]
-			]]
-		]]
-	},
-	externals: { "d.vec2f": () => vec2f }
-}) && $.f)({}));
-const reliefDisplacedUV = typegpu_default.fn([
-	vec2f,
-	vec2f,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, pos, distortion) => {
-	"use gpu";
-	const grad = perlin12d(pos);
-	const disp = vec2f(grad.y, grad.z).mul(distortion).mul(.012);
-	return uv.add(disp);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "uv"
-			},
-			{
-				"type": "i",
-				"name": "pos"
-			},
-			{
-				"type": "i",
-				"name": "distortion"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"grad",
-				[
-					6,
-					"perlin12d",
-					["pos"]
-				]
-			],
-			[
-				13,
-				"disp",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							[
-								7,
-								[
-									6,
-									"d.vec2f",
-									[[
-										7,
-										"grad",
-										"y"
-									], [
-										7,
-										"grad",
-										"z"
-									]]
-								],
-								"mul"
-							],
-							["distortion"]
-						],
-						"mul"
-					],
-					[[5, "0.012"]]
-				]
-			],
-			[10, [
-				6,
-				[
-					7,
-					"uv",
-					"add"
-				],
-				["disp"]
-			]]
-		]]
-	},
-	externals: {
-		"perlin12d": () => perlin12d,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const reliefBrightness = typegpu_default.fn([
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((h, contrast, intensity) => {
-	"use gpu";
-	const hAdj = __tsover_add(__tsover_mul(__tsover_sub(h, .5), __tsover_add(contrast, 1)), .5);
-	return clamp(__tsover_add(1, __tsover_mul(__tsover_sub(hAdj, .5), __tsover_mul(intensity, 1.1))), 0, 1.6);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "h"
-			},
-			{
-				"type": "i",
-				"name": "contrast"
-			},
-			{
-				"type": "i",
-				"name": "intensity"
-			}
-		],
-		"body": [0, [[
-			13,
-			"hAdj",
-			[
-				1,
-				[
-					1,
-					[
-						1,
-						"h",
-						"-",
-						[5, "0.5"]
-					],
-					"*",
-					[
-						1,
-						"contrast",
-						"+",
-						[5, "1"]
-					]
-				],
-				"+",
-				[5, "0.5"]
-			]
-		], [10, [
-			6,
-			"std.clamp",
-			[
-				[
-					1,
-					[5, "1"],
-					"+",
-					[
-						1,
-						[
-							1,
-							"hAdj",
-							"-",
-							[5, "0.5"]
-						],
-						"*",
-						[
-							1,
-							"intensity",
-							"*",
-							[5, "1.1"]
-						]
-					]
-				],
-				[5, "0"],
-				[5, "1.6"]
-			]
-		]]]]
-	},
-	externals: { "std.clamp": () => clamp }
-}) && $.f)({}));
-function applyNoiseReliefExpr(params, heightFn, heightHint) {
-	const { childNode, uniforms, ctx, convertToTexture } = params;
-	if (!childNode) return ZERO;
-	const texture = convertToTexture(childNode);
-	const pos = call(reliefPos, "reliefPos", [
-		ctx.uv,
-		ctx.aspect,
-		uniforms.scale,
-		uniforms.seed
-	]);
-	const displacedUV = call(reliefDisplacedUV, "reliefDisplacedUV", [
-		ctx.uv,
-		pos,
-		uniforms.distortion
-	]);
-	const straight = call(unpremultiplyAlpha, "unpremultiplyAlpha", [texture.sample(displacedUV)]);
-	const brightness = call(reliefBrightness, "reliefBrightness", [
-		call(heightFn, heightHint, [pos]),
-		uniforms.contrast,
-		uniforms.intensity
-	]);
-	return vec4(straight.member("rgb").mul(brightness), straight.member("a"));
-}
-function waves(axes, schedule) {
-	const axisTerm = (axis, k, name) => {
-		if (k === void 0) return void 0;
-		if (axis === void 0) throw new Error(`std: waves() schedule uses axis '${name}' but the axes object doesn't provide it`);
-		return k === 1 ? axis : mul(axis, k);
-	};
-	const waveExpr = (w) => {
-		const parts = [
-			axisTerm(axes.x, w.x, "x"),
-			axisTerm(axes.y, w.y, "y"),
-			axisTerm(axes.t, w.t, "t"),
-			w.phase
-		].filter((part) => part !== void 0);
-		if (parts.length === 0) throw new Error("std: a wave needs at least one axis coefficient or phase");
-		return sin(parts.reduce((a, b) => add(a, b)));
-	};
-	const terms = schedule.map((term) => {
-		if (term.waves.length === 0) throw new Error("std: a waves() term needs at least one wave");
-		const product = term.waves.map(waveExpr).reduce((a, b) => mul(a, b));
-		return term.weight === void 0 || term.weight === 1 ? product : mul(product, term.weight);
-	});
-	if (terms.length === 0) throw new Error("std: waves() needs at least one term");
-	return terms.reduce((a, b) => add(a, b));
-}
-function wavyLine(opts) {
-	return waves({
-		x: opts.along,
-		t: opts.time
-	}, opts.waves.map((w) => ({
-		waves: [{
-			x: w.freq,
-			t: w.speed,
-			phase: w.phase
-		}],
-		weight: w.amount
-	})));
-}
-function seededPlane(field, slots) {
-	return (params, uv) => {
-		const { viewport } = paintFrame(params);
-		return field(params, call(aspectScaledDomain, "aspectScaledDomain", [
-			uv,
-			viewport,
-			uniformOf(slots.scale, params),
-			uniformOf(slots.seed, params)
-		]));
-	};
-}
-function rawPlane(field, slots) {
-	return (params, uv) => {
-		const { viewport } = paintFrame(params);
-		return field(params, call(rawAspectScaledDomain, "rawAspectScaledDomain", [
-			uv,
-			viewport,
-			uniformOf(slots.scale, params),
-			uniformOf(slots.seed, params)
-		]));
-	};
-}
-function pixelGrid(field, slots) {
-	return (params, uv) => {
-		const { viewport } = paintFrame(params);
-		return field(params, call(pixelGridDomain, "pixelGridDomain", [
-			uv,
-			viewport,
-			uniformOf(slots.grain, params),
-			uniformOf(slots.seed, params)
-		]));
-	};
-}
-function evolving(field, opts) {
-	return (params, coord) => field(params, call(timeAxisDomain, "timeAxisDomain", [
-		coord,
-		animatedTime(params),
-		floatE(opts.rate)
-	]));
-}
-function gaborGrains(slots) {
-	return (params, coord) => call(gabor12, "gabor12", [
-		coord,
-		uniformOf(slots.frequency, params),
-		animatedTime(params)
-	]);
-}
-function waveletBands(slots) {
-	return (params, coord) => call(wavelet12, "wavelet12", [
-		coord,
-		animatedTime(params),
-		uniformOf(slots.detail, params)
-	]);
-}
-function blueSpeckle() {
-	return (_params, coord) => call(blue12, "blue12", [coord]);
-}
-function erosionRidges() {
-	return (_params, coord) => call(erosion12, "erosion12", [coord]).member("x");
-}
-function curlSpeed(opts) {
-	return (params, coord) => call(curlMagnitude, "curlMagnitude", [coord, animatedTime(params).mul(opts.rate)]);
-}
-function scratchStreaks(slots) {
-	return (params, coord) => call(scratches12, "scratches12", [
-		coord,
-		animatedTime(params),
-		uniformOf(slots.thickness, params)
-	]);
-}
-function unitized(field) {
-	return (params, coord) => call(signedToUnit, "signedToUnit", [field(params, coord)]);
-}
-function noiseTone(field, slots) {
-	return (params, coord) => call(noiseToneKColor, "noiseToneKColor", [
-		field(params, coord),
-		slots?.contrast ? uniformOf(slots.contrast, params) : floatE(0),
-		slots?.balance ? uniformOf(slots.balance, params) : floatE(0)
-	]);
-}
-function signedTone(field, slots) {
-	return (params, coord) => call(toneSignedInverted, "noiseToneSigned", [
-		field(params, coord),
-		uniformOf(slots.contrast, params),
-		uniformOf(slots.balance, params)
-	]);
-}
-function gainTone(field, slots) {
-	return (params, coord) => call(worleyTone, "worleyTone", [
-		field(params, coord),
-		uniformOf(slots.contrast, params),
-		uniformOf(slots.balance, params)
-	]);
-}
-function linearPair(a, b) {
-	return (t, params) => call(mixColorsLinear, "mixColors", [
-		uniformOf(a, params),
-		uniformOf(b, params),
-		t
-	]);
-}
-function fractalNoise(slots) {
-	const ridges = (params, uv) => {
-		const { viewport } = paintFrame(params);
-		return call(fbmNormalize, "fbmNormalize", [call(fractalSum, "fractalSum", [
-			call(rotatedCenteredDomain, "rotatedCenteredDomain", [
-				uv,
-				viewport,
-				uniformOf(slots.angle, params)
-			]),
-			uniformOf(slots.detail, params),
-			uniformOf(slots.contrast, params),
-			animatedTime(params),
-			uniformOf(slots.seed, params),
-			uniformOf(slots.octaves, params)
-		])]);
-	};
-	return rampOver(ridges, stops(slots.space));
-}
-function worleyNoise(slots) {
-	const cells = (params, uv) => {
-		const { viewport } = paintFrame(params);
-		const modeNum = worleyModeNum(params.propValues[slots.mode.name]);
-		const distNum = worleyDistNum(params.propValues[slots.distance.name]);
-		const octavesNum = Math.max(1, Math.min(4, Math.round(params.propValues[slots.octaves.name] ?? 1)));
-		return call(worleyNormalize, "worleyNormalize", [call(worleyCells, "worleyCells", [
-			call(aspectPlane, "aspectPlane", [uv, viewport]),
-			uniformOf(slots.scale, params),
-			uniformOf(slots.seed, params),
-			uniformOf(slots.jitter, params),
-			uniformOf(slots.lacunarity, params),
-			uniformOf(slots.persistence, params),
-			animatedTime(params),
-			floatE(octavesNum),
-			floatE(distNum),
-			floatE(modeNum)
-		]), floatE(worleyModeScale(modeNum, distNum))]);
-	};
-	return rampOver(gainTone(cells, {
-		contrast: slots.contrast,
-		balance: slots.balance
-	}), stops(slots.space));
-}
-function cellDistances(slots) {
-	return (params, uv) => {
-		const { viewport } = paintFrame(params);
-		return call(voronoiCells, "voronoiNearest2", [
-			call(aspectPlane, "aspectPlane", [uv, viewport]).mul(uniformOf(slots.scale, params)),
-			animatedTime(params),
-			uniformOf(slots.seed, params)
-		]);
-	};
-}
-function cellFill(cells, slots) {
-	return (params, coord) => call(cellFill$1, "cellFill", [cells(params, coord), uniformOf(slots.edgeIntensity, params)]);
-}
-function cellBorders(cells, slots) {
-	return (params, coord) => call(cellBorders$1, "cellBorders", [
-		cells(params, coord),
-		uniformOf(slots.softness, params),
-		uniformOf(slots.scale, params)
-	]);
-}
-function borderOverlay(paint, mask, slots) {
-	return (params) => {
-		const { uv } = paintFrame(params);
-		const base = asLocal(paint(params), "base");
-		return vec4(mixExpr(uniformOf(slots.color, params).member("rgb"), base.member("rgb"), mask(params, uv)), base.member("a"));
-	};
-}
-function overRgb(paint, ...stages) {
-	return (params) => {
-		const base = paint(params);
-		let rgb = base.member("rgb");
-		for (const stage of stages) rgb = stage(rgb, params);
-		return vec4(rgb, base.member("a"));
-	};
-}
-function backToP3(slots) {
-	return (rgb, params) => {
-		return backConvertToP3(rgb, slots.space ? colorSpaceModeOf(params.propValues[slots.space.name]) : 0);
-	};
-}
-function tonePow() {
-	return (rgb) => call(toneLift, "toneLift", [rgb]);
-}
-function ribbons(slots) {
-	return (params) => {
-		const { uniforms } = params;
-		const { uv, viewport } = paintFrame(params);
-		const waveT = animatedTime(params);
-		const colorT = animatedTime(params, void 0, "_animTime_color");
-		const packed1 = vec4(uniformOf(slots.amplitude, params), uniformOf(slots.frequency, params), uniformOf(slots.count, params), uniformOf(slots.width, params));
-		const packed2 = vec4(uniformOf(slots.softness, params), uniformOf(slots.spread, params), uniformOf(slots.colorScale, params), uniformOf(slots.colorVariance, params));
-		const packed3 = vec4(uniformOf(slots.pinEdges, params), waveT, colorT, uniforms.stopCount);
-		return call(ribbonsField, "ribbonsField", [
-			uv,
-			viewport,
-			uniformOf(slots.from, params),
-			uniformOf(slots.to, params),
-			packed1,
-			packed2,
-			packed3,
-			uniforms.colorsArray,
-			uniforms.positionsArray,
-			uniforms.convertedColorsArray
-		]);
-	};
-}
-const reliefBases = {
-	stone: {
-		fn: stone12,
-		hint: "stone12"
-	},
-	wool: {
-		fn: wool12,
-		hint: "wool12"
-	}
-};
-function noiseRelief(basis) {
-	return (params) => applyNoiseReliefExpr(params, basis.fn, basis.hint);
-}
-const transformWorleyMode = transformWorleyMode$1;
-const transformWorleyDistance = transformWorleyDistance$1;
-const worleyHash = worleyHash$1;
-export { worleyHash as A, tonePow as C, waveletBands as D, unitized as E, waves as O, signedTone as S, transformWorleyMode as T, rawPlane as _, cellDistances as a, scratchStreaks as b, erosionRidges as c, gaborGrains as d, linearPair as f, pixelGrid as g, overRgb as h, cellBorders as i, worleyNoise as j, wavyLine as k, evolving as l, noiseTone as m, blueSpeckle as n, cellFill as o, noiseRelief as p, borderOverlay as r, curlSpeed as s, backToP3 as t, fractalNoise as u, reliefBases as v, transformWorleyDistance as w, seededPlane as x, ribbons as y };