@vincentt-xr/sdk 2.0.0-alpha.8 → 2.0.0-alpha.9

package/dist/face-atlas/eyes.d.ts

@@ -0,0 +1,272 @@
+/**
+ * Eye-region masks (FACE-1: `Eyeshadow`, `Eyeliner`, `Brows`): distance
+ * fields to the lash lines and brows, evaluated per fragment on the rest
+ * position, so nothing is baked. This file is the TypeScript mirror of
+ * `MAKEUP_GLSL.eyes` (tests, triangle selection) and holds the constants
+ * the GLSL is generated from.
+ *
+ * - Distances are taken in the FRONTAL plane of the canonical head frame
+ *   (`x, y` in cm). Line widths run across the lash lines and brows, which
+ *   is nearly vertical, so a head turned about its vertical axis does not
+ *   shorten them; only lengths along a line (a wing) read up to ~15 %
+ *   shorter on the side of the eye.
+ * - Every shape is authored on the canonical −X half (landmark 33's eye and
+ *   brow) and the rest point is folded onto it (`x → −|x|`), so both eyes
+ *   match; which of them shows is the `uSide` weight (the person's own
+ *   sides, #298). Blinks stay on mesh sides (`FACE_ATLAS_BLINK_MORPHS`).
+ * - Lash lines run from the outer corner (33, position 0) to the inner
+ *   corner (133, position 1); brows from the tail (0) to the head (1).
+ */
+/** A frontal point or direction, cm. */
+export type MakeupEyeVec2 = readonly [x: number, y: number];
+/** Tuning of the eye masks (cm unless noted). The GLSL is generated from these. */
+export declare const MAKEUP_EYE_MODEL: Readonly<{
+    /** Half-width of the split between the lid (above the eye) and the under-eye. */
+    gateCm: 0.02;
+    /** Lower zones (liner and shadow) fade out as the mesh-side blink goes from 0.35 to 0.75. */
+    blinkFade: readonly [0.35, 0.75];
+    /** Edges are never sharper than this many pixels (antialiasing). */
+    antialiasPx: 1.5;
+    liner: Readonly<{
+        /** Where the line starts tapering toward the inner corner (0 outer … 1 inner). */
+        taperStart: 0.15;
+        /** The lower line's width relative to the upper line's. */
+        lowerWidth: 0.6;
+        /** How far in from the outer corner the lower line reaches: `start + perLower · lower`. */
+        lowerReach: readonly [0.3, 0.75];
+        /** The fade at the inner end of the lower line (position units). */
+        lowerReachSoftness: 0.2;
+        /** `lower` amounts below this fade the lower line in. */
+        lowerFadeIn: 0.3;
+        /** `softness` scale into the line's edge feather. */
+        softnessScale: 0.5;
+        /** `smudge` added to the edge feather (and the width grows by `1 + smudge`). */
+        smudgeSoftness: 0.8;
+        /** The wing's tip radius, relative to the line's width; never below `wingTipMinCm`. */
+        wingTip: 0.15;
+        wingTipMinCm: 0.02;
+        /** Under the eye, the wing fades out within this far along the lower lash line. */
+        wingBelow: 0.06;
+    }>;
+    shadow: Readonly<{
+        /** Lash line to brow edge is never taken as less than this (cm), for the lid position. */
+        minGap: 0.3;
+        /** The lid colour's top edge feather (in lash → brow units): `start + perSoftness · softness`. */
+        edge: readonly [0.06, 0.3];
+        /** A sharp lid edge (a shape's `lidSharpness` 1) feathers this many cm, or the antialiasing if wider. */
+        sharpEdgeCm: 0.02;
+        /** Every lid zone fades out between these lash → brow positions (never on the brow). */
+        top: readonly [0.9, 1.02];
+        /** Fade past the outer corner: `start + perSoftness · softness` cm. */
+        outerReach: readonly [0.35, 0.4];
+        /** Fade past the inner corner, cm. */
+        innerReach: 0.35;
+        /**
+         * The lid's sides lean in toward the brow: at lid position `t` the outer
+         * and inner fades start `slope · t²` cm further in (a rounded lid shape).
+         */
+        outerSlope: 0.3;
+        innerSlope: 0.8;
+        /** The crease band's centre follows `height` (plus a shape's lift), clamped to this range. */
+        creaseCentre: readonly [0.2, 0.9];
+        /** The crease band's half-width: `start + perSoftness · softness` (lash → brow units). */
+        creaseWidth: readonly [0.12, 0.18];
+        /** With a shape's `outer` 1, the crease fades to `1 − outerBias` at the inner corner. */
+        outerBias: 0.7;
+        /** Width of the lower lash-line shadow: `start + perLower · lower` cm. */
+        lowerWidth: readonly [0.15, 0.35];
+        /** Inner-corner highlight radius. */
+        innerRadius: 0.45;
+        /** The halo shapes' bright lid centre: radius, and how far above the lash line's middle. */
+        haloRadius: 0.45;
+        haloLift: 0.3;
+        /** The shadow wing (`winged`, `smoky`): from the outer corner, this long, this many degrees upward. */
+        wingLength: 1.3;
+        wingAngle: 25;
+        wingRadius: readonly [0.45, 0.08];
+    }>;
+    brow: Readonly<{
+        /** The tail's half-width relative to the measured brow. */
+        tailTaper: 0.75;
+        /** Hair strokes: lane spacing, stroke length, share of strokes kept, line half-width (of the spacing). */
+        strokeSpacing: 0.055;
+        strokeLength: 0.6;
+        strokeKeep: 0.6;
+        strokeWidth: readonly [0.12, 0.3];
+        /** A stroke fades in over the first `strokeFade[0]` of its segment and out from `strokeFade[1]`. */
+        strokeFade: readonly [0.15, 0.6];
+        /** How far a stroke's lane may shift sideways (of the spacing). */
+        strokeJitter: 0.4;
+        /** Strokes reach this far past the band (relative to its half-width). */
+        strokeReach: 1.15;
+        /** A stroke pattern finer than 1.5–3 px fades to its mean coverage (about 0.18; was 0.3, too dark). */
+        strokeMean: number;
+        strokeResolvePx: readonly [1.5, 3];
+        /**
+         * Hair angle from the brow line, degrees, pointing toward the tail and
+         * up: along the body, and at the head (where hairs stand up). The two
+         * patterns cross-fade over `strokeHeadBlend` of the brow's length.
+         */
+        strokeAngle: readonly [25, 75];
+        strokeHeadBlend: readonly [0.7, 0.95];
+        /** Hair tint gain `(1 − lum(C) / lum(L)) · gain`: from `boldness` 0 to 1. */
+        hairGain: readonly [1.8, 3.2];
+        /** Width of the whole brow at `boldness` 0, 0.5 and 1. */
+        boldnessWidth: readonly [0.6, 1, 1.45];
+    }>;
+}>;
+/**
+ * The brow strokes' hash (`makeupPcg3d`): lanes and stroke segments are
+ * offset to stay positive before the cast to unsigned, and salted apart
+ * from the flakes.
+ */
+export declare const MAKEUP_BROW_HASH: Readonly<{
+    offset: 4096;
+    salt: 7919;
+}>;
+/** Brow control points (tail → head) and capsules between them. */
+export declare const MAKEUP_BROW_POINTS = 5;
+export declare const MAKEUP_BROW_SEGMENTS: number;
+/** The segment arrays the shader holds as constants: `[ax, ay, bx, by]` per segment. */
+export type MakeupEyeLines = {
+    /** The upper lash line, outer (33) → inner (133). */
+    upper: Float32Array;
+    /** The lower lash line, outer (33) → inner (133). */
+    lower: Float32Array;
+    /** The brow's lower edge, tail (46) → head (55). */
+    browLower: Float32Array;
+};
+/** Where the eye regions sit on the canonical −X half (frontal cm). */
+export type MakeupEyeGeometry = {
+    lines: MakeupEyeLines;
+    /** The outer (33) and inner (133) eye corners. */
+    outer: MakeupEyeVec2;
+    inner: MakeupEyeVec2;
+    /** Between the corners; the lid / under-eye split runs through it. */
+    middle: MakeupEyeVec2;
+    /** Unit, inner corner → outer corner. */
+    axis: MakeupEyeVec2;
+    /** Corner to corner, cm. */
+    axisLength: number;
+    /** Unit normal of `axis`, pointing up (+Y). */
+    up: MakeupEyeVec2;
+    /** The halo shapes' bright spot on the lid. */
+    lidCentre: MakeupEyeVec2;
+    /** The shadow wing's ends. */
+    shadowWing: readonly [start: MakeupEyeVec2, end: MakeupEyeVec2];
+    /** The person's own brow, tail → head: centre `x, y` and half-width, cm. */
+    brow: readonly (readonly [x: number, y: number, halfWidth: number])[];
+};
+/**
+ * A direction `degrees` upward from `axis` (an outward direction on the −X
+ * half, where outward is −X): turning from −X toward +Y is up for the person.
+ */
+export declare const makeupEyeRotateUp: (axis: MakeupEyeVec2, degrees: number) => [number, number];
+/** The eye regions' geometry on the canonical face (built once, shared: do not mutate). */
+export declare const getMakeupEyeGeometry: () => MakeupEyeGeometry;
+/**
+ * Distance (cm) from `(x, y)` to a line of segments and the position along
+ * it (0 at its first point … 1 at its last), as `[distance, position]`.
+ * GLSL `makeupEyeLine`.
+ */
+export declare const makeupEyeLineDistance: (line: Float32Array, x: number, y: number, out?: [number, number]) => [number, number];
+/**
+ * The height (y, cm) of a line whose segments run left to right in x (the
+ * upper lash line, the brow's lower edge) at `x`; past an end, the end's
+ * height. GLSL
+ * `makeupEyeLineHeight`.
+ */
+export declare const makeupEyeLineHeight: (line: Float32Array, x: number) => number;
+/**
+ * 1 on the lid (above the eye), 0 under it, split where the two lash lines
+ * are equally near, and beyond the corners along the corner-to-corner axis.
+ * GLSL `makeupEyeLidGate`.
+ */
+export declare const makeupEyeLidGate: (x: number, y: number, upperCm: number, lowerCm: number) => number;
+/** The lower zones' blink fade for a mesh-side blink, 0..1. GLSL `makeupEyeBlinkFade`. */
+export declare const makeupEyeBlinkFade: (blink: number) => number;
+/** An edge feather of at least `antialiasPx` pixels for a shape `radiusCm` wide. GLSL `makeupEyeSoftness`. */
+export declare const makeupEyeSoftness: (softness: number, radiusCm: number, pixelCm: number) => number;
+/**
+ * The values the eye masks read (the `MAKEUP_GLSL.eyes` uniforms, as plain
+ * numbers): `uSoftness`, `uBlink` (negX, posX), `uLiner` (width cm, lower,
+ * taper, smudge), `uWingStart` / `uWingEnd` (x, y, radius; radius 0 = no
+ * wing), `uShadow` (height, crease, lower, inner), `uShadowShape` (outer,
+ * wing, halo), `uShadowCut` (crease lift, lid sharpness), `uBrowStart` /
+ * `uBrowEnd` (x, y, half-width per segment), `uBrow` (fill, strokes, hair
+ * gain).
+ */
+export type MakeupEyeParams = {
+    softness: number;
+    blink: readonly [negX: number, posX: number];
+    liner: readonly [widthCm: number, lower: number, taper: number, smudge: number];
+    wingStart: ArrayLike<number>;
+    wingEnd: ArrayLike<number>;
+    shadow: readonly [height: number, crease: number, lower: number, inner: number];
+    shadowShape: readonly [outer: number, wing: number, halo: number];
+    shadowCut: readonly [creaseLift: number, lidSharpness: number];
+    browStart: ArrayLike<number>;
+    browEnd: ArrayLike<number>;
+    brow: readonly [fill: number, strokes: number, hairGain: number];
+};
+/** The eyeliner mask at a rest point (cm). GLSL `eyelinerShape`. */
+export declare const evaluateEyelinerShape: (params: MakeupEyeParams, rest: readonly [number, number, number], pixelCm?: number) => number;
+/** The eyeshadow zones at a rest point: each 0..1. GLSL `MakeupEyeshadowZones`. */
+export type MakeupEyeshadowZones = {
+    lid: number;
+    lower: number;
+    wing: number;
+    crease: number;
+    inner: number;
+};
+/** The eyeshadow zones at a rest point (cm). GLSL `eyeshadowZones`. */
+export declare const evaluateEyeshadowZones: (params: MakeupEyeParams, rest: readonly [number, number, number], pixelCm?: number) => MakeupEyeshadowZones;
+/** The zones' union: the eyeshadow's mask. GLSL `eyeshadowMask`. */
+export declare const makeupEyeshadowMask: (z: MakeupEyeshadowZones) => number;
+/**
+ * The eyeshadow's colour from its zones, each laid over the last: lid and
+ * lower lash line in the shade, the wing toward the crease colour by
+ * `crease`, the crease band, then the inner corner (and halo centre).
+ * GLSL `eyeshadowColor`.
+ */
+export declare const makeupEyeshadowColor: (z: MakeupEyeshadowZones, shade: readonly [number, number, number], creaseColor: readonly [number, number, number], innerColor: readonly [number, number, number], crease: number) => [number, number, number];
+/** The brow's geometry at a rest point: the band and the hair strokes. GLSL `MakeupBrow`. */
+export type MakeupBrowSample = {
+    /** The powder band, 0..1. */
+    band: number;
+    /** The hair strokes (times `strokes`), 0..1. */
+    strokes: number;
+    /** Position along the brow: 0 tail … 1 head. */
+    along: number;
+};
+/**
+ * One hair-stroke pattern in the brow's own frame (`s` cm along the centre
+ * line from the tail, `n` cm across it, + above): lanes of strokes at
+ * `degrees` from the brow line, pointing toward the tail and up. GLSL
+ * `makeupBrowHairs`.
+ */
+export declare const makeupBrowHairs: (s: number, n: number, degrees: number, salt: number, pixelCm: number) => number;
+/**
+ * The brow's own frame at a frontal point: `s` cm along the tail → head
+ * chord, `n` cm above the shaped centre line there (continuous across the
+ * control points), and the chord's length. GLSL `makeupBrowFrame`.
+ */
+export declare const makeupBrowFrame: (params: MakeupEyeParams, x: number, y: number) => [s: number, n: number, length: number];
+/** The brow at a rest point (cm). GLSL `browGeometry`. */
+export declare const evaluateBrowGeometry: (params: MakeupEyeParams, rest: readonly [number, number, number], pixelCm?: number) => MakeupBrowSample;
+/**
+ * How much of a pixel is brow hair: `(1 − lum(C) / lum(L)) · gain`, clamped,
+ * from the camera's luminance and the local skin's (the probe's low-pass,
+ * which fills the brow from the skin around it). GLSL `browMask`.
+ */
+export declare const makeupBrowHairWeight: (cameraLuma: number, skinLuma: number, gain: number) => number;
+/**
+ * The brow's mask: the band times the hair tint mixed toward a full powder
+ * fill by `fill`, joined with the strokes. GLSL `browMask`.
+ */
+export declare const makeupBrowMask: (brow: MakeupBrowSample, hair: number, fill: number) => number;
+/** The `FACE_MORPH_NAMES` channels of the blink on each canonical half (`FACE_ATLAS_BLINK_MORPHS`). */
+export declare const MAKEUP_BLINK_CHANNELS: Readonly<{
+    negX: number;
+    posX: number;
+}>;

