shaders 2.5.135 → 3.0.437

package/dist/core/BrickPattern-BfTsjp4I.js

@@ -1,175 +0,0 @@
-import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-CJcUeZIC.js";
-import { t as mixColors } from "./colorMixing-BPpDnR5I.js";
-import { t as createAnimatedTime } from "./time-DUqSFWvT.js";
-import { cos, float, floor, fract, mix, mod, screenUV, sin, step, vec4, viewportSize } from "three/tsl";
-const componentDefinition = {
-	name: "BrickPattern",
-	category: "Textures",
-	description: "Classic brick wall pattern with alternating rows and mortar gaps",
-	props: {
-		colorBrick: {
-			default: "#000000",
-			transform: transformColor,
-			description: "Brick color",
-			ui: {
-				type: "color",
-				label: "Brick Color",
-				group: "Colors"
-			}
-		},
-		colorMortar: {
-			default: "#ffffff",
-			transform: transformColor,
-			description: "Mortar / gap color",
-			ui: {
-				type: "color",
-				label: "Mortar Color",
-				group: "Colors"
-			}
-		},
-		cellsX: {
-			default: 8,
-			description: "Number of bricks per row",
-			ui: {
-				type: ["range", "map"],
-				min: 1,
-				max: 30,
-				step: 1,
-				label: "Bricks per Row",
-				group: "Effect"
-			}
-		},
-		cellsY: {
-			default: 10,
-			description: "Number of brick rows",
-			ui: {
-				type: ["range", "map"],
-				min: 1,
-				max: 30,
-				step: 1,
-				label: "Rows",
-				group: "Effect"
-			}
-		},
-		mortar: {
-			default: .05,
-			description: "Width of mortar gaps — equal pixel thickness in both directions",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Mortar Gap",
-				group: "Effect"
-			}
-		},
-		angle: {
-			default: 0,
-			transform: transformAngle,
-			description: "Rotation angle in degrees",
-			ui: {
-				type: ["range", "map"],
-				min: -180,
-				max: 180,
-				step: 1,
-				label: "Angle",
-				group: "Effect"
-			}
-		},
-		speed: {
-			default: 0,
-			description: "Animation speed",
-			ui: {
-				type: "range",
-				min: -2,
-				max: 2,
-				step: .1,
-				label: "Speed",
-				group: "Animation"
-			}
-		},
-		offset: {
-			default: 0,
-			description: "Static horizontal offset — shifts the brick pattern without animating",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Offset",
-				group: "Animation"
-			}
-		},
-		speedVariance: {
-			default: 0,
-			description: "How much each row's speed varies — at high values rows move at different speeds and directions",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Speed Variance",
-				group: "Animation"
-			}
-		},
-		seed: {
-			default: 0,
-			description: "Random seed for per-row speed variation",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 100,
-				step: 1,
-				label: "Seed",
-				group: "Animation"
-			}
-		},
-		colorSpace: {
-			default: "linear",
-			transform: transformColorSpace,
-			compileTime: true,
-			description: "Color space for interpolation",
-			ui: {
-				type: "select",
-				options: colorSpaceOptions,
-				label: "Color Space",
-				group: "Colors"
-			}
-		}
-	},
-	fragmentNode: (params) => {
-		const { uniforms } = params;
-		const uv$1 = screenUV;
-		const aspect = viewportSize.x.div(viewportSize.y);
-		const au = uv$1.x.mul(aspect);
-		const av = uv$1.y;
-		const cu = au.sub(aspect.mul(.5));
-		const cv = av.sub(float(.5));
-		const rotRad = uniforms.angle.uniform.mul(float(.0174533));
-		const cosR = cos(rotRad);
-		const sinR = sin(rotRad);
-		const ru = cu.mul(cosR).add(cv.mul(sinR));
-		const rv = cu.mul(sinR).negate().add(cv.mul(cosR));
-		const u = ru.div(aspect).add(float(.5));
-		const v = rv.add(float(.5));
-		const cellsX = uniforms.cellsX.uniform;
-		const cellsY = uniforms.cellsY.uniform;
-		const animTime = createAnimatedTime(params, uniforms.speed);
-		const mortarU = uniforms.mortar.uniform.mul(float(.3));
-		const mortarV = mortarU.mul(aspect).mul(cellsY).div(cellsX);
-		const row = floor(v.mul(cellsY));
-		const rowOffset = mod(row, float(2)).mul(.5);
-		const rowDir = mod(row, float(2)).mul(2).sub(1);
-		const seedVal = uniforms.seed.uniform;
-		const rowSpeedMult = mix(rowDir, fract(sin(row.add(seedVal.mul(.137))).mul(43758.5453)).sub(.5).mul(2), uniforms.speedVariance.uniform);
-		const cellU = fract(u.mul(cellsX).add(rowOffset).add(animTime.mul(rowSpeedMult)).add(uniforms.offset.uniform));
-		const cellV = fract(v.mul(cellsY));
-		const brickU = step(mortarU, cellU).mul(step(mortarU, float(1).sub(cellU)));
-		const brickV = step(mortarV, cellV).mul(step(mortarV, float(1).sub(cellV)));
-		const brickMask = brickU.mul(brickV);
-		const result = mixColors(uniforms.colorMortar.uniform, uniforms.colorBrick.uniform, brickMask, uniforms.colorSpace.uniform.value);
-		return vec4(result.rgb, result.a);
-	}
-};
-var BrickPattern_default = componentDefinition;
-export { componentDefinition as n, BrickPattern_default as t };

