@vincentt-xr/sdk 2.0.0-alpha.1 → 2.0.0-alpha.2

package/dist/components/TextLabel/types.d.ts

@@ -0,0 +1,227 @@
+export type TextAlign = "left" | "center" | "right";
+export type TextVerticalAlign = "top" | "center" | "bottom";
+export type TextBendPreset = "arc" | "arc-lower" | "arc-upper" | "arch" | "bulge" | "shell-lower" | "shell-upper" | "flag" | "wave" | "fish" | "rise" | "fisheye" | "inflate" | "squeeze" | "twist";
+export type TextStrokeLayer = {
+    color: string;
+    width: number;
+    opacity?: number;
+};
+export type TextShadowLayer = {
+    color: string;
+    blur: number;
+    offsetX?: number;
+    offsetY?: number;
+    opacity?: number;
+};
+export type TextInnerShadow = {
+    color: string;
+    blur: number;
+    offsetX?: number;
+    offsetY?: number;
+    opacity?: number;
+};
+export type TextGlow = {
+    color: string;
+    style: "outward" | "contoured";
+    intensity?: number;
+    range?: number;
+    horizontalAngle?: number;
+    verticalAngle?: number;
+};
+export type TextOverflowMode = "clip" | "clamp" | "ellipsis" | "shrink";
+export type TextBackgroundFillMode = "solid" | "gradient";
+export type TextBackgroundFit = "full" | "text";
+export type TextBackgroundTextureFit = "cover" | "contain" | "stretch";
+export type TextGradientStop = {
+    color: string;
+    position: number;
+};
+/**
+ * `<TextLabel>` — a text label drawn into a CanvasTexture and rendered as
+ * a single mesh. First-class scene-tree primitive so lifecycle scripts
+ * don't have to hand-paint canvas textures for every quiz question,
+ * progress indicator, or floating answer.
+ *
+ * Sizes itself 1x1 in world units; use `scale` on the JSX node or a
+ * parent `<ScreenTransform>` / `<TrackingAnchor>` to place it.
+ *
+ * Word-wraps automatically inside the panel's width; when there are too
+ * many lines for the chosen font size, the font shrinks one step before
+ * the text is allowed to clip.
+ */
+export type TextLabelProps = {
+    /** The text to render. Required. */
+    text: string;
+    /** Optional precomputed lines. When provided, these are rendered directly without word wrapping. */
+    lines?: string[];
+    /** Text color. Default `#ffffff`. */
+    color?: string;
+    /** Multiple stroke layers, drawn outer-to-inner. */
+    strokeLayers?: TextStrokeLayer[];
+    /** Master visibility gate for all stroke/outline rendering. Default true. */
+    outlineEnabled?: boolean;
+    /** Optional text stroke color. Omit or pair with `strokeWidth={0}` for no stroke. */
+    strokeColor?: string;
+    /** Text stroke thickness in canvas px. Default 0. */
+    strokeWidth?: number;
+    /** Stroke opacity multiplier. Default 1. */
+    strokeOpacity?: number;
+    /** Multiple shadow / glow layers, drawn back-to-front. */
+    shadowLayers?: TextShadowLayer[];
+    /** Master visibility gate for all outer shadow rendering. Default true. */
+    shadowEnabled?: boolean;
+    /** Optional inner shadow rendered inside the glyphs. */
+    innerShadow?: TextInnerShadow;
+    /** Optional glow rendered behind the glyphs. */
+    glow?: TextGlow;
+    /** Optional text shadow/glow color. Omit for none. */
+    shadowColor?: string;
+    /** Shadow blur radius in canvas px. Default 0. */
+    shadowBlur?: number;
+    /** Shadow X offset in canvas px. Default 0. */
+    shadowOffsetX?: number;
+    /** Shadow Y offset in canvas px. Default 0. */
+    shadowOffsetY?: number;
+    /** Shadow opacity multiplier. Default 1. */
+    shadowOpacity?: number;
+    /** Font weight. Default `bold`. */
+    fontWeight?: "normal" | "bold" | number;
+    /** Font style. Default `normal`. */
+    fontStyle?: "normal" | "italic";
+    /** Font family. Default `Arial, sans-serif`. */
+    fontFamily?: string;
+    /**
+     * Font size in canvas px at the default 512px resolution. Roughly maps
+     * to "10pt" -> 28, "12pt" -> 36, "16pt" -> 48, etc. Default 48.
+     */
+    fontSize?: number;
+    /** Horizontal text alignment inside the available lane. Default `center`. */
+    textAlign?: TextAlign;
+    /** Vertical text alignment inside the available lane. Default `center`. */
+    verticalAlign?: TextVerticalAlign;
+    /** Overflow behavior. `clamp` keeps only full visible lines, `clip` allows canvas-edge clipping. */
+    overflow?: TextOverflowMode;
+    /** When true, keep shrinking until the text fits or `minFontSize` is hit. */
+    resizeToFit?: boolean;
+    /** Minimum shrink target in canvas px. Default 12. */
+    minFontSize?: number;
+    /** Character spacing as a normalized ratio from 0 to 1. Default 0. */
+    letterSpacing?: number;
+    /** Line spacing as a normalized ratio from 0 to 1. Default 0.3. */
+    lineSpacing?: number;
+    /** Panel background color. Use `'transparent'` for text-only. Default `rgba(20,40,110,0.88)`. */
+    bgColor?: string;
+    /** Background fill mode. Default `solid`. */
+    bgFillMode?: TextBackgroundFillMode;
+    /** Background opacity multiplier. Default 1. */
+    bgOpacity?: number;
+    /** Background fit mode. `full` fills the label rect, `text` hugs the measured text block. */
+    bgFit?: TextBackgroundFit;
+    /** When true, ignore explicit background width/height and size from the text block. */
+    bgAutoSize?: boolean;
+    /** Optional explicit background width in canvas px. */
+    bgWidth?: number;
+    /** Optional explicit background height in canvas px. */
+    bgHeight?: number;
+    /** Optional gradient stops when `bgFillMode` is `gradient`. */
+    bgGradientStops?: TextGradientStop[];
+    /** Optional static texture URL when `bgFillMode` is `texture`. */
+    bgTextureUrl?: string;
+    /** Texture fit behavior. Default `cover`. */
+    bgTextureFit?: TextBackgroundTextureFit;
+    /** Mirror the background texture horizontally. Default false. */
+    bgTextureFlipX?: boolean;
+    /** Mirror the background texture vertically. Default false. */
+    bgTextureFlipY?: boolean;
+    /** Optional border color. Omit for no border. */
+    borderColor?: string;
+    /** Border thickness. Default 0. */
+    borderWidth?: number;
+    /** Corner radius. Use 0 for square. Default 24. */
+    borderRadius?: number;
+    /** Inner padding in canvas px. Default 32. */
+    padding?: number;
+    /**
+     * Aspect ratio (width / height). The mesh itself is always 1x1; this
+     * controls how the texture canvas is shaped so wrapping and corner
+     * radius read correctly when the label isn't square. Default 2.5
+     * (roughly banner-shaped).
+     */
+    aspect?: number;
+    /** Canvas resolution (height in px). Default 512. */
+    resolution?: number;
+    /** Material opacity multiplier. Default 1. */
+    opacity?: number;
+    /** Draw an underline beneath each rendered line. Default false. */
+    underline?: boolean;
+    /** Draw a strikethrough across each rendered line. Default false. */
+    strikethrough?: boolean;
+    /** Bend text along a shallow vertical curve. Range -100..100. Default 0. */
+    bendPreset?: TextBendPreset;
+    bendStrength?: number;
+    /** Optional `name` for runtime `getObjectByName` lookups. */
+    name?: string;
+    /** Ignore depth - appropriate for overlay UI. Default true. */
+    overlay?: boolean;
+    /** Local position offset, forwarded to the underlying mesh. */
+    position?: [number, number, number];
+    /** Local rotation (Euler radians), forwarded to the underlying mesh. */
+    rotation?: [number, number, number];
+    /** Local scale, forwarded to the underlying mesh. */
+    scale?: [number, number, number] | number;
+    /** Mesh visibility, forwarded so descendants inherit correctly. */
+    visible?: boolean;
+    /** Render ordering for overlay composition. */
+    renderOrder?: number;
+};
+export type TextLabelDefaults = Required<Pick<TextLabelProps, "color" | "strokeWidth" | "strokeOpacity" | "shadowBlur" | "shadowOffsetX" | "shadowOffsetY" | "shadowOpacity" | "fontWeight" | "fontStyle" | "fontFamily" | "fontSize" | "textAlign" | "verticalAlign" | "minFontSize" | "letterSpacing" | "lineSpacing" | "bgColor" | "bgFillMode" | "bgOpacity" | "bgFit" | "bgTextureFit" | "bgTextureFlipX" | "bgTextureFlipY" | "borderWidth" | "borderRadius" | "padding" | "aspect" | "resolution" | "opacity" | "underline" | "strikethrough" | "bendPreset" | "bendStrength">>;
+export type BuildTextLabelTextureOptions = {
+    text: string;
+    lines?: string[];
+    color: string;
+    strokeLayers?: TextStrokeLayer[];
+    strokeColor?: string;
+    strokeWidth: number;
+    strokeOpacity: number;
+    shadowLayers?: TextShadowLayer[];
+    innerShadow?: TextInnerShadow;
+    glow?: TextGlow;
+    shadowColor?: string;
+    shadowBlur: number;
+    shadowOffsetX: number;
+    shadowOffsetY: number;
+    shadowOpacity: number;
+    fontWeight: "normal" | "bold" | number;
+    fontStyle: "normal" | "italic";
+    fontFamily: string;
+    fontSize: number;
+    textAlign: TextAlign;
+    verticalAlign: TextVerticalAlign;
+    overflow?: TextOverflowMode;
+    resizeToFit?: boolean;
+    minFontSize: number;
+    letterSpacing: number;
+    lineSpacing: number;
+    bgColor: string;
+    bgFillMode: TextBackgroundFillMode;
+    bgOpacity: number;
+    bgFit: TextBackgroundFit;
+    bgAutoSize?: boolean;
+    bgWidth?: number;
+    bgHeight?: number;
+    bgGradientStops?: TextGradientStop[];
+    bgTextureImage?: CanvasImageSource;
+    bgTextureFit: TextBackgroundTextureFit;
+    bgTextureFlipX: boolean;
+    bgTextureFlipY: boolean;
+    borderColor?: string;
+    borderWidth: number;
+    borderRadius: number;
+    padding: number;
+    width: number;
+    height: number;
+    underline: boolean;
+    strikethrough: boolean;
+    bendPreset: TextBendPreset;
+    bendStrength: number;
+};