package/dist/face-atlas/faceAtlas.generated.d.ts

@@ -0,0 +1,46 @@
+/** Where the atlas comes from: the canonical face OBJ the SDK pins (SHA-384). */
+export declare const FACE_ATLAS_SOURCE: {
+    readonly path: "/assets/sdk/face/v1/canonical_face_model.obj";
+    readonly integrity: "sha384-xP8YM/72TXKvbMptXB9a8JUlUf3MZQ8uLurExrsZc05v6/P5RrsaNGMUYS/BZx8A";
+    readonly vertexCount: 468;
+    readonly triangleCount: 898;
+};
+/**
+ * The face atlas: one UV per canonical landmark (flat `[u, v, …]`, 468 × 2,
+ * v up), the layout of the canonical OBJ's `vt` records (LipEffect designs,
+ * `Canonical_Face_Color.png`). u grows toward canonical +X (landmark 263);
+ * mirroring is exactly `u → 1 − u`. NOT `CANONICAL_FACE_UVS`.
+ */
+export declare const FACE_ATLAS_UVS: Float32Array;
+/**
+ * Atlas triangles: landmark indices, three per triangle (898), in the
+ * OBJ's face order, wound counter-clockwise seen from outside. Unlike
+ * `CANONICAL_FACE_TRIANGLES` the eye and mouth openings are filled.
+ */
+export declare const FACE_ATLAS_TRIANGLES: Uint16Array;
+/**
+ * `FACE_ATLAS_MIRROR[i]`: the landmark at `(−x, y, z)` of landmark i (exact).
+ * Its own inverse; the 28 midline landmarks map to themselves.
+ */
+export declare const FACE_ATLAS_MIRROR: Uint16Array;
+/** Triangle indices (into FACE_ATLAS_TRIANGLES) filling each eye opening. */
+export declare const FACE_ATLAS_EYE_FILLS: {
+    readonly negX: Uint16Array;
+    readonly posX: Uint16Array;
+};
+/** Triangle indices filling the mouth opening (inside the inner lip ring). */
+export declare const FACE_ATLAS_MOUTH_FILL: Uint16Array;
+/** Triangle indices of the two nostril openings. */
+export declare const FACE_ATLAS_NOSTRILS: Uint16Array;
+/** The face oval: the mesh boundary, in the triangle winding, from landmark 10. */
+export declare const FACE_ATLAS_OVAL_RING: readonly number[];
+/** Lash rings (eye openings), from the outer corner along the lower lid. */
+export declare const FACE_ATLAS_EYE_RINGS: {
+    readonly negX: readonly number[];
+    readonly posX: readonly number[];
+};
+/** Outer and inner lip rings (MediaPipe FACEMESH_LIPS), from mouth corner 61. */
+export declare const FACE_ATLAS_LIP_RINGS: {
+    readonly outer: readonly number[];
+    readonly inner: readonly number[];
+};

