shaders 3.1.463 → 3.2.465

package/dist/core/SmokeFlow-Dx6_BTmh.js

@@ -0,0 +1,290 @@
+import { Br as f32, H as decayFadeSeconds, Mr as arrayOf, Nr as struct, Ot as colorMixing_exports, Tr as vec4f, ft as vec4, jr as textureStorage2d, ot as call, rt as ZERO, t as defineStd, zn as typegpu_default } from "./lower-DSk_KxOY.js";
+import { Dt as mixColorStopsRuntime, M as buildStableFluidsKernels, O as buildEmitterSplatKernel, k as buildFluidOutputKernel, vt as colorStopsPropConfig } from "./porters-j4QbEOqj.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-COlfAEsk.js";
+import { n as cursorRibbon, r as fluidSim } from "./fluids-BPs3cdPe.js";
+var N = 256;
+var COUNT = N * N;
+var JACOBI_ITERS = 10;
+var VELOCITY_DISSIPATION = .2;
+var MAX_STEPS = 16;
+var STATE_FORMAT = "rgba16float";
+var cm = colorMixing_exports;
+var FlowParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	dt: f32,
+	emitX: f32,
+	emitY: f32,
+	emitVelX: f32,
+	emitVelY: f32,
+	emitGate: f32,
+	emitRad: f32,
+	emitIntensity: f32,
+	dyeFade: f32,
+	velFade: f32,
+	curlStrength: f32,
+	gravity: f32,
+	colorDecay: f32
+}), "FlowParams");
+var fluidLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
+	velA: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "mutable"
+	},
+	velB: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "mutable"
+	},
+	dyeA: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "mutable"
+	},
+	dyeB: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "mutable"
+	},
+	pressure: {
+		storage: arrayOf(f32, COUNT),
+		access: "mutable"
+	},
+	divergence: {
+		storage: arrayOf(f32, COUNT),
+		access: "mutable"
+	},
+	params: { uniform: FlowParams }
+}), "fluidLayout");
+var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
+	dyeA: {
+		storage: arrayOf(vec4f, COUNT),
+		access: "readonly"
+	},
+	outTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
+}), "outputLayout");
+const splatKernel = buildEmitterSplatKernel(fluidLayout, {
+	n: N,
+	namePrefix: "smokeFlow",
+	cone: false,
+	cursorPush: false,
+	gated: true,
+	densityGain: 10,
+	velocityBlendGain: 4
+});
+var solverKernels = buildStableFluidsKernels(fluidLayout, {
+	n: N,
+	namePrefix: "smokeFlow",
+	boundary: "clamped",
+	dye: "densityAge",
+	dyeDissipation: true,
+	ageAdvance: true
+});
+const { curl: curlKernel, vorticity: vorticityKernel, divergence: divergenceKernel, jacobi: jacobiKernel, gradSubtract: gradSubtractKernel, advectVel: advectVelKernel, copyVel: copyVelKernel, advectDye: advectDensKernel, copyDye: copyDensKernel } = solverKernels;
+const outputKernel = buildFluidOutputKernel(outputLayout, {
+	n: N,
+	namePrefix: "smokeFlow",
+	dye: "densityAge"
+});
+const componentDefinition = defineStd({
+	name: "SmokeFlow",
+	role: "simulation",
+	species: "custom",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Interactive",
+	description: "Cursor-driven smoke that lingers, swirls, and dissipates with fluid dynamics",
+	usesPointer: true,
+	props: {
+		colorA: {
+			default: "#e29c8b",
+			transform: transformColor,
+			description: "Color of fresh smoke",
+			ui: {
+				type: "color",
+				label: "Fresh Color",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#d517f9",
+			transform: transformColor,
+			description: "Color smoke transitions to as it ages",
+			ui: {
+				type: "color",
+				label: "Aged Color",
+				group: "Colors"
+			}
+		},
+		stops: colorStopsPropConfig(),
+		intensity: {
+			default: 1,
+			description: "How much smoke is emitted as you move the cursor",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 2,
+				step: .05,
+				label: "Intensity",
+				group: "Emission"
+			}
+		},
+		emitRadius: {
+			default: .07,
+			description: "Size of smoke puff emitted at cursor",
+			ui: {
+				type: "range",
+				min: .01,
+				max: .3,
+				step: .01,
+				label: "Puff Size",
+				group: "Emission"
+			}
+		},
+		momentum: {
+			default: 20,
+			description: "How much cursor velocity is transferred into the smoke (higher = more directed flow)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 50,
+				step: 1,
+				label: "Momentum",
+				group: "Emission"
+			}
+		},
+		dissipation: {
+			default: .5,
+			description: "How fast smoke fades over time",
+			ui: {
+				type: "range",
+				min: .05,
+				max: 3,
+				step: .05,
+				label: "Dissipation",
+				group: "Effect"
+			}
+		},
+		detail: {
+			default: 10,
+			description: "Fine-scale swirling detail driven by vorticity confinement",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 60,
+				step: 1,
+				label: "Swirl Detail",
+				group: "Effect"
+			}
+		},
+		gravity: {
+			default: 2,
+			description: "Vertical drift — negative floats up, positive sinks down",
+			ui: {
+				type: "range",
+				min: -5,
+				max: 5,
+				step: .05,
+				label: "Gravity",
+				group: "Effect"
+			}
+		},
+		colorDecay: {
+			default: .5,
+			description: "How quickly smoke shifts from fresh to aged color",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 3,
+				step: .1,
+				label: "Color Decay",
+				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"
+			}
+		}
+	},
+	...fluidSim(() => {
+		const speedGateOf = (smoothSpeed) => Math.min(smoothSpeed * smoothSpeed * 60, 1);
+		const strokes = cursorRibbon({
+			tracker: { teleportGuard: Number.POSITIVE_INFINITY },
+			activeWhen: (ptr) => speedGateOf(ptr.smoothSpeed) > .005,
+			fadeSeconds: (f) => decayFadeSeconds(255, f.num("dissipation", .4)),
+			pass: { kernel: splatKernel },
+			ribbon: (f, _ptr, values) => ({
+				stepSize: Math.max(.004, f.num("emitRadius", .07) * .5),
+				maxSteps: MAX_STEPS,
+				write: (emitX, emitY) => f.writeParams({
+					...values,
+					emitX,
+					emitY
+				})
+			})
+		});
+		return {
+			resolution: N,
+			layout: fluidLayout,
+			outputLayout,
+			paramsSchema: FlowParams,
+			solver: {
+				kernels: solverKernels,
+				jacobiIters: JACOBI_ITERS
+			},
+			output: {
+				kernel: outputKernel,
+				key: "smokeTexture"
+			},
+			inject: [strokes],
+			values: (f) => {
+				const ptr = strokes.ptr();
+				const momentumScale = f.num("momentum", 1.2);
+				const speedGate = speedGateOf(ptr.smoothSpeed);
+				const isActive = strokes.active();
+				const emitRadiusUv = f.num("emitRadius", .07);
+				return {
+					dt: f.dt,
+					emitX: ptr.x * N,
+					emitY: ptr.y * N,
+					emitGate: isActive ? speedGate : 0,
+					emitVelX: ptr.smoothVelX * N * momentumScale * .12,
+					emitVelY: ptr.smoothVelY * N * momentumScale * .12,
+					emitRad: emitRadiusUv * N,
+					emitIntensity: f.num("intensity", 1.2),
+					dyeFade: f.num("dissipation", .4),
+					velFade: VELOCITY_DISSIPATION,
+					curlStrength: f.num("detail", 28),
+					gravity: f.num("gravity", -.3),
+					colorDecay: f.num("colorDecay", .5)
+				};
+			}
+		};
+	}),
+	gpu: { fragment: ({ ctx, computeOutputs, propValues, uniforms }) => {
+		const smokeField = computeOutputs?.smokeTexture;
+		if (!smokeField) return ZERO;
+		const s = smokeField.sample(ctx.uv, "linearClamp");
+		const smokeDensity = s.member("x");
+		const smokeAge = s.member("y");
+		const colorSpaceMode = propValues.colorSpace ?? 0;
+		const stopCount = propValues.stopCount ?? 0;
+		let smokeColor;
+		if (stopCount > 1) smokeColor = mixColorStopsRuntime(smokeAge, {
+			colorsArray: uniforms.colorsArray,
+			positionsArray: uniforms.positionsArray,
+			convertedColorsArray: uniforms.convertedColorsArray,
+			stopCount: uniforms.stopCount
+		}, colorSpaceMode);
+		else smokeColor = call(cm.mixColorsVariants[colorSpaceMode] ?? cm.mixColorsLinear, "mixColors", [
+			uniforms.colorA,
+			uniforms.colorB,
+			smokeAge
+		]);
+		return vec4(smokeColor.member("rgb"), smokeColor.member("a").mul(smokeDensity));
+	} }
+});
+var SmokeFlow_default = componentDefinition;
+export { copyDensKernel as a, divergenceKernel as c, outputKernel as d, splatKernel as f, componentDefinition as i, gradSubtractKernel as l, advectDensKernel as n, copyVelKernel as o, vorticityKernel as p, advectVelKernel as r, curlKernel as s, SmokeFlow_default as t, jacobiKernel as u };