package/dist/components/TrackingAnchor/index.d.ts

@@ -1,6 +1,18 @@
 import { PropsWithChildren } from 'react';
-import { TrackingTarget } from '../../types/tracking';
+import { FaceCustomAnchorPoint, FaceTarget, TrackingTarget } from '../../types/tracking';
 import * as THREE from "three";
+export type TrackingAnchorSettings = {
+    target: FaceTarget;
+    customAnchorPoint: FaceCustomAnchorPoint;
+    offset: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    smoothing: number;
+    followFaceRoll: boolean;
+};
+export declare const DEFAULT_TRACKING_ANCHOR: TrackingAnchorSettings;
 /**
  * Frame-rate-independent lerp factor for a given smoothing rate and frame
  * delta: `alpha = 1 - e^(-smoothing*dt)`. Same rate produces the same visual
@@ -45,6 +57,8 @@ export type OneEuroState = {
  * each axis independently. On the first sample it seeds without smoothing.
  */
 export declare const stepOneEuro: (state: OneEuroState, sample: THREE.Vector3, dt: number, minCutoff: number, beta: number, dcutoff: number) => OneEuroState;
+/** Apply the SDK's tuned One Euro parameters for a public smoothing value. */
+export declare const stepTrackingSmoothing: (state: OneEuroState, sample: THREE.Vector3, dt: number, smoothing: number) => OneEuroState;
 type TrackingAnchorProps = PropsWithChildren & {
     /**
      * Landmark/joint to attach to. The namespace prefix (`face.`, `hand.`,
@@ -52,6 +66,8 @@ type TrackingAnchorProps = PropsWithChildren & {
      * mismatched anchors render `null` and emit a console warning.
      */
     target: TrackingTarget;
+    /** Face-local point used only when target is `face.custom`. */
+    customAnchorPoint?: FaceCustomAnchorPoint;
     /** Optional offset applied in the tracker's local frame after resolution. */
     offset?: [number, number, number];
     /**
@@ -70,5 +86,5 @@ type TrackingAnchorProps = PropsWithChildren & {
      */
     smoothing?: number;
 };