package/dist/face-atlas/glsl/atlasVertex.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Layout of the skin probe's statistics texture (`FaceSkinProbe.lightingMap`,
+ * `FACE_SKIN_STATS`), as the atlas vertex chunk reads it: `width` texels,
+ * read once per vertex through `FACE_SKIN_STATS_GLSL` (plain floats, or three
+ * bytes per value in the packed RGBA8 layout, `uSkinStatsPacked`) and passed
+ * to the fragment shader as flat varyings (no probe fetches per fragment
+ * except the local low-pass).
+ *
+ * | Texel | rgb | a |
+ * | --- | --- | --- |
+ * | `skinSlow` | Rs: the settled skin, linear | ready, 0..1 |
+ * | `skinFast` | Rf: the skin under the current light, linear | coverage |
+ * | `light` | the light gradient `b` in VIEW space (`vMakeupLight` gets `normalize`-able `b` and the confidence `|b| / a`) | ambient `a` |
+ * | `lip` | the person's own lip colour, linear | — |
+ * | `brow` | the person's own brow-hair colour, linear | — |
+ *
+ * A texture narrower than `width` (none bound yet: three binds a 1×1 empty
+ * texture for `null`) reads as "not ready", so layers draw before the probe
+ * exists.
+ */
+export declare const FACE_SKIN_STATS_TEXELS: Readonly<{
+    width: 8;
+    skinSlow: 0;
+    skinFast: 1;
+    light: 2;
+    lip: 3;
+    brow: 4;
+}>;
+/**
+ * The per-landmark attributes of a face-atlas surface geometry, declared
+ * for a vertex shader. three.js declares `position`, `normal` and `uv`
+ * itself on a `ShaderMaterial`.
+ */
+export declare const FACE_ATLAS_ATTRIBUTES_GLSL = "\nattribute vec3 basePosition;\nattribute vec3 restPosition;\nattribute vec3 restNormal;\nattribute float edge;\nattribute float lipEdge;\nattribute float eyeRing;\n";
+/**
+ * `MAKEUP_GLSL.atlasVertex`: the complete vertex shader of a makeup layer on
+ * the face-atlas surface. It writes every varying of `MAKEUP_VARYINGS_GLSL`:
+ * the camera at the un-warped point (`basePosition`, the FaceWarp3D
+ * pattern), the atlas uv, the rest point and normals, the view position, the
+ * edge / lip / eye attributes, the head's up axis, and the probe statistics
+ * from `uSkinStats` / `uSkinStatsPacked` (`FACE_SKIN_STATS_TEXELS`, read with
+ * the probe's own `MAKEUP_SKIN_STATS_VERTEX_GLSL`, so the float and packed
+ * layouts and the light's confidence match the probe) as flat varyings.
+ * `gl_Position` is computed exactly as the self-occlusion pre-pass does.
+ */
+export declare const MAKEUP_ATLAS_VERTEX_GLSL: string;

