shaders 2.2.23 → 2.2.25

package/dist/core/RadialGradient-B7ZZB_VJ.js

@@ -0,0 +1,71 @@
+import { i as transformColorSpace, o as transformPosition, r as transformColor, t as colorSpaceOptions } from "./transformations-DxfQXZWi.js";
+import { t as mixColors } from "./colorMixing-BXiTAqJU.js";
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "RadialGradient",
+	category: "Base Layers",
+	description: "Radial gradient radiating from a center point",
+	acceptsUVContext: true,
+	props: {
+		colorA: {
+			default: "#ff0000",
+			transform: transformColor,
+			description: "The starting color at the center of the gradient",
+			ui: {
+				type: "color",
+				label: "Color A"
+			}
+		},
+		colorB: {
+			default: "#0000ff",
+			transform: transformColor,
+			description: "The ending color at the edge of the gradient",
+			ui: {
+				type: "color",
+				label: "Color B"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "The center point of the radial gradient",
+			ui: {
+				type: "position",
+				label: "Center"
+			}
+		},
+		radius: {
+			default: 1,
+			description: "The radius of the gradient (normalized, 0.0-1.0)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Radius"
+			}
+		},
+		colorSpace: {
+			default: "linear",
+			transform: transformColorSpace,
+			description: "Color space for color interpolation",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, uvContext }) => {
+		const { vec2: vec2$1, float: float$1, distance, screenUV: screenUV$1, viewportSize: viewportSize$1 } = TSL;
+		const uv = uvContext ?? screenUV$1;
+		const aspect = viewportSize$1.x.div(viewportSize$1.y);
+		const t = distance(vec2$1(uv.x.mul(aspect), uv.y), vec2$1(uniforms.center.uniform.x.mul(aspect), uniforms.center.uniform.y.oneMinus())).div(uniforms.radius.uniform).clamp(float$1(0), float$1(1));
+		return mixColors(uniforms.colorA.uniform, uniforms.colorB.uniform, t, uniforms.colorSpace.uniform);
+	}
+};
+var RadialGradient_default = componentDefinition;
+export { componentDefinition as n, RadialGradient_default as t };

package/dist/core/RectangularCoordinates-muWR8mZS.js

