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

package/dist/coordinates/feed.d.ts

@@ -0,0 +1,52 @@
+import { FeedPoint, FeedSourceKind, PixelSize, SourceOrientation, SourcePoint } from './spaces';
+/** A cover/contain fit of `source` into `destination`: scale and centred offset in destination pixels. */
+export type FitLayout = {
+    scale: number;
+    drawWidth: number;
+    drawHeight: number;
+    offsetX: number;
+    offsetY: number;
+};
+/**
+ * Scale and centred offset that fits `source` into `destination`. `cover`
+ * fills the destination and crops the excess; `contain` shows all of the
+ * source and letterboxes. `zoom` (> 1) enlarges the draw rect about the
+ * centre, cropping more of the edges — the session's `cameraZoom`.
+ */
+export declare const computeFitLayout: (source: PixelSize, destination: PixelSize, fit?: "cover" | "contain", zoom?: number) => FitLayout | null;
+/**
+ * How the session turns a source frame into the feed: cover-crop to the
+ * render size, framing `zoom`, and a horizontal mirror for the webcam.
+ * This is the one description of that transform; the blit loop, the
+ * segmentation mask fit and every point conversion derive from it.
+ */
+export type FeedCrop = FitLayout & {
+    source: PixelSize;
+    feed: PixelSize;
+    zoom: number;
+    mirrored: boolean;
+};
+/** The session mirrors the (front) webcam feed only; the rear camera, images and videos are drawn straight. An unknown kind is treated as the webcam. */
+export declare const isMirroredSourceKind: (kind: FeedSourceKind) => boolean;
+export declare const computeFeedCrop: ({ source, feed, zoom, mirrored, }: {
+    source: PixelSize;
+    feed: PixelSize;
+    zoom?: number;
+    mirrored?: boolean;
+}) => FeedCrop | null;
+/** Source pixel → feed normalized. Mirrors first (the session flips the frame before cropping). */
+export declare const sourceToFeed: (point: SourcePoint, crop: FeedCrop, target?: FeedPoint) => FeedPoint;
+/** Feed normalized → source pixel (the inverse of `sourceToFeed`; may fall outside the source when cropped). */
+export declare const feedToSource: (point: FeedPoint, crop: FeedCrop, target?: SourcePoint) => SourcePoint;
+/** True when a feed point lies inside the part of the source the crop kept. */
+export declare const isFeedPointInSource: (point: FeedPoint, crop: FeedCrop) => boolean;
+/** Flip a feed point horizontally (x → 1 − x). Positions in the feed never need this; use it for *direction* signs. */
+export declare const mirrorFeedX: <P extends FeedPoint>(point: P, target?: FeedPoint) => FeedPoint;
+/**
+ * Rotate a source pixel by the clockwise `orientation` the frame was given
+ * before use (a native capture delivered sideways). Returns the point in the
+ * rotated frame, whose size is `width`×`height` swapped for 90 / 270.
+ */
+export declare const orientSourcePoint: (point: SourcePoint, size: PixelSize, orientation: SourceOrientation, target?: SourcePoint) => SourcePoint;
+/** Size of a frame after `orientSourcePoint`'s rotation. */
+export declare const orientedSize: (size: PixelSize, orientation: SourceOrientation) => PixelSize;

package/dist/coordinates/index.d.ts

@@ -0,0 +1,5 @@
+export type { FeedPoint, FeedSourceKind, PixelSize, SourceOrientation, SourcePoint, ViewportPoint, } from './spaces';
+export { computeFeedCrop, computeFitLayout, feedToSource, isFeedPointInSource, isMirroredSourceKind, mirrorFeedX, orientSourcePoint, orientedSize, sourceToFeed, } from './feed';
+export type { FeedCrop, FitLayout } from './feed';
+export { feedToWorld, trackerToWorld, worldToFeed, worldToTracker } from './world';
+export { feedToScreenPixels, feedToTracker, feedToViewport, screenPixelsToFeed, trackerToFeed, viewportToFeed, } from './viewport';