package/dist/core/Solarize-CjleKYpq.js

@@ -0,0 +1,46 @@
+import { c as p, t as defineStd } from "./lower-DSk_KxOY.js";
+import { p as solarize } from "./color-dbYyVLqf.js";
+import { i as isZero, n as crosses } from "./slots-BuIG6s6W.js";
+const componentDefinition = defineStd({
+	name: "Solarize",
+	role: "filter",
+	species: "pointwise",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Adjustments",
+	description: "Inverts tones above a luminance threshold — a classic darkroom and photo effect",
+	props: {
+		threshold: {
+			default: .5,
+			description: "Luminance level above which colors are inverted. Pixels brighter than this threshold get flipped.",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Threshold",
+				group: "Effect"
+			}
+		},
+		strength: {
+			default: 1,
+			description: "Blend between original (0) and fully solarized (1)",
+			recompile: crosses(0),
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Strength",
+				group: "Effect"
+			}
+		}
+	},
+	effect: solarize({
+		threshold: p("threshold"),
+		strength: p("strength")
+	}),
+	identityWhen: isZero("strength"),
+	missingChildMessage: "You must pass a child component into the Solarize shader."
+});
+var Solarize_default = componentDefinition;
+export { componentDefinition as n, Solarize_default as t };

package/dist/core/{SolidColor-Bp_KSGbp.js → SolidColor-BgxBiv00.js}