@@ -0,0 +1,101 @@
+import { t as applyEdgeHandling } from "./edges-Bn_OIa_h.js";
+import { a as transformEdges, o as transformPosition } from "./transformations-DxfQXZWi.js";
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "RectangularCoordinates",
+	category: "Distortions",
+	description: "Convert polar coordinates back to rectangular space",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "The center point for rectangular coordinate conversion",
+			ui: {
+				type: "position",
+				label: "Center"
+			}
+		},
+		scale: {
+			default: 1,
+			description: "Scale factor for the rectangular output",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 3,
+				step: .01,
+				label: "Scale"
+			}
+		},
+		intensity: {
+			default: 1,
+			description: "Blends between original UVs (0) and rectangular coordinates (1)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Intensity"
+			}
+		},
+		edges: {
+			default: "transparent",
+			description: "How to handle edges when distortion pushes content out of bounds",
+			transform: transformEdges,
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Stretch",
+						value: "stretch"
+					},
+					{
+						label: "Transparent",
+						value: "transparent"
+					},
+					{
+						label: "Mirror",
+						value: "mirror"
+					},
+					{
+						label: "Wrap",
+						value: "wrap"
+					}
+				],
+				label: "Edges"
+			}
+		}
+	},
+	uvTransformNode: ({ uv, uniforms, viewportSize: viewportSize$1 }) => {
+		const { vec2: vec2$1, cos: cos$1, sin: sin$1, PI, mix: mix$1 } = TSL;
+		const theta = uv.x.mul(PI.mul(2)).sub(PI);
+		const r = uv.y.mul(uniforms.scale.uniform);
+		const rectX = r.mul(cos$1(theta));
+		const rectY = r.mul(sin$1(theta));
+		const aspect = viewportSize$1.x.div(viewportSize$1.y);
+		const centerPos = vec2$1(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
+		return mix$1(uv, vec2$1(rectX.div(aspect).add(centerPos.x), rectY.add(centerPos.y)), uniforms.intensity.uniform);
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+		const { vec2: vec2$1, vec4: vec4$1, cos: cos$1, sin: sin$1, screenUV: screenUV$1, viewportSize: viewportSize$1, convertToTexture: convertToTexture$1, PI, mix: mix$1 } = TSL;
+		if (!childNode) return vec4$1(0, 0, 0, 0);
+		const childTexture = convertToTexture$1(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const theta = screenUV$1.x.mul(PI.mul(2)).sub(PI);
+		const r = screenUV$1.y.mul(uniforms.scale.uniform);
+		const rectX = r.mul(cos$1(theta));
+		const rectY = r.mul(sin$1(theta));
+		const aspect = viewportSize$1.x.div(viewportSize$1.y);
+		const centerPos = vec2$1(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
+		const blendedUV = mix$1(screenUV$1, vec2$1(rectX.div(aspect).add(centerPos.x), rectY.add(centerPos.y)), uniforms.intensity.uniform);
+		return applyEdgeHandling(blendedUV, childTexture.sample(blendedUV), childTexture, uniforms.edges.uniform);
+	}
+};
+var RectangularCoordinates_default = componentDefinition;
+export { componentDefinition as n, RectangularCoordinates_default as t };

package/dist/core/Ripples-8XaZaXQF.js

@@ -0,0 +1,117 @@
+import { t as createAnimatedTime } from "./time-CTJvRUZ4.js";
+import { o as transformPosition, r as transformColor } from "./transformations-DxfQXZWi.js";
+import { t as mixColors } from "./colorMixing-BXiTAqJU.js";
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "Ripples",
+	category: "Base Layers",
+	description: "Concentric animated ripples emanating from a point",
+	acceptsUVContext: true,
+	props: {
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "The center point where ripples emanate from",
+			ui: {
+				type: "position",
+				label: "Center"
+			}
+		},
+		colorA: {
+			default: "#ffffff",
+			transform: transformColor,
+			description: "Color of the ripple waves",
+			ui: {
+				type: "color",
+				label: "Color A"
+			}
+		},
+		colorB: {
+			default: "#000000",
+			transform: transformColor,
+			description: "Background color between ripples",
+			ui: {
+				type: "color",
+				label: "Color B"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "Speed of ripple animation",
+			ui: {
+				type: "range",
+				min: -5,
+				max: 5,
+				step: .1,
+				label: "Speed"
+			}
+		},
+		frequency: {
+			default: 20,
+			description: "Number of ripples/spacing between them",
+			ui: {
+				type: "range",
+				min: 1,
+				max: 80,
+				step: .1,
+				label: "Frequency"
+			}
+		},
+		softness: {
+			default: 0,
+			description: "Softness of ripple edges",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 3,
+				step: .01,
+				label: "Softness"
+			}
+		},
+		thickness: {
+			default: .5,
+			description: "Thickness of each ripple band",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Thickness"
+			}
+		},
+		phase: {
+			default: 0,
+			description: "Phase offset for ripple animation",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 6.28,
+				step: .01,
+				label: "Phase"
+			}
+		}
+	},
+	fragmentNode: (params) => {
+		const { uniforms, uvContext } = params;
+		const { vec2: vec2$1, float: float$1, screenUV: screenUV$1, sin: sin$1, distance, viewportSize: viewportSize$1, smoothstep } = TSL;
+		const uv = uvContext ?? screenUV$1;
+		const center = uniforms.center.uniform;
+		const colorA = uniforms.colorA.uniform;
+		const colorB = uniforms.colorB.uniform;
+		const frequency = uniforms.frequency.uniform;
+		const softness = uniforms.softness.uniform;
+		const thickness = uniforms.thickness.uniform;
+		const phase = uniforms.phase.uniform;
+		const aspect = viewportSize$1.x.div(viewportSize$1.y);
+		const dist = distance(vec2$1(uv.x.mul(aspect), uv.y), vec2$1(center.x.mul(aspect), center.y.oneMinus()));
+		const animTime = createAnimatedTime(params, uniforms.speed);
+		const baseWave = sin$1(dist.mul(frequency).sub(animTime).add(phase));
+		const thicknessThreshold = thickness.mul(float$1(2)).sub(float$1(1));
+		return mixColors(colorB, colorA, smoothstep(thicknessThreshold.add(softness), thicknessThreshold.sub(softness), baseWave), TSL.float(0));
+	}
+};
+var Ripples_default = componentDefinition;
+export { componentDefinition as n, Ripples_default as t };

package/dist/core/Saturation-CYFI1jzN.js

