@3driseai/3drise-viewer 0.1.28 → 0.1.30

package/dist/components/text/HandwritingText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HandwritingText.d.ts","sourceRoot":"","sources":["../../../src/components/text/HandwritingText.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACtG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAYhE,MAAM,WAAW,oBAAqB,SAAQ,gBAAgB;IAC1D,MAAM,EAAE,qBAAqB,CAAC;IAC9B,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,kEAAkE;IAClE,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/B,6DAA6D;IAC7D,SAAS,CAAC,EAAE,eAAe,CAAC;CAC/B;AAED,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAA+D,CAAC;AAEpH,eAAe,eAAe,CAAC"}

package/dist/components/text/HandwritingText.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import TextObjectView from './TextObjectView.js';
+const HandwritingText = (props) => _jsx(TextObjectView, { look: "handwriting", ...props });
+export default HandwritingText;

package/dist/components/text/InkBleedText.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { AnimationOptions, MouseMoveDomain, InkBleedTextConfig } from '@3driseai/3drise-core';
+import type { ObjectReadyProps } from '../../types/objectReady';
+export interface InkBleedTextProps extends ObjectReadyProps {
+    config: InkBleedTextConfig;
+    /** Scene object id: the live-edit handle is found by it. */
+    id?: string;
+    /** Keyframes on the config knobs (animations.text.animations). */
+    keyframes?: AnimationOptions[];
+    /** Pointer bindings on the config knobs (mouseMove.text). */
+    mouseMove?: MouseMoveDomain;
+}
+declare const InkBleedText: React.FC<InkBleedTextProps>;
+export default InkBleedText;
+//# sourceMappingURL=InkBleedText.d.ts.map

package/dist/components/text/InkBleedText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InkBleedText.d.ts","sourceRoot":"","sources":["../../../src/components/text/InkBleedText.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACnG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAYhE,MAAM,WAAW,iBAAkB,SAAQ,gBAAgB;IACvD,MAAM,EAAE,kBAAkB,CAAC;IAC3B,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,kEAAkE;IAClE,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/B,6DAA6D;IAC7D,SAAS,CAAC,EAAE,eAAe,CAAC;CAC/B;AAED,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAA4D,CAAC;AAE3G,eAAe,YAAY,CAAC"}

package/dist/components/text/InkBleedText.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import TextObjectView from './TextObjectView.js';
+const InkBleedText = (props) => _jsx(TextObjectView, { look: "inkBleed", ...props });
+export default InkBleedText;

package/dist/components/text/LightPaintingText.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { AnimationOptions, MouseMoveDomain, LightPaintingTextConfig } from '@3driseai/3drise-core';
+import type { ObjectReadyProps } from '../../types/objectReady';
+export interface LightPaintingTextProps extends ObjectReadyProps {
+    config: LightPaintingTextConfig;
+    /** Scene object id: the live-edit handle is found by it. */
+    id?: string;
+    /** Keyframes on the config knobs (animations.text.animations). */
+    keyframes?: AnimationOptions[];
+    /** Pointer bindings on the config knobs (mouseMove.text). */
+    mouseMove?: MouseMoveDomain;
+}
+declare const LightPaintingText: React.FC<LightPaintingTextProps>;
+export default LightPaintingText;
+//# sourceMappingURL=LightPaintingText.d.ts.map

package/dist/components/text/LightPaintingText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightPaintingText.d.ts","sourceRoot":"","sources":["../../../src/components/text/LightPaintingText.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AACxG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAYhE,MAAM,WAAW,sBAAuB,SAAQ,gBAAgB;IAC5D,MAAM,EAAE,uBAAuB,CAAC;IAChC,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,kEAAkE;IAClE,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/B,6DAA6D;IAC7D,SAAS,CAAC,EAAE,eAAe,CAAC;CAC/B;AAED,QAAA,MAAM,iBAAiB,EAAE,KAAK,CAAC,EAAE,CAAC,sBAAsB,CAAiE,CAAC;AAE1H,eAAe,iBAAiB,CAAC"}

package/dist/components/text/LightPaintingText.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import TextObjectView from './TextObjectView.js';
+const LightPaintingText = (props) => _jsx(TextObjectView, { look: "lightPainting", ...props });
+export default LightPaintingText;