package/dist/core/BrightnessContrast-GppIqtkO.js

@@ -1,45 +0,0 @@
-import { vec3, vec4 } from "three/tsl";
-const componentDefinition = {
-	name: "BrightnessContrast",
-	category: "Adjustments",
-	description: "Adjust brightness and contrast of the image",
-	requiresChild: true,
-	props: {
-		brightness: {
-			default: 0,
-			description: "Brightness adjustment (-1 to 1)",
-			ui: {
-				type: ["range", "map"],
-				min: -1,
-				max: 1,
-				step: .05,
-				label: "Brightness",
-				group: "Appearance"
-			}
-		},
-		contrast: {
-			default: 0,
-			description: "Contrast adjustment (-1 to 1)",
-			ui: {
-				type: ["range", "map"],
-				min: -1,
-				max: 1,
-				step: .05,
-				label: "Contrast",
-				group: "Appearance"
-			},
-			transform: (value) => value + 1
-		}
-	},
-	fragmentNode: ({ uniforms, childNode }) => {
-		if (!childNode) {
-			console.error("You must pass a child component into the Brightness Contrast shader.");
-			return vec4(0);
-		}
-		const brightness = uniforms.brightness.uniform;
-		const contrast = uniforms.contrast.uniform;
-		return vec4(vec3(childNode.r, childNode.g, childNode.b).sub(.5).mul(contrast).add(.5).add(brightness), childNode.a);
-	}
-};
-var BrightnessContrast_default = componentDefinition;
-export { componentDefinition as n, BrightnessContrast_default as t };

package/dist/core/Bulge-DMOATSEs.js

