text-shaper 0.1.1 → 0.1.2

package/dist/raster/msdf.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Multi-channel Signed Distance Field (MSDF) rasterizer
+ *
+ * MSDF uses three channels (RGB) to encode distance information,
+ * allowing sharp corners to be preserved when scaling.
+ *
+ * Algorithm:
+ * 1. Decompose glyph outline into edges (lines, quadratics, cubics)
+ * 2. Color edges so adjacent edges at sharp corners have different colors
+ * 3. For each pixel, compute signed distance to nearest edge of each color
+ * 4. Store R, G, B distances in output bitmap
+ * 5. Shader reconstructs using: median(r, g, b)
+ *
+ * Reference: https://github.com/Chlumsky/msdfgen
+ */
+import type { Font } from "../font/font.ts";
+import type { GlyphPath } from "../render/path.ts";
+import { type Bitmap, type GlyphAtlas, type MsdfAtlasOptions } from "./types.ts";
+/**
+ * A 2D point
+ */
+export interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * Edge color channels for MSDF
+ * 0 = red, 1 = green, 2 = blue
+ */
+export type EdgeColor = 0 | 1 | 2;
+/**
+ * An edge with color assignment
+ */
+export type MsdfEdge = {
+    type: "line";
+    p0: Point;
+    p1: Point;
+    color: EdgeColor;
+} | {
+    type: "quadratic";
+    p0: Point;
+    p1: Point;
+    p2: Point;
+    color: EdgeColor;
+} | {
+    type: "cubic";
+    p0: Point;
+    p1: Point;
+    p2: Point;
+    p3: Point;
+    color: EdgeColor;
+};
+/**
+ * Signed distance result with parameter t
+ */
+export interface SignedDistanceResult {
+    distance: number;
+    t: number;
+}
+/**
+ * Options for MSDF rendering
+ */
+export interface MsdfOptions {
+    /** Width in pixels */
+    width: number;
+    /** Height in pixels */
+    height: number;
+    /** Scale factor (font units to pixels) */
+    scale: number;
+    /** X offset in pixels */
+    offsetX?: number;
+    /** Y offset in pixels */
+    offsetY?: number;
+    /** Flip Y axis (font coords are Y-up, bitmap is Y-down) */
+    flipY?: boolean;
+    /** Spread/radius - how far the distance field extends in pixels (default: 8) */
+    spread?: number;
+}
+/**
+ * Return the median of three numbers
+ */
+export declare function median(a: number, b: number, c: number): number;
+/**
+ * Compute signed distance from point to line segment
+ */
+export declare function signedDistanceToLine(px: number, py: number, p0: Point, p1: Point): SignedDistanceResult;
+/**
+ * Compute signed distance from point to quadratic bezier curve
+ * Uses Newton-Raphson iteration to find closest point
+ */
+export declare function signedDistanceToQuadratic(px: number, py: number, p0: Point, p1: Point, p2: Point): SignedDistanceResult;
+/**
+ * Compute signed distance from point to cubic bezier curve
+ * Uses Newton-Raphson iteration with multiple starting points
+ */
+export declare function signedDistanceToCubic(px: number, py: number, p0: Point, p1: Point, p2: Point, p3: Point): SignedDistanceResult;
+/**
+ * Assign colors to edges based on corner angles
+ * At sharp corners, adjacent edges get different colors
+ */
+export declare function assignEdgeColors(contours: MsdfEdge[][]): void;
+/**
+ * Render a glyph path as a multi-channel signed distance field
+ */
+export declare function renderMsdf(path: GlyphPath, options: MsdfOptions): Bitmap;
+/**
+ * Build an MSDF texture atlas from a set of glyphs
+ */
+export declare function buildMsdfAtlas(font: Font, glyphIds: number[], options: MsdfAtlasOptions): GlyphAtlas;
+/**
+ * Build MSDF atlas for ASCII printable characters (32-126)
+ */
+export declare function buildMsdfAsciiAtlas(font: Font, options: MsdfAtlasOptions): GlyphAtlas;
+/**
+ * Build MSDF atlas for a specific string (including all unique glyphs)
+ */
+export declare function buildMsdfStringAtlas(font: Font, text: string, options: MsdfAtlasOptions): GlyphAtlas;
+/**
+ * Export MSDF atlas as RGB texture data
+ */
+export declare function msdfAtlasToRGB(atlas: GlyphAtlas): Uint8Array;
+/**
+ * Export MSDF atlas as RGBA texture data
+ */
+export declare function msdfAtlasToRGBA(atlas: GlyphAtlas): Uint8Array;

package/dist/raster/types.d.ts

@@ -160,6 +160,21 @@ export interface AtlasOptions {
     /** Enable hinting */
     hinting?: boolean;
 }
+/**
+ * Options for building an MSDF atlas
+ */
+export interface MsdfAtlasOptions {
+    /** Font size in pixels (size of each glyph cell in the atlas) */
+    fontSize: number;
+    /** Padding between glyphs */
+    padding?: number;
+    /** Maximum atlas width */
+    maxWidth?: number;
+    /** Maximum atlas height */
+    maxHeight?: number;
+    /** SDF spread/radius in pixels (default: 4) */
+    spread?: number;
+}
 /**
  * Create an empty bitmap
  */

