shaders 3.1.462 → 3.2.464

package/dist/core/Vignette-QPr1Cal2.js

@@ -0,0 +1,91 @@
+import { o as Scalar, s as p, t as defineStd } from "./lower-z2vuXP8M.js";
+import { a as transformColor, c as transformPosition } from "./transformations-CoIwF5JU.js";
+import { r as tintToward } from "./filter-Bw8Ogi4T.js";
+import { i as isZero, n as crosses } from "./slots-BqeQDVxy.js";
+function radialMask(slots) {
+	return new Scalar({
+		kind: "radialMask",
+		center: slots.center,
+		radius: slots.radius,
+		falloff: slots.falloff
+	});
+}
+const componentDefinition = defineStd({
+	name: "Vignette",
+	role: "filter",
+	species: "pointwise",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Stylize",
+	description: "Darkens or tints the edges of the frame, drawing attention toward the center",
+	props: {
+		color: {
+			default: "#000000",
+			transform: transformColor,
+			description: "Color of the vignette at the edges",
+			ui: {
+				type: "color",
+				label: "Color",
+				group: "Colors"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "Center of the clear area where the vignette begins",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position"
+			}
+		},
+		radius: {
+			default: .5,
+			description: "Distance from center where the vignette begins to fade in",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1.5,
+				step: .01,
+				label: "Radius",
+				group: "Effect"
+			}
+		},
+		falloff: {
+			default: .5,
+			description: "Width of the transition zone from clear to full vignette",
+			ui: {
+				type: ["range", "map"],
+				min: .01,
+				max: 1.5,
+				step: .01,
+				label: "Falloff",
+				group: "Effect"
+			}
+		},
+		intensity: {
+			default: 1,
+			description: "Strength of the vignette effect",
+			recompile: crosses(0),
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Intensity",
+				group: "Effect"
+			}
+		}
+	},
+	effect: tintToward(p("color"), { amount: radialMask({
+		center: p("center"),
+		radius: p("radius"),
+		falloff: p("falloff")
+	}).times(p("intensity")) }),
+	identityWhen: isZero("intensity"),
+	missingChildMessage: "You must pass a child component into the Vignette shader."
+});
+var Vignette_default = componentDefinition;
+export { componentDefinition as n, Vignette_default as t };

package/dist/core/Voronoi-c4jiH9Rs.js

@@ -0,0 +1,132 @@
+import { s as p, t as defineStd } from "./lower-z2vuXP8M.js";
+import { ct as colorStopsPropConfig } from "./porters-B1UjrM1y.js";
+import { a as cellDistances, i as cellBorders, o as cellFill, r as borderOverlay } from "./noise-DQWgxDEf.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CoIwF5JU.js";
+import { c as rampOver, d as share, p as stops } from "./fields-Cg5kOBDV.js";
+var cells = share(cellDistances({
+	scale: p("scale"),
+	seed: p("seed")
+}));
+const componentDefinition = defineStd({
+	name: "Voronoi",
+	role: "generator",
+	boundingBoxDeclaration: {
+		aspectRatio: null,
+		supportsResizeFit: true
+	},
+	category: "Textures",
+	description: "Cellular pattern where each pixel is colored by its distance to the nearest of many scattered points",
+	acceptsUVContext: true,
+	animatedTime: { speed: "speed" },
+	props: {
+		colorA: {
+			default: "#3186cf",
+			transform: transformColor,
+			description: "Color near each cell's center point",
+			ui: {
+				type: "color",
+				label: "Color A (Center)",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#fc02dd",
+			transform: transformColor,
+			description: "Color at cell boundaries, far from any center point",
+			ui: {
+				type: "color",
+				label: "Color B (Edge)",
+				group: "Colors"
+			}
+		},
+		stops: colorStopsPropConfig(),
+		colorBorder: {
+			default: "#000000",
+			transform: transformColor,
+			description: "Color of the cell boundary lines",
+			ui: {
+				type: "color",
+				label: "Border Color",
+				group: "Colors"
+			}
+		},
+		scale: {
+			default: 6,
+			description: "Number of cells across the canvas",
+			ui: {
+				type: ["range", "map"],
+				min: 1,
+				max: 20,
+				step: .5,
+				label: "Scale",
+				group: "Effect"
+			}
+		},
+		speed: {
+			default: .5,
+			description: "Animation speed — how fast the cell points drift",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 5,
+				step: .1,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Random seed — shifts the cell pattern without changing the overall structure",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Effect"
+			}
+		},
+		edgeIntensity: {
+			default: .5,
+			description: "Controls how much of the cell interior is filled by the edge color. Low = center color dominates with a sharp boundary. High = edge color spreads further into the cell.",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Edge Intensity",
+				group: "Effect"
+			}
+		},
+		edgeSoftness: {
+			default: .05,
+			description: "Width of the cell boundary lines.",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: .4,
+				step: .005,
+				label: "Edge Softness",
+				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"
+			}
+		}
+	},
+	paint: borderOverlay(rampOver(share(cellFill(cells, { edgeIntensity: p("edgeIntensity") })), stops(p("colorSpace"))), cellBorders(cells, {
+		softness: p("edgeSoftness"),
+		scale: p("scale")
+	}), { color: p("colorBorder") })
+});
+var Voronoi_default = componentDefinition;
+export { componentDefinition as n, Voronoi_default as t };

