shaders 3.1.462 → 3.2.464

package/dist/core/Hologram-DE3lGk0F.js

@@ -0,0 +1,334 @@
+import { nt as ZERO, t as defineStd, un as TWO_PI$1 } from "./lower-z2vuXP8M.js";
+import { t as animatedTime } from "./porters-B1UjrM1y.js";
+import { R as surfaceNoise, _ as insideShape, g as hashNoise, h as guarded, j as shapedSurface } 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, c as exp, d as fract, i as clamp, j as sub, k as splat3, l as float, n as add, o as div, t as abs, v as max, w as pow, x as mul, y as min } from "./math-BF-GBlb4.js";
+var DEFAULT_SHAPE_CONFIG = JSON.stringify({
+	type: "circleSDF",
+	radius: .35
+});
+var TWO_PI = TWO_PI$1;
+const componentDefinition = defineStd({
+	name: "Hologram",
+	role: "shapeEffect",
+	species: "custom",
+	boundingBoxDeclaration: shapeEffectBoundingBoxDeclaration,
+	category: "Shape Effects",
+	description: "Volumetric sci-fi hologram — a translucent emissive projection of the shape with fresnel-lit edges, depth scan-lines that wrap 3D forms, CRT scanlines, flicker and beam wobble",
+	animatedTime: { speed: "speed" },
+	...shapedSurface({
+		chord: "firstLobe",
+		stencil: {
+			kind: "central",
+			eps: .008
+		},
+		placeUV: (params) => {
+			const { uniforms: u, ctx } = params;
+			const t = animatedTime(params);
+			const uvY = ctx.uv.member("y");
+			const wob = add(mul(sin(add(mul(uvY, 38), mul(t, 2.3))), .5), mul(sin(sub(mul(uvY, 11.5), mul(t, 1.7))), .5));
+			return vec2(add(ctx.uv.member("x"), mul(mul(wob, u.distortion), .012)), uvY);
+		},
+		surface: (frame, params) => {
+			const { uniforms: u, ctx } = params;
+			const t = local(animatedTime(params), "animTime");
+			const vol = frame.volumetric;
+			const EPS = .008;
+			const sC = local(frame.surf0, "sC");
+			const pxH = local(div(1, ctx.viewportSize.member("y")), "pxH");
+			const sdf = local(div(sC.member("x"), u.scale), "sdf");
+			const sR = local(frame.surfX, "sR");
+			const sL = local(frame.surfL, "sL");
+			const sU = local(frame.surfY, "sU");
+			const sD = local(frame.surfD, "sD");
+			const sharp = max(mul(u.edgeSoftness, .5), .001);
+			const gradX = local(div(sub(sR.member("x"), sL.member("x")), EPS * 2), "gradX");
+			const thickness = local(max(mul(sdf, -1), 0), "thickness");
+			const thin = local(exp(mul(thickness, -5.5)), "thin");
+			let rimBase;
+			let depthMetric;
+			if (vol) {
+				const surfFres = pow(clamp(sub(1, abs(local(normalize(vec3(clamp(div(sub(sR.member("w"), sL.member("w")), EPS * 2), -2, 2), clamp(div(sub(sU.member("w"), sD.member("w")), EPS * 2), -2, 2), -1)), "nrm").member("z"))), 0, 1), 2.2);
+				rimBase = add(mul(thin, .55), surfFres);
+				depthMetric = sC.member("w");
+			} else {
+				rimBase = thin;
+				depthMetric = thickness;
+			}
+			const rim = local(mul(rimBase, u.edgeGlow), "rim");
+			const bodyFill = mul(sub(1, exp(mul(thickness, -5))), u.fill);
+			const f = local(fract(sub(mul(depthMetric, u.depthScale), mul(t, 1.2))), "phaseFract");
+			const contour = mul(smoothstep(.06, 0, min(f, sub(1, f))), u.depthLines);
+			const scan = add(mul(sin(mul(sub(mul(ctx.uv.member("y"), u.scanlineScale), mul(t, mul(u.scanlineSpeed, 3))), TWO_PI)), .5), .5);
+			const scanMask = local(mix(float(1), scan, u.scanlines), "scanMask");
+			const sweepPos = fract(mul(t, .16));
+			const sweepD = local(sub(ctx.uv.member("y"), sweepPos), "sweepD");
+			const sweepGlow = local(mul(exp(mul(mul(sweepD, sweepD), -650)), u.sweep), "sweepGlow");
+			const shimmer = add(mul(sin(mul(t, 40)), .04), mul(sin(mul(t, 23.3)), .03));
+			const drop = smoothstep(.6, .95, add(mul(surfaceNoise(mul(t, 6), 11), .5), .5));
+			const flick = mul(add(1, shimmer), sub(1, mul(mul(u.flicker, drop), .7)));
+			const grainMul = add(1, mul(mul(sub(hashNoise(add(mul(ctx.uv.member("x"), ctx.viewportSize.member("x")), mul(t, 57.3)), mul(ctx.uv.member("y"), ctx.viewportSize.member("y"))), .5), u.grain), .6));
+			const core = local(mul(add(mul(mul(mul(add(add(bodyFill, rim), contour), scanMask), flick), grainMul), mul(sweepGlow, scanMask)), u.brightness), "core");
+			const ca = add(mul(u.distortion, .12), .04);
+			const fringe = local(mul(mul(mul(rim, gradX), ca), .1), "fringe");
+			const rCore = add(core, fringe);
+			const bCore = sub(core, fringe);
+			const color = u.color.member("rgb");
+			const rgb = vec3(mul(color.member("x"), rCore), mul(color.member("y"), core), mul(color.member("z"), bCore));
+			const hot = clamp(add(mul(rim, .5), sweepGlow), 0, .8);
+			const hotRgb = local(mix(rgb, splat3(core), splat3(hot)), "hotRgb");
+			const transition = smoothstep(0, 1, clamp(mul(div(mul(sdf, -1), sharp), 32), 0, 1));
+			const alpha = mul(clamp(core, 0, 1), transition);
+			return guarded(insideShape(sdf, pxH), vec4(hotRgb, alpha), ZERO, "hologram");
+		}
+	}),
+	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 hologram shape",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position",
+				units: ["%", "px"]
+			}
+		},
+		scale: {
+			default: 1,
+			description: "Scale of the hologram shape (1 = default size)",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 3,
+				step: .01,
+				label: "Scale",
+				group: "Position"
+			}
+		},
+		rotation: {
+			default: 0,
+			description: "Rotation of the hologram shape in degrees",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Rotation",
+				group: "Position"
+			}
+		},
+		color: {
+			default: "#5ec8ff",
+			transform: transformColor,
+			description: "Projection tint — the colour the whole hologram emits (classic sci-fi cyan by default)",
+			ui: {
+				type: "color",
+				label: "Color",
+				group: "Style"
+			}
+		},
+		brightness: {
+			default: 2.5,
+			description: "Overall emission gain. Bright edges blow out toward white for a hot, projected look.",
+			ui: {
+				type: "range",
+				min: .2,
+				max: 3,
+				step: .01,
+				label: "Brightness",
+				group: "Style"
+			}
+		},
+		edgeSoftness: {
+			default: .04,
+			description: "Softness of the shape boundary edge — keep low for crisp projection edges",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Edge Softness",
+				group: "Style"
+			}
+		},
+		fill: {
+			default: .45,
+			description: "Translucent interior glow. Driven by optical thickness, so thicker parts of a 3D form glow more — the core volumetric cue.",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Volume Fill",
+				group: "Volume"
+			}
+		},
+		edgeGlow: {
+			default: 1,
+			description: "Fresnel rim intensity — bright glowing silhouette and, on 3D shapes, the grazing internal walls of extruded logos",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2.5,
+				step: .01,
+				label: "Edge Glow",
+				group: "Volume"
+			}
+		},
+		depthLines: {
+			default: .5,
+			description: "Iso-depth scan-lines that hug the surface and reveal the 3D form like a volumetric scan. On flat shapes they become concentric contour rings.",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Depth Lines",
+				group: "Volume"
+			}
+		},
+		depthScale: {
+			default: 26,
+			description: "Density of the depth scan-lines — higher packs more contour bands through the volume",
+			ui: {
+				type: "range",
+				min: 4,
+				max: 70,
+				step: 1,
+				label: "Depth Density",
+				group: "Volume"
+			}
+		},
+		scanlines: {
+			default: .55,
+			description: "CRT scanline contrast — how dark the gaps between horizontal projection lines get",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Scanlines",
+				group: "Scanlines"
+			}
+		},
+		scanlineScale: {
+			default: 130,
+			description: "Number of horizontal scanlines across the canvas height",
+			ui: {
+				type: "range",
+				min: 20,
+				max: 400,
+				step: 1,
+				label: "Scanline Count",
+				group: "Scanlines"
+			}
+		},
+		scanlineSpeed: {
+			default: 1,
+			description: "How fast the scanlines drift upward — 0 holds them static",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 5,
+				step: .01,
+				label: "Scanline Drift",
+				group: "Scanlines"
+			}
+		},
+		sweep: {
+			default: .1,
+			description: "Brightness of the refresh bar that sweeps vertically through the projection",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Sweep Bar",
+				group: "Scanlines"
+			}
+		},
+		flicker: {
+			default: .3,
+			description: "Unstable-projector flicker — a fast shimmer plus occasional brightness dropouts",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Flicker",
+				group: "Interference"
+			}
+		},
+		distortion: {
+			default: .1,
+			description: "Continuous horizontal wobble and chromatic edge fringing — the wavering of an unstable beam",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Distortion",
+				group: "Interference"
+			}
+		},
+		grain: {
+			default: .7,
+			description: "Fine projection static — animated per-pixel noise over the emission",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Grain",
+				group: "Interference"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "Master animation speed for every animated layer. 0 freezes the projection.",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 3,
+				step: .01,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		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 — when non-empty, activates SVG mode and triggers a shader recompile"
+		},
+		shapeType: {
+			default: "",
+			compileTime: true,
+			description: "Active SDF shape type — triggers recompile when shape is switched. When empty, derived from shape JSON at mount time."
+		}
+	}
+});
+var Hologram_default = componentDefinition;
+export { componentDefinition as n, Hologram_default as t };

