@3driseai/3drise-viewer 0.1.28 → 0.1.30

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

@@ -0,0 +1,146 @@
+declare const _default: {
+    key: string;
+    source: string;
+    drawMethods: string[];
+    eraseMethods: string[];
+    drawDefault: string;
+    eraseDefault: string;
+    catalog: {
+        name: string;
+        description: string;
+        tags: string[];
+    };
+    animDefaults: {
+        text: string;
+        font: string;
+        drawDuration: number;
+        eraseDuration: number;
+    };
+    defaults: {
+        color: string;
+        color2: string;
+        weight: number;
+        outline: number;
+        fill: number;
+        softness: number;
+        opacity: number;
+    };
+    ui: {
+        main: ({
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min?: undefined;
+            max?: undefined;
+            step?: undefined;
+            unit?: undefined;
+        } | {
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min: number;
+            max: number;
+            step: number;
+            unit: string;
+        } | {
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min: number;
+            max: number;
+            step: number;
+            unit?: undefined;
+        })[];
+        more: ({
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min?: undefined;
+            max?: undefined;
+            step?: undefined;
+            unit?: undefined;
+        } | {
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min: number;
+            max: number;
+            step: number;
+            unit?: undefined;
+        } | {
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min: number;
+            max: number;
+            step: number;
+            unit: string;
+        })[];
+    };
+    structural: any[];
+    presets: ({
+        name: string;
+        description: string;
+        patch: {
+            weight?: undefined;
+            fill?: undefined;
+            outline?: undefined;
+            color2?: undefined;
+            softness?: undefined;
+            color?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            weight: number;
+            fill?: undefined;
+            outline?: undefined;
+            color2?: undefined;
+            softness?: undefined;
+            color?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            fill: number;
+            outline: number;
+            color2: string;
+            weight?: undefined;
+            softness?: undefined;
+            color?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            softness: number;
+            weight: number;
+            fill?: undefined;
+            outline?: undefined;
+            color2?: undefined;
+            color?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            color: string;
+            weight: number;
+            fill?: undefined;
+            outline?: undefined;
+            color2?: undefined;
+            softness?: undefined;
+        };
+    })[];
+    build(layout: any, cfg: any, anim: any): any;
+};
+export default _default;
+//# sourceMappingURL=plain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plain.d.ts","sourceRoot":"","sources":["../../../../../src/components/text/engine/looks/plain.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,wBAsDE"}

package/dist/components/text/engine/looks/plain.js

