shaders 2.3.75 → 2.4.77

package/dist/core/Form3D-D3MoN95S.js

@@ -0,0 +1,574 @@
+import { c as transformEdges, l as transformPosition } from "./transformations-B5lM6fYX.js";
+import { t as createAnimatedTime } from "./time-DUqSFWvT.js";
+import { Break, Fn, If, Loop, abs, atan, clamp, convertToTexture, cos, dot, float, fract, max, min, mix, normalize, pow, screenUV, sin, uniform, vec2, vec3, vec4, viewportSize } from "three/tsl";
+function applyDistortion3D(childTexture, shape, uniforms, march = {}) {
+	const steps = march.steps ?? 96;
+	const stepCap = march.stepCap ?? .15;
+	const hitEps = march.hitEps ?? .001;
+	const maxDistance = march.maxDistance ?? 20;
+	const aspect = viewportSize.x.div(viewportSize.y);
+	const cx = uniforms.center.uniform.x;
+	const cy = uniforms.center.uniform.y.oneMinus();
+	const camDist = float(8).sub(uniforms.zoom.uniform.mul(.06));
+	const glossAmt = uniforms.glossiness.uniform.mul(.005);
+	const lightAmt = uniforms.lighting.uniform.mul(.005);
+	const uvMode = uniforms.uvMode.uniform;
+	const applyUVMode = (uv$1) => {
+		const stretched = clamp(uv$1, 0, 1);
+		const mirrored = abs(fract(uv$1.mul(.5)).mul(2).sub(1));
+		const wrapped = fract(uv$1);
+		const transparentVisible = uv$1.x.lessThan(0).or(uv$1.x.greaterThan(1)).or(uv$1.y.lessThan(0)).or(uv$1.y.greaterThan(1)).select(float(0), float(1));
+		return {
+			uv: uvMode.lessThan(float(.5)).select(stretched, uvMode.lessThan(float(1.5)).select(uv$1, uvMode.lessThan(float(2.5)).select(mirrored, wrapped))),
+			visible: uvMode.lessThan(float(.5)).select(float(1), uvMode.lessThan(float(1.5)).select(transparentVisible, float(1)))
+		};
+	};
+	const calcNormal = Fn(([p]) => {
+		const h = float(.001);
+		const hn = h.negate();
+		const k0 = shape.sdf(p.add(vec3(h, hn, hn)));
+		const k1 = shape.sdf(p.add(vec3(hn, hn, h)));
+		const k2 = shape.sdf(p.add(vec3(hn, h, hn)));
+		const k3 = shape.sdf(p.add(vec3(h, h, h)));
+		return normalize(vec3(1, -1, -1).mul(k0).add(vec3(-1, -1, 1).mul(k1)).add(vec3(-1, 1, -1).mul(k2)).add(vec3(1, 1, 1).mul(k3)));
+	});
+	return Fn(() => {
+		const uv$1 = screenUV;
+		const ro = vec3(0, 0, camDist.negate());
+		const focal = float(1.5);
+		const rd = normalize(vec3(uv$1.x.sub(cx).mul(aspect), uv$1.y.sub(cy), focal));
+		const rayT = float(0).toVar();
+		const hit = float(0).toVar();
+		Loop(steps, () => {
+			const p = ro.add(rd.mul(rayT));
+			const d = shape.sdf(p);
+			If(d.lessThan(float(hitEps)), () => {
+				hit.assign(1);
+				Break();
+			});
+			If(rayT.greaterThan(maxDistance), () => {
+				Break();
+			});
+			rayT.addAssign(min(d, float(stepCap)));
+		});
+		const hitPos = ro.add(rd.mul(rayT));
+		const normal = calcNormal(hitPos);
+		const { uv: finalUV, visible: uvVisible } = applyUVMode(shape.surfaceUV(hitPos, normal));
+		const surfaceColor = childTexture.sample(finalUV);
+		const lightDir = normalize(vec3(.4, .7, -.6));
+		const viewDir = rd.negate();
+		const diffuse = clamp(dot(normal, lightDir), 0, 1);
+		const halfVec = normalize(lightDir.add(viewDir));
+		const specPow = glossAmt.mul(256).add(4);
+		const specular = pow(clamp(dot(normal, halfVec), 0, 1), specPow).mul(glossAmt).mul(1.5);
+		const nDotV = clamp(dot(normal, viewDir), 0, 1);
+		const fresnel = pow(float(1).sub(nDotV), float(3)).mul(.5).mul(glossAmt);
+		const ambient = float(.35);
+		const lit = mix(float(1), ambient.add(diffuse.mul(.65)).add(specular).add(fresnel), lightAmt);
+		return vec4(clamp(surfaceColor.rgb.mul(clamp(lit, 0, 3)), 0, 1), hit.mul(surfaceColor.a).mul(uvVisible));
+	})();
+}
+var TWIST_SPEED = .08;
+function createRibbonShape(params) {
+	const { angleRad, twistAmt, halfW, ribbonWidth, ribbonThickness, twistPhase, t } = params;
+	const evalCrossSection = (rpy, pz, xPos) => {
+		const twistAngle = xPos.mul(twistAmt).add(twistPhase).add(t.mul(TWIST_SPEED));
+		const ca = cos(twistAngle);
+		const sa = sin(twistAngle);
+		const localU = rpy.mul(ca).add(pz.mul(sa));
+		const localV = rpy.mul(sa).negate().add(pz.mul(ca));
+		return vec2(max(abs(localU).sub(halfW), 0), localV).length().sub(ribbonThickness);
+	};
+	const getRotated = (p) => {
+		const cosA = cos(angleRad);
+		const sinA = sin(angleRad);
+		return {
+			rpx: p.x.mul(cosA).add(p.y.mul(sinA)),
+			rpy: p.x.mul(sinA).negate().add(p.y.mul(cosA))
+		};
+	};
+	const lipschitz = max(halfW.mul(twistAmt), float(1));
+	return {
+		sdf: Fn(([p]) => {
+			const { rpx, rpy } = getRotated(p);
+			return evalCrossSection(rpy, p.z, rpx).div(lipschitz);
+		}),
+		surfaceUV: Fn(([hitPos, _normal]) => {
+			const { rpx, rpy } = getRotated(hitPos);
+			const twistAngle = rpx.mul(twistAmt).add(twistPhase).add(t.mul(TWIST_SPEED));
+			const ca = cos(twistAngle);
+			const sa = sin(twistAngle);
+			const localUClamped = max(min(rpy.mul(ca).add(hitPos.z.mul(sa)), halfW), halfW.negate());
+			return vec2(rpx.mul(.15).add(.5), localUClamped.div(ribbonWidth).add(.5));
+		})
+	};
+}
+const rotateX = Fn(([p, a]) => {
+	const c = cos(a), s = sin(a);
+	return vec3(p.x, p.y.mul(c).sub(p.z.mul(s)), p.y.mul(s).add(p.z.mul(c)));
+});
+const rotateY = Fn(([p, a]) => {
+	const c = cos(a), s = sin(a);
+	return vec3(p.x.mul(c).add(p.z.mul(s)), p.y, p.x.mul(s).negate().add(p.z.mul(c)));
+});
+const rotateZ = Fn(([p, a]) => {
+	const c = cos(a), s = sin(a);
+	return vec3(p.x.mul(c).sub(p.y.mul(s)), p.x.mul(s).add(p.y.mul(c)), p.z);
+});
+const createApplyRot = (rotX_u, rotY_u, rotZ_u, spinX, spinY, spinZ) => (p) => rotateZ(rotateX(rotateY(p, rotY_u.add(spinY)), rotX_u.add(spinX)), rotZ_u.add(spinZ));
+function createTorusShape(u) {
+	const { outerRadius, tubeRadius, rotX, rotY, rotZ, spinAngleX, spinAngleY, spinAngleZ } = u;
+	const applyRot = createApplyRot(rotX, rotY, rotZ, spinAngleX, spinAngleY, spinAngleZ);
+	return {
+		sdf: Fn(([p]) => {
+			const rp = applyRot(p);
+			return vec2(vec2(rp.x, rp.z).length().sub(outerRadius), rp.y).length().sub(tubeRadius);
+		}),
+		surfaceUV: Fn(([hitPos, _normal]) => {
+			const rp = applyRot(hitPos);
+			const u$1 = atan(rp.z, rp.x).div(Math.PI * 2).add(.5);
+			const ringDist = vec2(rp.x, rp.z).length().sub(outerRadius);
+			return vec2(u$1, atan(rp.y, ringDist).div(Math.PI * 2).add(.5));
+		})
+	};
+}
+function createBoxShape(u) {
+	const { halfExtents, rounding, rotX, rotY, rotZ, spinAngleX, spinAngleY, spinAngleZ } = u;
+	const applyRot = createApplyRot(rotX, rotY, rotZ, spinAngleX, spinAngleY, spinAngleZ);
+	return {
+		sdf: Fn(([p]) => {
+			const rp = applyRot(p);
+			const q = vec3(abs(rp.x), abs(rp.y), abs(rp.z)).sub(halfExtents).add(rounding);
+			const outer = vec3(max(q.x, float(0)), max(q.y, float(0)), max(q.z, float(0))).length();
+			const inner = min(max(q.x, max(q.y, q.z)), float(0));
+			return outer.add(inner).sub(rounding);
+		}),
+		surfaceUV: Fn(([hitPos, normal]) => {
+			const rp = applyRot(hitPos);
+			const rn = applyRot(normal);
+			const absNorm = vec3(abs(rn.x), abs(rn.y), abs(rn.z));
+			const scaleX = float(.5).div(max(halfExtents.y, halfExtents.z));
+			const scaleY = float(.5).div(max(halfExtents.x, halfExtents.z));
+			const scaleZ = float(.5).div(max(halfExtents.x, halfExtents.y));
+			const uvX = vec2(rp.z, rp.y).mul(scaleX).add(.5);
+			const uvY = vec2(rp.x, rp.z).mul(scaleY).add(.5);
+			const uvZ = vec2(rp.x, rp.y).mul(scaleZ).add(.5);
+			return absNorm.x.greaterThan(absNorm.y).select(absNorm.x.greaterThan(absNorm.z).select(uvX, uvZ), absNorm.y.greaterThan(absNorm.z).select(uvY, uvZ));
+		})
+	};
+}
+function createSphereShape(u) {
+	const { radius, rotX, rotY, rotZ, spinAngleX, spinAngleY, spinAngleZ } = u;
+	const applyRot = createApplyRot(rotX, rotY, rotZ, spinAngleX, spinAngleY, spinAngleZ);
+	return {
+		sdf: Fn(([p]) => {
+			return applyRot(p).length().sub(radius);
+		}),
+		surfaceUV: Fn(([hitPos, _normal]) => {
+			const n = normalize(applyRot(hitPos));
+			return vec2(atan(n.z, n.x).div(Math.PI * 2).add(.5), n.y.add(1).mul(.5));
+		})
+	};
+}
+function createCapsuleShape(u) {
+	const { radius, halfHeight, rotX, rotY, rotZ, spinAngleX, spinAngleY, spinAngleZ } = u;
+	const applyRot = createApplyRot(rotX, rotY, rotZ, spinAngleX, spinAngleY, spinAngleZ);
+	return {
+		sdf: Fn(([p]) => {
+			const rp = applyRot(p);
+			const clampedY = clamp(rp.y, halfHeight.negate(), halfHeight);
+			return vec3(rp.x, rp.y.sub(clampedY), rp.z).length().sub(radius);
+		}),
+		surfaceUV: Fn(([hitPos, _normal]) => {
+			const rp = applyRot(hitPos);
+			const u$1 = atan(rp.z, rp.x).div(Math.PI * 2).add(.5);
+			const span = halfHeight.add(radius);
+			return vec2(u$1, clamp(rp.y.div(span).mul(.5).add(.5), float(0), float(1)));
+		})
+	};
+}
+function createMobiusShape(u) {
+	const { ringRadius, halfWidth, thickness, rotX, rotY, rotZ, spinAngleX, spinAngleY, spinAngleZ } = u;
+	const applyRot = createApplyRot(rotX, rotY, rotZ, spinAngleX, spinAngleY, spinAngleZ);
+	const mobiusSDF = (rp) => {
+		const phi = atan(rp.z, rp.x);
+		const spine = vec3(cos(phi).mul(ringRadius), float(0), sin(phi).mul(ringRadius));
+		const d = rp.sub(spine);
+		const halfPhi = phi.mul(.5);
+		const ev = vec3(cos(phi).mul(cos(halfPhi)), sin(halfPhi), sin(phi).mul(cos(halfPhi)));
+		const vProj = dot(d, ev);
+		return {
+			phi,
+			vProj,
+			du: max(abs(vProj).sub(halfWidth), float(0)),
+			perp: d.sub(ev.mul(vProj))
+		};
+	};
+	return {
+		sdf: Fn(([p]) => {
+			const { du, perp } = mobiusSDF(applyRot(p));
+			return vec2(du, perp.length()).length().sub(thickness);
+		}),
+		surfaceUV: Fn(([hitPos, _normal]) => {
+			const { phi, vProj } = mobiusSDF(applyRot(hitPos));
+			return vec2(phi.div(Math.PI * 2).add(.5), vProj.div(halfWidth).mul(.5).add(.5));
+		})
+	};
+}
+const componentDefinition = {
+	name: "Form3D",
+	category: "Distortions",
+	description: "Wraps child content onto a 3D raymarched shape with lighting.",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		shape3d: {
+			default: JSON.stringify({
+				type: "ribbon",
+				angle: 0,
+				twist: 50,
+				width: 40,
+				thickness: 20,
+				seed: 0
+			}),
+			description: "3D shape and its parameters",
+			ui: {
+				type: "shape3d",
+				label: "Shape",
+				group: "Shape"
+			}
+		},
+		shape3dType: {
+			default: "ribbon",
+			compileTime: true,
+			description: "Active shape type — triggers recompile when shape is switched"
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "Center position of the shape on screen",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position"
+			}
+		},
+		zoom: {
+			default: 50,
+			description: "Camera zoom level",
+			ui: {
+				type: ["range", "map"],
+				min: 10,
+				max: 200,
+				step: 1,
+				label: "Zoom",
+				group: "Scene"
+			}
+		},
+		glossiness: {
+			default: 50,
+			description: "Specular highlight intensity and sharpness",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 200,
+				step: 1,
+				label: "Glossiness",
+				group: "Lighting"
+			}
+		},
+		lighting: {
+			default: 50,
+			description: "Overall intensity of lighting effects",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 200,
+				step: 1,
+				label: "Lighting",
+				group: "Lighting"
+			}
+		},
+		uvMode: {
+			default: "stretch",
+			transform: transformEdges,
+			description: "How to handle UV coordinates at shape boundaries",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Stretch",
+						value: "stretch"
+					},
+					{
+						label: "Mirror",
+						value: "mirror"
+					},
+					{
+						label: "Wrap",
+						value: "wrap"
+					}
+				],
+				label: "UV Edges",
+				group: "Scene"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "Animation speed — scales all spin rates",
+			ui: {
+				type: "range",
+				min: -10,
+				max: 10,
+				step: .1,
+				label: "Speed",
+				group: "Animation"
+			}
+		}
+	},
+	fragmentNode: (params) => {
+		const { uniforms, childNode, onCleanup, onBeforeRender } = params;
+		if (!childNode) return vec4(0);
+		const childTexture = convertToTexture(childNode);
+		onCleanup(() => {
+			if (childTexture?.renderTarget?.dispose) childTexture.renderTarget.dispose();
+		});
+		const t = createAnimatedTime(params, uniforms.speed);
+		const shapeType = uniforms.shape3dType.uniform.value;
+		const parse = (raw) => {
+			try {
+				return JSON.parse(typeof raw === "string" ? raw : JSON.stringify(raw));
+			} catch {
+				return {};
+			}
+		};
+		const cfg0 = parse(uniforms.shape3d.uniform.value);
+		const DEG = Math.PI / 180;
+		const TAU_RATE = Math.PI * 2 / 10;
+		const makeRotSpin = (defaults) => {
+			const u_rotX = uniform((cfg0.rotX ?? defaults.rotX ?? 0) * DEG);
+			const u_rotY = uniform((cfg0.rotY ?? defaults.rotY ?? 0) * DEG);
+			const u_rotZ = uniform((cfg0.rotZ ?? defaults.rotZ ?? 0) * DEG);
+			const u_spinAngleX = uniform(0);
+			const u_spinAngleY = uniform(0);
+			const u_spinAngleZ = uniform(0);
+			onBeforeRender(({ deltaTime }) => {
+				const cfg = parse(uniforms.shape3d.uniform.value);
+				const speed = uniforms.speed.uniform.value;
+				u_rotX.value = (cfg.rotX ?? defaults.rotX ?? 0) * DEG;
+				u_rotY.value = (cfg.rotY ?? defaults.rotY ?? 0) * DEG;
+				u_rotZ.value = (cfg.rotZ ?? defaults.rotZ ?? 0) * DEG;
+				u_spinAngleX.value += deltaTime * speed * (cfg.spinX ?? defaults.spinX ?? 0) * TAU_RATE;
+				u_spinAngleY.value += deltaTime * speed * (cfg.spinY ?? defaults.spinY ?? 0) * TAU_RATE;
+				u_spinAngleZ.value += deltaTime * speed * (cfg.spinZ ?? defaults.spinZ ?? 0) * TAU_RATE;
+			});
+			return {
+				u_rotX,
+				u_rotY,
+				u_rotZ,
+				u_spinAngleX,
+				u_spinAngleY,
+				u_spinAngleZ
+			};
+		};
+		let shape;
+		if (shapeType === "torus") {
+			const u_outerR = uniform((cfg0.outerRadius ?? 60) * .008 + .1);
+			const u_tubeR = uniform((cfg0.tubeRadius ?? 25) * .006 + .05);
+			const { u_rotX, u_rotY, u_rotZ, u_spinAngleX, u_spinAngleY, u_spinAngleZ } = makeRotSpin({
+				rotX: -90,
+				rotY: 0,
+				rotZ: 0,
+				spinX: 0,
+				spinY: .05,
+				spinZ: 0
+			});
+			onBeforeRender(() => {
+				const cfg = parse(uniforms.shape3d.uniform.value);
+				u_outerR.value = (cfg.outerRadius ?? 60) * .008 + .1;
+				u_tubeR.value = (cfg.tubeRadius ?? 25) * .006 + .05;
+			});
+			shape = createTorusShape({
+				outerRadius: u_outerR,
+				tubeRadius: u_tubeR,
+				rotX: u_rotX,
+				rotY: u_rotY,
+				rotZ: u_rotZ,
+				spinAngleX: u_spinAngleX,
+				spinAngleY: u_spinAngleY,
+				spinAngleZ: u_spinAngleZ
+			});
+		} else if (shapeType === "box") {
+			const u_halfX = uniform((cfg0.sizeX ?? 50) * .006);
+			const u_halfY = uniform((cfg0.sizeY ?? 50) * .006);
+			const u_halfZ = uniform((cfg0.sizeZ ?? 50) * .006);
+			const u_rounding = uniform((cfg0.rounding ?? 20) * .001);
+			const { u_rotX, u_rotY, u_rotZ, u_spinAngleX, u_spinAngleY, u_spinAngleZ } = makeRotSpin({
+				rotX: 15,
+				rotY: 0,
+				rotZ: 0,
+				spinX: 0,
+				spinY: .1,
+				spinZ: 0
+			});
+			onBeforeRender(() => {
+				const cfg = parse(uniforms.shape3d.uniform.value);
+				u_halfX.value = (cfg.sizeX ?? 50) * .006;
+				u_halfY.value = (cfg.sizeY ?? 50) * .006;
+				u_halfZ.value = (cfg.sizeZ ?? 50) * .006;
+				u_rounding.value = (cfg.rounding ?? 20) * .001;
+			});
+			shape = createBoxShape({
+				halfExtents: vec3(u_halfX, u_halfY, u_halfZ),
+				rounding: u_rounding,
+				rotX: u_rotX,
+				rotY: u_rotY,
+				rotZ: u_rotZ,
+				spinAngleX: u_spinAngleX,
+				spinAngleY: u_spinAngleY,
+				spinAngleZ: u_spinAngleZ
+			});
+		} else if (shapeType === "sphere") {
+			const u_radius = uniform((cfg0.radius ?? 60) * .008 + .1);
+			const { u_rotX, u_rotY, u_rotZ, u_spinAngleX, u_spinAngleY, u_spinAngleZ } = makeRotSpin({
+				rotX: 0,
+				rotY: 0,
+				rotZ: 0,
+				spinX: 0,
+				spinY: .1,
+				spinZ: 0
+			});
+			onBeforeRender(() => {
+				u_radius.value = (parse(uniforms.shape3d.uniform.value).radius ?? 60) * .008 + .1;
+			});
+			shape = createSphereShape({
+				radius: u_radius,
+				rotX: u_rotX,
+				rotY: u_rotY,
+				rotZ: u_rotZ,
+				spinAngleX: u_spinAngleX,
+				spinAngleY: u_spinAngleY,
+				spinAngleZ: u_spinAngleZ
+			});
+		} else if (shapeType === "capsule") {
+			const u_radius = uniform((cfg0.radius ?? 25) * .006 + .05);
+			const u_halfHeight = uniform((cfg0.height ?? 80) * .005);
+			const { u_rotX, u_rotY, u_rotZ, u_spinAngleX, u_spinAngleY, u_spinAngleZ } = makeRotSpin({
+				rotX: 0,
+				rotY: 0,
+				rotZ: 0,
+				spinX: 0,
+				spinY: .1,
+				spinZ: 0
+			});
+			onBeforeRender(() => {
+				const cfg = parse(uniforms.shape3d.uniform.value);
+				u_radius.value = (cfg.radius ?? 25) * .006 + .05;
+				u_halfHeight.value = (cfg.height ?? 80) * .005;
+			});
+			shape = createCapsuleShape({
+				radius: u_radius,
+				halfHeight: u_halfHeight,
+				rotX: u_rotX,
+				rotY: u_rotY,
+				rotZ: u_rotZ,
+				spinAngleX: u_spinAngleX,
+				spinAngleY: u_spinAngleY,
+				spinAngleZ: u_spinAngleZ
+			});
+		} else if (shapeType === "mobius") {
+			const u_ringRadius = uniform((cfg0.ringRadius ?? 60) * .008 + .1);
+			const u_halfWidth = uniform((cfg0.halfWidth ?? 30) * .005);
+			const u_thickness = uniform((cfg0.thickness ?? 8) * .001 + .005);
+			const { u_rotX, u_rotY, u_rotZ, u_spinAngleX, u_spinAngleY, u_spinAngleZ } = makeRotSpin({
+				rotX: -30,
+				rotY: 0,
+				rotZ: 0,
+				spinX: 0,
+				spinY: .05,
+				spinZ: 0
+			});
+			onBeforeRender(() => {
+				const cfg = parse(uniforms.shape3d.uniform.value);
+				u_ringRadius.value = (cfg.ringRadius ?? 60) * .008 + .1;
+				u_halfWidth.value = (cfg.halfWidth ?? 30) * .005;
+				u_thickness.value = (cfg.thickness ?? 8) * .001 + .005;
+			});
+			shape = createMobiusShape({
+				ringRadius: u_ringRadius,
+				halfWidth: u_halfWidth,
+				thickness: u_thickness,
+				rotX: u_rotX,
+				rotY: u_rotY,
+				rotZ: u_rotZ,
+				spinAngleX: u_spinAngleX,
+				spinAngleY: u_spinAngleY,
+				spinAngleZ: u_spinAngleZ
+			});
+		} else {
+			const u_angle = uniform((cfg0.angle ?? 0) * DEG);
+			const u_twist = uniform((cfg0.twist ?? 50) * .03);
+			const u_width = uniform((cfg0.width ?? 40) * .012);
+			const u_thickness = uniform((cfg0.thickness ?? 20) * .001 + .01);
+			const u_seed = uniform(cfg0.seed ?? 0);
+			onBeforeRender(() => {
+				const cfg = parse(uniforms.shape3d.uniform.value);
+				u_angle.value = (cfg.angle ?? 0) * DEG;
+				u_twist.value = (cfg.twist ?? 50) * .03;
+				u_width.value = (cfg.width ?? 40) * .012;
+				u_thickness.value = (cfg.thickness ?? 20) * .001 + .01;
+				u_seed.value = cfg.seed ?? 0;
+			});
+			shape = createRibbonShape({
+				angleRad: u_angle,
+				twistAmt: u_twist,
+				halfW: u_width.mul(.5),
+				ribbonWidth: u_width,
+				ribbonThickness: u_thickness,
+				twistPhase: u_seed,
+				t
+			});
+		}
+		return applyDistortion3D(childTexture, shape, uniforms, {
+			ribbon: {
+				steps: 128,
+				stepCap: .08,
+				hitEps: .002
+			},
+			torus: {
+				steps: 96,
+				stepCap: .5,
+				hitEps: .001
+			},
+			box: {
+				steps: 96,
+				stepCap: .5,
+				hitEps: .001
+			},
+			sphere: {
+				steps: 64,
+				stepCap: 1.5,
+				hitEps: .001
+			},
+			capsule: {
+				steps: 64,
+				stepCap: 1.5,
+				hitEps: .001
+			},
+			mobius: {
+				steps: 96,
+				stepCap: .3,
+				hitEps: .001
+			}
+		}[shapeType] ?? {
+			steps: 96,
+			stepCap: .5,
+			hitEps: .001
+		});
+	}
+};
+var Form3D_default = componentDefinition;
+export { componentDefinition as n, Form3D_default as t };