package/dist/core/Holographic-DJqswtrS.js

@@ -0,0 +1,279 @@
+import { nt as ZERO, t as defineStd } from "./lower-z2vuXP8M.js";
+import { t as animatedTime } from "./porters-B1UjrM1y.js";
+import { B as surfacePattern, L as surfaceField, P as silhouette, R as surfaceNoise, _ as insideShape, c as fieldSlope, h as guarded, i as cosineRainbow, j as shapedSurface } from "./materials-D7QX3H4h.js";
+import { v as shapeEffectBoundingBoxDeclaration } from "./sdf3d-BD5m6HR6.js";
+import { c as transformPosition } from "./transformations-CoIwF5JU.js";
+import { C as normalize, D as smoothstep, E as sin, N as vec3, P as vec4, _ as local, b as mix, i as clamp, j as sub, k as splat3, l as float, n as add, o as div, s as dot, w as pow, x as mul } from "./math-BF-GBlb4.js";
+var DEFAULT_SHAPE_CONFIG = JSON.stringify({
+	type: "circleSDF",
+	radius: .35
+});
+var THIRD = 1 / 3;
+var TWOTHIRD = 2 / 3;
+var LIGHT_X = Math.cos(300 * Math.PI / 180);
+var LIGHT_Y = Math.sin(300 * Math.PI / 180);
+var L_X = .37164708971977234;
+var L_Y = -.6437116265296936;
+var L_Z = -.6689647436141968;
+var holoRainbow = (t) => cosineRainbow(t, [
+	0,
+	THIRD,
+	TWOTHIRD
+]);
+const componentDefinition = defineStd({
+	name: "Holographic",
+	role: "shapeEffect",
+	species: "custom",
+	boundingBoxDeclaration: shapeEffectBoundingBoxDeclaration,
+	category: "Shape Effects",
+	description: "Iridescent holographic foil sticker with animated rainbow sheen and glitter flakes",
+	animatedTime: { speed: "speed" },
+	...shapedSurface({
+		pattern: "raw",
+		stencil: {
+			kind: "forward",
+			eps: .008
+		},
+		surface: (frame, params) => {
+			const { uniforms: u } = params;
+			const t = local(animatedTime(params), "animTime");
+			const vol = frame.volumetric;
+			const EPS = .008;
+			const field = surfaceField(frame, params, { scale: u.scale });
+			const { s0, sX, sY, sdf, pxH } = field;
+			const transition = silhouette(field, u.edgeSoftness);
+			const suv = local(frame.sdfUV, "suv");
+			const pat = surfacePattern(frame, field, { uv: suv });
+			const pdx = pat.member("x");
+			const pdy = pat.member("y");
+			const qdx = sub(suv.member("x"), .5);
+			const qdy = sub(suv.member("y"), .5);
+			let baseNx;
+			let baseNy;
+			let steepAtten;
+			if (vol) {
+				const bx = local(clamp(div(sub(sX.member("w"), s0.member("w")), EPS), -1.5, 1.5), "baseNxVol");
+				const by = local(clamp(div(sub(sY.member("w"), s0.member("w")), EPS), -1.5, 1.5), "baseNyVol");
+				baseNx = bx;
+				baseNy = by;
+				steepAtten = local(div(1, add(1, mul(clamp(add(mul(bx, bx), mul(by, by)), 0, 2), 2))), "steepAtten");
+			} else {
+				const grad = fieldSlope(field, EPS);
+				const domeSlope = local(mul(sub(1, clamp(div(mul(sdf, -1), .06), 0, 1)), .35), "domeSlope");
+				baseNx = local(mul(grad.member("x"), domeSlope), "baseNx");
+				baseNy = local(mul(grad.member("y"), domeSlope), "baseNy");
+				steepAtten = float(1);
+			}
+			const crScale = local(mul(u.crinkleScale, 1.35), "crScale");
+			const crAmp = local(mul(mul(u.crinkle, .8), steepAtten), "crAmp");
+			const neps = .02;
+			const w0 = local(surfaceNoise(add(mul(pdx, crScale), 2.7), add(mul(pdy, crScale), 11.3)), "w0");
+			const wx = div(sub(surfaceNoise(add(mul(add(pdx, neps), crScale), 2.7), add(mul(pdy, crScale), 11.3)), w0), neps);
+			const wy = div(sub(surfaceNoise(add(mul(pdx, crScale), 2.7), add(mul(add(pdy, neps), crScale), 11.3)), w0), neps);
+			const n = local(normalize(vec3(add(baseNx, mul(mul(wx, crAmp), .4)), add(baseNy, mul(mul(wy, crAmp), .4)), -1)), "n");
+			const fScale = local(mul(u.foilScale, 2.2), "fScale");
+			const drift = local(mul(t, .06), "drift");
+			const blotch = add(surfaceNoise(add(mul(pdx, fScale), mul(drift, LIGHT_X)), add(mul(pdy, fScale), mul(drift, LIGHT_Y))), mul(surfaceNoise(sub(add(mul(mul(pdx, fScale), 2.1), 5.2), mul(mul(drift, LIGHT_X), 1.6)), sub(add(mul(mul(pdy, fScale), 2.1), 9.4), mul(mul(drift, LIGHT_Y), 1.6))), .4));
+			const normalTilt = add(mul(n.member("x"), LIGHT_X), mul(n.member("y"), LIGHT_Y));
+			const ramp = mul(add(mul(pdx, LIGHT_X), mul(pdy, LIGHT_Y)), .8);
+			const hue = local(add(add(add(add(mul(blotch, .45), ramp), mul(normalTilt, 1.4)), mul(t, .18)), div(u.hueShift, 360)), "hue");
+			const saturationC = clamp(u.saturation, 0, 1);
+			const spectral = holoRainbow(hue);
+			const foilTint = local(mix(vec3(.72, .73, .76), spectral, splat3(mul(saturationC, .85))), "foilTint");
+			const roughnessC = local(clamp(u.roughness, 0, 1), "roughnessC");
+			const L = local(vec3(L_X, L_Y, L_Z), "L");
+			const H = local(normalize(add(L, vec3(0, 0, -1))), "H");
+			const ndl = local(clamp(add(mul(dot(n, L), .5), .5), 0, 1), "ndl");
+			const ndh = local(clamp(dot(n, H), 0, 1), "ndh");
+			const sheen = mul(mul(pow(ndh, 7), .45), sub(1, mul(roughnessC, .35)));
+			const specCore = mul(mul(pow(ndh, mix(float(42), float(12), roughnessC)), .85), sub(1, mul(roughnessC, .55)));
+			const specRgb = add(mul(foilTint, sheen), mul(mix(foilTint, vec3(1, 1, 1), splat3(.6)), specCore));
+			const flakeN = surfaceNoise(mul(pdx, 190), mul(pdy, 190));
+			const flakePhase = local(surfaceNoise(add(mul(pdx, 190), 47.3), sub(mul(pdy, 190), 31.1)), "flakePhase");
+			const twinkle = local(add(mul(sin(add(mul(t, 2.2), mul(flakePhase, 12.6))), .5), .5), "twinkle");
+			const flakeMask = mul(mul(smoothstep(.52, .62, add(mul(flakeN, .75), mul(twinkle, .3))), clamp(u.sparkle, 0, 1)), steepAtten);
+			const flakeRgb = mul(mul(holoRainbow(add(add(hue, .33), mul(flakePhase, .5))), add(.85, mul(twinkle, .55))), add(mul(ndl, .6), .7));
+			const grainMul = add(1, mul(mul(surfaceNoise(mul(qdx, 420), mul(qdy, 420)), roughnessC), .28));
+			const foilRgb = local(mul(mix(add(mul(foilTint, add(mul(ndl, .5), .62)), specRgb), flakeRgb, splat3(flakeMask)), grainMul), "foilRgb");
+			return guarded(insideShape(sdf, pxH), vec4(foilRgb, transition), ZERO, "holo");
+		}
+	}),
+	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 foil shape",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position",
+				units: ["%", "px"]
+			}
+		},
+		scale: {
+			default: 1,
+			description: "Scale of the foil shape (1 = default size)",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 3,
+				step: .01,
+				label: "Scale",
+				group: "Position"
+			}
+		},
+		rotation: {
+			default: 0,
+			description: "Rotation of the foil shape in degrees",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Rotation",
+				group: "Position"
+			}
+		},
+		hueShift: {
+			default: 0,
+			description: "Rotates the rainbow spectrum across the foil",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Hue Shift",
+				group: "Foil"
+			}
+		},
+		foilScale: {
+			default: 1.5,
+			description: "Size of the iridescent color patches — higher = smaller, busier patches",
+			ui: {
+				type: "range",
+				min: .3,
+				max: 6,
+				step: .01,
+				label: "Foil Scale",
+				group: "Foil"
+			}
+		},
+		saturation: {
+			default: .75,
+			description: "Rainbow saturation — 0 = plain silver foil, 1 = fully spectral",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Saturation",
+				group: "Foil"
+			}
+		},
+		roughness: {
+			default: .25,
+			description: "Matte laminate grain — softens the gloss with fine paper-like noise",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Roughness",
+				group: "Foil"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "Animation speed — the spectrum drifts across the foil as if the sticker is tilting in your hand. 0 pauses.",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		crinkle: {
+			default: .5,
+			description: "Laminate wrinkles — perturbs the surface so the sheen and rainbow swirl locally instead of lying flat",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Crinkle",
+				group: "Foil"
+			}
+		},
+		crinkleScale: {
+			default: 1,
+			description: "Size of the laminate wrinkles — higher = smaller, denser wrinkles",
+			ui: {
+				type: "range",
+				min: .3,
+				max: 6,
+				step: .01,
+				label: "Crinkle Scale",
+				group: "Foil"
+			}
+		},
+		sparkle: {
+			default: .4,
+			description: "Glitter flakes embedded in the foil — tiny facets that refract a shifted hue and twinkle as the spectrum drifts",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Sparkle",
+				group: "Foil"
+			}
+		},
+		edgeSoftness: {
+			default: .05,
+			description: "Softness of the shape boundary edge",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Edge Softness",
+				group: "Foil"
+			}
+		},
+		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"
+		}
+	}
+});
+var Holographic_default = componentDefinition;
+export { componentDefinition as n, Holographic_default as t };