package/dist/render/outline-transform.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Outline Transform Operations
+ *
+ * Provides geometric transformations for glyph outlines:
+ * - 90° rotation
+ * - Power-of-2 scaling
+ * - 2D affine transforms (translate, rotate, scale, shear)
+ * - 3D perspective transforms
+ * - Bounding box computation
+ */
+import type { GlyphPath } from "./path.ts";
+/**
+ * 2D affine transformation matrix [a, b, c, d, tx, ty]
+ * Transforms point (x, y) to:
+ *   x' = a*x + c*y + tx
+ *   y' = b*x + d*y + ty
+ */
+export type Matrix2D = [number, number, number, number, number, number];
+/**
+ * 3x3 transformation matrix for 2D homogeneous coordinates
+ * | m00 m01 m02 |   | x |   | x' |
+ * | m10 m11 m12 | × | y | = | y' |
+ * | m20 m21 m22 |   | 1 |   | w  |
+ *
+ * Final coordinates: (x'/w, y'/w)
+ */
+export type Matrix3x3 = [
+    [
+        number,
+        number,
+        number
+    ],
+    [
+        number,
+        number,
+        number
+    ],
+    [
+        number,
+        number,
+        number
+    ]
+];
+/**
+ * Axis-aligned bounding box
+ */
+export interface BoundingBox {
+    xMin: number;
+    yMin: number;
+    xMax: number;
+    yMax: number;
+}
+/**
+ * Control box (bounding box of control points, not tight bounds)
+ */
+export interface ControlBox extends BoundingBox {
+}
+/**
+ * Create identity 2D matrix
+ */
+export declare function identity2D(): Matrix2D;
+/**
+ * Create identity 3x3 matrix
+ */
+export declare function identity3x3(): Matrix3x3;
+/**
+ * Create translation matrix
+ */
+export declare function translate2D(tx: number, ty: number): Matrix2D;
+/**
+ * Create scale matrix
+ */
+export declare function scale2D(sx: number, sy: number): Matrix2D;
+/**
+ * Create rotation matrix (angle in radians)
+ */
+export declare function rotate2D(angle: number): Matrix2D;
+/**
+ * Create shear/skew matrix
+ */
+export declare function shear2D(shearX: number, shearY: number): Matrix2D;
+/**
+ * Multiply two 2D matrices: result = a × b
+ */
+export declare function multiply2D(a: Matrix2D, b: Matrix2D): Matrix2D;
+/**
+ * Multiply two 3x3 matrices: result = a × b
+ */
+export declare function multiply3x3(a: Matrix3x3, b: Matrix3x3): Matrix3x3;
+/**
+ * Transform a point using 2D matrix
+ */
+export declare function transformPoint2D(x: number, y: number, m: Matrix2D): {
+    x: number;
+    y: number;
+};
+/**
+ * Transform a point using 3x3 matrix (with perspective division)
+ */
+export declare function transformPoint3x3(x: number, y: number, m: Matrix3x3): {
+    x: number;
+    y: number;
+};
+/**
+ * Rotate outline by 90 degrees counter-clockwise around origin
+ * Optionally apply offset after rotation
+ */
+export declare function rotateOutline90(path: GlyphPath, offsetX?: number, offsetY?: number): GlyphPath;
+/**
+ * Scale outline by power of 2
+ * scaleOrdX/Y: shift amount (positive = enlarge, negative = shrink)
+ * e.g., scaleOrdX=1 means multiply x by 2, scaleOrdX=-1 means divide by 2
+ */
+export declare function scaleOutlinePow2(path: GlyphPath, scaleOrdX: number, scaleOrdY: number): GlyphPath;
+/**
+ * Apply 2D affine transformation to outline
+ */
+export declare function transformOutline2D(path: GlyphPath, m: Matrix2D): GlyphPath;
+/**
+ * Apply 3D perspective transformation to outline
+ * Uses homogeneous coordinates for perspective projection
+ */
+export declare function transformOutline3D(path: GlyphPath, m: Matrix3x3): GlyphPath;
+/**
+ * Compute control box (bounding box of all control points)
+ * This is faster than computing tight bounds but may be larger
+ */
+export declare function computeControlBox(path: GlyphPath): ControlBox;
+/**
+ * Compute tight bounding box (exact bounds considering curve extrema)
+ */
+export declare function computeTightBounds(path: GlyphPath): BoundingBox;
+/**
+ * Update control box with transformed outline
+ * Used for finding minimum X after 3D transform (like libass)
+ */
+export declare function updateMinTransformedX(path: GlyphPath, m: Matrix3x3, currentMinX: number): number;
+/**
+ * Translate outline by offset
+ */
+export declare function translateOutline(path: GlyphPath, dx: number, dy: number): GlyphPath;
+/**
+ * Scale outline uniformly
+ */
+export declare function scaleOutline(path: GlyphPath, sx: number, sy?: number): GlyphPath;
+/**
+ * Rotate outline by angle (in radians) around origin
+ */
+export declare function rotateOutline(path: GlyphPath, angle: number): GlyphPath;
+/**
+ * Apply italic/oblique shear to outline
+ * @param angle Italic angle in degrees (typically 12-15 for italic)
+ */
+export declare function italicizeOutline(path: GlyphPath, angle: number): GlyphPath;
+/**
+ * Create 3x3 perspective matrix
+ * @param vanishingPointX X coordinate of vanishing point
+ * @param vanishingPointY Y coordinate of vanishing point
+ * @param strength Perspective strength (0 = none, larger = more perspective)
+ */
+export declare function perspectiveMatrix(vanishingPointX: number, vanishingPointY: number, strength: number): Matrix3x3;
+/**
+ * Combine multiple paths into one
+ */
+export declare function combinePaths(paths: GlyphPath[]): GlyphPath;
+/**
+ * Clone a path
+ */
+export declare function clonePath(path: GlyphPath): GlyphPath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "text-shaper",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "devDependencies": {
@@ -57,4 +57,4 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts"
-}
+}