package/dist/components/text/LiquidMetalText.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { AnimationOptions, MouseMoveDomain, LiquidMetalTextConfig } from '@3driseai/3drise-core';
+import type { ObjectReadyProps } from '../../types/objectReady';
+export interface LiquidMetalTextProps extends ObjectReadyProps {
+    config: LiquidMetalTextConfig;
+    /** Scene object id: the live-edit handle is found by it. */
+    id?: string;
+    /** Keyframes on the config knobs (animations.text.animations). */
+    keyframes?: AnimationOptions[];
+    /** Pointer bindings on the config knobs (mouseMove.text). */
+    mouseMove?: MouseMoveDomain;
+}
+declare const LiquidMetalText: React.FC<LiquidMetalTextProps>;
+export default LiquidMetalText;
+//# sourceMappingURL=LiquidMetalText.d.ts.map

package/dist/components/text/LiquidMetalText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LiquidMetalText.d.ts","sourceRoot":"","sources":["../../../src/components/text/LiquidMetalText.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACtG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAYhE,MAAM,WAAW,oBAAqB,SAAQ,gBAAgB;IAC1D,MAAM,EAAE,qBAAqB,CAAC;IAC9B,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,kEAAkE;IAClE,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/B,6DAA6D;IAC7D,SAAS,CAAC,EAAE,eAAe,CAAC;CAC/B;AAED,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAA+D,CAAC;AAEpH,eAAe,eAAe,CAAC"}

package/dist/components/text/LiquidMetalText.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import TextObjectView from './TextObjectView.js';
+const LiquidMetalText = (props) => _jsx(TextObjectView, { look: "liquidMetal", ...props });
+export default LiquidMetalText;

package/dist/components/text/NeonTubeText.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { AnimationOptions, MouseMoveDomain, NeonTubeTextConfig } from '@3driseai/3drise-core';
+import type { ObjectReadyProps } from '../../types/objectReady';
+export interface NeonTubeTextProps extends ObjectReadyProps {
+    config: NeonTubeTextConfig;
+    /** Scene object id: the live-edit handle is found by it. */
+    id?: string;
+    /** Keyframes on the config knobs (animations.text.animations). */
+    keyframes?: AnimationOptions[];
+    /** Pointer bindings on the config knobs (mouseMove.text). */
+    mouseMove?: MouseMoveDomain;
+}
+declare const NeonTubeText: React.FC<NeonTubeTextProps>;
+export default NeonTubeText;
+//# sourceMappingURL=NeonTubeText.d.ts.map

package/dist/components/text/NeonTubeText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NeonTubeText.d.ts","sourceRoot":"","sources":["../../../src/components/text/NeonTubeText.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACnG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAYhE,MAAM,WAAW,iBAAkB,SAAQ,gBAAgB;IACvD,MAAM,EAAE,kBAAkB,CAAC;IAC3B,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,kEAAkE;IAClE,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/B,6DAA6D;IAC7D,SAAS,CAAC,EAAE,eAAe,CAAC;CAC/B;AAED,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAA4D,CAAC;AAE3G,eAAe,YAAY,CAAC"}

package/dist/components/text/NeonTubeText.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import TextObjectView from './TextObjectView.js';
+const NeonTubeText = (props) => _jsx(TextObjectView, { look: "neonTube", ...props });
+export default NeonTubeText;

package/dist/components/text/PlainText.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { AnimationOptions, MouseMoveDomain, PlainTextConfig } from '@3driseai/3drise-core';
+import type { ObjectReadyProps } from '../../types/objectReady';
+export interface PlainTextProps extends ObjectReadyProps {
+    config: PlainTextConfig;
+    /** Scene object id: the live-edit handle is found by it. */
+    id?: string;
+    /** Keyframes on the config knobs (animations.text.animations). */
+    keyframes?: AnimationOptions[];
+    /** Pointer bindings on the config knobs (mouseMove.text). */
+    mouseMove?: MouseMoveDomain;
+}
+declare const PlainText: React.FC<PlainTextProps>;
+export default PlainText;
+//# sourceMappingURL=PlainText.d.ts.map

package/dist/components/text/PlainText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlainText.d.ts","sourceRoot":"","sources":["../../../src/components/text/PlainText.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAChG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAYhE,MAAM,WAAW,cAAe,SAAQ,gBAAgB;IACpD,MAAM,EAAE,eAAe,CAAC;IACxB,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,kEAAkE;IAClE,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/B,6DAA6D;IAC7D,SAAS,CAAC,EAAE,eAAe,CAAC;CAC/B;AAED,QAAA,MAAM,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC,cAAc,CAAyD,CAAC;AAElG,eAAe,SAAS,CAAC"}