@@ -1,118 +0,0 @@
-import { t as applyEdgeHandling } from "./edges-CX_lJB9R.js";
-import { c as transformEdges, l as transformPosition } from "./transformations-CJcUeZIC.js";
-import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { convertToTexture, float, length, max, screenUV, smoothstep, vec2, vec4, viewportSize } from "three/tsl";
-const componentDefinition = {
-	name: "Bulge",
-	category: "Distortions",
-	description: "Magnify or pinch content around a center point",
-	requiresRTT: true,
-	requiresChild: true,
-	props: {
-		center: {
-			default: {
-				x: .5,
-				y: .5
-			},
-			transform: transformPosition,
-			description: "The center point of the bulge effect",
-			ui: {
-				type: "position",
-				label: "Center",
-				group: "Position"
-			}
-		},
-		strength: {
-			default: 1,
-			description: "The intensity of the bulge effect (positive = bulge out, negative = pinch in)",
-			ui: {
-				type: ["range", "map"],
-				min: -1,
-				max: 1,
-				step: .05,
-				label: "Strength",
-				group: "Effect"
-			}
-		},
-		radius: {
-			default: 1,
-			description: "The radius of the bulge effect area",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 5,
-				step: .1,
-				label: "Radius",
-				group: "Effect"
-			}
-		},
-		falloff: {
-			default: .5,
-			description: "Controls the smoothness of the transition (0 = hard edge, 1 = very smooth)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .05,
-				label: "Falloff",
-				group: "Effect"
-			}
-		},
-		edges: {
-			default: "stretch",
-			description: "How to handle edges when distortion pushes content out of bounds",
-			transform: transformEdges,
-			compileTime: true,
-			ui: {
-				type: "select",
-				options: [
-					{
-						label: "Stretch",
-						value: "stretch"
-					},
-					{
-						label: "Transparent",
-						value: "transparent"
-					},
-					{
-						label: "Mirror",
-						value: "mirror"
-					},
-					{
-						label: "Wrap",
-						value: "wrap"
-					}
-				],
-				label: "Edges",
-				group: "Effect"
-			}
-		}
-	},
-	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		if (!childNode) return vec4(0, 0, 0, 0);
-		const childTexture = convertToTexture(childNode);
-		onCleanup(() => {
-			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
-		});
-		const aspect = viewportSize.x.div(viewportSize.y);
-		const aspectCorrectedUV = vec2(screenUV.x.mul(aspect), screenUV.y);
-		const centerPos = vec2(uniforms.center.uniform.x.mul(aspect), uniforms.center.uniform.y.oneMinus());
-		const delta = aspectCorrectedUV.sub(centerPos);
-		const distance$1 = length(delta);
-		const effectRadius = uniforms.radius.uniform.mul(.5);
-		const falloffAmount = uniforms.falloff.uniform;
-		const smoothFalloff = smoothstep(effectRadius.mul(float(1).sub(falloffAmount).sub(float(.001)).max(float(0))), effectRadius, distance$1).oneMinus();
-		const normalizedDist = distance$1.div(effectRadius);
-		const distSq = normalizedDist.mul(normalizedDist);
-		const quadraticFalloff = max(float(0), float(1).sub(distSq));
-		const falloff = smoothFalloff.mul(quadraticFalloff);
-		const displacementAmount = uniforms.strength.uniform.negate().mul(falloff);
-		const scaleFactor = float(1).add(displacementAmount);
-		const bulgedDelta = delta.mul(scaleFactor);
-		const bulgedUV = centerPos.add(bulgedDelta);
-		const finalUV = vec2(bulgedUV.x.div(aspect), bulgedUV.y);
-		return unpremultiplyAlpha(applyEdgeHandling(finalUV, childTexture.sample(finalUV), childTexture, uniforms.edges.uniform.value));
-	}
-};
-var Bulge_default = componentDefinition;
-export { componentDefinition as n, Bulge_default as t };

package/dist/core/CRTScreen-corekL_R.js