@@ -0,0 +1,30 @@
+import * as TSL from "three/tsl";
+import { saturation } from "three/src/nodes/display/ColorAdjustment";
+const componentDefinition = {
+	name: "Saturation",
+	category: "Adjustments",
+	description: "Adjust color saturation intensity",
+	requiresChild: true,
+	props: { intensity: {
+		default: 1,
+		description: "The intensity of the saturation effect (1 being no change)",
+		ui: {
+			type: "range",
+			min: 0,
+			max: 3,
+			step: .01,
+			label: "Intensity"
+		}
+	} },
+	fragmentNode: ({ uniforms, childNode }) => {
+		const { vec4: vec4$1 } = TSL;
+		if (!childNode) {
+			console.error("You must pass a child component into the Saturation shader.");
+			return vec4$1(0);
+		}
+		const sourceColor = childNode || vec4$1(0, 0, 0, 0);
+		return vec4$1(saturation(sourceColor.rgb, uniforms.intensity.uniform).rgb, sourceColor.a);
+	}
+};
+var Saturation_default = componentDefinition;
+export { componentDefinition as n, Saturation_default as t };

package/dist/core/SimplexNoise-DJUe0wz_.js

@@ -0,0 +1,99 @@
+import { t as createAnimatedTime } from "./time-CTJvRUZ4.js";
+import { r as transformColor } from "./transformations-DxfQXZWi.js";
+import { t as mixColors } from "./colorMixing-BXiTAqJU.js";
+import { clamp, exp, float, mx_noise_float, screenUV, vec2, vec3, viewportSize } from "three/tsl";
+const componentDefinition = {
+	name: "SimplexNoise",
+	category: "Base Layers",
+	description: "Organic noise with animated movement",
+	acceptsUVContext: true,
+	props: {
+		colorA: {
+			default: "#ffffff",
+			description: "First color",
+			transform: transformColor,
+			ui: {
+				type: "color",
+				label: "Color A"
+			}
+		},
+		colorB: {
+			default: "#000000",
+			description: "Second color",
+			transform: transformColor,
+			ui: {
+				type: "color",
+				label: "Color B"
+			}
+		},
+		scale: {
+			default: 2,
+			description: "Pattern scale (higher = larger patterns)",
+			ui: {
+				type: "range",
+				min: -2,
+				max: 5,
+				step: .1,
+				label: "Scale"
+			}
+		},
+		balance: {
+			default: 0,
+			description: "Balance between colors (negative = more colorB, positive = more colorA)",
+			ui: {
+				type: "range",
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Balance"
+			}
+		},
+		contrast: {
+			default: 0,
+			description: "Pattern contrast (higher = sharper transitions)",
+			ui: {
+				type: "range",
+				min: -2,
+				max: 5,
+				step: .1,
+				label: "Contrast"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Random seed for pattern variation",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "Animation speed",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 5,
+				step: .1,
+				label: "Speed"
+			}
+		}
+	},
+	fragmentNode: (params) => {
+		const { uniforms, uvContext } = params;
+		const uv = uvContext ?? screenUV;
+		const aspect = viewportSize.x.div(viewportSize.y);
+		const aspectCorrectedUV = vec2(uv.x.mul(aspect), uv.y);
+		const animTime = createAnimatedTime(params, uniforms.speed);
+		const pos = aspectCorrectedUV.mul(exp(uniforms.scale.uniform)).add(uniforms.seed.uniform);
+		const noise = mx_noise_float(vec3(pos.x, pos.y, animTime.mul(.5)));
+		const contrastMultiplier = uniforms.contrast.uniform.add(1);
+		const k = clamp(0, 1, noise.mul(contrastMultiplier).add(uniforms.balance.uniform).mul(.5).add(.5));
+		return mixColors(uniforms.colorB.uniform, uniforms.colorA.uniform, k, float(0));
+	}
+};
+var SimplexNoise_default = componentDefinition;
+export { componentDefinition as n, SimplexNoise_default as t };

package/dist/core/SineWave-Dl3nFO1W.js