package/dist/components/text/PlainText.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import TextObjectView from './TextObjectView.js';
+const PlainText = (props) => _jsx(TextObjectView, { look: "plain", ...props });
+export default PlainText;

package/dist/components/text/PlasmaDischargeText.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { AnimationOptions, MouseMoveDomain, PlasmaDischargeTextConfig } from '@3driseai/3drise-core';
+import type { ObjectReadyProps } from '../../types/objectReady';
+export interface PlasmaDischargeTextProps extends ObjectReadyProps {
+    config: PlasmaDischargeTextConfig;
+    /** Scene object id: the live-edit handle is found by it. */
+    id?: string;
+    /** Keyframes on the config knobs (animations.text.animations). */
+    keyframes?: AnimationOptions[];
+    /** Pointer bindings on the config knobs (mouseMove.text). */
+    mouseMove?: MouseMoveDomain;
+}
+declare const PlasmaDischargeText: React.FC<PlasmaDischargeTextProps>;
+export default PlasmaDischargeText;
+//# sourceMappingURL=PlasmaDischargeText.d.ts.map

package/dist/components/text/PlasmaDischargeText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlasmaDischargeText.d.ts","sourceRoot":"","sources":["../../../src/components/text/PlasmaDischargeText.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAC1G,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAYhE,MAAM,WAAW,wBAAyB,SAAQ,gBAAgB;IAC9D,MAAM,EAAE,yBAAyB,CAAC;IAClC,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,kEAAkE;IAClE,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/B,6DAA6D;IAC7D,SAAS,CAAC,EAAE,eAAe,CAAC;CAC/B;AAED,QAAA,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC,wBAAwB,CAAmE,CAAC;AAEhI,eAAe,mBAAmB,CAAC"}

package/dist/components/text/PlasmaDischargeText.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import TextObjectView from './TextObjectView.js';
+const PlasmaDischargeText = (props) => _jsx(TextObjectView, { look: "plasmaDischarge", ...props });
+export default PlasmaDischargeText;

package/dist/components/text/TextObjectView.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { TextObjectType } from '@3driseai/3drise-core';
+import { type TextObjectProps } from './useTextObject';
+/**
+ * The shared body of every text look: an empty group that the look's mesh is built into once the font has
+ * loaded, plus the pick proxy — an invisible plane over the text's box that is the only thing the pointer can
+ * hit (hover / click react to the text as a whole, not letter by letter). The inner group is the em scale, so
+ * the object's own transform stays the parent's.
+ */
+declare const TextObjectView: React.FC<TextObjectProps & {
+    look: TextObjectType;
+}>;
+export default TextObjectView;
+//# sourceMappingURL=TextObjectView.d.ts.map

package/dist/components/text/TextObjectView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextObjectView.d.ts","sourceRoot":"","sources":["../../../src/components/text/TextObjectView.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,EAA0B,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAG/E;;;;;GAKG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,GAAG;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,CAWxE,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/dist/components/text/TextObjectView.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo } from 'react';
+import { TEXT_EM, useTextObject } from './useTextObject.js';
+import { pickPlane } from '../../utils/pickProxy.js';
+/**
+ * The shared body of every text look: an empty group that the look's mesh is built into once the font has
+ * loaded, plus the pick proxy — an invisible plane over the text's box that is the only thing the pointer can
+ * hit (hover / click react to the text as a whole, not letter by letter). The inner group is the em scale, so
+ * the object's own transform stays the parent's.
+ */
+const TextObjectView = ({ look, ...props }) => {
+    const { rootRef, innerRef, proxyRef } = useTextObject(look, props);
+    const proxy = useMemo(() => pickPlane(), []);
+    useEffect(() => () => { proxy.geometry.dispose(); proxy.material.dispose(); }, [proxy]);
+    return (_jsx("group", { ref: rootRef, children: _jsx("group", { ref: innerRef, scale: TEXT_EM, children: _jsx("primitive", { ref: proxyRef, object: proxy }) }) }));
+};
+export default TextObjectView;

package/dist/components/text/engine/fieldkit.d.ts