@@ -1,148 +0,0 @@
-import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { convertToTexture, float, fract, length, mix, screenUV, sin, smoothstep, vec2, vec3, vec4, viewportSize } from "three/tsl";
-const componentDefinition = {
-	name: "CRTScreen",
-	category: "Stylize",
-	description: "Retro CRT monitor simulation with scanlines",
-	requiresRTT: true,
-	requiresChild: true,
-	props: {
-		pixelSize: {
-			default: 128,
-			description: "Size of individual TV pixels (lower = more pixels)",
-			ui: {
-				type: ["range", "map"],
-				min: 8,
-				max: 128,
-				step: 1,
-				label: "Pixel Size",
-				group: "Effect"
-			}
-		},
-		colorShift: {
-			default: 1,
-			description: "Chromatic aberration amount",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 10,
-				step: .1,
-				label: "Color Shift",
-				group: "Effect"
-			}
-		},
-		scanlineIntensity: {
-			default: .3,
-			description: "Strength of horizontal scanlines",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .1,
-				label: "Scanline Intensity",
-				group: "Effect"
-			}
-		},
-		scanlineFrequency: {
-			default: 200,
-			description: "Number of scanlines across screen",
-			ui: {
-				type: ["range", "map"],
-				min: 100,
-				max: 800,
-				step: 10,
-				label: "Scanline Frequency",
-				group: "Effect"
-			}
-		},
-		brightness: {
-			default: 1,
-			description: "Screen brightness boost",
-			ui: {
-				type: ["range", "map"],
-				min: .5,
-				max: 2,
-				step: .1,
-				label: "Brightness",
-				group: "Appearance"
-			}
-		},
-		contrast: {
-			default: 1,
-			description: "Screen contrast enhancement",
-			ui: {
-				type: ["range", "map"],
-				min: .5,
-				max: 2,
-				step: .1,
-				label: "Contrast",
-				group: "Appearance"
-			}
-		},
-		vignetteIntensity: {
-			default: 1,
-			description: "Strength of corner darkening effect (0 = off)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .1,
-				label: "Vignette Intensity",
-				group: "Effect"
-			}
-		},
-		vignetteRadius: {
-			default: .5,
-			description: "How far the vignette extends inward (0 = edges only, 1 = reaches center)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .05,
-				label: "Vignette Radius",
-				group: "Effect"
-			}
-		}
-	},
-	fragmentNode: ({ uniforms, childNode, onCleanup }) => {
-		if (!childNode) return vec4(0, 0, 0, 0);
-		const childTexture = convertToTexture(childNode);
-		onCleanup(() => {
-			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
-		});
-		const pixelSize = uniforms.pixelSize.uniform;
-		const colorShift = uniforms.colorShift.uniform;
-		const scanlineIntensity = uniforms.scanlineIntensity.uniform;
-		const scanlineFrequency = uniforms.scanlineFrequency.uniform;
-		const brightness = uniforms.brightness.uniform;
-		const contrast = uniforms.contrast.uniform;
-		const scaledColorShift = colorShift.mul(float(.002));
-		const redUV = screenUV.add(vec2(scaledColorShift, float(0)));
-		const greenUV = screenUV;
-		const blueUV = screenUV.sub(vec2(scaledColorShift, float(0)));
-		const redSample = childTexture.sample(redUV).r;
-		const greenSample = childTexture.sample(greenUV).g;
-		const blueSample = childTexture.sample(blueUV).b;
-		const adjustedColor = vec3(redSample, greenSample, blueSample).sub(float(.5)).mul(contrast).add(float(.5)).mul(brightness);
-		const scanlineWave = sin(screenUV.y.mul(scanlineFrequency).mul(float(3.14159 * 2)));
-		const scanlineEffect = float(1).sub(scanlineIntensity.mul(scanlineWave.mul(float(.5)).add(float(.5))));
-		const scanlinedColor = adjustedColor.mul(scanlineEffect);
-		const phosphorScale = pixelSize.mul(float(.5));
-		const pixelPhase = fract(screenUV.mul(phosphorScale));
-		const redMask = sin(pixelPhase.x.mul(float(6.28318))).mul(float(.1)).add(float(.95));
-		const greenMask = sin(pixelPhase.x.mul(float(6.28318)).add(float(2.09))).mul(float(.1)).add(float(.95));
-		const blueMask = sin(pixelPhase.x.mul(float(6.28318)).add(float(4.18))).mul(float(.1)).add(float(.95));
-		const phosphorColor = vec3(scanlinedColor.r.mul(redMask), scanlinedColor.g.mul(greenMask), scanlinedColor.b.mul(blueMask));
-		const aspect = viewportSize.x.div(viewportSize.y);
-		const centeredUV = screenUV.sub(vec2(.5, .5));
-		const vignetteDistance = length(vec2(centeredUV.x.mul(aspect), centeredUV.y));
-		const vignetteRadiusProp = uniforms.vignetteRadius.uniform;
-		const vignetteIntensity = uniforms.vignetteIntensity.uniform;
-		const innerEdge = float(1).sub(vignetteRadiusProp.mul(float(.9)));
-		const vignetteValue = smoothstep(innerEdge, innerEdge.add(float(.5)), vignetteDistance).oneMinus();
-		const vignette = mix(float(1), vignetteValue, vignetteIntensity);
-		return unpremultiplyAlpha(vec4(phosphorColor.mul(vignette), float(1)));
-	}
-};
-var CRTScreen_default = componentDefinition;
-export { componentDefinition as n, CRTScreen_default as t };

