framefields 2.2.0 → 2.3.1

package/dist/{dist-cjxDXQdx.mjs → dist-jU289ehm.mjs}

@@ -26508,7 +26508,8 @@ struct SkinningUniforms {
 @group(0) @binding(0) var<uniform> cam      : CameraUniforms;
 @group(1) @binding(0) var<uniform> model    : ModelUniforms;
 @group(1) @binding(1) var<uniform> skinning : SkinningUniforms;
-${matte3dWgsl(1, 2)}@group(2) @binding(0) var texSampler        : sampler;
+${matte3dWgsl(1, 2)}@group(1) @binding(3) var backdropTex : texture_2d<f32>;
+@group(2) @binding(0) var texSampler        : sampler;
 @group(2) @binding(1) var mainTex           : texture_2d<f32>;
 @group(2) @binding(2) var normalTex         : texture_2d<f32>;
 @group(2) @binding(3) var metalRoughTex     : texture_2d<f32>;
@@ -26630,6 +26631,75 @@ fn perturbNormal(N: vec3<f32>, p: vec3<f32>, uv: vec2<f32>, tn: vec3<f32>, dp1:
     return normalize(T * (tn.x * invmax) - B * (tn.y * invmax) + N * tn.z);
 }
 
+// Glass: what is behind the 3D batch on screen (backdrop), bent by
+// refraction along the surface normal with a red/blue split, frosted by a
+// disc blur, tinted by the color, under Fresnel-weighted reflections.
+// shade.rgb = (dispersion, thickness px, frost), pbr.w = ior.
+fn backdropAt(uv: vec2<f32>) -> vec3<f32> {
+    return textureSampleLevel(backdropTex, texSampler, clamp(uv, vec2<f32>(0.001), vec2<f32>(0.999)), 0.0).rgb;
+}
+
+// rimWidth: how much 1 - N·V changes across this pixel (fwidth, taken in
+// uniform control flow by the caller). Rim effects narrower than a pixel are
+// faded out, or per-pixel shading turns them into stair-stepped lines that
+// MSAA (coverage only) cannot smooth.
+fn shadeGlass(in: VertexOutput, Nin: vec3<f32>, tint: vec3<f32>, alpha: f32, rimWidth: f32) -> MeshFragment {
+    let V = normalize(cam.cameraPos.xyz - in.worldPos);
+    var N = Nin;
+    if (dot(N, V) < 0.0) { N = -N; }
+    let NdotV = clamp(dot(N, V), 0.0, 1.0);
+    // Also fade toward edge-on: a face seen at a grazing angle is a sliver
+    // under a pixel tall (a slab's bottom), which would alias the same way.
+    let rimAA = clamp(1.0 - rimWidth * 2.5, 0.0, 1.0) * smoothstep(0.03, 0.22, NdotV);
+    let rim = (1.0 - NdotV) * rimAA;
+    let ior = max(model.pbr.w, 1.0001);
+    let screen = max(cam.screenParams.xy, vec2<f32>(1.0));
+    let uv = in.clipPos.xy / screen;
+    // Screen-space bend: the normal's in-plane part, stronger toward the rim.
+    let bend = N.xy * model.shade.g * (1.0 - 1.0 / ior) * (0.6 + rim) * rimAA / screen;
+    let disp = model.shade.r;
+    let frost = model.shade.b * 22.0 / screen;
+    var col = vec3<f32>(0.0);
+    let taps = select(1, 8, model.shade.b > 0.001);
+    for (var i = 0; i < taps; i++) {
+        let a = f32(i) * 2.399963;
+        let r = sqrt((f32(i) + 0.5) / f32(taps));
+        let o = select(vec2<f32>(0.0), vec2<f32>(cos(a), sin(a)) * r * frost, taps > 1);
+        col += vec3<f32>(
+            backdropAt(uv - bend * (1.0 + disp * 6.0) + o).r,
+            backdropAt(uv - bend + o).g,
+            backdropAt(uv - bend * (1.0 - disp * 6.0) + o).b,
+        );
+    }
+    col /= f32(taps);
+    // Light travels further through the glass toward the rim: the tint
+    // deepens and the body darkens there, which is what outlines glass.
+    let depthTint = mix(vec3<f32>(1.0), tint, 0.55 + 0.45 * rim);
+    let transmitted = col * depthTint * (1.0 - 0.45 * rim * rim);
+    let f0 = pow((ior - 1.0) / (ior + 1.0), 2.0);
+    let F = f0 + (1.0 - f0) * pow(rim, 5.0);
+    let lit = shadeSurfaceFull(in.worldPos, N, vec3<f32>(0.0), model.materialParams, vec4<f32>(model.pbr.x, 0.0, 0.0, 0.0), vec4<f32>(0.0));
+    // Grazing faces mirror the room; keep that faint so dark scenes stay dark
+    // and the studio highlights below carry the shape.
+    let sheen = vec3<f32>(0.9, 0.94, 1.0) * F * 0.22 + tint * 0.05 * (0.4 + rim);
+    // A studio in the reflection: a sharp key and two strip softboxes, which
+    // is most of what makes glass read as glass.
+    let R = reflect(-V, N);
+    // Tight: a flat face only flashes as it turns through the light.
+    let key = pow(max(dot(R, normalize(vec3<f32>(-0.45, -0.75, -0.5))), 0.0), 600.0) * 1.8;
+    // Two tall softboxes: narrow bands in the reflection, brightest above.
+    let strips = (1.0 - smoothstep(0.03, 0.07, abs(R.x + 0.45))) * smoothstep(0.3, -0.5, R.y) * 1.1
+        + (1.0 - smoothstep(0.02, 0.05, abs(R.x - 0.6))) * smoothstep(0.4, -0.3, R.y) * 0.7;
+    let studio = vec3<f32>(1.0, 0.98, 0.95) * (key + strips * (0.25 + F));
+    // A thin bright line where the surface turns away: glass silhouettes.
+    let edge = vec3<f32>(1.0, 0.99, 0.97) * smoothstep(0.8, 0.97, rim) * 0.55;
+    let rgb = transmitted * (1.0 - F) + lit.display + sheen + studio + edge;
+    var out: MeshFragment;
+    out.color = vec4<f32>(rgb * alpha, alpha);
+    out.hdr = vec4<f32>(srgbToLinear(transmitted * (1.0 - F)) * alpha + lit.hdr * alpha + srgbToLinear(sheen + studio + edge) * alpha, alpha);
+    return out;
+}
+
 fn shadeMesh(in: VertexOutput, isFront: bool) -> MeshFragment {
     // Every sample and derivative up front, in uniform control flow.
     var texColor = textureSample(mainTex, texSampler, in.uv);
@@ -26641,6 +26711,7 @@ fn shadeMesh(in: VertexOutput, isFront: bool) -> MeshFragment {
     let dp2 = dpdy(in.worldPos);
     let duv1 = dpdx(in.uv);
     let duv2 = dpdy(in.uv);
+    let rimWidth = fwidth(1.0 - abs(dot(normalize(in.worldNormal), normalize(cam.cameraPos.xyz - in.worldPos))));
 
     if (!isFront && model.params.y < 0.5) {
         discard;
@@ -26681,6 +26752,9 @@ fn shadeMesh(in: VertexOutput, isFront: bool) -> MeshFragment {
         pbr.x = select(pbr.x, 1.0, pbr.x < 0.0) * mrSample.g;
         pbr.y = pbr.y * mrSample.b;
     }
+    if (model.pbr.z > 0.5) {
+        return shadeGlass(in, N, baseRgb, alpha, rimWidth);
+    }
     var material = model.materialParams;
     material.z = material.z * mix(1.0, aoSample, clamp(model.maps.y, 0.0, 1.0));
     var emissive = model.emissive;
@@ -27372,7 +27446,8 @@ var Mesh3DPipeline = class {
 					visibility: GPUShaderStage.VERTEX,
 					buffer: { type: "uniform" }
 				},
-				matteLayoutEntry(2)
+				matteLayoutEntry(2),
+				matteLayoutEntry(3)
 			]
 		});
 		this.textureLayout = device.createBindGroupLayout({
@@ -27555,6 +27630,14 @@ var Mesh3DPipeline = class {
 		this.modelData[57] = maps?.occlusion ? maps.occlusionStrength ?? 1 : 0;
 		this.modelData[58] = maps?.metallicRoughness ? 1 : 0;
 		this.modelData[59] = maps?.emissive ? 1 : 0;
+		const glass = data.glass;
+		if (glass) {
+			this.modelData[44] = glass.dispersion;
+			this.modelData[45] = glass.thickness;
+			this.modelData[46] = glass.frost;
+			this.modelData[50] = 1;
+			this.modelData[51] = glass.ior;
+		}
 		const modelBuffer = this.modelPool.getBuffer(this.device, this.modelData);
 		const skinningBuffer = data.isSkinned && data.skinningMatrices ? this.skinningPool.getBuffer(this.device, data.skinningMatrices) : this.defaultSkinningBuffer;
 		return this.device.createBindGroup({
@@ -27571,6 +27654,10 @@ var Mesh3DPipeline = class {
 				{
 					binding: 2,
 					resource: data.matte?.createView() ?? fullCoverageView(this.device)
+				},
+				{
+					binding: 3,
+					resource: data.glass && data.backdrop?.createView() || fullCoverageView(this.device)
 				}
 			]
 		});
@@ -28118,43 +28205,125 @@ function organizeGlyphPolygons({ contours: glyphContours, simplified }) {
 	}
 	return polygons;
 }
+/** Where segments ab and cd cross strictly inside both, or null. */
+function segmentCrossing(a, b, c, d) {
+	const rx = b.x - a.x;
+	const ry = b.y - a.y;
+	const sx = d.x - c.x;
+	const sy = d.y - c.y;
+	const den = rx * sy - ry * sx;
+	if (Math.abs(den) < 1e-12) return null;
+	const t = ((c.x - a.x) * sy - (c.y - a.y) * sx) / den;
+	const u = ((c.x - a.x) * ry - (c.y - a.y) * rx) / den;
+	const eps = 1e-9;
+	if (t <= eps || t >= 1 - eps || u <= eps || u >= 1 - eps) return null;
+	return {
+		x: a.x + rx * t,
+		y: a.y + ry * t
+	};
+}
 /**
-* For outlines that may overlap: fonts wind filled contours one way and holes
-* the other, so the winding of the largest contour marks the outlines; each
-* hole goes to the smallest outline around it. Overlapping outlines become
-* separate solids, which look the same once extruded.
+* Splits a contour that crosses itself into simple loops: at each crossing
+* the contour is cut into the part between the two crossing edges and the
+* rest. Font outlines meant to be filled with the nonzero rule (variable
+* fonts, overlapping strokes) often cross themselves, and a triangulator
+* given such a contour fills the wrong areas (a "V" with its notch filled).
+*/
+function untangleContour(contour, depth = 0) {
+	const n = contour.length;
+	if (n < 3) return [];
+	if (depth > 64) return [contour];
+	for (let i = 0; i < n; i++) {
+		const a = contour[i];
+		const b = contour[(i + 1) % n];
+		for (let j = i + 2; j < n; j++) {
+			if (i === 0 && j === n - 1) continue;
+			const x = segmentCrossing(a, b, contour[j], contour[(j + 1) % n]);
+			if (!x) continue;
+			const inner = [x, ...contour.slice(i + 1, j + 1)];
+			const outer = [
+				x,
+				...contour.slice(j + 1),
+				...contour.slice(0, i + 1)
+			];
+			return [...untangleContour(inner, depth + 1), ...untangleContour(outer, depth + 1)];
+		}
+	}
+	return Math.abs(computeContourSignedArea(contour)) > 1e-9 ? [contour] : [];
+}
+/** Nonzero winding number of a set of contours around a point. */
+function windingNumber(p, contours) {
+	let w = 0;
+	for (const c of contours) for (let i = 0; i < c.length; i++) {
+		const a = c[i];
+		const b = c[(i + 1) % c.length];
+		const side = (b.x - a.x) * (p.y - a.y) - (p.x - a.x) * (b.y - a.y);
+		if (a.y <= p.y) {
+			if (b.y > p.y && side > 0) w++;
+		} else if (b.y <= p.y && side < 0) w--;
+	}
+	return w;
+}
+/** A point just inside a simple loop, next to its longest edge. */
+function pointJustInside(loop) {
+	let best = 0;
+	let bestLen = -1;
+	for (let i = 0; i < loop.length; i++) {
+		const a$1 = loop[i];
+		const b$1 = loop[(i + 1) % loop.length];
+		const len = Math.hypot(b$1.x - a$1.x, b$1.y - a$1.y);
+		if (len > bestLen) {
+			bestLen = len;
+			best = i;
+		}
+	}
+	const a = loop[best];
+	const b = loop[(best + 1) % loop.length];
+	const mx = (a.x + b.x) / 2;
+	const my = (a.y + b.y) / 2;
+	const eps = Math.max(1e-4, Math.min(.01, bestLen * .001));
+	const nx = -(b.y - a.y) / bestLen * eps;
+	const ny = (b.x - a.x) / bestLen * eps;
+	const p = {
+		x: mx + nx,
+		y: my + ny
+	};
+	return isPointInsidePolygon(p, loop) ? p : {
+		x: mx - nx,
+		y: my - ny
+	};
+}
+/**
+* For outlines that were not simplified (no skia, as in the browser):
+* contours may cross themselves and each other, and are meant to be filled
+* with the nonzero rule. Self-crossings are split into simple loops; a loop
+* whose inside is filled under the nonzero rule becomes an outline, and one
+* that is empty (a counter) becomes a hole of the smallest outline around it.
+* Overlapping outlines become separate solids, which look the same once
+* extruded.
 */
 function organizeByWinding(glyphContours) {
-	const contours = glyphContours.map((contour) => {
-		const signed = computeContourSignedArea(contour);
-		return {
-			contour,
-			signed,
-			area: Math.abs(signed)
-		};
-	});
-	if (contours.length === 0) return [];
-	contours.sort((a, b) => b.area - a.area);
-	const filled = Math.sign(contours[0].signed);
+	const loops = glyphContours.flatMap((c) => untangleContour(c));
 	const polygons = [];
-	for (const c of contours) if (Math.sign(c.signed) === filled) polygons.push({
-		outer: c.contour,
+	const holes = [];
+	for (const loop of loops) if (windingNumber(pointJustInside(loop), glyphContours) !== 0) polygons.push({
+		outer: loop,
 		holes: []
 	});
-	for (const c of contours) {
-		if (Math.sign(c.signed) === filled) continue;
-		const probe = c.contour[0];
-		const mid = c.contour[Math.floor(c.contour.length / 2)];
+	else holes.push(loop);
+	for (const hole of holes) {
+		const area = Math.abs(computeContourSignedArea(hole));
+		const probe = pointJustInside(hole);
 		let home;
 		let homeArea = Number.POSITIVE_INFINITY;
 		for (const poly of polygons) {
-			const area = Math.abs(computeContourSignedArea(poly.outer));
-			if (area > c.area && area < homeArea && (isPointInsidePolygon(probe, poly.outer) || isPointInsidePolygon(mid, poly.outer))) {
+			const outerArea = Math.abs(computeContourSignedArea(poly.outer));
+			if (outerArea > area && outerArea < homeArea && isPointInsidePolygon(probe, poly.outer)) {
 				home = poly;
-				homeArea = area;
+				homeArea = outerArea;
 			}
 		}
-		home?.holes.push(c.contour);
+		home?.holes.push(hole);
 	}
 	return polygons;
 }
@@ -30131,7 +30300,16 @@ var Renderer3D = class {
 			addressModeU: address,
 			addressModeV: address
 		});
+		const glassy = material === "glass" || material === "acrylic" || material === "frosted";
+		const glass = glassy ? {
+			ior: opts.ior ?? (material === "acrylic" ? 1.49 : 1.5),
+			dispersion: opts.dispersion ?? (material === "glass" ? .04 : .015),
+			thickness: opts.thickness ?? 80,
+			frost: material === "frosted" ? roughness ?? .5 : 0
+		} : void 0;
 		this.mesh3dPipeline.draw(pass, cameraBindGroup, lightsBindGroup, meshBuffers, texture, sampler, {
+			glass,
+			backdrop: opts.backdrop,
 			modelMatrix: m,
 			normalMatrix,
 			colorTint,
@@ -30140,11 +30318,11 @@ var Renderer3D = class {
 			wireframe,
 			isSkinned,
 			skinningMatrices,
-			material,
+			material: material === "unlit" || material === "toon" ? material : "lit",
 			shadeColor,
 			alphaCutoff,
 			shininess,
-			roughness,
+			roughness: glassy ? Math.min(roughness ?? .05, .3) : roughness,
 			specularIntensity,
 			ambientIntensity,
 			metallic,
@@ -30956,5 +31134,5 @@ var NodeSurfaceProvider = class {
 if (typeof globalThis !== "undefined") globalThis.__GATEWAI_DELAYS__ = globalThis.__GATEWAI_DELAYS__ || /* @__PURE__ */ new Set();
 
 //#endregion
-export { spansText as $, TextWigglySelectorSchema as $t, fitSpansToText as A, samplePathChainGeometry as An, KineticMarqueeConfigSchema as At, loadOBJ as B, Spatial3DPropertiesSchema as Bt, drawImageNode as C, generateArcLengthLUT as Cn, CubicBezierSegmentSchema as Ct, drawSvgNode as D, parseSvgPathToCubicBeziers as Dn, ExtendedGlyphPropertiesSchema as Dt, drawSignalNode as E, getShuffledOrder as En, ExpressionSelectorSchema as Et, initHeadlessWebGPU as F, SelectorModeSchema as Ft, parseFBX as G, TextCursorStyleSchema as Gt, measureMaxCaptionHeight as H, TextAnchorConfigSchema as Ht, inputStore as I, SelectorShapeSchema as It, poseNodes as J, TextPathSourceSchema as Jt, parseMTL as K, TextPathBuilder as Kt, jointMatrices as L, SelectorUnitsSchema as Lt, getHeadlessFontPath as M, waveToCubicBeziers as Mn, LongShadowConfigSchema as Mt, getPrimitiveGeometry as N, ParticleDissolveConfigSchema as Nt, drawVideoNode as O, sampleAudioSpectrumScale as On, GlyphAnchorGroupingSchema as Ot, getRenderer2D as P, SelectorBasedOnSchema as Pt, shaderStore as Q, TextSignalSelectorSchema as Qt, loadFBX as R, SignalRegistry as Rt, drawGifNode as S, evaluateVolumetricFormation as Sn, ChromaticGlitchConfigSchema as St, drawParagraphNode as T, getScramblePool as Tn, EnhancedTextNodeSchema as Tt, mediaDecoderCache as U, TextAnimatorBuilder as Ut, lutStore as V, SpringPhysicsSchema as Vt, parseColor as W, TextCursorConfigSchema as Wt, registerHeadlessFont as X, TextScrambleConfigSchema as Xt, probeVideoSize as Y, TextRangeSelectorSchema as Yt, resolveTextSpans as Z, TextSelectorSchema as Zt, clearAllVideoCache as _, evaluateMarqueeOffset as _n, AnchorGroupingSchema as _t, GlassPipeline as a, VolumetricFormationModeSchema as an, ENVIRONMENT_PRESETS as at, describeGpu as b, evaluateSpringProgress as bn, AudioSignalComputePipeline as bt, Renderer2D as c, computeAnchorPivotOffset as cn, MAX_LIGHTS as ct, ScreenSpaceRelightPipeline as d, deterministicWigglyNoise as dn, Vector3Math as dt, TypewriterAnimatorSchema as en, srtLoader as et, ShadowPipeline as f, distanceToCurveParameter as fn, parseColorToRgb as ft, WebGPUAudioProcessor as g, evaluateExpressionSelector as gn, AdvancedTextAnimatorSchema as gt, SlugPipeline as h, evaluateCubicBezierDerivative as hn, AdvancedTextAnimatorBuilder as ht, EffectPipeline as i, VolumetricFormationConfigSchema as in, Camera3D as it, generateExtrudedTextGeometry as j, signalRegistry as jn, LineSpacingDynamicsSchema as jt, ensureDevice as k, sampleCurveGeometry as kn, GlyphAnchorPointSchema as kt, Renderer3D as l, computeLineLeadingDisplacement as ln, Matrix4Math as lt, SlugGeometry as m, evaluateCubicBezier as mn, AETextAnimatorSchema as mt, AudioLatentTrackCache as n, VariableFontAxesSchema as nn, GetFontAssetUrl as nt, MotionBlurPipeline as o, buildPathLUT as on, LIGHT_UNIFORM_SIZE_BYTES as ot, SlugFontCache as p, ellipseToCubicBeziers as pn, resolveEnvironment as pt, parseOBJ as q, TextPathOptionsSchema as qt, AudioMeshDeformPipeline as r, Vec2Schema as rn, resolveMediaSourceUrl as rt, NodeSurfaceProvider as s, buildWGSLSignalFn as sn, Light3D as st, AudioLatentEngine as t, TypingCadenceSchema as tn, textureCache as tt, SSAOPipeline as u, computeRangeSelectorWeight as un, Path3D as ut, clearHeadlessFonts as v, evaluateSelectorCombination as vn, AnchorPresetSchema as vt, drawLottieNode as w, generatePathSegments as wn, DynamicStrokePropertiesSchema as wt, drawCaptionNode as x, evaluateTypewriterState as xn, AudioSpectrumTypographySchema as xt, colorMatrixWgsl as y, evaluateSkewMatrix as yn, AnimatableGlyphPropsSchema as yt, loadModel3D as z, SkewPropertiesSchema as zt };
-//# sourceMappingURL=dist-cjxDXQdx.mjs.map
+export { resolveTextSpans as $, TextSelectorSchema as $t, ensureDevice as A, sampleAudioSpectrumScale as An, GlyphAnchorGroupingSchema as At, loadModel3D as B, SignalRegistry as Bt, drawGifNode as C, evaluateTypewriterState as Cn, AudioSpectrumTypographySchema as Ct, drawSignalNode as D, getScramblePool as Dn, EnhancedTextNodeSchema as Dt, drawParagraphNode as E, generatePathSegments as En, DynamicStrokePropertiesSchema as Et, getRenderer2D as F, ParticleDissolveConfigSchema as Ft, parseColor as G, TextAnimatorBuilder as Gt, lutStore as H, Spatial3DPropertiesSchema as Ht, initHeadlessWebGPU as I, SelectorBasedOnSchema as It, parseOBJ as J, TextPathBuilder as Jt, parseFBX as K, TextCursorConfigSchema as Kt, inputStore as L, SelectorModeSchema as Lt, generateExtrudedTextGeometry as M, samplePathChainGeometry as Mn, KineticMarqueeConfigSchema as Mt, getHeadlessFontPath as N, signalRegistry as Nn, LineSpacingDynamicsSchema as Nt, drawSvgNode as O, getShuffledOrder as On, ExpressionSelectorSchema as Ot, getPrimitiveGeometry as P, waveToCubicBeziers as Pn, LongShadowConfigSchema as Pt, registerHeadlessFont as Q, TextScrambleConfigSchema as Qt, jointMatrices as R, SelectorShapeSchema as Rt, drawCaptionNode as S, evaluateSpringProgress as Sn, AudioSignalComputePipeline as St, drawLottieNode as T, generateArcLengthLUT as Tn, CubicBezierSegmentSchema as Tt, measureMaxCaptionHeight as U, SpringPhysicsSchema as Ut, loadOBJ as V, SkewPropertiesSchema as Vt, mediaDecoderCache as W, TextAnchorConfigSchema as Wt, poseNodes as X, TextPathSourceSchema as Xt, parseSvgPathToSegments as Y, TextPathOptionsSchema as Yt, probeVideoSize as Z, TextRangeSelectorSchema as Zt, buildShapeSvgPath as _, evaluateCubicBezierDerivative as _n, AdvancedTextAnimatorBuilder as _t, GlassPipeline as a, Vec2Schema as an, resolveMediaSourceUrl as at, colorMatrixWgsl as b, evaluateSelectorCombination as bn, AnchorPresetSchema as bt, Renderer2D as c, buildPathLUT as cn, LIGHT_UNIFORM_SIZE_BYTES as ct, ScreenSpaceRelightPipeline as d, computeLineLeadingDisplacement as dn, Matrix4Math as dt, TextSignalSelectorSchema as en, shaderStore as et, ShadowPipeline as f, computeRangeSelectorWeight as fn, Path3D as ft, WebGPUAudioProcessor as g, evaluateCubicBezier as gn, AETextAnimatorSchema as gt, SlugPipeline as h, ellipseToCubicBeziers as hn, resolveEnvironment as ht, EffectPipeline as i, VariableFontAxesSchema as in, GetFontAssetUrl as it, fitSpansToText as j, sampleCurveGeometry as jn, GlyphAnchorPointSchema as jt, drawVideoNode as k, parseSvgPathToCubicBeziers as kn, ExtendedGlyphPropertiesSchema as kt, Renderer3D as l, buildWGSLSignalFn as ln, Light3D as lt, SlugGeometry as m, distanceToCurveParameter as mn, parseColorToRgb as mt, AudioLatentTrackCache as n, TypewriterAnimatorSchema as nn, srtLoader as nt, MotionBlurPipeline as o, VolumetricFormationConfigSchema as on, Camera3D as ot, SlugFontCache as p, deterministicWigglyNoise as pn, Vector3Math as pt, parseMTL as q, TextCursorStyleSchema as qt, AudioMeshDeformPipeline as r, TypingCadenceSchema as rn, textureCache as rt, NodeSurfaceProvider as s, VolumetricFormationModeSchema as sn, ENVIRONMENT_PRESETS as st, AudioLatentEngine as t, TextWigglySelectorSchema as tn, spansText as tt, SSAOPipeline as u, computeAnchorPivotOffset as un, MAX_LIGHTS as ut, clearAllVideoCache as v, evaluateExpressionSelector as vn, AdvancedTextAnimatorSchema as vt, drawImageNode as w, evaluateVolumetricFormation as wn, ChromaticGlitchConfigSchema as wt, describeGpu as x, evaluateSkewMatrix as xn, AnimatableGlyphPropsSchema as xt, clearHeadlessFonts as y, evaluateMarqueeOffset as yn, AnchorGroupingSchema as yt, loadFBX as z, SelectorUnitsSchema as zt };
+//# sourceMappingURL=dist-jU289ehm.mjs.map