package/dist/core/Water-D9HuYCj8.js

@@ -0,0 +1,373 @@
+import { nt as ZERO, t as defineStd } from "./lower-z2vuXP8M.js";
+import { t as animatedTime } from "./porters-B1UjrM1y.js";
+import { A as schlickFresnel, B as surfacePattern, D as reflect, L as surfaceField, M as sharpGlint, O as refract, P as silhouette, _ as insideShape, c as fieldSlope, h as guarded, j as shapedSurface, l as flowWarp, n as beerLambert, p as grazingFlat, v as keyLightAt, w as opticalThickness, x as marchedNormal, z as surfaceNoiseAt } from "./materials-D7QX3H4h.js";
+import { v as shapeEffectBoundingBoxDeclaration } from "./sdf3d-BD5m6HR6.js";
+import { a as transformColor, c as transformPosition } from "./transformations-CoIwF5JU.js";
+import { C as normalize, D as smoothstep, E as sin, M as vec2, N as vec3, P as vec4, _ as local, b as mix, g as length, i as clamp, j as sub, k as splat3, l as float, n as add, o as div, s as dot, t as abs, w as pow, x as mul } from "./math-BF-GBlb4.js";
+import { t as direction } from "./frames-BWC4dNMQ.js";
+var DEFAULT_SHAPE_CONFIG = JSON.stringify({
+	type: "circleSDF",
+	radius: .35
+});
+var waterFbm = (uvE, hint) => {
+	const uv = local(uvE, hint);
+	const n0 = surfaceNoiseAt(uv);
+	const n1 = mul(surfaceNoiseAt(add(mul(uv, 2.07), vec2(4.3, 9.1))), .5);
+	const n2 = mul(surfaceNoiseAt(add(mul(uv, 4.13), vec2(1.7, 8.2))), .25);
+	return mul(add(add(n0, n1), n2), .52);
+};
+var waterNoise1 = (uv) => mul(surfaceNoiseAt(uv), .52);
+var waterSky = (rx, ry, lx, ly, envC, envS, sharp, hint) => {
+	const ex = local(sub(mul(rx, envC), mul(ry, envS)), `${hint}Ex`);
+	const ey = local(add(mul(rx, envS), mul(ry, envC)), `${hint}Ey`);
+	const up = local(clamp(add(mul(ey, .5), .5), 0, 1), `${hint}Up`);
+	const horizon = vec3(.9, .96, 1);
+	const zenith = vec3(.2, .46, .85);
+	const base = mix(vec3(.04, .1, .16), mix(horizon, zenith, splat3(smoothstep(.5, 1, up))), splat3(smoothstep(.4, .55, up)));
+	const sunCenter = vec2(mul(lx, .8), add(mul(ly, .8), .12));
+	const sunRad = local(mix(.5, .13, sharp), `${hint}SunRad`);
+	const sd = length(sub(vec2(ex, ey), sunCenter));
+	const sun = smoothstep(sunRad, mul(sunRad, .15), sd);
+	return add(base, mul(vec3(1, .97, .88), mul(sun, 1.5)));
+};
+const componentDefinition = defineStd({
+	name: "Water",
+	role: "shapeEffect",
+	species: "custom",
+	boundingBoxDeclaration: shapeEffectBoundingBoxDeclaration,
+	category: "Shape Effects",
+	description: "Translucent water — a refractive, light-absorbing body that deepens to its colour with thickness, wrapped in a wind-driven wave surface that reflects a procedural sky, with Fresnel-bright grazing edges and foam breaking on the crests and shoreline",
+	animatedTime: { speed: "speed" },
+	props: {
+		origin: {
+			default: "center",
+			description: "Reference edge the center position is measured from (center default). Lets you pin the shape relative to a corner or the canvas centre.",
+			ui: {
+				type: "origin",
+				label: "Origin",
+				group: "Position"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "Center position of the water shape",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position",
+				units: ["%", "px"]
+			}
+		},
+		scale: {
+			default: 1,
+			description: "Scale of the water shape (1 = default size)",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 3,
+				step: .01,
+				label: "Scale",
+				group: "Position"
+			}
+		},
+		rotation: {
+			default: 0,
+			description: "Rotation of the water shape in degrees",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Rotation",
+				group: "Position"
+			}
+		},
+		waterColor: {
+			default: "#00bfeb",
+			transform: transformColor,
+			description: "The colour the water saturates toward with depth",
+			ui: {
+				type: "color",
+				label: "Water Color",
+				group: "Water"
+			}
+		},
+		clarity: {
+			default: .4,
+			description: "How much of the reflected sky transmits through the body",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Clarity",
+				group: "Water"
+			}
+		},
+		depth: {
+			default: 5,
+			description: "How quickly the water darkens and saturates toward its colour with thickness",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 8,
+				step: .01,
+				label: "Depth",
+				group: "Water"
+			}
+		},
+		shallows: {
+			default: .5,
+			description: "Brightness of the thin shallow water at the edges — high fades the rim to light translucent water, low keeps the edges close to the deep water colour",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Shallows",
+				group: "Water"
+			}
+		},
+		caustics: {
+			default: .15,
+			description: "Intensity of the light caustics bubbling up through the body — bright veins of focused light churning inside the water",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Caustics",
+				group: "Water"
+			}
+		},
+		causticScale: {
+			default: 6,
+			description: "Size of the caustic veins — higher = finer, busier light patterns inside the body",
+			ui: {
+				type: "range",
+				min: 1,
+				max: 20,
+				step: .1,
+				label: "Caustic Scale",
+				group: "Water"
+			}
+		},
+		choppiness: {
+			default: .8,
+			description: "Height of the wind-driven waves — the depth of the folds that bend the reflection",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1.5,
+				step: .01,
+				label: "Choppiness",
+				group: "Waves"
+			}
+		},
+		waveScale: {
+			default: 3.5,
+			description: "Scale of the wave fronts — higher = smaller, busier ripples",
+			ui: {
+				type: "range",
+				min: .5,
+				max: 8,
+				step: .01,
+				label: "Wave Scale",
+				group: "Waves"
+			}
+		},
+		swirl: {
+			default: .6,
+			description: "Swirl of the flow — domain-warps the wave fronts into curling eddies",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1.5,
+				step: .01,
+				label: "Swirl",
+				group: "Waves"
+			}
+		},
+		speed: {
+			default: .5,
+			description: "Speed of the rolling waves. 0 pauses the surface.",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 4,
+				step: .01,
+				label: "Speed",
+				group: "Waves"
+			}
+		},
+		reflection: {
+			default: 2,
+			description: "Strength of the reflected sky across the surface",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Reflection",
+				group: "Surface"
+			}
+		},
+		envRotation: {
+			default: 0,
+			description: "Rotates the reflected sky — spins where the bright sky and sun fall",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Env Rotation",
+				group: "Surface"
+			}
+		},
+		sharpness: {
+			default: .1,
+			description: "Tightness of the sun glint and reflected sun",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Sharpness",
+				group: "Surface"
+			}
+		},
+		lightAngle: {
+			default: 30,
+			description: "Direction of the sun, in degrees — drives the glint and where the sun reflects",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Light Angle",
+				group: "Surface"
+			}
+		},
+		foam: {
+			default: .3,
+			description: "White foam breaking on the wave crests and along the shoreline edge",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Foam",
+				group: "Surface"
+			}
+		},
+		edgeSoftness: {
+			default: .05,
+			description: "Softness of the shape boundary edge",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Edge Softness",
+				group: "Surface"
+			}
+		},
+		shape: {
+			default: DEFAULT_SHAPE_CONFIG,
+			description: "Serialized shape configuration (JSON)",
+			ui: {
+				type: "shape",
+				label: "Shape",
+				group: "Shape"
+			}
+		},
+		shapeSdfUrl: {
+			default: "",
+			compileTime: true,
+			description: "URL to a pre-generated SDF .bin file"
+		},
+		shapeType: {
+			default: "",
+			compileTime: true,
+			description: "Active SDF shape type"
+		}
+	},
+	...shapedSurface({
+		pattern: "raw",
+		surface: (frame, params) => {
+			const { uniforms: u } = params;
+			const t = animatedTime(params);
+			const vol = frame.volumetric;
+			const field = surfaceField(frame, params, { scale: u.scale });
+			const { sdf, pxH } = field;
+			const light = direction(u.lightAngle, "light");
+			const lx = light.member("x");
+			const ly = light.member("y");
+			const env = direction(u.envRotation, "env");
+			const envC = env.member("x");
+			const envS = env.member("y");
+			const grad = fieldSlope(field);
+			let nGeo;
+			if (vol) nGeo = marchedNormal(field);
+			else {
+				const rimBevel = local(mul(sub(1, clamp(div(mul(sdf, -1), .05), 0, 1)), 1.6), "rimBevel");
+				nGeo = local(normalize(vec3(mul(grad.member("x"), rimBevel), mul(grad.member("y"), rimBevel), -1)), "nGeo");
+			}
+			const pat = surfacePattern(frame, field);
+			const fx = pat.member("x");
+			const fy = pat.member("y");
+			const freq = local(mul(u.waveScale, 2.4), "freq");
+			const flowT = local(mul(t, .2), "flowT");
+			const q = local(vec2(mul(mul(fx, freq), .8), mul(mul(fy, freq), 1.25)), "q");
+			const wAmt = mul(u.swirl, .9);
+			const qw = local(add(add(q, mul(flowWarp(mul(q, .6), flowT), wAmt)), vec2(0, mul(flowT, -1))), "qw");
+			const re = .06;
+			const h0 = local(waterFbm(qw, "fbmH0"), "h0");
+			const h0n1 = local(waterNoise1(qw), "h0n1");
+			const hx = clamp(div(sub(waterNoise1(add(qw, vec2(re, 0))), h0n1), re), -4, 4);
+			const hy = clamp(div(sub(waterNoise1(add(qw, vec2(0, re))), h0n1), re), -4, 4);
+			const fineRe = .025;
+			const qf = local(add(add(mul(qw, 3.3), vec2(mul(flowT, 1.7), mul(flowT, -1.15))), vec2(11.3, 4.7)), "qf");
+			const f0n1 = local(waterNoise1(qf), "f0n1");
+			const fxg = clamp(div(sub(waterNoise1(add(qf, vec2(fineRe, 0))), f0n1), fineRe), -4, 4);
+			const fyg = clamp(div(sub(waterNoise1(add(qf, vec2(0, fineRe))), f0n1), fineRe), -4, 4);
+			const relief = local(mul(u.choppiness, .5), "relief");
+			const reliefFine = local(mul(u.choppiness, .22), "reliefFine");
+			const n = local(normalize(vec3(sub(sub(nGeo.member("x"), mul(hx, relief)), mul(fxg, reliefFine)), sub(sub(nGeo.member("y"), mul(hy, relief)), mul(fyg, reliefFine)), nGeo.member("z"))), "n");
+			const sharp = local(clamp(u.sharpness, 0, 1), "sharp");
+			const R = local(reflect(vec3(0, 0, 1), n), "R");
+			const reflCol = local(mul(waterSky(R.member("x"), R.member("y"), lx, ly, envC, envS, sharp, "refl"), u.reflection), "reflCol");
+			const thickness = local(mul(opticalThickness(field, frame), u.depth), "thickness");
+			const depthT = local(clamp(mul(thickness, 1.3), 0, 1), "depthT");
+			const wc = local(u.waterColor.member("rgb"), "wc");
+			const transmit = local(beerLambert(thickness, vec3(mul(sub(1, wc.member("x")), 2.2), mul(sub(1, wc.member("y")), 2.2), mul(sub(1, wc.member("z")), 2.2))), "transmit");
+			const shallowsC = clamp(u.shallows, 0, 1);
+			const bodyTint = local(add(mul(mix(mix(wc, vec3(1, 1, 1), splat3(shallowsC)), wc, splat3(depthT)), transmit), mul(wc, mul(depthT, .18))), "bodyTint");
+			const kl = keyLightAt(light, -.7);
+			const diffuse = local(add(mul(pow(clamp(add(mul(dot(n, kl.member("L")), .5), .5), 0, 1), .8), .5), .5), "diffuse");
+			const tDir = local(refract(vec3(0, 0, 1), n, float(1 / 1.333)), "tDir");
+			const transSky = mul(waterSky(tDir.member("x"), tDir.member("y"), lx, ly, envC, envS, sharp, "trans"), transmit);
+			const clarityT = mul(clamp(u.clarity, 0, 1), sub(1, mul(depthT, .8)));
+			const body0 = mul(mix(bodyTint, add(mul(transSky, .6), mul(bodyTint, .4)), splat3(clarityT)), diffuse);
+			const causT = local(mul(t, 3), "causT");
+			const causP = local(add(mul(vec2(fx, fy), u.causticScale), vec2(mul(sin(mul(causT, .15)), .4), mul(mul(causT, .3), -1))), "causP");
+			const c1 = sub(1, abs(waterFbm(causP, "fbmC1")));
+			const c2 = sub(1, abs(waterFbm(add(mul(causP, 1.9), vec2(3.7, mul(mul(causT, .18), -1))), "fbmC2")));
+			const causV = local(pow(clamp(add(mul(c1, .6), mul(c2, .4)), 0, 1), 3), "causV");
+			const causMask = local(mul(add(mul(depthT, .8), .2), u.caustics), "causMask");
+			const surface0 = mix(add(mul(body0, add(1, mul(mul(causV, causMask), .7))), mul(vec3(.55, .82, 1), mul(mul(causV, causMask), .45))), reflCol, splat3(clamp(schlickFresnel(grazingFlat(n), { gain: .96 }), 0, 1)));
+			const spec = sharpGlint(clamp(dot(n, kl.member("H")), 0, 1), sharp, vec4(40, 600, .3, 1.3));
+			const surface1 = add(surface0, mul(vec3(1, .98, .92), spec));
+			const foamMask = local(mul(clamp(add(smoothstep(.62, .92, clamp(add(mul(h0, .5), .5), 0, 1)), mul(sub(1, smoothstep(0, .045, mul(sdf, -1))), .7)), 0, 1), u.foam), "foamMask");
+			const surface2 = local(mix(surface1, vec3(1, 1, 1), splat3(mul(foamMask, .85))), "waterRgb");
+			const transition = silhouette(field, u.edgeSoftness);
+			return guarded(insideShape(sdf, pxH), vec4(surface2, transition), ZERO, "water");
+		}
+	})
+});
+var Water_default = componentDefinition;
+export { componentDefinition as n, Water_default as t };

