three-text 0.5.2 → 0.6.0

package/dist/vector/index.cjs

@@ -1,234 +1,10 @@
 'use strict';
 
-var core = require('./core.cjs');
-var loopBlinnTSL = require('./loopBlinnTSL.cjs');
+require('./core/index.cjs');
+var index = require('./index2.cjs');
+require('three');
 
-const CONTOUR_EPSILON = 0.001;
-const CURVE_LINEARITY_EPSILON = 1e-5;
-function nearlyEqual(a, b, epsilon) {
-    return Math.abs(a - b) < epsilon;
-}
-function extractContours(segments) {
-    const contours = [];
-    let contourVertices = [];
-    let contourSegments = [];
-    const pushCurrentContour = () => {
-        if (contourVertices.length < 3) {
-            contourVertices = [];
-            contourSegments = [];
-            return;
-        }
-        const first = contourVertices[0];
-        const last = contourVertices[contourVertices.length - 1];
-        if (nearlyEqual(first.x, last.x, CONTOUR_EPSILON) &&
-            nearlyEqual(first.y, last.y, CONTOUR_EPSILON)) {
-            contourVertices.pop();
-        }
-        if (contourVertices.length >= 3) {
-            contours.push({
-                vertices: contourVertices,
-                segments: contourSegments
-            });
-        }
-        contourVertices = [];
-        contourSegments = [];
-    };
-    for (const segment of segments) {
-        if (contourVertices.length === 0) {
-            contourVertices.push({ x: segment.p0x, y: segment.p0y }, { x: segment.p2x, y: segment.p2y });
-            contourSegments.push(segment);
-            continue;
-        }
-        const previousEnd = contourVertices[contourVertices.length - 1];
-        if (nearlyEqual(segment.p0x, previousEnd.x, CONTOUR_EPSILON) &&
-            nearlyEqual(segment.p0y, previousEnd.y, CONTOUR_EPSILON)) {
-            contourVertices.push({ x: segment.p2x, y: segment.p2y });
-            contourSegments.push(segment);
-            continue;
-        }
-        pushCurrentContour();
-        contourVertices.push({ x: segment.p0x, y: segment.p0y }, { x: segment.p2x, y: segment.p2y });
-        contourSegments.push(segment);
-    }
-    pushCurrentContour();
-    return contours;
-}
-function triangulateContourFan(vertices, offsetX, offsetY, positions, indices) {
-    const baseIndex = positions.length / 3;
-    for (const vertex of vertices) {
-        positions.push(vertex.x + offsetX, vertex.y + offsetY, 0);
-    }
-    if (vertices.length < 3)
-        return 0;
-    for (let index = 1; index < vertices.length - 1; index++) {
-        indices.push(baseIndex, baseIndex + index, baseIndex + index + 1);
-    }
-    return vertices.length - 2;
-}
-function shouldSkipCurveSegment(segment) {
-    const dx = segment.p2x - segment.p0x;
-    const dy = segment.p2y - segment.p0y;
-    const lenSq = dx * dx + dy * dy;
-    if (lenSq <= 0)
-        return true;
-    const cross = (segment.p1x - segment.p0x) * dy - (segment.p1y - segment.p0y) * dx;
-    return Math.abs(cross) < CURVE_LINEARITY_EPSILON * lenSq;
-}
-function fillGlyphAttrs(center, idx, progress, lineIdx, baselineY, vertCount, gc, gi, gp, gl, gb) {
-    for (let v = 0; v < vertCount; v++) {
-        gc.push(center[0], center[1], center[2]);
-        gi.push(idx);
-        gp.push(progress);
-        gl.push(lineIdx);
-        gb.push(baselineY);
-    }
-}
-function packAttrs(gc, gi, gp, gl, gb) {
-    return {
-        glyphCenter: new Float32Array(gc),
-        glyphIndex: new Float32Array(gi),
-        glyphProgress: new Float32Array(gp),
-        glyphLineIndex: new Float32Array(gl),
-        glyphBaselineY: new Float32Array(gb)
-    };
-}
-function buildVectorGeometry(input) {
-    const interiorPositions = [];
-    const interiorIndices = [];
-    const curvePositions = [];
-    const iGC = [], iGI = [], iGP = [], iGL = [], iGB = [];
-    const cGC = [], cGI = [], cGP = [], cGL = [], cGB = [];
-    const fGC = [], fGI = [], fGP = [], fGL = [], fGB = [];
-    const glyphCount = input.glyphs.length;
-    let contourCount = 0;
-    let interiorTriangleCount = 0;
-    let curveTriangleCount = 0;
-    const glyphRanges = [];
-    const fillPositions = new Float32Array(glyphCount * 12);
-    const fillIndices = new Uint32Array(glyphCount * 6);
-    for (let i = 0; i < glyphCount; i++) {
-        const glyph = input.glyphs[i];
-        const { minX, minY, maxX, maxY } = glyph.bounds;
-        const cx = glyph.offsetX + (minX + maxX) * 0.5;
-        const cy = glyph.offsetY + (minY + maxY) * 0.5;
-        const center = [cx, cy, 0];
-        const progress = glyphCount > 1 ? i / (glyphCount - 1) : 0;
-        const intIdxStart = interiorIndices.length;
-        const curveVertStart = curvePositions.length / 3;
-        const contours = extractContours(glyph.segments);
-        contourCount += contours.length;
-        for (const contour of contours) {
-            const intVertsBefore = interiorPositions.length / 3;
-            interiorTriangleCount += triangulateContourFan(contour.vertices, glyph.offsetX, glyph.offsetY, interiorPositions, interiorIndices);
-            const intVertsAfter = interiorPositions.length / 3;
-            fillGlyphAttrs(center, i, progress, glyph.lineIndex, glyph.baselineY, intVertsAfter - intVertsBefore, iGC, iGI, iGP, iGL, iGB);
-            for (const segment of contour.segments) {
-                if (shouldSkipCurveSegment(segment))
-                    continue;
-                curvePositions.push(glyph.offsetX + segment.p0x, glyph.offsetY + segment.p0y, 0, glyph.offsetX + segment.p1x, glyph.offsetY + segment.p1y, 0, glyph.offsetX + segment.p2x, glyph.offsetY + segment.p2y, 0);
-                curveTriangleCount++;
-                fillGlyphAttrs(center, i, progress, glyph.lineIndex, glyph.baselineY, 3, cGC, cGI, cGP, cGL, cGB);
-            }
-        }
-        glyphRanges.push({
-            interiorIndexStart: intIdxStart,
-            interiorIndexCount: interiorIndices.length - intIdxStart,
-            curveVertexStart: curveVertStart,
-            curveVertexCount: (curvePositions.length / 3) - curveVertStart
-        });
-        const fp = i * 12;
-        fillPositions[fp] = glyph.offsetX + minX;
-        fillPositions[fp + 1] = glyph.offsetY + minY;
-        fillPositions[fp + 2] = 0;
-        fillPositions[fp + 3] = glyph.offsetX + maxX;
-        fillPositions[fp + 4] = glyph.offsetY + minY;
-        fillPositions[fp + 5] = 0;
-        fillPositions[fp + 6] = glyph.offsetX + maxX;
-        fillPositions[fp + 7] = glyph.offsetY + maxY;
-        fillPositions[fp + 8] = 0;
-        fillPositions[fp + 9] = glyph.offsetX + minX;
-        fillPositions[fp + 10] = glyph.offsetY + maxY;
-        fillPositions[fp + 11] = 0;
-        fillGlyphAttrs(center, i, progress, glyph.lineIndex, glyph.baselineY, 4, fGC, fGI, fGP, fGL, fGB);
-        const fi = i * 6;
-        const fv = i * 4;
-        fillIndices[fi] = fv;
-        fillIndices[fi + 1] = fv + 1;
-        fillIndices[fi + 2] = fv + 2;
-        fillIndices[fi + 3] = fv;
-        fillIndices[fi + 4] = fv + 2;
-        fillIndices[fi + 5] = fv + 3;
-    }
-    return {
-        interiorPositions: new Float32Array(interiorPositions),
-        interiorIndices: new Uint32Array(interiorIndices),
-        curvePositions: new Float32Array(curvePositions),
-        fillPositions,
-        fillIndices,
-        glyphRanges,
-        interiorGlyphAttrs: packAttrs(iGC, iGI, iGP, iGL, iGB),
-        curveGlyphAttrs: packAttrs(cGC, cGI, cGP, cGL, cGB),
-        fillGlyphAttrs: packAttrs(fGC, fGI, fGP, fGL, fGB),
-        planeBounds: input.planeBounds,
-        stats: {
-            glyphCount,
-            contourCount,
-            interiorTriangleCount,
-            curveTriangleCount
-        }
-    };
-}
 