package/dist/coordinates/spaces.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The coordinate spaces a tracking consumer meets, named once.
+ *
+ *   source ──cover-crop + zoom (+ mirror for webcam)──▶ feed ◀──identity per axis──▶ viewport
+ *                                                       │                               │
+ *                                                       ▼                               ▼
+ *                                                    tracker                         screen (design px)
+ *                                                       │
+ *                                                       ▼ (camera, z = 0 plane)
+ *                                                     world
+ *
+ * - **source**: the raw media frame (webcam, video, image) in pixels; top-left
+ *   origin, Y down. Never mirrored.
+ * - **feed**: the session camera texture, i.e. the source cover-cropped to
+ *   the render size with `cameraZoom` and, for the webcam only, mirrored.
+ *   Normalized 0..1, top-left origin, Y down. Every landmark and every SDK
+ *   mask lives here; MediaPipe's `z` rides along as tracker-relative depth.
+ * - **tracker**: feed remapped to center origin, X right, Y up, Z toward the
+ *   viewer (`TrackerPoint`); what hand, body and holistic nodes publish.
+ * - **viewport**: the rendered canvas in CSS pixels, top-left, Y down. The
+ *   feed fills it exactly, so feed and viewport agree per axis.
+ * - **screen**: SDK design pixels (720×1280 by default), center origin, Y up.
+ * - **world**: three.js world space; tracked content sits on the z = 0 plane.
+ */
+/** Pixel size of a frame or surface. */
+export type PixelSize = {
+    width: number;
+    height: number;
+};
+/** Source-media pixels: top-left origin, Y down, never mirrored. */
+export type SourcePoint = {
+    x: number;
+    y: number;
+};
+/** Feed (camera texture) coordinates, normalized 0..1, top-left origin, Y down; `z` optional depth. */
+export type FeedPoint = {
+    x: number;
+    y: number;
+    z?: number;
+};
+/** Viewport pixels: top-left origin, Y down. */
+export type ViewportPoint = {
+    x: number;
+    y: number;
+};
+/** The session media kinds; `undefined` is treated as the webcam. Only `webcam` (and undefined) is mirrored. */
+export type FeedSourceKind = "webcam" | "rear-camera" | "image" | "video" | undefined;
+/** Clockwise rotation applied to a source frame before it is used, in degrees. */
+export type SourceOrientation = 0 | 90 | 180 | 270;

package/dist/coordinates/viewport.d.ts

@@ -0,0 +1,22 @@
+import { ScreenPixelPoint } from '../screen2d/coordinates';
+import { ScreenTransformRoot } from '../screen2d/screenTransform';
+import { TrackerPoint } from '../types/common';
+import { FeedPoint, PixelSize, ViewportPoint } from './spaces';
+/** Feed point → tracker point (center origin, Y up, Z toward the viewer). */
+export declare const feedToTracker: (point: FeedPoint, target?: TrackerPoint) => TrackerPoint;
+/** Tracker point → feed point. */
+export declare const trackerToFeed: (point: TrackerPoint, target?: FeedPoint) => FeedPoint;
+/** Feed point → viewport pixels. The feed fills the viewport, so this is a per-axis scale. */
+export declare const feedToViewport: (point: FeedPoint, viewport: PixelSize, target?: ViewportPoint) => ViewportPoint;
+/** Viewport pixels → feed point. */
+export declare const viewportToFeed: (point: ViewportPoint, viewport: PixelSize, target?: FeedPoint) => FeedPoint;
+/** Feed point → SDK design pixels (center origin, Y up). */
+export declare const feedToScreenPixels: (point: FeedPoint, viewport: PixelSize, options?: {
+    root?: ScreenTransformRoot;
+    target?: ScreenPixelPoint;
+}) => ScreenPixelPoint;
+/** SDK design pixels → feed point. */
+export declare const screenPixelsToFeed: (point: ScreenPixelPoint, viewport: PixelSize, options?: {
+    root?: ScreenTransformRoot;
+    target?: FeedPoint;
+}) => FeedPoint;

package/dist/coordinates/world.d.ts

@@ -0,0 +1,15 @@
+import { TrackerPoint } from '../types/common';
+import { FeedPoint } from './spaces';
+import * as THREE from "three";
+/**
+ * Feed point (0..1, top-left, Y down) → world position on the `z = planeZ`
+ * plane (default 0, the tracking plane). Depth (`z`) does not move the
+ * result: the ray through the pixel is the same at any depth.
+ */
+export declare const feedToWorld: (point: FeedPoint, camera: THREE.Camera, out?: THREE.Vector3, planeZ?: number) => THREE.Vector3;
+/** Tracker point (center origin, Y up) → world position on the `z = planeZ` plane. */
+export declare const trackerToWorld: (point: TrackerPoint, camera: THREE.Camera, out?: THREE.Vector3, planeZ?: number) => THREE.Vector3;
+/** World position → feed point (0..1, top-left, Y down); `z` carries the NDC depth. */
+export declare const worldToFeed: (point: THREE.Vector3Like, camera: THREE.Camera, target?: Required<FeedPoint>) => Required<FeedPoint>;
+/** World position → tracker point (center origin, Y up); `z` carries the NDC depth. */
+export declare const worldToTracker: (point: THREE.Vector3Like, camera: THREE.Camera, target?: TrackerPoint) => TrackerPoint;