package/dist/core/Watercolor-DQUk4Fp6.js

@@ -0,0 +1,91 @@
+import { s as p, t as defineStd } from "./lower-z2vuXP8M.js";
+import { f as wash, s as kuwahara, t as bleedWarp, u as paperGrain } from "./stylize-DuY5wWZo.js";
+import { a as transformColor } from "./transformations-CoIwF5JU.js";
+import { n as crosses } from "./slots-BqeQDVxy.js";
+var wet = bleedWarp({ amount: p("bleed") });
+const componentDefinition = defineStd({
+	name: "Watercolor",
+	role: "filter",
+	species: "gather",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Stylize",
+	description: "Painterly watercolor look — Kuwahara flattening, pigment edge darkening, paper grain and bleeding",
+	props: {
+		radius: {
+			default: 3,
+			compileTime: true,
+			description: "Brush size — radius of the painterly flattening",
+			ui: {
+				type: "range",
+				min: 1,
+				max: 8,
+				step: 1,
+				label: "Brush",
+				group: "Effect",
+				hidden: true
+			}
+		},
+		bleed: {
+			default: 1,
+			recompile: crosses(0),
+			description: "Amount the pigment bleeds and wobbles past hard edges",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 3,
+				step: .01,
+				label: "Bleed",
+				group: "Effect"
+			}
+		},
+		strength: {
+			default: 1,
+			recompile: crosses(0),
+			description: "Blend between the original image (0) and the full watercolor effect (1)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Strength",
+				group: "Effect"
+			}
+		},
+		paper: {
+			default: .35,
+			recompile: crosses(0),
+			description: "Strength of the paper grain the pigment settles into",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Paper",
+				group: "Effect"
+			}
+		},
+		paperColor: {
+			default: "#fbf7ec",
+			transform: transformColor,
+			description: "Tint of the paper grain",
+			ui: {
+				type: "color",
+				label: "Paper Color",
+				group: "Colors"
+			}
+		}
+	},
+	effect: wash({
+		at: wet,
+		brush: kuwahara({
+			at: wet,
+			radius: p("radius")
+		}),
+		grain: paperGrain({ amount: p("paper") }),
+		paper: p("paper"),
+		paperColor: p("paperColor"),
+		strength: p("strength")
+	})
+});
+var Watercolor_default = componentDefinition;
+export { componentDefinition as n, Watercolor_default as t };