@3driseai/3drise-viewer 0.1.27 → 0.1.29

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"}

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

@@ -0,0 +1,269 @@
+// Glyph pipeline: font -> strokes (polylines in em units, y up, origin = text centre).
+// A stroke: { pts: Float32Array [x,y,...], cum: Float32Array (arc length per point), len, closed,
+//             glyph (index), hole (bool), area }
+// Outline fonts give closed contours (outer first, then counters); Hershey gives open pen strokes.
+const sub = (n) => Math.max(3, Math.min(32, n));
+function signedArea(p) { let a = 0; for (let i = 0, n = p.length / 2; i < n; i++) {
+    const j = (i + 1) % n;
+    a += p[2 * i] * p[2 * j + 1] - p[2 * j] * p[2 * i + 1];
+} return a / 2; }
+function finishStroke(pts, closed, glyph, hole) {
+    // drop a duplicated closing point, then re-append it so a closed ribbon meets itself
+    let a = Array.from(pts);
+    const n = a.length / 2;
+    if (closed && n > 2 && Math.hypot(a[0] - a[2 * n - 2], a[1] - a[2 * n - 1]) < 1e-6)
+        a.length -= 2;
+    if (closed)
+        a.push(a[0], a[1]);
+    const P = Float32Array.from(a);
+    const m = P.length / 2;
+    const cum = new Float32Array(m);
+    for (let i = 1; i < m; i++)
+        cum[i] = cum[i - 1] + Math.hypot(P[2 * i] - P[2 * i - 2], P[2 * i + 1] - P[2 * i - 1]);
+    return { pts: P, cum, len: cum[m - 1], closed, glyph, hole, area: Math.abs(signedArea(a)) };
+}
+// closed contour: begin at the top-left-most point, like a hand starting a letter
+function rotateStart(p) {
+    const n = p.length / 2;
+    let best = 0, bs = -1e9;
+    for (let i = 0; i < n; i++) {
+        const s = p[2 * i + 1] - 0.35 * p[2 * i];
+        if (s > bs) {
+            bs = s;
+            best = i;
+        }
+    }
+    const o = [];
+    for (let i = 0; i < n; i++) {
+        const j = (best + i) % n;
+        o.push(p[2 * j], p[2 * j + 1]);
+    }
+    return o;
+}
+function wrapLines(text, maxWidth, measure) {
+    const out = [];
+    for (const raw of String(text).split('\n')) {
+        if (!(maxWidth > 0)) {
+            out.push(raw);
+            continue;
+        }
+        let line = '';
+        for (const w of raw.split(' ')) {
+            const t = line ? line + ' ' + w : w;
+            if (line && measure(t) > maxWidth) {
+                out.push(line);
+                line = w;
+            }
+            else
+                line = t;
+        }
+        out.push(line);
+    }
+    return out;
+}
+function center(glyphs, strokes) {
+    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]);
+        }
+    if (x0 > x1) {
+        x0 = y0 = -0.5;
+        x1 = y1 = 0.5;
+    }
+    const cx = (x0 + x1) / 2, cy = (y0 + y1) / 2;
+    for (const s of strokes)
+        for (let i = 0; i < s.pts.length; i += 2) {
+            s.pts[i] -= cx;
+            s.pts[i + 1] -= cy;
+        }
+    return { w: x1 - x0, h: y1 - y0 };
+}
+// --- Outline font layout (packed outline font: { adv, kern, g: contours per char, em units, y up }) --------
+export function layoutOutline(font, text, o = {}) {
+    const { lineHeight = 1.25, letterSpacing = 0, align = 'center', maxWidth = 0 } = o;
+    const adv = (c) => (font.adv[c] ?? font.adv['?'] ?? 0.5);
+    const kern = (a, b) => font.kern[a + b] || 0;
+    const widthOf = (s) => { let x = 0; for (let i = 0; i < s.length; i++)
+        x += adv(s[i]) + letterSpacing + (i + 1 < s.length ? kern(s[i], s[i + 1]) : 0); return x; };
+    const lines = wrapLines(text, maxWidth, widthOf);
+    const glyphs = [];
+    const strokes = [];
+    lines.forEach((line, li) => {
+        const items = [];
+        let x = 0;
+        for (let i = 0; i < line.length; i++) {
+            const c = line[i];
+            items.push({ x, cs: font.g[c] || [], ch: c });
+            x += adv(c) + letterSpacing + (i + 1 < line.length ? kern(c, line[i + 1]) : 0);
+        }
+        const off = align === 'left' ? 0 : align === 'right' ? -x : -x / 2;
+        for (const it of items) {
+            if (!it.cs.length)
+                continue;
+            const gi = glyphs.length;
+            glyphs.push({ ch: it.ch, line: li, strokes: [] });
+            const cs = it.cs.map((p) => { const q = p.slice(); for (let i = 0; i < q.length; i += 2) {
+                q[i] += it.x + off;
+                q[i + 1] -= li * lineHeight;
+            } return q; });
+            const areas = cs.map(signedArea);
+            let big = 0;
+            areas.forEach((a, i) => { if (Math.abs(a) > Math.abs(areas[big]))
+                big = i; });
+            const sign = Math.sign(areas[big]);
+            const list = cs.map((p, i) => ({ p, hole: Math.sign(areas[i]) !== sign, a: Math.abs(areas[i]) }));
+            list.sort((a, b) => (Number(a.hole) - Number(b.hole)) || (b.a - a.a));
+            for (const c of list) {
+                const s = finishStroke(rotateStart(c.p), true, gi, c.hole);
+                glyphs[gi].strokes.push(strokes.length);
+                strokes.push(s);
+            }
+        }
+    });
+    const bounds = center(glyphs, strokes);
+    return { glyphs, strokes, bounds };
+}
+// --- Pen timing: 2/3 power law (speed ~ curvature^-1/3) -----------------------------------
+// fills s.t (cumulative time 0..1 per point), s.pressure (0..1: slow = pressed hard), s.time (relative duration)
+export function penTiming(s, smooth = 9) {
+    const n = s.pts.length / 2;
+    const kap = new Float32Array(n);
+    for (let i = 1; i < n - 1; i++) {
+        const ax = s.pts[2 * i] - s.pts[2 * i - 2], ay = s.pts[2 * i + 1] - s.pts[2 * i - 1], bx = s.pts[2 * i + 2] - s.pts[2 * i], by = s.pts[2 * i + 3] - s.pts[2 * i + 1];
+        const la = Math.hypot(ax, ay), lb = Math.hypot(bx, by);
+        if (la < 1e-9 || lb < 1e-9)
+            continue;
+        const ang = Math.abs(Math.atan2(ax * by - ay * bx, ax * bx + ay * by));
+        kap[i] = ang / (0.5 * (la + lb));
+    }
+    const ks = new Float32Array(n);
+    for (let i = 0; i < n; i++) {
+        let a = 0, c = 0;
+        for (let j = Math.max(0, i - smooth); j <= Math.min(n - 1, i + smooth); j++) {
+            a += kap[j];
+            c++;
+        }
+        ks[i] = a / c;
+    }
+    const v = new Float32Array(n);
+    let vmax = 0, vmin = 1e9;
+    for (let i = 0; i < n; i++) {
+        v[i] = Math.pow(0.5 + ks[i], -1 / 3);
+        vmax = Math.max(vmax, v[i]);
+        vmin = Math.min(vmin, v[i]);
+    }
+    const t = new Float32Array(n);
+    for (let i = 1; i < n; i++)
+        t[i] = t[i - 1] + (s.cum[i] - s.cum[i - 1]) / (0.5 * (v[i] + v[i - 1]));
+    const T = Math.max(1e-6, t[n - 1]);
+    let pr = new Float32Array(n);
+    for (let i = 0; i < n; i++) {
+        pr[i] = 1 - (v[i] - vmin) / Math.max(1e-6, vmax - vmin);
+        t[i] /= T;
+    }
+    for (let pass = 0; pass < 2; pass++) {
+        const q = new Float32Array(n);
+        for (let i = 0; i < n; i++) {
+            let a = 0, c = 0;
+            for (let j = Math.max(0, i - 8); j <= Math.min(n - 1, i + 8); j++) {
+                a += pr[j];
+                c++;
+            }
+            q[i] = a / c;
+        }
+        pr = q;
+    }
+    s.t = t;
+    s.pressure = pr;
+    s.time = T;
+}
+// --- Stroke-font layout (fonts pre-converted to pen strokes by tools/skeleton.mjs) -------------
+// sf = { wm (median stroke width, em), space, glyphs: { ch: { adv, s: [{p:[x,y..], w:[..], dot?}] } } }
+// Strokes of neighbouring letters whose ends meet are joined, so cursive hands write a word without lifting.
+export function layoutStrokeFont(sf, text, o = {}) {
+    const { lineHeight = 1.35, letterSpacing = 0, align = 'center', maxWidth = 0, connect = 0.05 } = o;
+    const adv = (ch) => (ch === ' ' ? sf.space * 0.9 : (sf.glyphs[ch] ? sf.glyphs[ch].adv : 0.3)) + letterSpacing;
+    const measure = (s) => [...s].reduce((a, ch) => a + adv(ch), 0);
+    const lines = wrapLines(text, maxWidth, measure);
+    const glyphs = [];
+    const raws = [];
+    lines.forEach((line, li) => {
+        const w = measure(line);
+        let x = align === 'left' ? 0 : align === 'right' ? -w : -w / 2;
+        let prev = [];
+        for (const ch of line) {
+            const g = ch === ' ' ? null : sf.glyphs[ch];
+            if (g && g.s.length) {
+                const gi = glyphs.length;
+                glyphs.push({ ch, line: li, strokes: [] });
+                const mine = [];
+                for (const s of g.s) {
+                    const P = [];
+                    for (let i = 0; i < s.p.length; i += 2)
+                        P.push(s.p[i] + x, s.p[i + 1] - li * lineHeight);
+                    const st = { p: P, w: s.w.slice(), gi, dot: !!s.dot, line: li };
+                    if (!st.dot && connect > 0) {
+                        let best = null, bd = connect;
+                        for (const a of prev) {
+                            if (a.dot || a.joined)
+                                continue;
+                            const d = Math.hypot(a.p[a.p.length - 2] - P[0], a.p[a.p.length - 1] - P[1]);
+                            if (d < bd) {
+                                bd = d;
+                                best = a;
+                            }
+                        }
+                        if (best) {
+                            for (let i = 0; i < P.length; i += 2)
+                                best.p.push(P[i], P[i + 1]);
+                            for (const q of st.w)
+                                best.w.push(q);
+                            best.joined = true;
+                            mine.push(best);
+                            best.gi2 = gi;
+                            continue;
+                        }
+                    }
+                    raws.push(st);
+                    mine.push(st);
+                }
+                prev = mine;
+            }
+            else if (ch === ' ')
+                prev = [];
+            x += adv(ch);
+        }
+    });
+    const strokes = [];
+    for (const r of raws) {
+        const s = finishStroke(r.p, false, r.gi, false);
+        s.dot = r.dot;
+        // resample widths onto the (possibly merged) stroke: widths were per original point, same count
+        const n = s.pts.length / 2;
+        const wf = new Float32Array(n);
+        for (let i = 0; i < n; i++)
+            wf[i] = r.w[Math.min(r.w.length - 1, i)] / sf.wm;
+        let wsm = wf;
+        for (let pass = 0; pass < 2; pass++) {
+            const q = new Float32Array(n);
+            for (let i = 0; i < n; i++) {
+                let a = 0, c = 0;
+                for (let j = Math.max(0, i - 3); j <= Math.min(n - 1, i + 3); j++) {
+                    a += wsm[j];
+                    c++;
+                }
+                q[i] = a / c;
+            }
+            wsm = q;
+        }
+        s.wfactor = wsm;
+        glyphs[r.gi].strokes.push(strokes.length);
+        strokes.push(s);
+    }
+    const bounds = center(glyphs, strokes);
+    return { glyphs, strokes, bounds, natural: sf.wm };
+}