package/dist/core/HueShift-BfopB_hn.js

@@ -0,0 +1,29 @@
+import { s as p, t as defineStd } from "./lower-z2vuXP8M.js";
+import { s as hueRotate } from "./color-C9iR6boM.js";
+import { i as isZero, n as crosses } from "./slots-BqeQDVxy.js";
+const componentDefinition = defineStd({
+	name: "HueShift",
+	role: "filter",
+	species: "pointwise",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Adjustments",
+	description: "Rotate hue around the color wheel",
+	props: { shift: {
+		default: 0,
+		description: "The amount to shift the hue by",
+		recompile: crosses(0),
+		ui: {
+			type: ["range", "map"],
+			min: -180,
+			max: 180,
+			step: 1,
+			label: "Shift",
+			group: "Adjustments"
+		}
+	} },
+	effect: hueRotate(p("shift")),
+	identityWhen: isZero("shift"),
+	missingChildMessage: "You must pass a child component into the Hue Shift shader."
+});
+var HueShift_default = componentDefinition;
+export { componentDefinition as n, HueShift_default as t };

package/dist/core/ImageTexture-B5gNePC8.js

@@ -0,0 +1,39 @@
+import { d as objectFitProp, s as p, t as defineStd } from "./lower-z2vuXP8M.js";
+import { t as imageMedia } from "./media-By6o6a83.js";
+const componentDefinition = defineStd({
+	name: "ImageTexture",
+	role: "media",
+	species: "custom",
+	boundingBoxDeclaration: {
+		aspectRatio: null,
+		supportsResizeFit: true
+	},
+	category: "Textures",
+	description: "Display an image with customizable object-fit modes",
+	acceptsUVContext: true,
+	naturalSizeKey: { fromProp: "url" },
+	props: {
+		url: {
+			default: "https://shaders.com/sample.jpg",
+			description: "Upload an image or provide a URL",
+			ui: {
+				type: "image-upload",
+				label: "Image",
+				group: "Media"
+			}
+		},
+		objectFit: objectFitProp("fill", "How the image should be sized within the viewport", { allowNone: false })
+	},
+	...imageMedia({
+		src: p("url"),
+		fit: p("objectFit"),
+		decode: "srgb-linear-alpha-cut",
+		label: "ImageTexture",
+		onError(error, url) {
+			const isRelative = !url.startsWith("http://") && !url.startsWith("https://") && !url.startsWith("data:");
+			console.error(`[ImageTexture] Failed to load image\n  Requested URL: ${url}\n  Path type: ${isRelative ? "relative" : "absolute"}\n  Error:`, error);
+		}
+	})
+});
+var ImageTexture_default = componentDefinition;
+export { componentDefinition as n, ImageTexture_default as t };