@@ -0,0 +1,24 @@
+import * as THREE from 'three';
+export declare function buildField(strokes: any, { source, texels, pad, maxDist }?: {
+    source?: string;
+    texels?: number;
+    pad?: number;
+    maxDist?: number;
+}): {
+    f0: THREE.DataTexture;
+    f1: THREE.DataTexture;
+    ext: THREE.Vector4;
+    size: number[];
+    texel: number;
+    maxDist: number;
+    dispose(): void;
+};
+export declare const FIELD_UNIFORMS = "uniform sampler2D uF0; uniform sampler2D uF1; uniform vec4 uFExt; uniform float uFMax;\nvarying vec2 vPos;\n";
+export declare const FIELD_FUNCS = "\nfloat h21(vec2 p){ return fract(sin(dot(p, vec2(12.9898, 78.233)))*43758.5453); }\nvec2 fieldUV(vec2 p){ return (p - uFExt.xy)/uFExt.zw; }\nvec4 fieldA(vec2 p){ return texture2D(uF0, fieldUV(p)); }     // signed distance (em), gD, gO, arc\nvec4 fieldB(vec2 p){ return texture2D(uF1, fieldUV(p)); }     // glyphN, width factor, stroke id, 0\nfloat revealInG(float g){ return uFadeIn > 0.5 ? uD : smoothstep(0.0, max(uSoftIn, 1e-4), uHead - g); }\nfloat revealOutG(float g){ return uFadeOut > 0.5 ? 1.0 - uE : smoothstep(0.0, max(uSoftOut, 1e-4), g - uErase); }\nfloat ageG(float g){ return max(0.0, uHead - g)*uDur + uSince; }          // seconds since the front passed this pixel\n";
+export declare const fieldFrag: (body: any, extra?: string) => string;
+export declare function fieldMaterial(field: any, fragBody: any, uniforms: any, { additive, extra }?: {
+    additive?: boolean;
+    extra?: string;
+}): THREE.ShaderMaterial;
+export declare function fieldQuad(field: any, material: any): THREE.Mesh<THREE.PlaneGeometry, any, THREE.Object3DEventMap>;
+//# sourceMappingURL=fieldkit.d.ts.map

package/dist/components/text/engine/fieldkit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldkit.d.ts","sourceRoot":"","sources":["../../../../src/components/text/engine/fieldkit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAoB/B,wBAAgB,UAAU,CAAC,OAAO,KAAA,EAAE,EAAE,MAAkB,EAAE,MAAa,EAAE,GAAS,EAAE,OAAa,EAAE;;;;;CAAK;;;;;;;;EAwEvG;AAED,eAAO,MAAM,cAAc,iHAE1B,CAAC;AACF,eAAO,MAAM,WAAW,grBAQvB,CAAC;AACF,eAAO,MAAM,SAAS,GAAI,SAAI,EAAE,cAAU,WAAyG,CAAC;AAGpJ,wBAAgB,aAAa,CAAC,KAAK,KAAA,EAAE,QAAQ,KAAA,EAAE,QAAQ,KAAA,EAAE,EAAE,QAAgB,EAAE,KAAU,EAAE;;;CAAK,wBAQ7F;AACD,wBAAgB,SAAS,CAAC,KAAK,KAAA,EAAE,QAAQ,KAAA,gEAGxC"}

package/dist/components/text/engine/fieldkit.js