@@ -1,6 +1,9 @@
-import { a as transformColor } from "./transformations-u-UZrXjj.js";
-const componentDefinition = {
+import { c as p, t as defineStd } from "./lower-DSk_KxOY.js";
+import { a as transformColor } from "./transformations-COlfAEsk.js";
+import { a as solidColor } from "./gradients-DT6nJTmW.js";
+const componentDefinition = defineStd({
 	name: "SolidColor",
+	role: "generator",
 	boundingBoxDeclaration: { aspectRatio: null },
 	category: "Textures",
 	description: "Fill the canvas with a single solid color",
@@ -15,7 +18,7 @@ const componentDefinition = {
 			group: "Colors"
 		}
 	} },
-	fragment: ({ uniforms }) => uniforms.color
-};
+	paint: solidColor(p("color"))
+});
 var SolidColor_default = componentDefinition;
 export { componentDefinition as n, SolidColor_default as t };

package/dist/core/Spherize-B8aaXFYF.js

@@ -0,0 +1,110 @@
+import { c as p, t as defineStd } from "./lower-DSk_KxOY.js";
+import { a as transformColor, c as transformPosition } from "./transformations-COlfAEsk.js";
+import { F as rimLit, U as sphereFrame, u as crispTap, v as gatherStack } from "./blurs-D1HfQTGP.js";
+var sphere = sphereFrame({
+	center: p("center"),
+	radius: p("radius"),
+	depth: p("depth")
+});
+const componentDefinition = defineStd({
+	name: "Spherize",
+	role: "filter",
+	species: "gather",
+	category: "Distortions",
+	description: "Map content onto a 3D sphere surface with depth distortion",
+	boundingBoxDeclaration: { aspectRatio: null },
+	props: {
+		radius: {
+			default: 1,
+			description: "Radius of the sphere (1 = half viewport height)",
+			ui: {
+				type: ["range", "map"],
+				min: .1,
+				max: 3,
+				step: .1,
+				label: "Radius",
+				group: "Effect"
+			}
+		},
+		depth: {
+			default: 1,
+			description: "How much the sphere bulges toward viewer (0 = flat, higher = more bulge)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 3,
+				step: .1,
+				label: "Depth",
+				group: "Effect"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "The center point of the sphere",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position"
+			}
+		},
+		lightPosition: {
+			default: {
+				x: .3,
+				y: .3
+			},
+			transform: transformPosition,
+			description: "Position of the specular light source",
+			ui: {
+				type: "position",
+				label: "Light Position",
+				group: "Position"
+			}
+		},
+		lightIntensity: {
+			default: .5,
+			description: "Intensity of the rim light (0 = off)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .1,
+				label: "Light Intensity",
+				group: "Effect"
+			}
+		},
+		lightSoftness: {
+			default: .5,
+			description: "Softness of the rim light falloff (0 = hard edge, 1 = soft glow)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .1,
+				label: "Light Softness",
+				group: "Effect"
+			}
+		},
+		lightColor: {
+			default: "#ffffff",
+			transform: transformColor,
+			description: "Color of the specular highlight",
+			ui: {
+				type: "color",
+				label: "Light Color",
+				group: "Effect"
+			}
+		}
+	},
+	effect: gatherStack(crispTap(sphere), [rimLit(sphere, {
+		position: p("lightPosition"),
+		intensity: p("lightIntensity"),
+		softness: p("lightSoftness"),
+		color: p("lightColor")
+	})], { resultAlpha: "straight" })
+});
+var Spherize_default = componentDefinition;
+export { componentDefinition as n, Spherize_default as t };