package/dist/face-atlas/glsl/common.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The varyings between the atlas vertex chunk and the makeup fragment chunks.
+ * The vertex side declares the same string: three.js turns `varying` into
+ * `out` / `in` for each stage (every ShaderMaterial compiles as GLSL ES 3.00),
+ * and `flat` carries the probe stats the vertex shader fetches once.
+ *
+ * - `vMakeupCamera`: clip-space `xyw` of the UN-warped point (`basePosition`);
+ *   the camera is sampled at `xy / z * 0.5 + 0.5` (the FaceWarp3D pattern).
+ * - `vMakeupUv`: the face-atlas coordinate (`FACE_ATLAS_UVS`), for the skin map.
+ * - `vMakeupRest`: the rest position in canonical cm (masks, sides, flakes).
+ * - `vMakeupNormal`: the live metric normal in view space.
+ * - `vMakeupFlakeNormal`: the rest normal rotated by the pose, view space.
+ * - `vMakeupViewPosition`: the view-space position.
+ * - `vMakeupEdge`: S1's `edge` attribute passed through unchanged: the
+ *   distance to the face oval along the surface, cm (faded in over
+ *   `MAKEUP_SHADING.edgeFadeCm`).
+ * - `vMakeupLipEdge`, `vMakeupEyeRing`: the `lipEdge` and `eyeRing` attributes.
+ * - flat `vMakeupSkinSlow` / `vMakeupSkinFast`: the probe's Rs / Rf, linear.
+ * - flat `vMakeupSkinReady`: 0 until the probe has data, then 1.
+ * - flat `vMakeupLight`: xyz the fitted light direction in VIEW space (any
+ *   length, 0 = none), w the fit's confidence `|b| / a`.
+ * - flat `vMakeupLipColor` / `vMakeupBrowColor`: the person's own lip and
+ *   brow-hair colours, linear.
+ * - flat `vMakeupHeadUp`: the head frame's +Y in view space
+ *   (`normalMatrix * vec3(0.0, 1.0, 0.0)`), the flakes' tangent frame.
+ */
+export declare const MAKEUP_VARYINGS_GLSL = "\nvarying vec3 vMakeupCamera;\nvarying vec2 vMakeupUv;\nvarying vec3 vMakeupRest;\nvarying vec3 vMakeupNormal;\nvarying vec3 vMakeupFlakeNormal;\nvarying vec3 vMakeupViewPosition;\nvarying float vMakeupEdge;\nvarying float vMakeupLipEdge;\nvarying float vMakeupEyeRing;\nflat varying vec3 vMakeupSkinSlow;\nflat varying vec3 vMakeupSkinFast;\nflat varying float vMakeupSkinReady;\nflat varying vec4 vMakeupLight;\nflat varying vec3 vMakeupLipColor;\nflat varying vec3 vMakeupBrowColor;\nflat varying vec3 vMakeupHeadUp;\n";
+/**
+ * `MAKEUP_GLSL.common`: what every makeup fragment shader starts with.
+ * Constants, the fragment output, the varyings, the shared uniforms
+ * (`createMakeupShadingUniforms()` supplies every one), the `MakeupSample`
+ * struct and `makeupSample()`, which reads the camera, the three skin
+ * references, the light, the rest point, the pixel footprint, the side
+ * weight and the fades. Call `makeupSample()` first in `main()`: it takes
+ * screen-space derivatives.
+ *
+ * `makeupSample()` is `makeupSampleGeometry()` (derivatives, rest point,
+ * normals, light, sides and fades: no texture reads) then
+ * `makeupSampleColor(s)` (the camera and skin texture reads, each at an
+ * explicit LOD, so they are valid after a `discard`). A shader with a mask
+ * calls the two halves around its early `discard`, so fragments outside the
+ * shape skip the texture reads:
+ *
+ * ```glsl
+ * MakeupSample s = makeupSampleGeometry();
+ * float mask = blushShape(s.rest);
+ * if (mask * s.fade < 1.0 / 255.0) discard;
+ * makeupSampleColor(s);
+ * ```
+ *
+ * Under `glslVersion: THREE.GLSL3` three.js declares no output, so this
+ * chunk declares `pc_fragColor` and maps `gl_FragColor` to it; under the
+ * default version three.js already has.
+ */
+export declare const MAKEUP_COMMON_GLSL: string;

