vireglass 0.1.0

package/dist/web/index.d.cts

@@ -0,0 +1,148 @@
+import { j as VireGlassGeometry, k as VireGlassMorph, q as VireGlassTouch, V as VireGlassAccent, n as VireGlassRefScene } from '../adapters-BPB0D5nr.cjs';
+import { V as VireGlassOptics, n as VireGlassDebugMode } from '../material-CkUHUBoy.cjs';
+
+declare const PROBE_GRID_WIDTH = 48;
+declare const PROBE_GRID_HEIGHT = 96;
+/** Stats for the lens rectangle from a single probe sample. `null` until the first ready frame
+ *  has come in — the shader falls back to `u_probeLuma = -1` in that case (see `lens-shader.ts`). */
+type ProbeStats = {
+    luma: number;
+    busy: number;
+    lo: number;
+    hi: number;
+    slopeX: number;
+    slopeY: number;
+    r: number;
+    g: number;
+    b: number;
+};
+type ProbeRect = {
+    centerX: number;
+    centerY: number;
+    halfWidth: number;
+    halfHeight: number;
+};
+type Probe = {
+    /** Renders a downsample of the current `contentTexture` into its own FBO and advances the PBO
+     *  read pipeline. Returns stats for the lens rectangle — lagging by a frame or two, or `null`
+     *  until a reader is ready. */
+    sample(contentTexture: WebGLTexture, contentWidth: number, contentHeight: number, rect: ProbeRect): ProbeStats | null;
+    /** Stats for another rectangle from the ALREADY-captured grid — no new pass, no new read. */
+    statsFor(contentWidth: number, contentHeight: number, rect: ProbeRect): ProbeStats | null;
+    destroy(): void;
+};
+declare function createProbe(gl: WebGL2RenderingContext, vertexSource: string): Probe;
+
+/** The scene draws itself with an offset: the lenses in the frame stay put while the canvas
+ *  underneath them slides — only this way can you actually see what refraction does to whatever
+ *  passes under the element. Offset in device-px. */
+type VireGlassSceneDrawer = (ctx: CanvasRenderingContext2D, width: number, height: number, offsetX: number, offsetY: number, 
+/** Pixels per dp — the same value used for elements. The canvas and the glass must live at the
+ *  same scale: as a fraction of canvas width, a cell on desktop came out five times larger than
+ *  on a phone, and an element of the same size looked completely different on the lab bench
+ *  than on a device. */
+density: number) => void;
+/** One glass element in the frame. Each has its own material — that's how they're compared side by side. */
+type VireGlassPiece = {
+    optics: VireGlassOptics;
+    geometry: VireGlassGeometry;
+    /** Element center in CANVAS PIXELS (device-px). Shared between the lens and the surface. */
+    centerX: number;
+    centerY: number;
+    morph?: VireGlassMorph;
+    /** Third shape of the same body: breaking the element into pieces uses two bridges. */
+    morph2?: VireGlassMorph;
+    /** Local finger response: touch point, drag, press, wave. */
+    touch?: VireGlassTouch;
+    /** Press response, 0…1 — the highlight blooms, the body thickens slightly. */
+    press?: number;
+    /** Element under the finger, 0…1 — a stronger highlight and rim light. */
+    active?: number;
+    /** Played fraction, 0…1: an active state expressed as a field. Omitted means no progress. */
+    progress?: number;
+    /** Whether to draw the icon from the frame's shared mask on this element (see `iconMask` in the frame options). */
+    icon?: boolean;
+    /** Whether to draw the frame's colored layer on this element (see `colorLayer`). */
+    overlay?: boolean;
+    /** Icon color at rest and in the active state, RGBA 0…1. */
+    inkIdle?: readonly number[];
+    inkActive?: readonly number[];
+    /** Key light direction in screen space; defaults to the light at rest. */
+    light?: readonly [number, number];
+    /** 0…1: the element appearing as the lens builds up (M 2:55). */
+    appear?: number;
+    /** 0 — the element sinks in under the finger, 1 — it rises into glass (reference §5). */
+    lift?: number;
+    /** Tint for the primary action — colored glass, not a fill. */
+    accent?: VireGlassAccent;
+};
+type VireGlassRenderOptions = {
+    /** `devicePixelRatio` — passed as an argument rather than read globally, so the renderer stays
+     *  testable and isn't tied to a specific window. */
+    density: number;
+    debug: VireGlassDebugMode;
+    pieces: readonly VireGlassPiece[];
+    scene: VireGlassSceneDrawer;
+    /** Canvas offset under stationary elements, device-px. */
+    offsetX?: number;
+    offsetY?: number;
+    /**
+     * Ink mask the size of the canvas, screen coordinates, read from the GREEN channel. White on
+     * BLACK: antialiasing has to live in color, not alpha, otherwise green holds at one all the way
+     * to the edge inside a stroke and the icon's edges tear.
+     *
+     * The mask does NOT carry and must not carry a calm backing under the ink: that's a property of
+     * the material itself (`legibility`), the same across the whole element. While the app used to
+     * supply that backing, one element had it and another didn't, with nothing to explain the
+     * difference.
+     */
+    iconMask?: TexImageSource | null;
+    /**
+     * App-colored layer the size of the canvas, screen coordinates: cover art, a thumbnail —
+     * anything the app puts ON the glass in color. Separate from the ink mask, because that one
+     * carries a single channel colored by polarity, while this one has its own color.
+     *
+     * Drawn INSIDE the material, at the same coordinate as the ink: only this way does the
+     * surface's deformation carry them together. As a separate layer on top of the glass, text used
+     * to shake on press while the cover art stayed put.
+     */
+    colorLayer?: TexImageSource | null;
+};
+type VireGlassRenderResult = {
+    /** One backdrop sample per element, in the same order as `pieces`. */
+    probes: readonly (ProbeStats | null)[];
+};
+type VireGlassRenderer = {
+    resize(widthPx: number, heightPx: number): void;
+    render(options: VireGlassRenderOptions): VireGlassRenderResult;
+    destroy(): void;
+};
+declare function createVireGlassRenderer(canvas: HTMLCanvasElement): VireGlassRenderer;
+
+/**
+ * Drawing the reference canvas onto a canvas element. Lives in `web/` because it knows about the
+ * 2D context; the canvases themselves are data in `reference-scene.ts`, and the mobile lab lays
+ * out the same data as native views.
+ *
+ * The same drawer is used by the `check:optics` gate: only this way do the eye at the bench and
+ * the number in the gate look at the same canvas. The one difference between them is the fit mode.
+ */
+
+type VireGlassRefDrawOptions = {
+    /** Pixels per dp. The same value used for elements: the canvas and the glass must live at the
+     *  same scale. */
+    readonly density: number;
+    /** Canvas lightness; canvases that don't need it ignore it. Defaults to the canvas's own. */
+    readonly level?: number;
+    /**
+     * `band` — a `REFERENCE_SCENE_WIDTH`×`REFERENCE_SCENE_HEIGHT` dp panel centered on the stage,
+     * with a surrounding field: only this way do two benches show the SAME canvas, including the
+     * pattern's phase under the element. `frame` — stripes stretched across the whole frame: the
+     * gate has its own fixed stage, and the surrounding field would get in the way of sampling
+     * pixels.
+     */
+    readonly fit?: 'band' | 'frame';
+};
+declare function drawReferenceScene(ctx: CanvasRenderingContext2D, scene: VireGlassRefScene, width: number, height: number, options: VireGlassRefDrawOptions): void;
+
+export { PROBE_GRID_HEIGHT, PROBE_GRID_WIDTH, type Probe, type ProbeRect, type ProbeStats, type VireGlassPiece, type VireGlassRefDrawOptions, type VireGlassRenderOptions, type VireGlassRenderResult, type VireGlassRenderer, type VireGlassSceneDrawer, createProbe, createVireGlassRenderer, drawReferenceScene };