package/dist/core/Spiral-CMHZAfrE.js

@@ -0,0 +1,131 @@
+import { c as p, t as defineStd } from "./lower-DSk_KxOY.js";
+import { f as rampOver, l as pair, r as dist } from "./fields-Cv-wBDLP.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-COlfAEsk.js";
+const componentDefinition = defineStd({
+	name: "Spiral",
+	role: "generator",
+	boundingBoxDeclaration: {
+		aspectRatio: null,
+		supportsResizeFit: true
+	},
+	category: "Textures",
+	description: "Rotating spiral pattern with animated movement",
+	acceptsUVContext: true,
+	animatedTime: { speed: "speed" },
+	props: {
+		colorA: {
+			default: "#000000",
+			transform: transformColor,
+			description: "Background color",
+			ui: {
+				type: "color",
+				label: "Color A",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#ffffff",
+			transform: transformColor,
+			description: "Spiral stroke color",
+			ui: {
+				type: "color",
+				label: "Color B",
+				group: "Colors"
+			}
+		},
+		strokeWidth: {
+			default: .5,
+			description: "Thickness of spiral stroke",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 2,
+				step: .1,
+				label: "Stroke Width",
+				group: "Effect"
+			}
+		},
+		strokeFalloff: {
+			default: 0,
+			description: "Stroke losing width further from center",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .1,
+				label: "Stroke Falloff",
+				group: "Effect"
+			}
+		},
+		softness: {
+			default: 0,
+			description: "Color transition sharpness (0 = hard edge, 1 = smooth fade)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .1,
+				label: "Softness",
+				group: "Effect"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "Animation speed (negative values reverse direction)",
+			ui: {
+				type: "range",
+				min: -3,
+				max: 3,
+				step: .1,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "The center point of the spiral",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position"
+			}
+		},
+		scale: {
+			default: 1,
+			description: "Scale factor for spiral bands (higher = more bands, lower = fewer bands)",
+			ui: {
+				type: ["range", "map"],
+				min: .1,
+				max: 5,
+				step: .1,
+				label: "Scale",
+				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: rampOver(dist.spiral({
+		center: p("center"),
+		scale: p("scale"),
+		width: p("strokeWidth"),
+		falloff: p("strokeFalloff"),
+		softness: p("softness")
+	}), pair(p("colorA"), p("colorB"), p("colorSpace")))
+});
+var Spiral_default = componentDefinition;
+export { componentDefinition as n, Spiral_default as t };

package/dist/core/Star-CCs7sc0U.js

@@ -0,0 +1,56 @@
+import { t as defineStd } from "./lower-DSk_KxOY.js";
+import { p as star } from "./shape-Dfa7_eQh.js";
+const componentDefinition = defineStd({
+	role: "shape",
+	name: "Star",
+	description: "Classic star polygon with straight sides and sharp pointed tips",
+	shape: {
+		distance: ({ x, y }, u) => star(x, y, u("radius"), u("sides"), u("innerRatio")),
+		colorDescription: "Fill color of the star",
+		centerDescription: "Center position of the star",
+		bounds: { size: {
+			width: "radius",
+			height: "radius"
+		} },
+		shapeProps: {
+			radius: {
+				default: .4,
+				description: "Outer tip radius — distance from center to the pointed tips",
+				ui: {
+					type: "range",
+					min: 0,
+					max: 1,
+					step: .01,
+					label: "Radius",
+					group: "Shape"
+				}
+			},
+			sides: {
+				default: 5,
+				description: "Number of points on the star",
+				ui: {
+					type: "range",
+					min: 3,
+					max: 12,
+					step: 1,
+					label: "Points",
+					group: "Shape"
+				}
+			},
+			innerRatio: {
+				default: .4,
+				description: "Inner vertex radius as a ratio of outer radius (0.382 = golden-ratio 5-star)",
+				ui: {
+					type: "range",
+					min: .1,
+					max: .9,
+					step: .01,
+					label: "Inner Ratio",
+					group: "Shape"
+				}
+			}
+		}
+	}
+});
+var Star_default = componentDefinition;
+export { componentDefinition as n, Star_default as t };

package/dist/core/{Stone-B5syMjia.js → Stone-DGW4Z0fk.js}

@@ -1,7 +1,10 @@
-import { v as stone12 } from "./noise-eXd1Bfrw.js";
-import { n as applyNoiseReliefExpr, t as reliefStylizeProps } from "./noiseStylize-CZRUH_jm.js";
-const componentDefinition = {
+import { t as defineStd } from "./lower-DSk_KxOY.js";
+import { p as noiseRelief, v as reliefBases } from "./noise-DrbAbu3H.js";
+import { t as reliefStylizeProps } from "./noiseStylize-BfLjdB5R.js";
+const componentDefinition = defineStd({
 	name: "Stone",
+	role: "filter",
+	species: "custom",
 	boundingBoxDeclaration: { aspectRatio: null },
 	category: "Stylize",
 	description: "Applies a marbled stone relief and surface distortion to child content",
@@ -13,7 +16,7 @@ const componentDefinition = {
 		contrast: 0,
 		distortion: .15
 	}),
-	fragment: (params) => applyNoiseReliefExpr(params, stone12, "stone12")
-};
+	gpu: { fragment: noiseRelief(reliefBases.stone) }
+});
 var Stone_default = componentDefinition;
 export { componentDefinition as n, Stone_default as t };