package/dist/core/ChannelBlur-CxlVaYGM.js

@@ -1,160 +0,0 @@
-import { t as unpremultiplyAlpha } from "./alpha-C4ptedXe.js";
-import { r as createGaussianBlurCompute } from "./computeBlur-oxyhoztH.js";
-import { Fn, convertToTexture, float, mix, screenUV, texture, vec2, vec4, viewportSize } from "three/tsl";
-const componentDefinition = {
-	name: "ChannelBlur",
-	category: "Blurs",
-	description: "Independent blur for red, green, and blue channels",
-	requiresRTT: true,
-	requiresChild: true,
-	props: {
-		redIntensity: {
-			default: 0,
-			description: "Blur intensity for red channel",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 100,
-				step: 1,
-				label: "Red Intensity",
-				group: "Effect"
-			}
-		},
-		greenIntensity: {
-			default: 20,
-			description: "Blur intensity for green channel",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 100,
-				step: 1,
-				label: "Green Intensity",
-				group: "Effect"
-			}
-		},
-		blueIntensity: {
-			default: 40,
-			description: "Blur intensity for blue channel",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 100,
-				step: 1,
-				label: "Blue Intensity",
-				group: "Effect"
-			}
-		}
-	},
-	computeNode: ({ childNode, onCleanup, dimensions, renderer, uniforms, onResize }) => {
-		if (!childNode) return null;
-		const childTexture = convertToTexture(childNode);
-		onCleanup(() => {
-			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
-		});
-		const dpr = renderer?.getPixelRatio?.() ?? 1;
-		const blur = createGaussianBlurCompute(childTexture, Math.round(dimensions.width * dpr), Math.round(dimensions.height * dpr), onCleanup);
-		const { computeNodes, outputTexture, updateRadius } = blur;
-		onResize(({ width, height }) => {
-			blur.setInputDimensions(Math.round(width * dpr), Math.round(height * dpr));
-		});
-		return {
-			outputs: {
-				childTexture,
-				blurredTexture: outputTexture
-			},
-			getComputeNodes: () => {
-				const r = uniforms.redIntensity.uniform.value * .1;
-				const g = uniforms.greenIntensity.uniform.value * .1;
-				const b = uniforms.blueIntensity.uniform.value * .1;
-				updateRadius(Math.max(r, g, b, .01));
-				return computeNodes;
-			}
-		};
-	},
-	fragmentNode: ({ uniforms, childNode, onCleanup, computeOutputs }) => {
-		if (!childNode) return vec4(0, 0, 0, 0);
-		if (computeOutputs?.blurredTexture) {
-			const sharp = computeOutputs.childTexture.sample(screenUV);
-			const blurred = texture(computeOutputs.blurredTexture).sample(screenUV);
-			const redRadius$1 = uniforms.redIntensity.uniform.mul(.1);
-			const greenRadius$1 = uniforms.greenIntensity.uniform.mul(.1);
-			const blueRadius$1 = uniforms.blueIntensity.uniform.mul(.1);
-			const maxRadius = redRadius$1.max(greenRadius$1).max(blueRadius$1).max(float(.01));
-			const rMix = redRadius$1.div(maxRadius);
-			const gMix = greenRadius$1.div(maxRadius);
-			const bMix = blueRadius$1.div(maxRadius);
-			return unpremultiplyAlpha(vec4(mix(sharp.r, blurred.r, rMix), mix(sharp.g, blurred.g, gMix), mix(sharp.b, blurred.b, bMix), sharp.a));
-		}
-		const childTexture = convertToTexture(childNode);
-		onCleanup(() => {
-			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
-		});
-		const weights = [
-			.056,
-			.135,
-			.278,
-			.487,
-			.726,
-			.923,
-			1,
-			.923,
-			.726,
-			.487,
-			.278,
-			.135,
-			.056
-		];
-		const weightSum = 6.214;
-		const redRadius = uniforms.redIntensity.uniform.mul(.1);
-		const greenRadius = uniforms.greenIntensity.uniform.mul(.1);
-		const blueRadius = uniforms.blueIntensity.uniform.mul(.1);
-		const horizontalTexture = convertToTexture(Fn(() => {
-			const uv$1 = screenUV;
-			const pixelSize = vec2(1).div(viewportSize);
-			const redTotal = float(0).toVar();
-			const greenTotal = float(0).toVar();
-			const blueTotal = float(0).toVar();
-			for (let x = -6; x <= 6; x++) {
-				const weight = float(weights[x + 6] / weightSum);
-				const xOffset = float(x).mul(pixelSize.x);
-				const redOffset = vec2(xOffset.mul(redRadius), float(0));
-				const greenOffset = vec2(xOffset.mul(greenRadius), float(0));
-				const blueOffset = vec2(xOffset.mul(blueRadius), float(0));
-				const redSample = childTexture.sample(uv$1.add(redOffset)).r.mul(weight);
-				const greenSample = childTexture.sample(uv$1.add(greenOffset)).g.mul(weight);
-				const blueSample = childTexture.sample(uv$1.add(blueOffset)).b.mul(weight);
-				redTotal.assign(redTotal.add(redSample));
-				greenTotal.assign(greenTotal.add(greenSample));
-				blueTotal.assign(blueTotal.add(blueSample));
-			}
-			return vec4(redTotal, greenTotal, blueTotal, float(1));
-		})());
-		onCleanup(() => {
-			if (horizontalTexture?.renderTarget?.dispose) horizontalTexture.renderTarget.dispose();
-		});
-		return Fn(() => {
-			const uv$1 = screenUV;
-			const pixelSize = vec2(1).div(viewportSize);
-			const redTotal = float(0).toVar();
-			const greenTotal = float(0).toVar();
-			const blueTotal = float(0).toVar();
-			for (let y = -6; y <= 6; y++) {
-				const weight = float(weights[y + 6] / weightSum);
-				const yOffset = float(y).mul(pixelSize.y);
-				const redOffset = vec2(float(0), yOffset.mul(redRadius));
-				const greenOffset = vec2(float(0), yOffset.mul(greenRadius));
-				const blueOffset = vec2(float(0), yOffset.mul(blueRadius));
-				const redSample = horizontalTexture.sample(uv$1.add(redOffset)).r.mul(weight);
-				const greenSample = horizontalTexture.sample(uv$1.add(greenOffset)).g.mul(weight);
-				const blueSample = horizontalTexture.sample(uv$1.add(blueOffset)).b.mul(weight);
-				redTotal.assign(redTotal.add(redSample));
-				greenTotal.assign(greenTotal.add(greenSample));
-				blueTotal.assign(blueTotal.add(blueSample));
-			}
-			const originalAlpha = childTexture.sample(uv$1).a;
-			return unpremultiplyAlpha(vec4(redTotal, greenTotal, blueTotal, originalAlpha));
-		})();
-	}
-};
-var ChannelBlur_default = componentDefinition;
-export { componentDefinition as n, ChannelBlur_default as t };