package/dist/components/text/engine/looks/burnAway.d.ts

@@ -0,0 +1,144 @@
+import * as THREE from 'three';
+declare const _default: {
+    key: string;
+    source: string;
+    drawMethods: string[];
+    eraseMethods: string[];
+    drawDefault: string;
+    eraseDefault: string;
+    animDefaults: {
+        eraseDuration: number;
+        holdTime: number;
+        eraseEase: string;
+    };
+    methodInfo: {
+        burn: {
+            label: string;
+            hint: string;
+        };
+    };
+    catalog: {
+        name: string;
+        description: string;
+        tags: string[];
+    };
+    defaults: {
+        color: string;
+        color2: string;
+        char: number;
+        ashLace: number;
+        curl: number;
+        spread: number;
+        ember: number;
+        roughness: number;
+        singe: number;
+        opacity: number;
+        seed: number;
+    };
+    ui: {
+        main: ({
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min: number;
+            max: number;
+            step: number;
+        } | {
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min?: undefined;
+            max?: undefined;
+            step?: undefined;
+        })[];
+        more: ({
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min?: undefined;
+            max?: undefined;
+            step?: undefined;
+        } | {
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min: number;
+            max: number;
+            step: number;
+        })[];
+    };
+    structural: string[];
+    presets: ({
+        name: string;
+        description: string;
+        patch: {
+            char?: undefined;
+            spread?: undefined;
+            roughness?: undefined;
+            ember?: undefined;
+            singe?: undefined;
+            color?: undefined;
+            color2?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            char: number;
+            spread: number;
+            roughness: number;
+            ember: number;
+            singe?: undefined;
+            color?: undefined;
+            color2?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            char: number;
+            spread: number;
+            roughness: number;
+            ember: number;
+            singe: number;
+            color?: undefined;
+            color2?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            color: string;
+            singe: number;
+            char: number;
+            roughness: number;
+            spread?: undefined;
+            ember?: undefined;
+            color2?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            color: string;
+            color2: string;
+            ember: number;
+            singe: number;
+            char?: undefined;
+            spread?: undefined;
+            roughness?: undefined;
+        };
+    })[];
+    build(layout: any, cfg: any, anim: any): {
+        object: THREE.Group<THREE.Object3DEventMap>;
+        apply(c: any): void;
+        update(S: any, time: any, px: any): void;
+        dispose(): void;
+    };
+};
+export default _default;
+//# sourceMappingURL=burnAway.d.ts.map

package/dist/components/text/engine/looks/burnAway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"burnAway.d.ts","sourceRoot":"","sources":["../../../../../src/components/text/engine/looks/burnAway.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmV/B,wBAiFE"}