package/dist/web/index.d.ts

@@ -0,0 +1,148 @@
+import { j as VireGlassGeometry, k as VireGlassMorph, q as VireGlassTouch, V as VireGlassAccent, n as VireGlassRefScene } from '../adapters-BgSc-smX.js';
+import { V as VireGlassOptics, n as VireGlassDebugMode } from '../material-CkUHUBoy.js';
+
+declare const PROBE_GRID_WIDTH = 48;
+declare const PROBE_GRID_HEIGHT = 96;
+/** Stats for the lens rectangle from a single probe sample. `null` until the first ready frame
+ *  has come in — the shader falls back to `u_probeLuma = -1` in that case (see `lens-shader.ts`). */
+type ProbeStats = {
+    luma: number;
+    busy: number;
+    lo: number;
+    hi: number;
+    slopeX: number;
+    slopeY: number;
+    r: number;
+    g: number;
+    b: number;
+};
+type ProbeRect = {
+    centerX: number;
+    centerY: number;
+    halfWidth: number;
+    halfHeight: number;
+};
+type Probe = {
+    /** Renders a downsample of the current `contentTexture` into its own FBO and advances the PBO
+     *  read pipeline. Returns stats for the lens rectangle — lagging by a frame or two, or `null`
+     *  until a reader is ready. */
+    sample(contentTexture: WebGLTexture, contentWidth: number, contentHeight: number, rect: ProbeRect): ProbeStats | null;
+    /** Stats for another rectangle from the ALREADY-captured grid — no new pass, no new read. */
+    statsFor(contentWidth: number, contentHeight: number, rect: ProbeRect): ProbeStats | null;
+    destroy(): void;
+};
+declare function createProbe(gl: WebGL2RenderingContext, vertexSource: string): Probe;
+
+/** The scene draws itself with an offset: the lenses in the frame stay put while the canvas
+ *  underneath them slides — only this way can you actually see what refraction does to whatever
+ *  passes under the element. Offset in device-px. */
+type VireGlassSceneDrawer = (ctx: CanvasRenderingContext2D, width: number, height: number, offsetX: number, offsetY: number, 
+/** Pixels per dp — the same value used for elements. The canvas and the glass must live at the
+ *  same scale: as a fraction of canvas width, a cell on desktop came out five times larger than
+ *  on a phone, and an element of the same size looked completely different on the lab bench
+ *  than on a device. */
+density: number) => void;
+/** One glass element in the frame. Each has its own material — that's how they're compared side by side. */
+type VireGlassPiece = {
+    optics: VireGlassOptics;
+    geometry: VireGlassGeometry;
+    /** Element center in CANVAS PIXELS (device-px). Shared between the lens and the surface. */
+    centerX: number;
+    centerY: number;
+    morph?: VireGlassMorph;
+    /** Third shape of the same body: breaking the element into pieces uses two bridges. */
+    morph2?: VireGlassMorph;
+    /** Local finger response: touch point, drag, press, wave. */
+    touch?: VireGlassTouch;
+    /** Press response, 0…1 — the highlight blooms, the body thickens slightly. */
+    press?: number;
+    /** Element under the finger, 0…1 — a stronger highlight and rim light. */
+    active?: number;
+    /** Played fraction, 0…1: an active state expressed as a field. Omitted means no progress. */
+    progress?: number;
+    /** Whether to draw the icon from the frame's shared mask on this element (see `iconMask` in the frame options). */
+    icon?: boolean;
+    /** Whether to draw the frame's colored layer on this element (see `colorLayer`). */
+    overlay?: boolean;
+    /** Icon color at rest and in the active state, RGBA 0…1. */
+    inkIdle?: readonly number[];
+    inkActive?: readonly number[];
+    /** Key light direction in screen space; defaults to the light at rest. */
+    light?: readonly [number, number];
+    /** 0…1: the element appearing as the lens builds up (M 2:55). */
+    appear?: number;
+    /** 0 — the element sinks in under the finger, 1 — it rises into glass (reference §5). */
+    lift?: number;
+    /** Tint for the primary action — colored glass, not a fill. */
+    accent?: VireGlassAccent;
+};
+type VireGlassRenderOptions = {
+    /** `devicePixelRatio` — passed as an argument rather than read globally, so the renderer stays
+     *  testable and isn't tied to a specific window. */
+    density: number;
+    debug: VireGlassDebugMode;
+    pieces: readonly VireGlassPiece[];
+    scene: VireGlassSceneDrawer;
+    /** Canvas offset under stationary elements, device-px. */
+    offsetX?: number;
+    offsetY?: number;
+    /**
+     * Ink mask the size of the canvas, screen coordinates, read from the GREEN channel. White on
+     * BLACK: antialiasing has to live in color, not alpha, otherwise green holds at one all the way
+     * to the edge inside a stroke and the icon's edges tear.
+     *
+     * The mask does NOT carry and must not carry a calm backing under the ink: that's a property of
+     * the material itself (`legibility`), the same across the whole element. While the app used to
+     * supply that backing, one element had it and another didn't, with nothing to explain the
+     * difference.
+     */
+    iconMask?: TexImageSource | null;
+    /**
+     * App-colored layer the size of the canvas, screen coordinates: cover art, a thumbnail —
+     * anything the app puts ON the glass in color. Separate from the ink mask, because that one
+     * carries a single channel colored by polarity, while this one has its own color.
+     *
+     * Drawn INSIDE the material, at the same coordinate as the ink: only this way does the
+     * surface's deformation carry them together. As a separate layer on top of the glass, text used
+     * to shake on press while the cover art stayed put.
+     */
+    colorLayer?: TexImageSource | null;
+};
+type VireGlassRenderResult = {
+    /** One backdrop sample per element, in the same order as `pieces`. */
+    probes: readonly (ProbeStats | null)[];
+};
+type VireGlassRenderer = {
+    resize(widthPx: number, heightPx: number): void;
+    render(options: VireGlassRenderOptions): VireGlassRenderResult;
+    destroy(): void;
+};
+declare function createVireGlassRenderer(canvas: HTMLCanvasElement): VireGlassRenderer;
+
+/**
+ * Drawing the reference canvas onto a canvas element. Lives in `web/` because it knows about the
+ * 2D context; the canvases themselves are data in `reference-scene.ts`, and the mobile lab lays
+ * out the same data as native views.
+ *
+ * The same drawer is used by the `check:optics` gate: only this way do the eye at the bench and
+ * the number in the gate look at the same canvas. The one difference between them is the fit mode.
+ */
+
+type VireGlassRefDrawOptions = {
+    /** Pixels per dp. The same value used for elements: the canvas and the glass must live at the
+     *  same scale. */
+    readonly density: number;
+    /** Canvas lightness; canvases that don't need it ignore it. Defaults to the canvas's own. */
+    readonly level?: number;
+    /**
+     * `band` — a `REFERENCE_SCENE_WIDTH`×`REFERENCE_SCENE_HEIGHT` dp panel centered on the stage,
+     * with a surrounding field: only this way do two benches show the SAME canvas, including the
+     * pattern's phase under the element. `frame` — stripes stretched across the whole frame: the
+     * gate has its own fixed stage, and the surrounding field would get in the way of sampling
+     * pixels.
+     */
+    readonly fit?: 'band' | 'frame';
+};
+declare function drawReferenceScene(ctx: CanvasRenderingContext2D, scene: VireGlassRefScene, width: number, height: number, options: VireGlassRefDrawOptions): void;
+
+export { PROBE_GRID_HEIGHT, PROBE_GRID_WIDTH, type Probe, type ProbeRect, type ProbeStats, type VireGlassPiece, type VireGlassRefDrawOptions, type VireGlassRenderOptions, type VireGlassRenderResult, type VireGlassRenderer, type VireGlassSceneDrawer, createProbe, createVireGlassRenderer, drawReferenceScene };