package/dist/face-atlas/glsl/design.d.ts

@@ -0,0 +1,49 @@
+import type * as THREE from "three";
+/**
+ * `MAKEUP_GLSL.design` (after `common`; any place after it): creator art in
+ * the face atlas (`MakeupDesign`). The art is painted as on an unmirrored
+ * photo (image-left = the person's right, `FACE_ATLAS_UVS`, image top
+ * `v = 1`); `makeupDesignUv` samples `(1 − u, v)` when `uPersonLeftSign` is
+ * negative (the mirrored webcam), so each side of the art stays on the
+ * person's own side on every feed. The atlas is symmetric to 0.001, so the
+ * flip is exact.
+ *
+ * `makeupDesignSample(uv)` returns the art at an atlas uv as linear rgb and
+ * straight alpha: it divides out premultiplied alpha
+ * (`uDesignPremultiplied`) and decodes sRGB bytes (`uDesignSrgb`; a texture
+ * tagged `SRGBColorSpace` is decoded by the GPU instead). It reads the
+ * texture with implicit derivatives (mipmapped art stays clean on a small
+ * face), so call it before any `discard`:
+ *
+ * ```glsl
+ * MakeupSample s = makeupSampleGeometry();
+ * vec4 art = makeupDesignSample(s.uv);
+ * if (art.a * s.fade < 1.0 / 255.0) discard;
+ * makeupSampleColor(s);
+ * makeupOutput(s, makeupFinish(s, art.rgb * uColor, art.a));
+ * ```
+ *
+ * Uniforms: `createMakeupDesignUniforms()`; `setMakeupDesignTexture` sets
+ * the texture and its two flags.
+ */
+export declare const MAKEUP_DESIGN_GLSL = "\nuniform sampler2D uDesignMap;\nuniform float uDesignSrgb;\nuniform float uDesignPremultiplied;\n\n// The art's uv on this feed: (1 - u, v) on a mirrored feed (uPersonLeftSign < 0).\nvec2 makeupDesignUv(vec2 uv) {\n  return vec2(uPersonLeftSign < 0.0 ? 1.0 - uv.x : uv.x, uv.y);\n}\n\nvec3 makeupDesignDecode(vec3 c) {\n  vec3 low = c / 12.92;\n  vec3 high = pow((c + 0.055) / 1.055, vec3(2.4));\n  return mix(low, high, step(vec3(0.04045), c));\n}\n\n// The art at an atlas uv: linear rgb, straight alpha. Implicit derivatives: call before any discard.\nvec4 makeupDesignSample(vec2 uv) {\n  vec4 texel = texture(uDesignMap, makeupDesignUv(uv));\n  float a = clamp(texel.a, 0.0, 1.0);\n  vec3 c = uDesignPremultiplied > 0.5 ? texel.rgb / max(a, 1e-4) : texel.rgb;\n  c = clamp(c, 0.0, 1.0);\n  return vec4(uDesignSrgb > 0.5 ? makeupDesignDecode(c) : c, a);\n}\n";
+/**
+ * The uniforms `MAKEUP_GLSL.design` declares, empty: no art (three binds a
+ * transparent 1×1 texture for `null`, so nothing is painted).
+ */
+export declare const createMakeupDesignUniforms: () => {
+    /** The art, in the face atlas (v up, as a texture loaded with `flipY`). */
+    uDesignMap: {
+        value: THREE.Texture | null;
+    };
+    /** 1 when the texture holds sRGB bytes the shader decodes (not tagged `SRGBColorSpace` or linear). */
+    uDesignSrgb: {
+        value: number;
+    };
+    /** 1 when the texture was uploaded premultiplied (`texture.premultiplyAlpha`). */
+    uDesignPremultiplied: {
+        value: number;
+    };
+};
+/** The uniforms `MAKEUP_GLSL.design` reads. */
+export type MakeupDesignUniforms = ReturnType<typeof createMakeupDesignUniforms>;