@@ -0,0 +1,201 @@
+import * as THREE from 'three';
+import { REVEAL_UNIFORMS, uniformsBase } from './ribbon.js';
+// ---------------------------------------------------------------------------------------------
+// FIELD KIT — shared by every text variant that is shaded per pixel on a plane (burn, ink, chalk, metal, frost fill…).
+//
+// From the schedules the draw / erase methods already wrote on the strokes (s.seg, s.t, s.segO, s.tO), the kit bakes two
+// RGBA16F textures over the text's extent (em units, y up, origin = text centre):
+//   F0 = ( signed distance to the glyph [em; <0 inside a filled outline glyph, outline source only],
+//          draw arrival gD   [global draw progress at which the nearest stroke point appears],
+//          erase arrival gO  [global erase progress at which the nearest stroke point disappears],
+//          arc u             [0..1 along the nearest stroke] )
+//   F1 = ( glyphN [0..1 across the text], width factor wfactor (hand source), stroke index / 255 (for hashing), 0 )
+// The values come from the NEAREST stroke point (CPU jump flooding, exact sub-texel positions), so a filled letter reveals
+// from its contour inwards and "meets in the middle", whatever draw method is chosen.
+// Sampling is bilinear (half-float linear filtering is core WebGL2).
+//
+// Reveal helpers in GLSL mirror ribbon.mjs exactly (revealInG / revealOutG / ageG), so every method works unchanged.
+// ---------------------------------------------------------------------------------------------
+export function buildField(strokes, { source = 'outline', texels = 1024, pad = 0.3, maxDist = 0.4 } = {}) {
+    let x0 = 1e9, y0 = 1e9, x1 = -1e9, y1 = -1e9;
+    for (const s of strokes)
+        for (let i = 0; i < s.pts.length; i += 2) {
+            x0 = Math.min(x0, s.pts[i]);
+            x1 = Math.max(x1, s.pts[i]);
+            y0 = Math.min(y0, s.pts[i + 1]);
+            y1 = Math.max(y1, s.pts[i + 1]);
+        }
+    x0 -= pad;
+    y0 -= pad;
+    x1 += pad;
+    y1 += pad;
+    const ew = x1 - x0, eh = y1 - y0;
+    const W = Math.max(8, Math.min(texels, Math.round(texels * (ew >= eh ? 1 : ew / eh)))), H = Math.max(8, Math.min(texels, Math.round(texels * (eh > ew ? 1 : eh / ew))));
+    const cell = ew / W; // em per texel (square texels: eh/H == ew/W up to rounding)
+    const sx = ew / W, sy = eh / H;
+    const N = W * H;
+    const SX = new Float32Array(N), SY = new Float32Array(N), GD = new Float32Array(N), GO = new Float32Array(N), AR = new Float32Array(N), GN = new Float32Array(N), WF = new Float32Array(N), SI = new Float32Array(N);
+    const own = new Int32Array(N).fill(-1);
+    // 1. seeds: sample every segment of every stroke at half-texel spacing
+    strokes.forEach((s, si) => {
+        const n = s.pts.length / 2;
+        for (let i = 0; i < n - 1; i++) {
+            const ax = s.pts[2 * i], ay = s.pts[2 * i + 1], bx = s.pts[2 * i + 2], by = s.pts[2 * i + 3];
+            const L = Math.hypot(bx - ax, by - ay), m = Math.max(1, Math.ceil(L / (0.5 * cell)));
+            for (let k = 0; k <= m; k++) {
+                const f = k / m, X = ax + (bx - ax) * f, Y = ay + (by - ay) * f;
+                const ix = Math.floor((X - x0) / sx), iy = Math.floor((Y - y0) / sy);
+                if (ix < 0 || iy < 0 || ix >= W || iy >= H)
+                    continue;
+                const p = iy * W + ix, cx = x0 + (ix + 0.5) * sx, cy = y0 + (iy + 0.5) * sy;
+                if (own[p] >= 0 && Math.hypot(SX[p] - cx, SY[p] - cy) <= Math.hypot(X - cx, Y - cy))
+                    continue; // keep the seed closest to the texel centre
+                own[p] = p;
+                SX[p] = X;
+                SY[p] = Y;
+                const tI = s.t[i] + (s.t[i + 1] - s.t[i]) * f, tO = s.tO[i] + (s.tO[i + 1] - s.tO[i]) * f;
+                GD[p] = s.seg[0] + tI * (s.seg[1] - s.seg[0]);
+                GO[p] = s.segO[0] + tO * (s.segO[1] - s.segO[0]);
+                AR[p] = (s.cum[i] + (s.cum[i + 1] - s.cum[i]) * f) / Math.max(1e-6, s.len);
+                GN[p] = s.glyphN || 0;
+                WF[p] = s.wfactor ? s.wfactor[i] + (s.wfactor[i + 1] - s.wfactor[i]) * f : 1;
+                SI[p] = si / 255;
+            }
+        }
+    });
+    // 2. jump flooding: every texel learns its nearest seed
+    let cur = own, nxt = new Int32Array(N);
+    const jump = (step) => {
+        for (let y = 0; y < H; y++)
+            for (let x = 0; x < W; x++) {
+                const p = y * W + x, cx = x0 + (x + 0.5) * sx, cy = y0 + (y + 0.5) * sy;
+                let best = cur[p], bd = best >= 0 ? (SX[best] - cx) ** 2 + (SY[best] - cy) ** 2 : 1e30;
+                for (let dy = -1; dy <= 1; dy++) {
+                    const yy = y + dy * step;
+                    if (yy < 0 || yy >= H)
+                        continue;
+                    for (let dx = -1; dx <= 1; dx++) {
+                        const xx = x + dx * step;
+                        if (xx < 0 || xx >= W)
+                            continue;
+                        const q = cur[yy * W + xx];
+                        if (q < 0)
+                            continue;
+                        const d = (SX[q] - cx) ** 2 + (SY[q] - cy) ** 2;
+                        if (d < bd) {
+                            bd = d;
+                            best = q;
+                        }
+                    }
+                }
+                nxt[p] = best;
+            }
+        const t = cur;
+        cur = nxt;
+        nxt = t;
+    };
+    for (let st = 1 << Math.floor(Math.log2(Math.max(W, H))); st >= 1; st >>= 1)
+        jump(st);
+    jump(1);
+    // 3. inside mask (outline source): fill every glyph's contours with the even-odd rule
+    let inside = null;
+    if (source === 'outline') {
+        const cv = document.createElement('canvas');
+        cv.width = W;
+        cv.height = H;
+        const g = cv.getContext('2d', { willReadFrequently: true });
+        g.fillStyle = '#fff';
+        g.fillRect(0, 0, W, H);
+        g.fillStyle = '#000';
+        const byGlyph = new Map();
+        for (const s of strokes) {
+            if (!byGlyph.has(s.glyph))
+                byGlyph.set(s.glyph, []);
+            byGlyph.get(s.glyph).push(s);
+        }
+        for (const list of byGlyph.values()) {
+            g.beginPath();
+            for (const s of list) {
+                for (let i = 0; i < s.pts.length; i += 2) {
+                    const X = (s.pts[i] - x0) / sx, Y = H - (s.pts[i + 1] - y0) / sy;
+                    if (i === 0)
+                        g.moveTo(X, Y);
+                    else
+                        g.lineTo(X, Y);
+                }
+                g.closePath();
+            }
+            g.fill('evenodd');
+        }
+        const im = g.getImageData(0, 0, W, H).data;
+        inside = new Uint8Array(N);
+        for (let y = 0; y < H; y++)
+            for (let x = 0; x < W; x++)
+                inside[y * W + x] = im[((H - 1 - y) * W + x) * 4] < 128 ? 1 : 0; // canvas rows run top-down
+    }
+    // 4. pack
+    const h = THREE.DataUtils.toHalfFloat;
+    const D0 = new Uint16Array(N * 4), D1 = new Uint16Array(N * 4);
+    const far = h(maxDist);
+    for (let y = 0; y < H; y++)
+        for (let x = 0; x < W; x++) {
+            const p = y * W + x, k = cur[p], o = p * 4;
+            if (k < 0) {
+                D0[o] = far;
+                D0[o + 1] = h(2);
+                D0[o + 2] = h(2);
+                D0[o + 3] = 0;
+                D1[o] = 0;
+                D1[o + 1] = h(1);
+                D1[o + 2] = 0;
+                D1[o + 3] = 0;
+                continue;
+            }
+            const cx = x0 + (x + 0.5) * sx, cy = y0 + (y + 0.5) * sy;
+            let d = Math.hypot(SX[k] - cx, SY[k] - cy);
+            if (inside && inside[p])
+                d = -d;
+            D0[o] = h(Math.max(-maxDist, Math.min(maxDist, d)));
+            D0[o + 1] = h(GD[k]);
+            D0[o + 2] = h(GO[k]);
+            D0[o + 3] = h(AR[k]);
+            D1[o] = h(GN[k]);
+            D1[o + 1] = h(WF[k]);
+            D1[o + 2] = h(SI[k]);
+            D1[o + 3] = 0;
+        }
+    const mk = (d) => { const t = new THREE.DataTexture(d, W, H, THREE.RGBAFormat, THREE.HalfFloatType); t.minFilter = t.magFilter = THREE.LinearFilter; t.wrapS = t.wrapT = THREE.ClampToEdgeWrapping; t.generateMipmaps = false; t.needsUpdate = true; return t; };
+    const f0 = mk(D0), f1 = mk(D1);
+    return { f0, f1, ext: new THREE.Vector4(x0, y0, ew, eh), size: [W, H], texel: cell, maxDist, dispose() { f0.dispose(); f1.dispose(); } };
+}
+export const FIELD_UNIFORMS = /* glsl */ `uniform sampler2D uF0; uniform sampler2D uF1; uniform vec4 uFExt; uniform float uFMax;
+varying vec2 vPos;
+`;
+export const FIELD_FUNCS = /* glsl */ `
+float h21(vec2 p){ return fract(sin(dot(p, vec2(12.9898, 78.233)))*43758.5453); }
+vec2 fieldUV(vec2 p){ return (p - uFExt.xy)/uFExt.zw; }
+vec4 fieldA(vec2 p){ return texture2D(uF0, fieldUV(p)); }     // signed distance (em), gD, gO, arc
+vec4 fieldB(vec2 p){ return texture2D(uF1, fieldUV(p)); }     // glyphN, width factor, stroke id, 0
+float revealInG(float g){ return uFadeIn > 0.5 ? uD : smoothstep(0.0, max(uSoftIn, 1e-4), uHead - g); }
+float revealOutG(float g){ return uFadeOut > 0.5 ? 1.0 - uE : smoothstep(0.0, max(uSoftOut, 1e-4), g - uErase); }
+float ageG(float g){ return max(0.0, uHead - g)*uDur + uSince; }          // seconds since the front passed this pixel
+`;
+export const fieldFrag = (body, extra = '') => /* glsl */ `precision highp float;\n${REVEAL_UNIFORMS}${FIELD_UNIFORMS}${extra}${FIELD_FUNCS}${body}`;
+// A quad over the field extent (em units); the fragment shader gets vPos in em. Premultiplied alpha blending by default.
+export function fieldMaterial(field, fragBody, uniforms, { additive = false, extra = '' } = {}) {
+    return new THREE.ShaderMaterial({
+        uniforms: { ...uniformsBase(), uF0: { value: field.f0 }, uF1: { value: field.f1 }, uFExt: { value: field.ext }, uFMax: { value: field.maxDist }, ...uniforms },
+        vertexShader: /* glsl */ `varying vec2 vPos; void main(){ vPos = position.xy; gl_Position = projectionMatrix*modelViewMatrix*vec4(position, 1.0); }`,
+        fragmentShader: fieldFrag(fragBody, extra), transparent: true, depthWrite: false, side: THREE.DoubleSide,
+        blending: additive ? THREE.AdditiveBlending : THREE.CustomBlending,
+        ...(additive ? {} : { blendEquation: THREE.AddEquation, blendSrc: THREE.OneFactor, blendDst: THREE.OneMinusSrcAlphaFactor }),
+    });
+}
+export function fieldQuad(field, material) {
+    const e = field.ext;
+    const g = new THREE.PlaneGeometry(e.z, e.w);
+    g.translate(e.x + e.z / 2, e.y + e.w / 2, 0);
+    const m = new THREE.Mesh(g, material);
+    m.frustumCulled = false;
+    return m;
+}