@@ -0,0 +1,120 @@
+import { n as transformAngle, o as transformPosition, r as transformColor } from "./transformations-DxfQXZWi.js";
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "SineWave",
+	category: "Base Layers",
+	description: "Animated wave with thickness and softness",
+	acceptsUVContext: true,
+	props: {
+		color: {
+			default: "#ffffff",
+			transform: transformColor,
+			description: "The color of the sine wave",
+			ui: {
+				type: "color",
+				label: "Color"
+			}
+		},
+		amplitude: {
+			default: .15,
+			description: "The height/amplitude of the sine wave",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Amplitude"
+			}
+		},
+		frequency: {
+			default: 1,
+			description: "The frequency/number of wave cycles",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 20,
+				step: .1,
+				label: "Frequency"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "The animation speed of the wave",
+			ui: {
+				type: "range",
+				min: -5,
+				max: 5,
+				step: .1,
+				label: "Speed"
+			}
+		},
+		angle: {
+			default: 0,
+			transform: transformAngle,
+			description: "The rotation angle of the wave (in degrees)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Angle"
+			}
+		},
+		position: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "The center position of the wave",
+			ui: {
+				type: "position",
+				label: "Position"
+			}
+		},
+		thickness: {
+			default: .2,
+			description: "The thickness of the wave line",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Thickness"
+			}
+		},
+		softness: {
+			default: .4,
+			description: "Edge softness of the wave line",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Softness"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, uvContext }) => {
+		const { vec2: vec2$1, vec4: vec4$1, sin: sin$1, cos: cos$1, abs: abs$1, smoothstep, screenUV: screenUV$1, viewportSize: viewportSize$1, time, radians, PI } = TSL;
+		const uv = uvContext ?? screenUV$1;
+		const aspect = viewportSize$1.x.div(viewportSize$1.y);
+		const aspectCorrectedUV = vec2$1(uv.x.mul(aspect), uv.y);
+		const centerPos = vec2$1(uniforms.position.uniform.x.mul(aspect), uniforms.position.uniform.y.oneMinus());
+		const centeredUV = aspectCorrectedUV.sub(centerPos);
+		const angleRad = radians(uniforms.angle.uniform);
+		const cosAngle = cos$1(angleRad);
+		const sinAngle = sin$1(angleRad);
+		const rotatedX = centeredUV.x.mul(cosAngle).sub(centeredUV.y.mul(sinAngle));
+		const rotatedY = centeredUV.x.mul(sinAngle).add(centeredUV.y.mul(cosAngle));
+		const animatedTime = time.mul(uniforms.speed.uniform);
+		const sineWave = sin$1(rotatedX.mul(uniforms.frequency.uniform).mul(PI.mul(2)).add(animatedTime)).mul(uniforms.amplitude.uniform);
+		const distanceFromWave = abs$1(rotatedY.sub(sineWave));
+		const halfThickness = uniforms.thickness.uniform.mul(.5);
+		const halfSoftness = uniforms.softness.uniform.mul(.5);
+		const waveMask = smoothstep(halfThickness.add(halfSoftness), halfThickness.sub(halfSoftness), distanceFromWave);
+		return vec4$1(uniforms.color.uniform.rgb, uniforms.color.uniform.a.mul(waveMask));
+	}
+};
+var SineWave_default = componentDefinition;
+export { componentDefinition as n, SineWave_default as t };

package/dist/core/SolidColor-CWGq_Bjq.js

@@ -0,0 +1,21 @@
+import { r as transformColor } from "./transformations-DxfQXZWi.js";
+const componentDefinition = {
+	name: "SolidColor",
+	category: "Base Layers",
+	description: "Fill the canvas with a single solid color",
+	acceptsUVContext: true,
+	props: { color: {
+		default: "#5b18ca",
+		transform: transformColor,
+		description: "The solid color to display",
+		ui: {
+			type: "color",
+			label: "Color"
+		}
+	} },
+	fragmentNode: ({ uniforms }) => {
+		return uniforms.color.uniform;
+	}
+};
+var SolidColor_default = componentDefinition;
+export { componentDefinition as n, SolidColor_default as t };

package/dist/core/Spherize-C-jZEUsN.js