package/dist/face-atlas/glsl/eyes.d.ts

@@ -0,0 +1,73 @@
+import * as THREE from "three";
+/**
+ * `MAKEUP_GLSL.eyes` (after `common`, `shading`, `sparkle`, `finish` and
+ * `shapes`): the eye regions' masks on the rest point, mirrored by
+ * `lib/face-atlas/eyes.ts`. Lash lines and the brow's lower edge are
+ * constants; everything a setting moves is a uniform, so no edit
+ * recompiles.
+ *
+ * - `eyelinerShape(s.rest, s.pixelCm)`: the liner's mask.
+ * - `eyeshadowZones(s.rest, s.pixelCm)` → `MakeupEyeshadowZones`;
+ *   `eyeshadowMask(z)` and `eyeshadowColor(z, makeupShade(s))`.
+ * - `browGeometry(s.rest, s.pixelCm)` → `MakeupBrow` (band and strokes;
+ *   `browReach` bounds it before the camera is read) and
+ *   `browMask(s, brow)`, which needs `makeupSampleColor(s)` first (the
+ *   real hairs are where the camera is darker than the local skin);
+ *   `browShape(s)` is both.
+ */
+export declare const MAKEUP_EYES_GLSL: string;
+/**
+ * The uniforms `MAKEUP_GLSL.eyes` declares, neutral (nothing paints until
+ * a region writes its settings). Colours are linear; brow capsules are
+ * `[x, y, halfWidth]` per segment (Float32Arrays whose identity never
+ * changes).
+ */
+export declare const createMakeupEyeUniforms: () => {
+    /** The blink on each canonical half, `(negX, posX)`, 0..1 (the face rig's morphs). */
+    uBlink: {
+        value: THREE.Vector2;
+    };
+    /** Eyeliner: `(width cm, lower 0..1, inner taper, smudge)`. */
+    uLiner: {
+        value: THREE.Vector4;
+    };
+    /** The liner wing's start and end: `(x, y, radius)` cm on the −X half; radius 0 = no wing. */
+    uWingStart: {
+        value: THREE.Vector3;
+    };
+    uWingEnd: {
+        value: THREE.Vector3;
+    };
+    /** Eyeshadow: `(height, crease, lower, inner)`, each 0..1. */
+    uShadow: {
+        value: THREE.Vector4;
+    };
+    /** The eyeshadow shape's `(outer bias, wing, halo)`, each 0..1. */
+    uShadowShape: {
+        value: THREE.Vector3;
+    };
+    /** The eyeshadow shape's `(crease lift, lid sharpness)`, each 0..1 (0, 0: a crease blended into the lid). */
+    uShadowCut: {
+        value: THREE.Vector2;
+    };
+    /** Crease and inner-corner colours, linear. */
+    uShadowCreaseColor: {
+        value: THREE.Color;
+    };
+    uShadowInnerColor: {
+        value: THREE.Color;
+    };
+    /** The brow's capsules, tail → head: `[x, y, halfWidth]` at each start and end, cm. */
+    uBrowStart: {
+        value: Float32Array<ArrayBuffer>;
+    };
+    uBrowEnd: {
+        value: Float32Array<ArrayBuffer>;
+    };
+    /** Brows: `(fill, strokes, hair gain)`. */
+    uBrow: {
+        value: THREE.Vector3;
+    };
+};
+/** The uniforms `MAKEUP_GLSL.eyes` reads. */
+export type MakeupEyeUniforms = ReturnType<typeof createMakeupEyeUniforms>;

