framefields 2.3.0 → 2.3.1

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

@@ -28205,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
+	};
+}
+/**
+* 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 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.
+* 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;
 }
@@ -31053,4 +31135,4 @@ if (typeof globalThis !== "undefined") globalThis.__GATEWAI_DELAYS__ = globalThi
 
 //#endregion
 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-PwT_Vmax.mjs.map
+//# sourceMappingURL=dist-jU289ehm.mjs.map