libraries-dev-svelte 0.1.0

package/dist/bot-avatars/path-cache.js

@@ -0,0 +1,10 @@
+const pathCache = new Map();
+/** Parse and reuse the package's SVG outline paths. */
+export function bodyPath(data) {
+    let path = pathCache.get(data);
+    if (!path) {
+        path = new Path2D(data);
+        pathCache.set(data, path);
+    }
+    return path;
+}

package/dist/bot-avatars/plastic.d.ts

@@ -0,0 +1,80 @@
+import type { DrawConfig } from './draw';
+/** The texture covers design units [-PAD, 100 + PAD]. */
+export declare const PAD = 3;
+export declare const SPAN: number;
+/** the matcap's side, in cells */
+export declare const MATCAP_SIZE = 64;
+type V3 = [number, number, number];
+export interface Form {
+    N: number;
+    /** bilinear cell in the matcap: index of the top-left cell … */
+    i00: Uint16Array;
+    /** … and the weights inside it, 0–255 */
+    wx: Uint8Array;
+    wy: Uint8Array;
+    /** baked occlusion × edge darkening, gamma-compensated, 0–255; 0 = not drawn */
+    ao: Uint8Array;
+}
+/**
+ * The form of one outline from its coverage raster (N × N, 0–255, over
+ * design units [-PAD, 100 + PAD]): a pillow height field, its normals as
+ * matcap cells, and baked occlusion; outside texels near the edge borrow
+ * their nearest inside texel so upscaling never bleeds transparent black.
+ */
+export declare function buildForm(cov: Uint8Array | Uint8ClampedArray, N: number, halfDepth: number): Form;
+/** Coverage raster of the outline: N × N over design units [-PAD, 100 + PAD]. */
+export declare function rasterize(path: Path2D, N: number): Uint8ClampedArray | null;
+/** Build a form ahead of time (call from an idle callback at mount). */
+export declare function warmPlastic(key: string, path: Path2D, devicePx?: number, depth?: number): void;
+/** Texture size for an avatar `devicePx` wide (CSS px × device pixel ratio). */
+export declare function tierFor(devicePx: number): number;
+export interface Material {
+    shadow: number;
+    highlight: number;
+    spread: number;
+    rim: number;
+}
+export interface Frame {
+    L: V3;
+    V: V3;
+    H: V3;
+    U: V3;
+    W: V3;
+    A: V3;
+    B: V3;
+}
+/** Fill `out` (M × M × rgb, sRGB 0–255) with the lit sphere for body colour `c` (linear). */
+export declare function buildMatcap(out: Float32Array, c: V3, f: Frame, p: Material): void;
+/** Per frame: matcap lookup × baked AO into the texture's pixels. */
+export declare function shadeTexels(form: Form, mc: Float32Array, px: Uint8ClampedArray, aoMul: Float32Array): void;
+export interface Rig {
+    /** the rig's (floored) cos/sin of yaw and pitch, as used by the slice affines */
+    cy: number;
+    sy: number;
+    cp: number;
+    sp: number;
+    /** cos(yaw)·cos(pitch), unfloored: the front cap faces the viewer while positive */
+    facing: number;
+    roll: number;
+    halfDepth: number;
+    cap: number;
+    /** unit vector toward the light on screen */
+    lx: number;
+    ly: number;
+    /** the avatar box in device pixels (CSS px × dpr) */
+    dev: number;
+    /** the context's transform for body space (a, b, c, d, e, f): the
+        slices set theirs from it directly rather than through save/restore */
+    ctm: readonly number[];
+    /** no animation loop will follow: build the form now rather than on idle time */
+    still?: boolean;
+}
+/** Screen-space vectors into the cap's frame: un-roll, then the transpose
+    of the rig's rotation; the back cap is the front mirrored in z. */
+export declare function capFrame(r: Rig): Frame;
+/** A · B for canvas affines (a, b, c, d, e, f) */
+export declare function mulAffine(A: readonly number[], B: readonly number[]): number[];
+export declare function drawPlasticCap(ctx: CanvasRenderingContext2D, cfg: DrawConfig, rig: Rig, pal: {
+    base: string;
+}, union: Path2D | null, mat: Material): boolean;
+export {};