package/dist/components/text/engine/glyphs.d.ts

@@ -0,0 +1,19 @@
+export declare function layoutOutline(font: any, text: any, o?: any): {
+    glyphs: any[];
+    strokes: any[];
+    bounds: {
+        w: number;
+        h: number;
+    };
+};
+export declare function penTiming(s: any, smooth?: number): void;
+export declare function layoutStrokeFont(sf: any, text: any, o?: any): {
+    glyphs: any[];
+    strokes: any[];
+    bounds: {
+        w: number;
+        h: number;
+    };
+    natural: any;
+};
+//# sourceMappingURL=glyphs.d.ts.map

package/dist/components/text/engine/glyphs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glyphs.d.ts","sourceRoot":"","sources":["../../../../src/components/text/engine/glyphs.ts"],"names":[],"mappings":"AAiDA,wBAAgB,aAAa,CAAC,IAAI,KAAA,EAAE,IAAI,KAAA,EAAE,CAAC,GAAE,GAAQ;;;;;;;EA4BpD;AAID,wBAAgB,SAAS,CAAC,CAAC,KAAA,EAAE,MAAM,SAAI,QAkBtC;AAKD,wBAAgB,gBAAgB,CAAC,EAAE,KAAA,EAAE,IAAI,KAAA,EAAE,CAAC,GAAE,GAAQ;;;;;;;;EAqCrD"}