@@ -0,0 +1,104 @@
+import * as THREE from 'three';
+import { prepare, applyAnim, DRAW_METHODS, ERASE_METHODS } from '../methods.js';
+import { buildField, fieldMaterial, fieldQuad } from '../fieldkit.js';
+import { setReveal } from '../ribbon.js';
+// =========================================================================================
+// plain — flat, solid text from the font's outlines: the everyday label, caption and title.
+//
+// THE CONSTRUCTION
+//  1. The glyph outlines are baked once into a signed distance field over the text's extent (fieldkit: exact
+//     nearest-contour distance by jump flooding, negative inside the even-odd filled glyph). Shading is per pixel
+//     from that field, so the edge is anti-aliased in screen space with fwidth(d) — crisp at any camera distance,
+//     like SDF text rendering, and never a hard step.
+//  2. Weight offsets the zero contour (d - weight): a positive weight makes the face bolder, a negative one lighter,
+//     the way a variable font's wght axis thickens every stroke from its centreline outwards.
+//  3. Outline is the band 0 < d < outline just outside the (weighted) face, in colour2; fill is the face itself,
+//     with its own opacity so an outline-only label is one slider away. Softness widens the edge transition
+//     symmetrically for a soft, printed-on-fabric look.
+//  4. Draw / erase: every pixel carries the arrival of its nearest contour point (fieldkit gD / gO), so every
+//     shared method works unchanged — pen and trace ink the letters in from their contours, wipe / radial sweep
+//     across the face, scatter / dissolve break it up, fade is a plain cross-fade.
+//  There is no idle motion: a plain label stands still.
+// =========================================================================================
+const hex = (h) => new THREE.Color(h);
+const PLAIN_FRAG = /* glsl */ `
+uniform vec3 uColor; uniform vec3 uColor2; uniform float uOpacity; uniform float uFill; uniform float uWeight; uniform float uOutline; uniform float uSoft;
+void main(){
+  vec4 A = fieldA(vPos);
+  float d = A.x - uWeight;                                   // signed distance to the weighted face (em; < 0 inside)
+  float aa = max(fwidth(d), 1e-5)*0.7 + uSoft;               // derivatives first: no discard before them
+  float face = 1.0 - smoothstep(-aa, aa, d);
+  float ring = smoothstep(-aa, aa, d)*(1.0 - smoothstep(uOutline - aa, uOutline + aa, d))*step(0.0005, uOutline);
+  float vis = revealInG(A.y)*revealOutG(A.z)*uOpacity;
+  float f = face*uFill;
+  float a = (f + ring*(1.0 - f))*vis;
+  if (a < 0.002) discard;
+  vec3 col = (uColor*f + uColor2*ring*(1.0 - f))*vis;         // premultiplied
+  gl_FragColor = vec4(col, a);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`;
+export default {
+    key: 'plain', source: 'outline', drawMethods: DRAW_METHODS, eraseMethods: ERASE_METHODS, drawDefault: 'fade', eraseDefault: 'fade',
+    catalog: {
+        name: 'Plain',
+        description: 'Flat solid text from the font outlines with a weight axis, an optional outline and soft edges, anti-aliased from a signed distance field. Use for labels, captions, prices, menus and titles.',
+        tags: ['plain', 'label', 'caption', 'solid', 'flat', 'sans', 'title', 'text'],
+    },
+    animDefaults: { text: 'Hello', font: 'inter', drawDuration: 1.2, eraseDuration: 0.8 },
+    defaults: { color: '#ffffff', color2: '#111111', weight: 0, outline: 0, fill: 1, softness: 0, opacity: 1 },
+    ui: {
+        main: [
+            { name: 'color', label: 'Colour', description: 'Colour of the face', type: 'color' },
+            { name: 'weight', label: 'Weight', description: 'Bolder (right) or lighter (left) face: offsets every edge of the letters', type: 'number', min: -0.04, max: 0.05, step: 0.001, unit: 'em' },
+            { name: 'outline', label: 'Outline', description: 'Width of the outline drawn just outside the face (0 = none)', type: 'number', min: 0, max: 0.08, step: 0.001, unit: 'em' },
+            { name: 'opacity', label: 'Opacity', description: 'Overall opacity', type: 'number', min: 0, max: 1, step: 0.01 },
+        ],
+        more: [
+            { name: 'color2', label: 'Outline colour', description: 'Colour of the outline', type: 'color' },
+            { name: 'fill', label: 'Fill', description: 'Opacity of the face alone (0 with an outline = hollow letters)', type: 'number', min: 0, max: 1, step: 0.01 },
+            { name: 'softness', label: 'Softness', description: 'Width of the edge transition: 0 is crisp, more is a soft printed edge', type: 'number', min: 0, max: 0.06, step: 0.001, unit: 'em' },
+        ],
+    },
+    structural: [],
+    presets: [
+        { name: 'Default', description: 'White, crisp', patch: {} },
+        { name: 'Bold', description: 'A heavier face', patch: { weight: 0.025 } },
+        { name: 'Hollow', description: 'Outline only', patch: { fill: 0, outline: 0.03, color2: '#ffffff' } },
+        { name: 'Soft', description: 'Soft printed edge', patch: { softness: 0.03, weight: 0.012 } },
+        { name: 'Caption', description: 'Light grey, a little lighter in weight', patch: { color: '#c9ced6', weight: -0.01 } },
+    ],
+    build(layout, cfg, anim) {
+        const strokes = layout.strokes;
+        prepare(strokes, 'outline');
+        const G = layout.glyphs.length;
+        strokes.forEach((s) => { s.glyphN = s.glyph / Math.max(1, G - 1); });
+        const { infoD, infoE } = applyAnim(strokes, anim, G);
+        // The cheapest look, and the one read closest: a finer field than the others (1536 along the long side).
+        const field = buildField(strokes, { source: 'outline', texels: 1536, pad: 0.2, maxDist: 0.3 });
+        const mat = fieldMaterial(field, PLAIN_FRAG, {
+            uColor: { value: hex(cfg.color) }, uColor2: { value: hex(cfg.color2) }, uOpacity: { value: 1 }, uFill: { value: 1 }, uWeight: { value: 0 }, uOutline: { value: 0 }, uSoft: { value: 0 },
+        });
+        const mesh = fieldQuad(field, mat);
+        const group = new THREE.Group();
+        group.add(mesh);
+        const api = {
+            object: group,
+            apply(c) {
+                const u = mat.uniforms;
+                u.uColor.value.set(c.color);
+                u.uColor2.value.set(c.color2);
+                u.uOpacity.value = c.opacity;
+                u.uFill.value = c.fill;
+                u.uWeight.value = c.weight;
+                u.uOutline.value = c.outline;
+                u.uSoft.value = c.softness;
+                api.c = c;
+            },
+            update(S, time) { setReveal(mat.uniforms, S, infoD, infoE, anim.draw.duration, time); },
+            dispose() { mesh.geometry.dispose(); mat.dispose(); field.dispose(); },
+        };
+        api.apply(cfg);
+        return api;
+    },
+};

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

@@ -0,0 +1,126 @@
+import * as THREE from 'three';
+declare const _default: {
+    key: string;
+    source: string;
+    drawMethods: string[];
+    eraseMethods: string[];
+    drawDefault: string;
+    eraseDefault: string;
+    methodInfo: {
+        strike: {
+            label: string;
+            hint: string;
+        };
+    };
+    catalog: {
+        name: string;
+        description: string;
+        tags: string[];
+    };
+    defaults: {
+        branches: number;
+        reach: number;
+        branchiness: number;
+        pulse: number;
+        glow: number;
+        spectrum: number;
+        core: number;
+        color: string;
+        color2: string;
+        opacity: number;
+        seed: number;
+    };
+    ui: {
+        main: {
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min: number;
+            max: number;
+            step: number;
+        }[];
+        more: ({
+            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;
+        })[];
+    };
+    structural: string[];
+    presets: ({
+        name: string;
+        description: string;
+        patch: {
+            branches?: undefined;
+            reach?: undefined;
+            pulse?: undefined;
+            glow?: undefined;
+            color?: undefined;
+            color2?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            branches: number;
+            reach: number;
+            pulse: number;
+            glow: number;
+            color: string;
+            color2: string;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            branches: number;
+            reach: number;
+            pulse: number;
+            glow: number;
+            color?: undefined;
+            color2?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            color: string;
+            color2: string;
+            branches: number;
+            reach: number;
+            pulse?: undefined;
+            glow?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            color: string;
+            color2: string;
+            branches: number;
+            reach: number;
+            pulse: number;
+            glow?: undefined;
+        };
+    })[];
+    build(layout: any, cfg: any, anim: any): {
+        object: THREE.Group<THREE.Object3DEventMap>;
+        apply(c: any): void;
+        update(S: any, time: any): void;
+        dispose(): void;
+    };
+};
+export default _default;
+//# sourceMappingURL=plasmaDischarge.d.ts.map

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

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