shaders 3.2.475 → 4.0.0

package/dist/core/Voxels-B3e3LHH5.js

@@ -0,0 +1,469 @@
+import { Ac as defineStd, Dc as vec3, Gs as clamp, Hd as call, Jr as grazingOf, Js as dot, Ks as cos, Ml as p, Oc as vec4, Po as mixColorsIn, Ru as shapeEffectBoundingBoxDeclaration, Tc as sub, Ws as add, Xs as exp2, bc as smoothstep, cc as max, dc as mul, fc as neg, fr as voxelSurface, mc as pow, mf as DEG_TO_RAD$1, mi as schlickFresnel, oc as local, pc as normalize, ti as lambert, uc as mix, yc as sin } from "./std-ClftfWpF.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
+var DEG_TO_RAD = DEG_TO_RAD$1;
+var DEFAULT_SHAPE_CONFIG = JSON.stringify({
+	type: "sphere3D",
+	radius: .35
+});
+var KEY_WRAP = .12;
+var GROUND_GAIN = .35;
+var GLOSS_EXP_RANGE = [3, 7.5];
+var VARIATION_RANGE = .6;
+var SEAM_WIDTH = [.04, .12];
+var SEAM_DARKEN = .75;
+const componentDefinition = defineStd({
+	name: "Voxels",
+	role: "shapeEffect",
+	species: "custom",
+	boundingBoxDeclaration: shapeEffectBoundingBoxDeclaration,
+	category: "Shape Effects",
+	description: "Rebuild any shape out of voxels — a flat shape becomes chunky pixel art, a 3D shape a lit voxel model with smooth ambient occlusion, cast shadows, a key light you can orbit or drive, and per-cube color",
+	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 voxel model",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position",
+				units: ["%", "px"]
+			}
+		},
+		scale: {
+			default: 1,
+			description: "Scale of the voxel model (1 = default size)",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 3,
+				step: .01,
+				label: "Scale",
+				group: "Position"
+			}
+		},
+		rotation: {
+			default: 0,
+			description: "Rotation of the voxel model in degrees",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Rotation",
+				group: "Position"
+			}
+		},
+		voxelSize: {
+			default: .035,
+			description: "Edge length of one voxel relative to the shape field — small for fine detail, large for chunky blocks",
+			ui: {
+				type: "range",
+				min: .006,
+				max: .15,
+				step: .001,
+				label: "Voxel Size",
+				group: "Voxels"
+			}
+		},
+		voxelShape: {
+			default: "cube",
+			compileTime: true,
+			description: "What each cell is built from: hard cubes, rounded cubes (see Bevel) or spheres",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Cube",
+						value: "cube"
+					},
+					{
+						label: "Rounded Cube",
+						value: "rounded"
+					},
+					{
+						label: "Sphere",
+						value: "sphere"
+					}
+				],
+				label: "Voxel Shape",
+				group: "Voxels"
+			}
+		},
+		voxelScale: {
+			default: 1,
+			description: "Size of each voxel inside its cell — 1 = touching neighbours, lower opens gaps between the blocks",
+			ui: {
+				type: "range",
+				min: .3,
+				max: 1,
+				step: .01,
+				label: "Voxel Fill",
+				group: "Voxels"
+			}
+		},
+		fill: {
+			default: 0,
+			description: "How eagerly cells fill in along the surface — negative carves a thinner model, positive puffs it out",
+			ui: {
+				type: "range",
+				min: -.5,
+				max: .5,
+				step: .01,
+				label: "Surface Bias",
+				group: "Voxels"
+			}
+		},
+		bevel: {
+			default: .08,
+			description: "Edge rounding of each voxel as a fraction of its size — a hairline chamfer catching light on cubes, the corner radius of rounded cubes",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Bevel",
+				group: "Voxels"
+			}
+		},
+		depth: {
+			default: .12,
+			description: "Thickness given to flat shapes (2D shapes and flat SVGs) so they become a slab of voxels — 3D shapes ignore it",
+			ui: {
+				type: "range",
+				min: .01,
+				max: .6,
+				step: .005,
+				label: "Depth",
+				group: "Voxels"
+			}
+		},
+		gridSpace: {
+			default: "shape",
+			compileTime: true,
+			description: "Model: the grid rotates with the shape like a built voxel model. Screen: the grid is fixed to the canvas and the shape moves through it like a 3D pixelation",
+			ui: {
+				type: "select",
+				options: [{
+					label: "Model",
+					value: "shape"
+				}, {
+					label: "Screen",
+					value: "view"
+				}],
+				label: "Grid",
+				group: "Voxels"
+			}
+		},
+		colorA: {
+			default: "#6ea8ff",
+			transform: transformColor,
+			description: "Base color of the voxels (the first color of the palette mode)",
+			ui: {
+				type: "color",
+				label: "Color A",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#1d2b4f",
+			transform: transformColor,
+			description: "Second palette color — blended in by height, depth, per voxel or on the side faces",
+			ui: {
+				type: "color",
+				label: "Color B",
+				group: "Colors"
+			}
+		},
+		colorMode: {
+			default: "height",
+			compileTime: true,
+			description: "How the two colors are laid over the model: one solid color, a gradient by height or depth, a random pick per voxel, or Color A on top faces and Color B on the sides",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Solid",
+						value: "solid"
+					},
+					{
+						label: "Height",
+						value: "height"
+					},
+					{
+						label: "Depth",
+						value: "depth"
+					},
+					{
+						label: "Random",
+						value: "random"
+					},
+					{
+						label: "Top / Sides",
+						value: "faces"
+					}
+				],
+				label: "Palette",
+				group: "Colors"
+			}
+		},
+		colorVariation: {
+			default: .25,
+			description: "Per-voxel tonal jitter — the slightly-off shades that make blocks read as individual bricks",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Variation",
+				group: "Colors"
+			}
+		},
+		colorSpace: {
+			default: "oklab",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Color space for color interpolation",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Colors"
+			}
+		},
+		lightAngle: {
+			default: 225,
+			description: "Direction the key light comes from, in degrees around the canvas — shadows fall away from it",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Light Angle",
+				group: "Light"
+			}
+		},
+		lightElevation: {
+			default: 42,
+			description: "How high the key light sits above the canvas — low for long raking shadows, high for a flat top-down light",
+			ui: {
+				type: ["range", "map"],
+				min: 5,
+				max: 85,
+				step: 1,
+				label: "Light Elevation",
+				group: "Light"
+			}
+		},
+		lightColor: {
+			default: "#fff2df",
+			transform: transformColor,
+			description: "color of the key light",
+			ui: {
+				type: "color",
+				label: "Light Color",
+				group: "Light"
+			}
+		},
+		lightIntensity: {
+			default: 1.1,
+			description: "Strength of the key light",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 3,
+				step: .01,
+				label: "Light Intensity",
+				group: "Light"
+			}
+		},
+		ambientColor: {
+			default: "#9fb4d8",
+			transform: transformColor,
+			description: "Sky color of the ambient light — the fill on faces the key light misses",
+			ui: {
+				type: "color",
+				label: "Ambient Color",
+				group: "Light"
+			}
+		},
+		ambient: {
+			default: .55,
+			description: "Strength of the ambient sky/ground fill",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Ambient",
+				group: "Light"
+			}
+		},
+		shadows: {
+			default: .85,
+			description: "Darkness of the shadows voxels cast onto each other",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Shadows",
+				group: "Light"
+			}
+		},
+		shadowSoftness: {
+			default: .35,
+			description: "Penumbra of the cast shadows — 0 is razor sharp, higher spreads the light into a soft area source whose shadows sharpen at contact",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Shadow Softness",
+				group: "Light"
+			}
+		},
+		ao: {
+			default: 1,
+			description: "Ambient occlusion in the creases between voxels — the soft contact darkening that sells the geometry",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Occlusion",
+				group: "Light"
+			}
+		},
+		glossiness: {
+			default: .35,
+			description: "How tight the specular highlight is — satin plastic at 0, lacquered at 1",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Glossiness",
+				group: "Surface"
+			}
+		},
+		specular: {
+			default: .6,
+			description: "Strength of the specular highlight and the fresnel rim on grazing faces",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Specular",
+				group: "Surface"
+			}
+		},
+		seams: {
+			default: .2,
+			description: "Dark seam lines along every voxel edge — 0 for seamless blocks, higher for a drawn-outline brick look",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Seams",
+				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"
+		}
+	},
+	...voxelSurface({
+		style: p("voxelShape"),
+		gridSpace: p("gridSpace"),
+		voxelSize: p("voxelSize"),
+		fill: p("fill"),
+		voxelScale: p("voxelScale"),
+		bevel: p("bevel"),
+		shadowSoftness: p("shadowSoftness"),
+		lightAngle: p("lightAngle"),
+		lightElevation: p("lightElevation"),
+		depth: p("depth"),
+		surface: (vox, _frame, params) => {
+			const { uniforms: u, propValues } = params;
+			const n = vox.normal;
+			const mixVariant = mixColorsIn(p("colorSpace"), params);
+			const mixAB = (t) => call(mixVariant, "mixColors", [
+				u.colorA,
+				u.colorB,
+				t
+			]).member("rgb");
+			const upness = local(clamp(neg(n.member("y")), 0, 1), "upness");
+			let base;
+			switch (propValues.colorMode) {
+				case "height":
+					base = mixAB(sub(1, vox.heightT));
+					break;
+				case "depth":
+					base = mixAB(vox.depthT);
+					break;
+				case "random":
+					base = mixAB(vox.cellHash);
+					break;
+				case "faces":
+					base = mixAB(sub(1, smoothstep(.35, .75, upness)));
+					break;
+				default: base = u.colorA.member("rgb");
+			}
+			const jitter = add(1, mul(sub(vox.cellHash, .5), mul(u.colorVariation, VARIATION_RANGE)));
+			const albedo = local(mul(base, jitter), "albedo");
+			const az = mul(u.lightAngle, DEG_TO_RAD);
+			const el = mul(u.lightElevation, DEG_TO_RAD);
+			const cosEl = local(cos(el), "cosEl");
+			const L = local(normalize(vec3(mul(cos(az), cosEl), mul(sin(az), cosEl), neg(sin(el)))), "L");
+			const ndl = local(lambert(n, L, { wrap: KEY_WRAP }), "ndl");
+			const lit = local(sub(1, mul(vox.shadow, u.shadows)), "lit");
+			const keyRgb = local(mul(u.lightColor.member("rgb"), u.lightIntensity), "keyRgb");
+			const direct = mul(keyRgb, mul(ndl, lit));
+			const occlusion = local(sub(1, mul(u.ao, sub(1, vox.ao))), "occl");
+			const sky = local(u.ambientColor.member("rgb"), "sky");
+			const ambient = local(mul(mul(mix(mul(sky, GROUND_GAIN), sky, upness), u.ambient), max(occlusion, 0)), "ambient");
+			const view = vox.view;
+			const specRgb = mul(keyRgb, mul(mul(mul(pow(clamp(dot(n, local(normalize(sub(L, view)), "H")), 0, 1), local(exp2(mix(GLOSS_EXP_RANGE[0], GLOSS_EXP_RANGE[1], u.glossiness)), "shininess")), mix(.2, 1.4, u.glossiness)), u.specular), lit));
+			const rimRgb = mul(sky, mul(mul(schlickFresnel(grazingOf(n, view), {
+				r0: .02,
+				gain: mul(u.glossiness, .5)
+			}), mul(u.specular, .5)), max(occlusion, 0)));
+			const seamLine = smoothstep(sub(1, add(SEAM_WIDTH[0], mul(u.seams, SEAM_WIDTH[1]))), 1, vox.edge);
+			const seamShade = sub(1, mul(mul(u.seams, SEAM_DARKEN), seamLine));
+			return vec4(clamp(mul(add(mul(albedo, add(direct, ambient)), add(specRgb, rimRgb)), seamShade), vec3(0, 0, 0), vec3(1, 1, 1)), vox.coverage);
+		}
+	})
+});
+var Voxels_default = componentDefinition;
+export { componentDefinition as n, Voxels_default as t };