package/dist/face-atlas/glsl/finish.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `MAKEUP_GLSL.finish` (after `common`, `shading` and `sparkle`): the six
+ * finishes as one function. Mirrors `makeupFinishLayer` in
+ * `lib/face-atlas/shading.ts`; the finish is a uniform (`uFinish`), so
+ * switching it never recompiles.
+ *
+ * | finish   | diffuse                       | highlight                                              |
+ * |----------|-------------------------------|--------------------------------------------------------|
+ * | matte    | hard clip (shine removed)     | none                                                   |
+ * | satin    | soft clip                     | 0.35 Hcam + broad lobe (rough 0.6) x shine             |
+ * | gloss    | soft clip                     | (1 + 1.5 shine) Hcam + sharp lobe (rough 0.12) + Fresnel, white, x mask (not opacity) |
+ * | shimmer  | as satin                      | satin + dense micro-flakes x lobe, tinted              |
+ * | metallic | D x mix(1, 0.45, coverage)    | Fresnel(F0 = shade) x (coverage x environment + Hcam + lobe (rough 0.35)) |
+ * | glitter  | satin base + flake bodies     | satin + sparse flakes (normals ~40 deg, hue jitter) x mask |
+ *
+ * Coverage 0 never lightens the skin: a sheer metallic is the sheer filter
+ * plus its lobe, Fresnel and camera highlight. The "x mask" terms keep their
+ * strength at low opacity and fade out below
+ * `MAKEUP_FINISH_MODEL.maskTermsFullOpacity`, so opacity 0 shows nothing.
+ *
+ * `makeupFinish(s, color, mask)` returns a `MakeupLayer` for `makeupOutput`.
+ * `mask` is the region's shape; `s.fade` applies on top.
+ */
+export declare const MAKEUP_FINISH_GLSL: string;

package/dist/face-atlas/glsl/format.d.ts

@@ -0,0 +1,4 @@
+/** A JS number as a GLSL float literal: `1` → `"1.0"`, `0.15` → `"0.15"`, `1e-7` → `"1e-7"`. */
+export declare const glslFloat: (x: number) => string;
+/** A JS triple as a GLSL `vec3(...)` literal. */
+export declare const glslVec3: (v: readonly [number, number, number]) => string;