@@ -0,0 +1,128 @@
+import { o as transformPosition, r as transformColor } from "./transformations-DxfQXZWi.js";
+import * as TSL from "three/tsl";
+const componentDefinition = {
+	name: "Spherize",
+	category: "Distortions",
+	description: "Map content onto a 3D sphere surface with depth distortion",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		radius: {
+			default: 1,
+			description: "Radius of the sphere (1 = half viewport height)",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 3,
+				step: .01,
+				label: "Radius"
+			}
+		},
+		depth: {
+			default: 1,
+			description: "How much the sphere bulges toward viewer (0 = flat, higher = more bulge)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 3,
+				step: .01,
+				label: "Depth"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "The center point of the sphere",
+			ui: {
+				type: "position",
+				label: "Center"
+			}
+		},
+		lightPosition: {
+			default: {
+				x: .3,
+				y: .3
+			},
+			transform: transformPosition,
+			description: "Position of the specular light source",
+			ui: {
+				type: "position",
+				label: "Light Position"
+			}
+		},
+		lightIntensity: {
+			default: .5,
+			description: "Intensity of the rim light (0 = off)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Light Intensity"
+			}
+		},
+		lightSoftness: {
+			default: .5,
+			description: "Softness of the rim light falloff (0 = hard edge, 1 = soft glow)",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Light Softness"
+			}
+		},
+		lightColor: {
+			default: "#ffffff",
+			transform: transformColor,
+			description: "Color of the specular highlight",
+			ui: {
+				type: "color",
+				label: "Light Color"
+			}
+		}
+	},
+	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
+		const { vec2: vec2$1, vec3: vec3$1, vec4: vec4$1, float: float$1, screenUV: screenUV$1, convertToTexture: convertToTexture$1, viewportSize: viewportSize$1, sqrt: sqrt$1, max: max$1, smoothstep, pow: pow$1, normalize, dot: dot$1 } = TSL;
+		if (!childNode) return vec4$1(0, 0, 0, 0);
+		const childTexture = convertToTexture$1(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const uv = screenUV$1;
+		const aspect = viewportSize$1.x.div(viewportSize$1.y);
+		const centerPos = vec2$1(uniforms.center.uniform.x, uniforms.center.uniform.y.oneMinus());
+		const radius = uniforms.radius.uniform;
+		const sphereUV = vec2$1(uv.x.sub(centerPos.x).mul(aspect), uv.y.sub(centerPos.y)).mul(2).div(radius);
+		const radiusSq = sphereUV.x.mul(sphereUV.x).add(sphereUV.y.mul(sphereUV.y));
+		const sphereAlpha = float$1(1).sub(smoothstep(float$1(.98), float$1(1), radiusSq));
+		const z = sqrt$1(max$1(float$1(0), float$1(1).sub(radiusSq)));
+		const depthFactor = float$1(1).add(z.mul(uniforms.depth.uniform));
+		const finalUV = sphereUV.div(depthFactor).mul(radius).div(2);
+		const transformedUV = vec2$1(finalUV.x.div(aspect).add(centerPos.x), finalUV.y.add(centerPos.y));
+		const sampledColor = childTexture.sample(transformedUV);
+		const lightPos = vec2$1(uniforms.lightPosition.uniform.x, uniforms.lightPosition.uniform.y.oneMinus());
+		const lightIntensity = uniforms.lightIntensity.uniform;
+		const lightSoftness = uniforms.lightSoftness.uniform;
+		const lightColor = vec3$1(uniforms.lightColor.uniform.x, uniforms.lightColor.uniform.y, uniforms.lightColor.uniform.z);
+		const normal = normalize(vec3$1(sphereUV.x, sphereUV.y, z));
+		const viewDir = vec3$1(0, 0, 1);
+		const fresnelPower = float$1(1).add(float$1(4).mul(float$1(1).sub(lightSoftness)));
+		const fresnel = pow$1(float$1(1).sub(max$1(dot$1(normal, viewDir), float$1(0))), fresnelPower);
+		const lightDir2D = vec2$1(lightPos.x.sub(float$1(.5)).mul(2), lightPos.y.sub(float$1(.5)).mul(2));
+		const normalDir = normalize(vec2$1(normal.x, normal.y).add(vec2$1(1e-4, 1e-4)));
+		const lightDirNorm = normalize(lightDir2D.add(vec2$1(1e-4, 1e-4)));
+		const directionalBias = pow$1(max$1(float$1(0), dot$1(normalDir, lightDirNorm)), float$1(2));
+		const rimLight = fresnel.mul(directionalBias).mul(lightIntensity).mul(float$1(2));
+		const finalR = sampledColor.x.add(lightColor.x.mul(rimLight));
+		const finalG = sampledColor.y.add(lightColor.y.mul(rimLight));
+		const finalB = sampledColor.z.add(lightColor.z.mul(rimLight));
+		const finalA = sampledColor.w.mul(sphereAlpha);
+		return vec4$1(finalR.mul(finalA), finalG.mul(finalA), finalB.mul(finalA), finalA);
+	}
+};
+var Spherize_default = componentDefinition;
+export { componentDefinition as n, Spherize_default as t };