package/dist/debug-ui/gesture-settings/index.d.ts

@@ -0,0 +1,14 @@
+import { GestureSettings } from '../../gestures/settings';
+export type GestureSettingsPanelProps = {
+    title?: string;
+    value: Partial<GestureSettings>;
+    /** The gesture's own defaults, so untouched fields show what it really uses. */
+    defaults?: GestureSettings;
+    onChange: (next: GestureSettings) => void;
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+};
+/** Live detector controls for one gesture; spread the emitted settings into `useGesture` options. */
+export declare const GestureSettingsPanel: ({ title, value, defaults, onChange, initialPosition, }: GestureSettingsPanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/debug-ui/holistic-tracker-settings/index.d.ts

@@ -0,0 +1,16 @@
+import { HolisticTrackerSettings } from '../../components/HolisticTracker';
+export type HolisticTrackerSettingsPanelProps = {
+    title?: string;
+    value: Partial<HolisticTrackerSettings>;
+    onChange: (next: HolisticTrackerSettings) => void;
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+};
+/**
+ * Live controls for `<HolisticTracker>`; map the emitted settings onto the
+ * component with `toHolisticTrackerProps`. Hands, hold/predict and the
+ * analysis size apply without re-initializing; blendshapes and FPS re-acquire.
+ */
+export declare const HolisticTrackerSettingsPanel: ({ title, value, onChange, initialPosition, }: HolisticTrackerSettingsPanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/debug-ui/index.d.ts

@@ -33,6 +33,20 @@ export type { FaceWarp3DSettingsPanelProps } from './face-warp-3d';
 export { FaceWarp3DSettingsPanel } from './face-warp-3d';
 export type { FaceRetouchSettingsPanelProps } from './face-retouch';
 export { FaceRetouchSettingsPanel } from './face-retouch';
+export type { GestureSettingsPanelProps } from './gesture-settings';
+export { GestureSettingsPanel } from './gesture-settings';
+export type { IrisEffectSettingsPanelProps } from './iris-effect-settings';
+export { IrisEffectSettingsPanel } from './iris-effect-settings';
+export type { LipEffectSettingsPanelProps } from './lip-effect-settings';
+export { LipEffectSettingsPanel } from './lip-effect-settings';
+export type { ProductHotspotPanelProps } from './product-hotspots';
+export { ProductHotspotPanel } from './product-hotspots';
+export type { XRDiagnosticsPanelProps } from './xr-diagnostics';
+export { XRDiagnosticsPanel } from './xr-diagnostics';
+export type { HolisticTrackerSettingsPanelProps } from './holistic-tracker-settings';
+export { HolisticTrackerSettingsPanel } from './holistic-tracker-settings';
+export type { SegmentationOverlaySettingsPanelProps } from './segmentation-overlay-settings';
+export { SegmentationOverlaySettingsPanel } from './segmentation-overlay-settings';
 export type { Transform3DSettingsPanelProps } from './transform-3d-settings';
 export { Transform3DSettingsPanel, Transform3DSettingsSection } from './transform-3d-settings';
 export type { MeshRendererSettingsPanelProps } from './mesh-renderer-settings';

package/dist/debug-ui/iris-effect-settings/index.d.ts

@@ -0,0 +1,12 @@
+import { IrisEffectSettings } from '../../components/IrisEffect';
+export type IrisEffectSettingsPanelProps = {
+    title?: string;
+    value: Partial<IrisEffectSettings>;
+    onChange: (next: IrisEffectSettings) => void;
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+};
+/** Live controls for `<IrisEffect>`; spread the emitted settings onto the component. */
+export declare const IrisEffectSettingsPanel: ({ title, value, onChange, initialPosition, }: IrisEffectSettingsPanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/debug-ui/lip-effect-settings/index.d.ts

@@ -0,0 +1,15 @@
+import { LipEffectSettings } from '../../components/LipEffect';
+export type LipEffectSettingsPanelProps = {
+    title?: string;
+    value: Partial<LipEffectSettings>;
+    onChange: (next: LipEffectSettings) => void;
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+};
+/**
+ * Live controls for `LipEffect`: presets, mask mode, material and texture
+ * transform. Spread the emitted settings onto `<LipEffect>`.
+ */
+export declare const LipEffectSettingsPanel: ({ title, value, onChange, initialPosition, }: LipEffectSettingsPanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/debug-ui/media-source.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../session-CpkiK5YA.cjs");exports.MediaSourceSwitcher=e.MediaSourceSwitcher;exports.defaultMediaSources=e.defaultMediaSources;exports.sdkImageMediaSources=e.sdkImageMediaSources;exports.sdkVideoMediaSources=e.sdkVideoMediaSources;exports.useFaceTrackingMediaSourceSession=e.useFaceTrackingMediaSourceSession;exports.useMediaSourceSession=e.useMediaSourceSession;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../session-BBr0yN8h.cjs");exports.MediaSourceSwitcher=e.MediaSourceSwitcher;exports.defaultMediaSources=e.defaultMediaSources;exports.sdkImageMediaSources=e.sdkImageMediaSources;exports.sdkVideoMediaSources=e.sdkVideoMediaSources;exports.useFaceTrackingMediaSourceSession=e.useFaceTrackingMediaSourceSession;exports.useMediaSourceSession=e.useMediaSourceSession;

package/dist/debug-ui/media-source.js

@@ -1,4 +1,4 @@
-import { M as a, d, s as i, a as o, u as r, b as u } from "../session-DLFN_VII.js";
+import { M as a, d, s as i, a as o, u as r, b as u } from "../session-Cy0m7l7-.js";
 export {
   a as MediaSourceSwitcher,
   d as defaultMediaSources,

package/dist/debug-ui/product-hotspots/index.d.ts

@@ -0,0 +1,24 @@
+import { UseProductHotspotsResult } from '../../product/useProductDetails';
+export type ProductHotspotPanelProps = {
+    title?: string;
+    hotspots: UseProductHotspotsResult;
+    /** Called when placement mode toggles; the page forwards pointer clicks on the viewer to `placeFromPointer` while on. */
+    placing: boolean;
+    onPlacingChange: (placing: boolean) => void;
+    /** Variants from `useProductVariants`, optional. */
+    variants?: {
+        variants: string[];
+        variant: string | null;
+        setVariant: (name: string | null) => void;
+    };
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+};
+/**
+ * Authoring panel for product hotspots (and variants): toggle click-to-place,
+ * edit labels, remove, copy the JSON. Debug UI only; the data it produces is
+ * what the app ships as `initial` to `useProductHotspots`.
+ */
+export declare const ProductHotspotPanel: ({ title, hotspots, placing, onPlacingChange, variants, initialPosition, }: ProductHotspotPanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/debug-ui/segmentation-overlay-settings/index.d.ts

@@ -0,0 +1,12 @@
+import { SegmentationOverlaySettings } from '../../components/SegmentationOverlay';
+export type SegmentationOverlaySettingsPanelProps = {
+    title?: string;
+    value: Partial<SegmentationOverlaySettings>;
+    onChange: (next: SegmentationOverlaySettings) => void;
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+};
+/** Live controls for `SegmentationOverlay`; spread the emitted settings onto the component. */
+export declare const SegmentationOverlaySettingsPanel: ({ title, value, onChange, initialPosition, }: SegmentationOverlaySettingsPanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/debug-ui/xr-diagnostics/index.d.ts

@@ -0,0 +1,25 @@
+import { XRModel } from '../../constants';
+import { XRDiagnostics } from '../../hooks/useXRDiagnostics';
+export type XRDiagnosticsPanelProps = {
+    title?: string;
+    /** Sampling period in ms (default 250). */
+    intervalMs?: number;
+    /** Models to list; default every `XRModel`. */
+    models?: XRModel[];
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+    /** Start collapsed (header only). */
+    defaultCollapsed?: boolean;
+    /** Called with every sample (for logging / assertions). */
+    onSample?: (sample: XRDiagnostics) => void;
+};
+/**
+ * Read-only tracking diagnostics: session lifecycle, source and feed, feed
+ * frame rate, and one block per model with state, inference time and rate,
+ * skipped frames, detections, confidence and the last error. Mount it
+ * anywhere under `<XRProvider>` (outside the R3F canvas); it samples on an
+ * interval and unmounting stops the sampling.
+ */
+export declare const XRDiagnosticsPanel: ({ title, intervalMs, models, initialPosition, defaultCollapsed, onSample, }: XRDiagnosticsPanelProps) => import("react/jsx-runtime").JSX.Element;