-export declare const TrackingAnchor: ({ target, offset, smoothing, children, }: TrackingAnchorProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const TrackingAnchor: ({ target, customAnchorPoint, offset, smoothing, children, }: TrackingAnchorProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/components/Transform3D/index.d.ts

@@ -0,0 +1,30 @@
+import { ReactNode } from 'react';
+import { Group } from 'three';
+export type Transform3DVector = {
+    x: number;
+    y: number;
+    z: number;
+};
+export type Transform3DSettings = {
+    enabled: boolean;
+    linked: {
+        position: boolean;
+        rotation: boolean;
+        scale: boolean;
+    };
+    showTransformControls: boolean;
+    transformControlMode: "translate" | "rotate" | "scale";
+    transformControlSpace: "local" | "world";
+    position: Transform3DVector;
+    rotation: Transform3DVector;
+    scale: Transform3DVector;
+    visible: boolean;
+};
+export type Transform3DProps = {
+    children: ReactNode;
+    objectRef?: (object: Group | null) => void;
+    onChange?: (next: Transform3DSettings) => void;
+    value: Transform3DSettings;
+};
+export declare const DEFAULT_TRANSFORM_3D: Transform3DSettings;
+export declare const Transform3D: ({ children, objectRef, onChange, value }: Transform3DProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/components/XRMediaSurface/index.d.ts

@@ -1,25 +1,25 @@
 import { RefObject } from 'react';
 import { XRLayerConfig, XRMediaLayout, XRMediaSourceKind } from '../../types/compositor';
 export declare const XRMediaSurface: ({ canvasRef, imageRef, layer, layout, mirrored, sourceKind, videoRef, }: {
-    canvasRef: RefObject<HTMLCanvasElement>;
-    imageRef: RefObject<HTMLImageElement>;
+    canvasRef: RefObject<HTMLCanvasElement | null>;
+    imageRef: RefObject<HTMLImageElement | null>;
     layer: XRLayerConfig;
     layout: XRMediaLayout | null;
     mirrored: boolean;
     sourceKind: XRMediaSourceKind;
-    videoRef: RefObject<HTMLVideoElement>;
+    videoRef: RefObject<HTMLVideoElement | null>;
 }) => import("react/jsx-runtime").JSX.Element;
 export declare const XRTrackingOverlay: ({ canvasRef, controlInsetTop, debugVisible, fps, imageRef, layer, layout, mirrored, sourceKind, videoRef, viewportSize, }: {
-    canvasRef: RefObject<HTMLCanvasElement>;
+    canvasRef: RefObject<HTMLCanvasElement | null>;
     controlInsetTop?: number;
     debugVisible: boolean;
     fps?: number;
-    imageRef: RefObject<HTMLImageElement>;
+    imageRef: RefObject<HTMLImageElement | null>;
     layer: XRLayerConfig;
     layout: XRMediaLayout | null;
     mirrored: boolean;
     sourceKind: XRMediaSourceKind;
-    videoRef: RefObject<HTMLVideoElement>;
+    videoRef: RefObject<HTMLVideoElement | null>;
     viewportSize: {
         width: number;
         height: number;

package/dist/components/XRViewport/XRViewport.d.ts

@@ -0,0 +1,11 @@
+import { XRViewportComponent } from './types';
+export { computeViewportLayout, resolveViewportFitMode, resolveViewportSourceSelection, } from './layout';
+export { useXRViewportRenderOutputs, useXRViewportState } from './contexts';
+export { resolveViewportExternalFaces } from './hooks/useViewportExternalFaces';
+export { resolveViewportSlotContent, resolveViewportSlots } from './slots';
+export { useViewportMediaSource } from './hooks/useViewportMediaSource';
+export { useViewportMediaTexture } from './hooks/useViewportMediaTexture';
+export { useViewportPipeline } from './hooks/useViewportPipeline';
+export { useViewportRenderOutputs, useViewportRenderState } from './hooks/useViewportRenderState';
+export type { XRViewportFitMode, XRViewportMediaAssetOption, XRViewportMediaStrategy, XRViewportMode, XRViewportPreviewMode, XRViewportRenderOutputRequest, XRViewportRenderOutputs, XRViewportRenderState, XRViewportSize, XRViewportSourceConfig, XRViewportSourceKind, } from './types';
+export declare const XRViewport: XRViewportComponent;

package/dist/components/XRViewport/components/HiddenMedia.d.ts

@@ -0,0 +1,7 @@
+import { RefObject } from 'react';
+import { XRViewportSourceKind } from '../types';
+export declare const HiddenMedia: ({ imageRef, selectedSource, videoRef, }: {
+    imageRef: RefObject<HTMLImageElement>;
+    selectedSource: XRViewportSourceKind;
+    videoRef: RefObject<HTMLVideoElement>;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/XRViewport/components/MediaAssetPicker.d.ts

@@ -0,0 +1,8 @@
+import { XRViewportMediaAssetOption } from '../types';
+export declare const MediaAssetPicker: ({ dock, label, onChange, options, value, }: {
+    dock: "top-left" | "bottom-left";
+    label: string;
+    onChange: (value: string) => void;
+    options: XRViewportMediaAssetOption[];
+    value: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/XRViewport/components/MediaControlStack.d.ts

@@ -0,0 +1,13 @@
+import { XRViewportMediaAssetOption, XRViewportSourceKind } from '../types';
+export declare const MediaControlStack: ({ dock, imageOptions, selectedImageId, selectedSource, selectedVideoId, setSelectedImageId, setSelectedSource, setSelectedVideoId, showMediaControls, videoOptions, }: {
+    dock: "top-left" | "bottom-left";
+    imageOptions: XRViewportMediaAssetOption[];
+    selectedImageId: string;
+    selectedSource: XRViewportSourceKind;
+    selectedVideoId: string;
+    setSelectedImageId: (value: string) => void;
+    setSelectedSource: (value: XRViewportSourceKind) => void;
+    setSelectedVideoId: (value: string) => void;
+    showMediaControls: boolean;
+    videoOptions: XRViewportMediaAssetOption[];
+}) => import("react/jsx-runtime").JSX.Element | null;

package/dist/components/XRViewport/components/XRViewportLayers.d.ts

@@ -0,0 +1,30 @@
+import { CSSProperties, ReactNode, RefObject } from 'react';
+import { XRSceneRenderOutputs } from '../../XRScene';
+import { XRViewportMediaAssetOption, XRViewportMode, XRViewportRenderOutputRequest, XRViewportSize, XRViewportSourceKind } from '../types';
+import { XRMediaLayout } from '../../../types/compositor';
+export declare const XRViewportLayers: ({ containerRef, displayCanvasRef, imageOptions, imageRef, layout, managesOwnMedia, mediaDock, mode, overlayContent, renderOutputs, sceneContent, selectedImageId, selectedSource, selectedVideoId, setSceneRenderOutputs, setSelectedImageId, setSelectedSource, setSelectedVideoId, showMediaControls, style, videoOptions, videoRef, viewportSize, mirrored, }: {
+    containerRef: RefObject<HTMLDivElement>;
+    displayCanvasRef: RefObject<HTMLCanvasElement>;
+    imageOptions: XRViewportMediaAssetOption[];
+    imageRef: RefObject<HTMLImageElement>;
+    layout: XRMediaLayout | null;
+    managesOwnMedia: boolean;
+    mediaDock: "top-left" | "bottom-left";
+    mode: XRViewportMode;
+    mirrored: boolean;
+    overlayContent: ReactNode;
+    renderOutputs: XRViewportRenderOutputRequest;
+    sceneContent: ReactNode;
+    selectedImageId: string;
+    selectedSource: XRViewportSourceKind;
+    selectedVideoId: string;
+    setSceneRenderOutputs: (outputs: XRSceneRenderOutputs) => void;
+    setSelectedImageId: (value: string) => void;
+    setSelectedSource: (value: XRViewportSourceKind) => void;
+    setSelectedVideoId: (value: string) => void;
+    showMediaControls: boolean;
+    style?: CSSProperties;
+    videoOptions: XRViewportMediaAssetOption[];
+    videoRef: RefObject<HTMLVideoElement>;
+    viewportSize: XRViewportSize;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/XRViewport/constants.d.ts

@@ -0,0 +1,24 @@
+import { XRViewportSourceKind } from './types';
+export declare const DEFAULT_VIDEO_CONSTRAINTS: MediaStreamConstraints;
+export declare const liveLayer: {
+    name: string;
+    clearColor: string;
+    pointerEvents: "none";
+    zIndex: number;
+};
+export declare const uiLayer: {
+    name: string;
+    clearColor: string;
+    pointerEvents: "auto";
+    zIndex: number;
+};
+export declare const sceneLayer: {
+    name: string;
+    clearColor: string;
+    pointerEvents: "auto";
+    zIndex: number;
+};
+export declare const MEDIA_OPTION_META: Record<XRViewportSourceKind, {
+    icon: string;
+    label: string;
+}>;

package/dist/components/XRViewport/contexts.d.ts

@@ -0,0 +1,6 @@
+import { Context } from 'react';
+import { XRViewportRenderOutputs, XRViewportRenderState } from './types';
+export declare const XRViewportStateContext: Context<XRViewportRenderState | null>;
+export declare const XRViewportRenderOutputsContext: Context<XRViewportRenderOutputs | null>;
+export declare const useXRViewportState: () => XRViewportRenderState | null;
+export declare const useXRViewportRenderOutputs: () => XRViewportRenderOutputs | null;

package/dist/components/XRViewport/hooks/useViewportExternalFaces.d.ts

@@ -0,0 +1,13 @@
+import { CalibrationMediaSourceKind } from '../../../hooks/useCalibrationFaceTracker';
+import { XRModelNodeFaceTracking } from '../../../types/nodes';
+export declare const resolveViewportExternalFaces: ({ detectionResults, selectedSource, }: {
+    detectionResults: ReturnType<XRModelNodeFaceTracking["getDetectionResults"]> | null | undefined;
+    selectedSource: CalibrationMediaSourceKind;
+}) => import('../../../types').FaceTrackingResult[];
+export declare const useViewportExternalFaces: ({ enabled, selectedSource, }: {
+    enabled: boolean;
+    selectedSource: CalibrationMediaSourceKind;
+}) => {
+    faces: import('../../../types').FaceTrackingResult[];
+    trackerStatus: "idle" | "ready";
+};

package/dist/components/XRViewport/hooks/useViewportMediaSource.d.ts

@@ -0,0 +1,16 @@
+import { XRViewportMediaAssetOption, XRViewportSize, XRViewportSourceKind } from '../types';
+export declare const clearVideoElement: (video: HTMLVideoElement | null) => void;
+export declare const clearImageElement: (image: HTMLImageElement | null) => void;
+export declare const useViewportMediaSource: ({ enabled, imageAsset, selectedSource, videoAsset, }: {
+    enabled: boolean;
+    imageAsset?: XRViewportMediaAssetOption;
+    selectedSource: XRViewportSourceKind;
+    videoAsset?: XRViewportMediaAssetOption;
+}) => {
+    videoRef: import('react').RefObject<HTMLVideoElement>;
+    imageRef: import('react').RefObject<HTMLImageElement>;
+    stream: MediaStream | null;
+    mediaSize: XRViewportSize;
+    status: "idle" | "ready" | "error" | "requesting";
+    error: string | null;
+};

package/dist/components/XRViewport/hooks/useViewportMediaTexture.d.ts

@@ -0,0 +1,10 @@
+import { RefObject } from 'react';
+import { XRViewportSourceKind } from '../types';
+import * as THREE from "three";
+export declare const useViewportMediaTexture: ({ enabled, imageRef, selectedSource, status, videoRef, }: {
+    enabled: boolean;
+    imageRef: RefObject<HTMLImageElement>;
+    selectedSource: XRViewportSourceKind;
+    status: "idle" | "requesting" | "ready" | "error";
+    videoRef: RefObject<HTMLVideoElement>;
+}) => THREE.Texture | null;

package/dist/components/XRViewport/hooks/useViewportPipeline.d.ts

@@ -0,0 +1,41 @@
+import { XRSceneRenderOutputs } from '../../XRScene';
+import { XRViewportFitMode, XRViewportMediaAssetOption, XRViewportMediaStrategy, XRViewportPreviewMode, XRViewportRenderOutputRequest, XRViewportSourceConfig, XRViewportSourceKind } from '../types';
+export declare const useViewportPipeline: ({ fitMode, imageOptions, initialImageId, initialMirrored, initialSource, initialVideoId, mediaStrategy, previewMode, renderOutputs, showMediaControlsByDefault, source, videoOptions, }: {
+    fitMode: XRViewportFitMode;
+    imageOptions: XRViewportMediaAssetOption[];
+    initialImageId?: string;
+    initialMirrored: boolean;
+    initialSource: XRViewportSourceKind;
+    initialVideoId?: string;
+    mediaStrategy: XRViewportMediaStrategy;
+    previewMode: XRViewportPreviewMode;
+    renderOutputs: XRViewportRenderOutputRequest;
+    showMediaControlsByDefault: boolean;
+    source?: XRViewportSourceConfig;
+    videoOptions: XRViewportMediaAssetOption[];
+}) => {
+    containerRef: import('react').RefObject<HTMLDivElement>;
+    displayCanvasRef: import('react').RefObject<HTMLCanvasElement>;
+    displayMirrored: boolean;
+    layout: import('../../../types').XRMediaLayout | null;
+    managesOwnMedia: boolean;
+    media: {
+        videoRef: import('react').RefObject<HTMLVideoElement>;
+        imageRef: import('react').RefObject<HTMLImageElement>;
+        stream: MediaStream | null;
+        mediaSize: import('..').XRViewportSize;
+        status: "idle" | "ready" | "error" | "requesting";
+        error: string | null;
+    };
+    renderOutputState: import('..').XRViewportRenderOutputs;
+    renderState: import('..').XRViewportRenderState;
+    selectedImageId: string;
+    selectedSource: XRViewportSourceKind;
+    selectedVideoId: string;
+    setSceneRenderOutputs: import('react').Dispatch<import('react').SetStateAction<XRSceneRenderOutputs>>;
+    setSelectedImageId: import('react').Dispatch<import('react').SetStateAction<string>>;
+    setSelectedSource: import('react').Dispatch<import('react').SetStateAction<XRViewportSourceKind>>;
+    setSelectedVideoId: import('react').Dispatch<import('react').SetStateAction<string>>;
+    showMediaControls: boolean;
+    viewportSize: import('..').XRViewportSize;
+};

package/dist/components/XRViewport/hooks/useViewportRenderState.d.ts

@@ -0,0 +1,47 @@
+import { XRViewportMediaAssetOption, XRViewportPreviewMode, XRViewportRenderOutputRequest, XRViewportRenderOutputs, XRViewportRenderState, XRViewportSize, XRViewportSourceKind } from '../types';
+import { XRMediaLayout } from '../../../types/compositor';
+import { FaceTrackingResult } from '../../../types/face';
+import { XRSceneRenderOutputs } from '../../XRScene';
+import type * as THREE from "three";
+type InternalTrackerState = {
+    activeDelegate: "GPU" | "CPU" | null;
+    error: string | null;
+    faces: FaceTrackingResult[];
+    status: "idle" | "initializing" | "ready" | "error";
+};
+type ExternalTrackerState = {
+    faces: FaceTrackingResult[];
+    trackerStatus: "idle" | "ready";
+};
+export declare const useViewportRenderState: ({ externalTracker, imageOptions, layout, managesOwnMedia, mediaError, mediaFitMode, mediaSize, mediaStatus, mirrored, selectedImage, selectedImageId, selectedSource, selectedVideo, selectedVideoId, setMirrored, setSelectedImageId, setSelectedSource, setSelectedVideoId, setShowMediaControls, showMediaControls, tracker, videoOptions, viewportSize, }: {
+    externalTracker: ExternalTrackerState;
+    imageOptions: XRViewportMediaAssetOption[];
+    layout: XRMediaLayout | null;
+    managesOwnMedia: boolean;
+    mediaError: string | null;
+    mediaFitMode: Exclude<XRViewportRenderState["mediaFitMode"], "auto">;
+    mediaSize: XRViewportSize;
+    mediaStatus: XRViewportRenderState["mediaStatus"];
+    mirrored: boolean;
+    selectedImage?: XRViewportMediaAssetOption;
+    selectedImageId: string;
+    selectedSource: XRViewportSourceKind;
+    selectedVideo?: XRViewportMediaAssetOption;
+    selectedVideoId: string;
+    setMirrored: (value: boolean) => void;
+    setSelectedImageId: (value: string) => void;
+    setSelectedSource: (value: XRViewportSourceKind) => void;
+    setSelectedVideoId: (value: string) => void;
+    setShowMediaControls: (value: boolean) => void;
+    showMediaControls: boolean;
+    tracker: InternalTrackerState;
+    videoOptions: XRViewportMediaAssetOption[];
+    viewportSize: XRViewportSize;
+}) => XRViewportRenderState;
+export declare const useViewportRenderOutputs: ({ mediaTexture, previewMode, renderOutputs, sceneRenderOutputs, }: {
+    mediaTexture: THREE.Texture | null;
+    previewMode: XRViewportPreviewMode;
+    renderOutputs: XRViewportRenderOutputRequest;
+    sceneRenderOutputs: XRSceneRenderOutputs;
+}) => XRViewportRenderOutputs;
+export {};