package/dist/core/{Water-Dh4UB4UF.js → Water-CoYwvqKx.js}

@@ -1,12 +1,7 @@
-import { at as ZERO, t as defineStd } from "./lower-DtoDQ7hV.js";
-import { t as animatedTime } from "./porters-CQwDd2t4.js";
-import { F as shapedSurface, I as sharpGlint, O as opticalThickness, P as schlickFresnel, R as silhouette, U as surfaceNoiseAt, V as surfaceField, W as surfacePattern, b as keyLightAt, g as guarded, l as fieldSlope, m as grazingFlat, n as beerLambert, u as flowWarp, v as insideShape, w as marchedNormal } from "./materials-BjsiWqS0.js";
-import { k as shapeEffectBoundingBoxDeclaration } from "./sdf3d-BMqCSSPB.js";
-import { a as transformColor, c as transformPosition } from "./transformations-CzFmhZww.js";
-import { B as vec2, C as mix, D as pow, E as normalize, H as vec4, I as splat3, N as sin, O as reflect, P as smoothstep, V as vec3, i as clamp, k as refract, n as add, o as div, s as dot, t as abs, u as float, v as length, w as mul, y as local, z as sub } from "./math-7PlusTFx.js";
-import { n as direction } from "./frames-Clw8-BpA.js";
+import { $r as keyLightAt, Ac as defineStd, Bd as ZERO, Ci as surfaceNoiseAt, Dc as vec3, Ec as vec2, Fr as beerLambert, Gs as clamp, Hr as fieldSlope, Ic as animatedTime, Js as dot, Oc as vec4, Ru as shapeEffectBoundingBoxDeclaration, Sc as splat3, Tc as sub, Ur as flowWarp, Us as abs, Ws as add, Yr as guarded, Zr as insideShape, Zs as float, ac as length, ar as direction, bc as smoothstep, ci as opticalThickness, dc as mul, gc as refract, gi as sharpGlint, hc as reflect, hi as shapedSurface, mc as pow, mi as schlickFresnel, oc as local, pc as normalize, qr as grazingFlat, qs as div, ri as marchedNormal, uc as mix, vi as silhouette, wi as surfacePattern, xi as surfaceField, yc as sin } from "./std-ClftfWpF.js";
+import { a as transformColor, c as transformPosition } from "./transformations-P50Uo_Ju.js";
 var DEFAULT_SHAPE_CONFIG = JSON.stringify({
-	type: "circleSDF",
+	type: "sphere3D",
 	radius: .35
 });
 var waterFbm = (uvE, hint) => {

package/dist/core/{Watercolor-C70_K8Lv.js → Watercolor-DUNjSIN1.js}

@@ -1,7 +1,5 @@
-import { c as p, t as defineStd } from "./lower-DtoDQ7hV.js";
-import { f as wash, s as kuwahara, t as bleedWarp, u as paperGrain } from "./stylize-CiN0ZaMu.js";
-import { a as transformColor } from "./transformations-CzFmhZww.js";
-import { n as crosses } from "./slots-BqIef2iV.js";
+import { Ac as defineStd, J as wash, K as paperGrain, L as bleedWarp, Ml as p, U as kuwahara, ys as crosses } from "./std-ClftfWpF.js";
+import { a as transformColor } from "./transformations-P50Uo_Ju.js";
 var wet = bleedWarp({ amount: p("bleed") });
 const componentDefinition = defineStd({
 	name: "Watercolor",

package/dist/core/{WaveDistortion-BCKxUa-p.js → WaveDistortion-Dp8ws0z1.js}

@@ -1,5 +1,4 @@
-import { c as p, t as defineStd, u as edgesPropConfig } from "./lower-DtoDQ7hV.js";
-import { y as wave } from "./warps-gIr3RmZV.js";
+import { Ac as defineStd, Ml as p, Pl as edgesPropConfig, rr as wave } from "./std-ClftfWpF.js";
 const componentDefinition = defineStd({
 	name: "WaveDistortion",
 	role: "warp",

package/dist/core/{Waveform-BKMFhH8R.js → Waveform-DDBLB6zu.js}

@@ -1,12 +1,5 @@
-import { c as p, o as uniformOf, t as defineStd } from "./lower-DtoDQ7hV.js";
-import { t as animatedTime, vt as colorStopsPropConfig } from "./porters-CQwDd2t4.js";
-import { b as stops } from "./fields-CXwmEUsd.js";
-import { O as waves } from "./noise-G7a5U0ar.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CzFmhZww.js";
-import { C as mix, H as vec4, L as sqrt, P as smoothstep, R as step, T as neg, d as floor, f as fract, i as clamp, n as add, o as div, p as gaussBell, t as abs, w as mul, x as max, y as local, z as sub } from "./math-7PlusTFx.js";
-import { n as crispStroke, t as crispFill } from "./mask-6rnSCir2.js";
-import { f as roundedRect, r as circle } from "./shape-B2CoDi6l.js";
-import { o as segmentFrame, s as surfaceOf } from "./frames-Clw8-BpA.js";
+import { $s as fract, Ac as defineStd, Al as uniformOf, Cc as sqrt, Gs as clamp, Ic as animatedTime, Ml as p, Ms as crispFill, Ns as crispStroke, Oc as vec4, Qs as floor, Tc as sub, Us as abs, Ws as add, bc as smoothstep, cc as max, dc as mul, dr as surfaceOf, ec as gaussBell, fc as neg, fs as roundedRect, oc as local, ou as colorStopsPropConfig, qo as stops, qs as div, rs as circle, sa as waves, uc as mix, ur as segmentFrame, wc as step } from "./std-ClftfWpF.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 var SPECTRUM = [
 	{
 		waves: [{

package/dist/core/{WaveletNoise-CFpncHiR.js → WaveletNoise-CpBkzfRT.js}

@@ -1,7 +1,5 @@
-import { c as p, t as defineStd } from "./lower-DtoDQ7hV.js";
-import { b as stops, f as rampOver } from "./fields-CXwmEUsd.js";
-import { D as waveletBands, E as unitized, m as noiseTone, x as seededPlane } from "./noise-G7a5U0ar.js";
-import { i as noiseToneProps, r as noiseSpeedProp, t as noiseColorProps } from "./noiseColor-_P7nIu_L.js";
+import { Ac as defineStd, Ki as noiseTone, Ml as p, aa as unitized, ea as seededPlane, oa as waveletBands, qo as stops, zo as rampOver } from "./std-ClftfWpF.js";
+import { i as noiseToneProps, r as noiseSpeedProp, t as noiseColorProps } from "./noiseColor-D_bPhJ4m.js";
 const componentDefinition = defineStd({
 	name: "WaveletNoise",
 	role: "generator",

package/dist/core/{Weave-CYgbepeB.js → Weave-cWkvSEAy.js}

@@ -1,6 +1,5 @@
-import { c as p, t as defineStd } from "./lower-DtoDQ7hV.js";
-import { O as weaveThreads, r as cellFrame } from "./patterns-RTt6Fek8.js";
-import { a as transformColor } from "./transformations-CzFmhZww.js";
+import { Ac as defineStd, Ka as cellFrame, Ml as p, yo as weaveThreads } from "./std-ClftfWpF.js";
+import { a as transformColor } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "Weave",
 	role: "generator",

package/dist/core/{WebcamTexture-B0vkMk_l.js → WebcamTexture-D484SXSE.js}

@@ -1,5 +1,4 @@
-import { c as p, f as objectFitProp, t as defineStd } from "./lower-DtoDQ7hV.js";
-import { r as webcamMedia } from "./media-CgWmWvGq.js";
+import { Ac as defineStd, Il as objectFitProp, Ml as p, br as webcamMedia } from "./std-ClftfWpF.js";
 const componentDefinition = defineStd({
 	name: "WebcamTexture",
 	role: "media",

package/dist/core/{Wool-CLkJUMng.js → Wool-C9L7O9fD.js}

@@ -1,6 +1,4 @@
-import { t as defineStd } from "./lower-DtoDQ7hV.js";
-import { p as noiseRelief, v as reliefBases } from "./noise-G7a5U0ar.js";
-import { t as reliefStylizeProps } from "./noiseStylize-CUrW_HiC.js";
+import { Ac as defineStd, Gi as noiseRelief, Zi as reliefBases, c as reliefStylizeProps } from "./std-ClftfWpF.js";
 const componentDefinition = defineStd({
 	name: "Wool",
 	role: "filter",

package/dist/core/{WorleyNoise-BxznxOxV.js → WorleyNoise-B5j5lDQZ.js}

@@ -1,6 +1,5 @@
-import { c as p, t as defineStd } from "./lower-DtoDQ7hV.js";
-import { T as transformWorleyMode, j as worleyNoise, w as transformWorleyDistance } from "./noise-G7a5U0ar.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CzFmhZww.js";
+import { Ac as defineStd, Ml as p, ia as transformWorleyMode, ra as transformWorleyDistance, ua as worleyNoise } from "./std-ClftfWpF.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "WorleyNoise",
 	role: "generator",

package/dist/core/{ZoomBlur-DtujxMsW.js → ZoomBlur-bPC1dBu2.js}

@@ -1,6 +1,5 @@
-import { c as p, t as defineStd } from "./lower-DtoDQ7hV.js";
-import { c as transformPosition } from "./transformations-CzFmhZww.js";
-import { C as motionBlur, i as blurPath } from "./blurs-D5a6ad3o.js";
+import { Ac as defineStd, Kt as blurPath, Ml as p, fn as motionBlur } from "./std-ClftfWpF.js";
+import { c as transformPosition } from "./transformations-P50Uo_Ju.js";
 const componentDefinition = defineStd({
 	name: "ZoomBlur",
 	role: "filter",

package/dist/core/customShaders.d.ts

@@ -0,0 +1,71 @@
+import { GpuShaderDefinition } from './gpu/contract';
+
+/**
+ * Make a user-defined shader findable by its `name`, so preset JSON can reference it as `type: 'Halo'`.
+ *
+ * Returns the definition, so it can wrap `defineShader` inline. Registering the same object
+ * again does nothing. A different definition under a taken name replaces it (live editing,
+ * hot reload) and notifies `onShaderRegistered` listeners. `<CustomShader>` calls this for
+ * you on mount; `createShader(canvas, preset, {components: [Halo]})` is the other way to
+ * make a name resolvable without registering globally.
+ *
+ * @example
+ * ```ts
+ * import {createShader} from 'shaders/js'
+ * import {Halo} from './halo'
+ *
+ * registerShader(Halo)
+ * const shader = await createShader(canvas, {components: [{type: 'Halo', props: {bands: 6}}]})
+ * ```
+ * @see defineShader, unregisterShader, getRegisteredShader, onShaderRegistered
+ */
+export declare function registerShader<T extends GpuShaderDefinition<any>>(definition: T): T;
+/**
+ * Forget a user-defined shader by name.
+ *
+ * Does nothing for a name that was never registered. Listeners from `onShaderRegistered` are
+ * told with a `null` definition.
+ *
+ * @example
+ * ```ts
+ * unregisterShader('Halo')
+ * ```
+ * @see registerShader
+ */
+export declare function unregisterShader(name: string): void;
+/**
+ * Look up a user-defined shader by name.
+ *
+ * Returns `undefined` for unknown names. The library's own shaders are not in this registry.
+ *
+ * @example
+ * ```ts
+ * const definition = getRegisteredShader('Halo')
+ * ```
+ * @see getRegisteredShaders, registerShader
+ */
+export declare function getRegisteredShader(name: string): GpuShaderDefinition | undefined;
+/**
+ * Every user-defined shader currently registered, oldest first.
+ *
+ * @example
+ * ```ts
+ * const names = getRegisteredShaders().map((d) => d.name)
+ * ```
+ * @see getRegisteredShader, onShaderRegistered
+ */
+export declare function getRegisteredShaders(): GpuShaderDefinition[];
+/**
+ * Be told when a user-defined shader is registered, replaced or removed.
+ *
+ * The listener gets the name and the new definition, or `null` on removal. Returns a function
+ * that unsubscribes. Useful for a component picker or a live editor that lists custom shaders.
+ *
+ * @example
+ * ```ts
+ * const stop = onShaderRegistered((name, definition) => refreshPicker())
+ * ```
+ * @see registerShader, getRegisteredShaders
+ */
+export declare function onShaderRegistered(listener: (name: string, definition: GpuShaderDefinition | null) => void): () => void;
+//# sourceMappingURL=customShaders.d.ts.map

package/dist/core/customShaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customShaders.d.ts","sourceRoot":"","sources":["../src/customShaders.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gBAAgB,CAAA;AAKvD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,mBAAmB,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,CAanF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAGnD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAEjF;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,IAAI,mBAAmB,EAAE,CAE5D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,mBAAmB,GAAG,IAAI,KAAK,IAAI,GAAG,MAAM,IAAI,CAKvH"}