-function wrapResult(coreResult, opts) {
-    const meshes = loopBlinnTSL.createVectorMeshes(coreResult.geometryData, {
-        color: opts.color,
-        positionNode: opts.positionNode,
-        colorNode: opts.colorNode,
-        center: opts.center,
-    });
-    return {
-        glyphs: coreResult.glyphs,
-        geometryData: coreResult.geometryData,
-        group: meshes.group,
-        interiorGeometry: meshes.interiorGeometry,
-        curveGeometry: meshes.curveGeometry,
-        fillGeometry: meshes.fillGeometry,
-        query: coreResult.query,
-        getLoadedFont: coreResult.getLoadedFont,
-        measureTextWidth: coreResult.measureTextWidth,
-        updateMaterials: meshes.updateMaterials,
-        async update(newOptions) {
-            const newCore = await coreResult.update(newOptions);
-            return wrapResult(newCore, { ...opts, ...newOptions });
-        },
-        dispose() {
-            meshes.dispose();
-            coreResult.dispose();
-        }
-    };
-}
-class Text {
-    static { this.setHarfBuzzPath = core.Text.setHarfBuzzPath; }
-    static { this.setHarfBuzzBuffer = core.Text.setHarfBuzzBuffer; }
-    static { this.init = core.Text.init; }
-    static { this.registerPattern = core.Text.registerPattern; }
-    static { this.preloadPatterns = core.Text.preloadPatterns; }
-    static { this.setMaxFontCacheMemoryMB = core.Text.setMaxFontCacheMemoryMB; }
-    static { this.enableWoff2 = core.Text.enableWoff2; }
-    static async create(options) {
-        const coreResult = await core.Text.create(options);
-        return wrapResult(coreResult, options);
-    }
-}
 
-Object.defineProperty(exports, 'createVectorMeshes', {
-    enumerable: true,
-    get: function () { return loopBlinnTSL.createVectorMeshes; }
-});
-Object.defineProperty(exports, 'loopBlinnFragment', {
-    enumerable: true,
-    get: function () { return loopBlinnTSL.loopBlinnFragment; }
-});
-exports.Text = Text;
-exports.buildVectorGeometry = buildVectorGeometry;
-exports.extractContours = extractContours;
+exports.Text = index.Text;
+exports.createSlugGLSLMesh = index.createSlugGLSLMesh;