package/dist/face-atlas/glsl/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * GLSL chunks for makeup shaders (FACE-1).
+ *
+ * `atlasVertex` is the whole vertex shader of a layer on the face-atlas
+ * surface (`FaceAtlasLayer`): it writes every varying the fragment chunks
+ * read. For the fragment shader, concatenate these in order, then your
+ * `main()`:
+ *
+ * `common` → `shading` → `sparkle` → `finish` → `shapes`
+ *
+ * ```glsl
+ * void main() {
+ *   MakeupSample s = makeupSample();           // first: it takes derivatives
+ *   float mask = blushShape(s.rest);           // or your own shape
+ *   makeupOutput(s, makeupFinish(s, makeupShade(s), mask));
+ * }
+ * ```
+ *
+ * With a mask, split the sample around an early out, so fragments outside
+ * the shape read no texture:
+ *
+ * ```glsl
+ * MakeupSample s = makeupSampleGeometry();     // derivatives, rest point, fades
+ * float mask = blushShape(s.rest);
+ * if (mask * s.fade < 1.0 / 255.0) discard;
+ * makeupSampleColor(s);                        // camera and skin, explicit LODs
+ * ```
+ *
+ * `common` alone with `shading` is enough for a matte layer:
+ * `makeupOutput(s, makeupDiffuse(s, uColor, uCoverage), mask * s.fade * uOpacity, vec3(0.0))`.
+ * Draw with `MAKEUP_BLENDING` (premultiplied over). A custom vertex side
+ * declares `MAKEUP_VARYINGS_GLSL` and writes every varying in it.
+ *
+ * `design` (after `common`) samples creator art in the face atlas
+ * (`MakeupDesign`): `makeupDesignSample(s.uv)` returns linear rgb and
+ * straight alpha, flipped on mirrored feeds so each side stays on the
+ * person's own side. Call it before any `discard`.
+ *
+ * `eyes` (after `shapes`) holds the eye regions' masks (`Eyeshadow`,
+ * `Eyeliner`, `Brows`): `eyelinerShape`, `eyeshadowZones` / `eyeshadowMask`
+ * / `eyeshadowColor`, and `browGeometry` / `browReach` / `browMask`, on the
+ * rest point in canonical cm, with blink fades from `uBlink`.
+ */
+export declare const MAKEUP_GLSL: Readonly<{
+    atlasVertex: string;
+    common: string;
+    shading: string;
+    sparkle: string;
+    finish: string;
+    shapes: string;
+    design: "\nuniform sampler2D uDesignMap;\nuniform float uDesignSrgb;\nuniform float uDesignPremultiplied;\n\n// The art's uv on this feed: (1 - u, v) on a mirrored feed (uPersonLeftSign < 0).\nvec2 makeupDesignUv(vec2 uv) {\n  return vec2(uPersonLeftSign < 0.0 ? 1.0 - uv.x : uv.x, uv.y);\n}\n\nvec3 makeupDesignDecode(vec3 c) {\n  vec3 low = c / 12.92;\n  vec3 high = pow((c + 0.055) / 1.055, vec3(2.4));\n  return mix(low, high, step(vec3(0.04045), c));\n}\n\n// The art at an atlas uv: linear rgb, straight alpha. Implicit derivatives: call before any discard.\nvec4 makeupDesignSample(vec2 uv) {\n  vec4 texel = texture(uDesignMap, makeupDesignUv(uv));\n  float a = clamp(texel.a, 0.0, 1.0);\n  vec3 c = uDesignPremultiplied > 0.5 ? texel.rgb / max(a, 1e-4) : texel.rgb;\n  c = clamp(c, 0.0, 1.0);\n  return vec4(uDesignSrgb > 0.5 ? makeupDesignDecode(c) : c, a);\n}\n";
+    eyes: string;
+}>;
+export { MAKEUP_VARYINGS_GLSL } from './common';
+export { FACE_ATLAS_ATTRIBUTES_GLSL, FACE_SKIN_STATS_TEXELS } from './atlasVertex';
+export { createMakeupShadingUniforms, type MakeupShadingUniforms } from './uniforms';
+export { createMakeupShapeUniforms, type MakeupShapeUniforms } from './shapes';
+export { createMakeupDesignUniforms, type MakeupDesignUniforms } from './design';
+export { createMakeupEyeUniforms, type MakeupEyeUniforms } from './eyes';

package/dist/face-atlas/glsl/shading.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `MAKEUP_GLSL.shading` (after `common`): skin-relative light terms, the
+ * diffuse (sheer / opaque coverage), auto shades and the output operator.
+ * Mirrors `makeupLighting`, `makeupDiffuse`, `makeupAutoShade` and
+ * `makeupOutput` in `lib/face-atlas/shading.ts`.
+ *
+ * - `S = lum(C) / lum(Rs)`: light on this pixel relative to the GLOBAL
+ *   settled skin, so a side-lit face keeps its shadow side and skin tone
+ *   never enters the paint.
+ * - `L` (local low-pass) only clips the skin's own shine out of the diffuse
+ *   (`Sd`) and measures the real highlight `Hcam`.
+ * - `makeupOutput` writes premultiplied `(k·enc(D) + enc(base+H) − enc(base), k)`;
+ *   draw it with `MAKEUP_BLENDING` (One, OneMinusSrcAlpha): opacity is linear.
+ */
+export declare const MAKEUP_SHADING_GLSL: string;