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

package/dist/scene-object/index.d.ts

@@ -0,0 +1,146 @@
+import { MeshRendererSettings } from '../components/MeshRenderer';
+import { FaceMeshRendererSettings } from '../components/FaceMesh';
+import { LightSettings } from '../components/LightObject';
+import { PinToMeshSettings } from '../components/PinToMesh';
+import { TrackingAnchorSettings } from '../components/TrackingAnchor';
+import { LookAtSettings } from '../components/LookAt';
+import { Transform3DSettings } from '../components/Transform3D';
+import { ScreenImageSettings } from '../screen-image/screenImageSettings';
+import { ScreenTextSettings } from '../screen-text/screenTextSettings';
+import { ScreenShapeSettings } from '../components/ScreenShape';
+import { ScreenTransform2DSettings } from '../screen2d';
+export type SceneObjectId = string;
+export type SceneComponentId = string;
+export type MaterialSettings = {
+    type: "standard" | "basic";
+    color: string;
+    opacity: number;
+    wireframe: boolean;
+    roughness: number;
+    metalness: number;
+};
+export type TextureSettings = {
+    sourceId?: string;
+    url?: string;
+    flipX: boolean;
+    flipY: boolean;
+};
+export type ComponentRegistry = {
+    Transform: Transform3DSettings;
+    ScreenTransform: ScreenTransform2DSettings;
+    ScreenImage: ScreenImageSettings;
+    ScreenText: ScreenTextSettings;
+    ScreenShape: ScreenShapeSettings;
+    MeshRenderer: MeshRendererSettings;
+    FaceMeshRenderer: FaceMeshRendererSettings;
+    Material: MaterialSettings;
+    Texture: TextureSettings;
+    Light: LightSettings;
+    LookAt: LookAtSettings;
+    PinToMesh: PinToMeshSettings;
+    TrackingAnchor: TrackingAnchorSettings;
+};
+export type SceneComponentType = keyof ComponentRegistry;
+export type SceneObject = {
+    id: SceneObjectId;
+    name: string;
+    enabled: boolean;
+    /**
+     * Optional parent scene object. Child transforms are evaluated in the
+     * parent's runtime Object3D space, so moving/rotating/scaling the parent
+     * affects all descendants while each child keeps its own local transform.
+     */
+    parentObjectId?: SceneObjectId | null;
+    /** Ordered child scene-object IDs for hierarchy/runtime nesting. */
+    childObjectIds?: SceneObjectId[];
+    renderGroupId?: string;
+    /** @deprecated Use renderGroupId. Retained for persisted-scene migration. */
+    layerId?: string;
+    componentIds: SceneComponentId[];
+};
+export type SceneComponent<TType extends SceneComponentType = SceneComponentType> = TType extends SceneComponentType ? {
+    id: SceneComponentId;
+    objectId: SceneObjectId;
+    type: TType;
+    enabled: boolean;
+    settings: ComponentRegistry[TType];
+} : never;
+export type SceneObjectStore = {
+    objects: Record<SceneObjectId, SceneObject>;
+    components: Record<SceneComponentId, SceneComponent>;
+};
+export declare const createSceneId: (prefix: string) => string;
+export declare const createSceneObjectId: () => string;
+export declare const createSceneComponentId: () => string;
+export declare const createDefaultTransformSettings: () => Transform3DSettings;
+export declare const createDefaultScreenTransformSettings: () => ScreenTransform2DSettings;
+export declare const createDefaultScreenImageSettings: () => ScreenImageSettings;
+export declare const createDefaultScreenTextSettings: () => ScreenTextSettings;
+export declare const createDefaultScreenShapeSettings: () => ScreenShapeSettings;
+export declare const createDefaultMeshRendererSettings: () => MeshRendererSettings;
+export declare const createDefaultFaceMeshRendererSettings: () => FaceMeshRendererSettings;
+export declare const createDefaultMaterialSettings: () => MaterialSettings;
+export declare const createDefaultTextureSettings: () => TextureSettings;
+export declare const createDefaultLightSettings: () => LightSettings;
+export declare const createDefaultLookAtSettings: () => {
+    enabled: boolean;
+    targetObjectId: SceneObjectId | null;
+    mode: "point";
+    inheritChildren: boolean;
+    offsetRotation: {
+        x: number;
+        y: number;
+        z: number;
+    };
+};
+export declare const createDefaultPinToMeshSettings: () => PinToMeshSettings;
+export declare const createDefaultTrackingAnchorSettings: () => TrackingAnchorSettings;
+export declare const componentDefaults: {
+    Transform: () => Transform3DSettings;
+    ScreenTransform: () => ScreenTransform2DSettings;
+    ScreenImage: () => ScreenImageSettings;
+    ScreenText: () => ScreenTextSettings;
+    ScreenShape: () => ScreenShapeSettings;
+    MeshRenderer: () => MeshRendererSettings;
+    FaceMeshRenderer: () => FaceMeshRendererSettings;
+    Material: () => MaterialSettings;
+    Texture: () => TextureSettings;
+    Light: () => LightSettings;
+    LookAt: () => {
+        enabled: boolean;
+        targetObjectId: SceneObjectId | null;
+        mode: "point";
+        inheritChildren: boolean;
+        offsetRotation: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    PinToMesh: () => PinToMeshSettings;
+    TrackingAnchor: () => TrackingAnchorSettings;
+};
+export declare const createSceneObject: ({ componentIds, enabled, id, parentObjectId, childObjectIds, renderGroupId, layerId, name, }: {
+    componentIds?: SceneComponentId[];
+    enabled?: boolean;
+    id?: SceneObjectId;
+    parentObjectId?: SceneObjectId | null;
+    childObjectIds?: SceneObjectId[];
+    renderGroupId?: string;
+    /** @deprecated Use renderGroupId. */
+    layerId?: string;
+    name: string;
+}) => SceneObject;
+export declare const createDefaultComponent: <TType extends SceneComponentType>(type: TType, objectId: SceneObjectId) => SceneComponent<TType>;
+export declare const getOrderedComponents: (store: SceneObjectStore, objectId: SceneObjectId) => SceneComponent[];
+export declare const createOrderedComponentsSelector: () => (store: SceneObjectStore, objectId: SceneObjectId) => SceneComponent[];
+export declare const addComponentToObject: <TStore extends SceneObjectStore>(store: TStore, component: SceneComponent) => TStore;
+export declare const moveComponent: <TStore extends SceneObjectStore>(store: TStore, objectId: SceneObjectId, componentId: SceneComponentId, nextIndex: number) => TStore;
+export declare const removeComponent: <TStore extends SceneObjectStore>(store: TStore, objectId: SceneObjectId, componentId: SceneComponentId) => TStore;
+export declare const replaceSceneComponent: <TStore extends SceneObjectStore>(store: TStore, component: SceneComponent) => TStore;
+export declare const replaceSceneObject: <TStore extends SceneObjectStore>(store: TStore, object: SceneObject) => TStore;
+export declare const getSceneObjectChildren: (store: SceneObjectStore, objectId: SceneObjectId) => SceneObject[];
+export declare const setSceneObjectParent: <TStore extends SceneObjectStore>(store: TStore, objectId: SceneObjectId, parentObjectId: SceneObjectId | null, nextIndex?: number) => TStore;
+export declare const setSceneObjectParentPreserveWorldTransform: <TStore extends SceneObjectStore>(store: TStore, objectId: SceneObjectId, parentObjectId: SceneObjectId | null, nextIndex?: number) => TStore;
+export declare const setSceneObjectVisible: <TStore extends SceneObjectStore>(store: TStore, objectId: SceneObjectId, visible: boolean) => TStore;
+export declare const deleteSceneObject: <TStore extends SceneObjectStore>(store: TStore, objectId: SceneObjectId) => TStore;

package/dist/scene-object/runtimeRegistry.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import { Object3D } from 'three';
+export type RuntimeObjectRegistry = {
+    register: (id: string, object: Object3D | null) => void;
+    resolve: (id: string | null | undefined) => Object3D | null;
+};
+export declare const RuntimeObjectRegistryProvider: ({ children }: {
+    children: ReactNode;
+}) => import('react').FunctionComponentElement<import('react').ProviderProps<RuntimeObjectRegistry | null>>;
+export declare const useRuntimeObjectRegistry: () => RuntimeObjectRegistry;
+export declare const useRegisterRuntimeObject: () => (id: string, object: Object3D | null) => void;
+export declare const useResolveRuntimeObject: () => (id: string | null | undefined) => Object3D | null;
+export declare const registerRuntimeObject: (id: string, object: Object3D | null) => void;
+export declare const resolveRuntimeObject: (id: string | null | undefined) => Object3D | null;

package/dist/scene-object.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./renderPasses-CT5iBwtg.cjs"),t=require("./renderGroups-Dvm1J4lW.cjs");exports.addComponentToObject=e.addComponentToObject;exports.componentDefaults=e.componentDefaults;exports.createDefaultComponent=e.createDefaultComponent;exports.createDefaultFaceMeshRendererSettings=e.createDefaultFaceMeshRendererSettings;exports.createDefaultMaterialSettings=e.createDefaultMaterialSettings;exports.createDefaultMeshRendererSettings=e.createDefaultMeshRendererSettings;exports.createDefaultScreenImageSettings=e.createDefaultScreenImageSettings;exports.createDefaultScreenShapeSettings=e.createDefaultScreenShapeSettings;exports.createDefaultScreenTextSettings=e.createDefaultScreenTextSettings;exports.createDefaultScreenTransformSettings=e.createDefaultScreenTransformSettings;exports.createDefaultTextureSettings=e.createDefaultTextureSettings;exports.createDefaultTransformSettings=e.createDefaultTransformSettings;exports.createOrderedComponentsSelector=e.createOrderedComponentsSelector;exports.createSceneComponentId=e.createSceneComponentId;exports.createSceneId=e.createSceneId;exports.createSceneObject=e.createSceneObject;exports.createSceneObjectId=e.createSceneObjectId;exports.deleteSceneObject=e.deleteSceneObject;exports.getOrderedComponents=e.getOrderedComponents;exports.getSceneObjectChildren=e.getSceneObjectChildren;exports.moveComponent=e.moveComponent;exports.removeComponent=e.removeComponent;exports.replaceSceneComponent=e.replaceSceneComponent;exports.replaceSceneObject=e.replaceSceneObject;exports.setSceneObjectParent=e.setSceneObjectParent;exports.setSceneObjectParentPreserveWorldTransform=e.setSceneObjectParentPreserveWorldTransform;exports.setSceneObjectVisible=e.setSceneObjectVisible;exports.DEFAULT_RENDER_GROUP_IDS=t.DEFAULT_RENDER_GROUP_IDS;exports.RENDER_GROUP_POLICIES=t.RENDER_GROUP_POLICIES;exports.createRenderPlan=t.createRenderPlan;exports.getDefaultRenderGroupId=t.getDefaultRenderGroupId;exports.migrateToRenderGroups=t.migrateToRenderGroups;exports.moveObjectToGroup=t.moveObjectToGroup;exports.reorderObjectWithinGroup=t.reorderObjectWithinGroup;exports.reorderRenderGroup=t.reorderRenderGroup;exports.validateGroupCompatibility=t.validateGroupCompatibility;

package/dist/scene-object.js

@@ -0,0 +1,40 @@
+import { a, c as r, b as s, d as n, e as c, f as o, g as S, i as l, h as d, j as m, k as p, l as i, q as u, m as f, n as D, o as g, p as O, r as b, s as R, t as j, u as C, v as T, w as G, x as I, y as v, z as P, A as h } from "./renderPasses-CjgG_6kQ.js";
+import { D as x, R as _, c as M, g as U, m as y, a as A, r as F, b as L, v as N } from "./renderGroups-C9QJrAXu.js";
+export {
+  x as DEFAULT_RENDER_GROUP_IDS,
+  _ as RENDER_GROUP_POLICIES,
+  a as addComponentToObject,
+  r as componentDefaults,
+  s as createDefaultComponent,
+  n as createDefaultFaceMeshRendererSettings,
+  c as createDefaultMaterialSettings,
+  o as createDefaultMeshRendererSettings,
+  S as createDefaultScreenImageSettings,
+  l as createDefaultScreenShapeSettings,
+  d as createDefaultScreenTextSettings,
+  m as createDefaultScreenTransformSettings,
+  p as createDefaultTextureSettings,
+  i as createDefaultTransformSettings,
+  u as createOrderedComponentsSelector,
+  M as createRenderPlan,
+  f as createSceneComponentId,
+  D as createSceneId,
+  g as createSceneObject,
+  O as createSceneObjectId,
+  b as deleteSceneObject,
+  U as getDefaultRenderGroupId,
+  R as getOrderedComponents,
+  j as getSceneObjectChildren,
+  y as migrateToRenderGroups,
+  C as moveComponent,
+  A as moveObjectToGroup,
+  T as removeComponent,
+  F as reorderObjectWithinGroup,
+  L as reorderRenderGroup,
+  G as replaceSceneComponent,
+  I as replaceSceneObject,
+  v as setSceneObjectParent,
+  P as setSceneObjectParentPreserveWorldTransform,
+  h as setSceneObjectVisible,
+  N as validateGroupCompatibility
+};

package/dist/screen-image/screenImagePresets.d.ts

@@ -0,0 +1,13 @@
+import { ScreenImageSettings } from './screenImageSettings';
+export type ScreenImagePreset = "placeholder" | "hero-image" | "photo-frame";
+export type ScreenImagePresetPatch = Partial<Omit<ScreenImageSettings, "image" | "transformation">> & {
+    transformation?: Partial<ScreenImageSettings["transformation"]>;
+    image?: Partial<ScreenImageSettings["image"]>;
+};
+export declare const SCREEN_IMAGE_PRESET_LABELS: Record<ScreenImagePreset, string>;
+export declare const SCREEN_IMAGE_PRESET_OPTIONS: {
+    value: ScreenImagePreset;
+    label: string;
+}[];
+export declare const SCREEN_IMAGE_PRESETS: Record<ScreenImagePreset, ScreenImagePresetPatch>;
+export declare const applyScreenImagePreset: (settings: ScreenImageSettings, preset: ScreenImagePreset) => ScreenImageSettings;

package/dist/screen-image/screenImageSettings.d.ts

@@ -0,0 +1,57 @@
+import { ScreenImageProps, ScreenImageBlendMode, ScreenImageMaterialType, ScreenImageStretchMode } from '../components/ScreenImage';
+import { ScreenCanvasSize, ScreenCoordinateSpace } from '../screen2d';
+import { ScreenTransform2DSettings } from '../screen2d/screenTransform';
+import { ScreenImagePreset } from './screenImagePresets';
+export type ScreenImageSourceKind = "default" | "image" | "texture" | "video" | "sequence" | "gif";
+export type ScreenImageTransformationSettings = {
+    enabled: boolean;
+    showFitGuides: boolean;
+    coordinateSpace?: ScreenCoordinateSpace;
+    canvasSize?: ScreenCanvasSize;
+    position: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+        height: number;
+    };
+    rotation: number;
+    pivot: [number, number];
+    renderOrder: number;
+    overlay: boolean;
+    visible: boolean;
+};
+export type ScreenImageImageSettings = {
+    sourceKind: ScreenImageSourceKind;
+    src: string;
+    stretchMode: ScreenImageStretchMode;
+    materialType: ScreenImageMaterialType;
+    blendMode: ScreenImageBlendMode;
+    opacity: number;
+    color: string;
+    flipX: boolean;
+    flipY: boolean;
+    transparent: boolean;
+    alphaTest: number;
+};
+export type ScreenImageSettings = {
+    enabled: boolean;
+    preset: ScreenImagePreset;
+    screenTransform?: ScreenTransform2DSettings;
+    transformation: ScreenImageTransformationSettings;
+    image: ScreenImageImageSettings;
+};
+export type ScreenImageSceneSettings = {
+    screenImage: ScreenImageSettings;
+    screenSpaceUI: {
+        enabled: boolean;
+    };
+};
+export type ScreenImageRenderMapping = {
+    shouldRender: boolean;
+    props: Omit<ScreenImageProps, "backdropTexture" | "onScreenTransformChange">;
+};
+export declare function mapScreenImageSettingsToProps(settings: ScreenImageSceneSettings): ScreenImageRenderMapping;
+export declare const DEFAULT_SCREEN_IMAGE_SETTINGS: ScreenImageSettings;
+export declare const DEFAULT_SCREEN_IMAGE_SCENE_SETTINGS: ScreenImageSceneSettings;

package/dist/screen-text/screenTextPresets.d.ts

@@ -0,0 +1,6 @@
+import { ScreenTextArtPreset, ScreenTextStyle } from './screenTextSettings';
+export type ScreenTextStylePatch = Partial<Omit<ScreenTextStyle, "background">> & {
+    background?: Partial<ScreenTextStyle["background"]>;
+};
+export declare const SCREEN_TEXT_ART_PRESETS: Record<ScreenTextArtPreset, ScreenTextStylePatch>;
+export declare const applyScreenTextArtPreset: (style: ScreenTextStyle, textArtPreset: ScreenTextArtPreset) => ScreenTextStyle;

package/dist/screen-text/screenTextSettings.d.ts

@@ -0,0 +1,147 @@
+import { ScreenImageSettings } from '../screen-image/screenImageSettings';
+import { ScreenTextProps } from '../components/ScreenText';
+import { ScreenCanvasSize, ScreenCoordinateSpace } from '../screen2d';
+import { ScreenTransform2DSettings } from '../screen2d/screenTransform';
+export type ScreenTextArtPreset = "clean" | "sticker" | "shadow-pop" | "neon" | "editorial" | "comic-burst" | "ice-outline" | "sunset-glow" | "cutout" | "badge-arc" | "chrome-bulge" | "retro-wave" | "flag-pop" | "fisheye-poster";
+export type ScreenTextContent = {
+    text: string;
+};
+export type ScreenTextLayout = {
+    textAlign?: "left" | "center" | "right";
+    verticalAlign?: "top" | "center" | "bottom";
+    overflow?: "clip" | "ellipsis" | "clamp" | "shrink";
+    resizeToFit?: boolean;
+    minFontSize?: number;
+};
+export type ScreenTextBackground = {
+    enabled: boolean;
+    autoSize: boolean;
+    fit: "full" | "text";
+    fillMode: "solid" | "gradient";
+    color: string;
+    opacity: number;
+    borderRadius: number;
+    padding: number;
+    width: number;
+    height: number;
+    borderEnabled: boolean;
+    borderWidth: number;
+    borderColor: string;
+    gradientStops: Array<{
+        color: string;
+        position: number;
+    }>;
+    textureUrl?: string;
+    textureFit: "cover" | "contain" | "stretch";
+    textureFlipX: boolean;
+    textureFlipY: boolean;
+};
+export type ScreenTextStrokeLayer = {
+    color: string;
+    width: number;
+    opacity?: number;
+};
+export type ScreenTextShadowLayer = {
+    color: string;
+    blur: number;
+    offsetX?: number;
+    offsetY?: number;
+    opacity?: number;
+    offset?: number;
+    angle?: number;
+    feather?: number;
+};
+export type ScreenTextInnerShadow = {
+    color: string;
+    opacity?: number;
+    offset?: number;
+    angle?: number;
+    feather?: number;
+};
+export type ScreenTextGlow = {
+    color: string;
+    style: "outward" | "contoured";
+    intensity?: number;
+    range?: number;
+    horizontalAngle?: number;
+    verticalAngle?: number;
+};
+export type ScreenTextBendPreset = "arc" | "arc-lower" | "arc-upper" | "arch" | "bulge" | "shell-lower" | "shell-upper" | "flag" | "wave" | "fish" | "rise" | "fisheye" | "inflate" | "squeeze" | "twist";
+export type ScreenTextBend = {
+    preset: ScreenTextBendPreset;
+    strength: number;
+};
+export type ScreenTextStyle = {
+    fontSize: number;
+    fontFamily?: string;
+    fontWeight?: number | "normal" | "bold";
+    bold?: boolean;
+    fontStyle?: "normal" | "italic";
+    underline?: boolean;
+    strikethrough?: boolean;
+    letterSpacing: number;
+    lineSpacing: number;
+    color: string;
+    opacity: number;
+    aspect: number;
+    outlineEnabled?: boolean;
+    shadowEnabled?: boolean;
+    innerShadowEnabled?: boolean;
+    innerShadow?: ScreenTextInnerShadow;
+    glowEnabled?: boolean;
+    glow?: ScreenTextGlow;
+    bendEnabled?: boolean;
+    bend?: ScreenTextBend;
+    background: ScreenTextBackground;
+    strokeLayers?: ScreenTextStrokeLayer[];
+    shadowLayers?: ScreenTextShadowLayer[];
+};
+export type ScreenTextSettings = {
+    enabled: boolean;
+    content: ScreenTextContent;
+    layout: ScreenTextLayout;
+    style: ScreenTextStyle;
+    screenTransform?: ScreenTransform2DSettings;
+    transformation: ScreenTextTransformationSettings;
+    textArtPreset: ScreenTextArtPreset;
+};
+export type ScreenTextTransformationSettings = {
+    enabled: boolean;
+    showTransformGuides: boolean;
+    coordinateSpace?: ScreenCoordinateSpace;
+    canvasSize?: ScreenCanvasSize;
+    position: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+        height: number;
+    };
+    rotation: number;
+    pivot: [number, number];
+    renderOrder: number;
+    overlay: boolean;
+    visible: boolean;
+};
+export type ScreenTextSceneSettings = {
+    screenText: ScreenTextSettings;
+    screenImage: ScreenImageSettings;
+    screenSpaceUI: {
+        enabled: boolean;
+    };
+};
+export type ScreenTextRenderMapping = {
+    shouldRender: boolean;
+    props: Omit<ScreenTextProps, "onScreenTransformChange">;
+};
+export declare function mapScreenTextInnerShadowToProps(innerShadow?: ScreenTextInnerShadow): {
+    color: string;
+    opacity: number | undefined;
+    blur: number;
+    offsetX: number;
+    offsetY: number;
+} | undefined;
+export declare function mapScreenTextSettingsToProps(settings: ScreenTextSceneSettings): ScreenTextRenderMapping;
+export declare const DEFAULT_SCREEN_TEXT_SHADOW_LAYER: ScreenTextShadowLayer;
+export declare const DEFAULT_SCREEN_TEXT_SCENE_SETTINGS: ScreenTextSceneSettings;

package/dist/screen2d/coordinates.d.ts

@@ -0,0 +1,87 @@
+import { Camera, Ray, Vector3Like } from 'three';
+import { ScreenTransformRoot } from './screenTransform';
+import { XRMediaLayout } from '../types/compositor';
+export type ScreenViewportSize = {
+    width: number;
+    height: number;
+};
+export type ScreenPixelPoint = {
+    x: number;
+    y: number;
+};
+export type ProjectedScreenPixelPoint = ScreenPixelPoint & {
+    depth: number;
+};
+export type ScreenClientRect = ScreenViewportSize & {
+    left: number;
+    top: number;
+};
+export type ScreenUnitConversionOptions = {
+    parentSize: ScreenViewportSize;
+    referencePixelsPerUnit?: number;
+    root?: ScreenTransformRoot;
+};
+/** Converts SDK design-canvas pixels to Three.js ScreenSpaceUI plane units. */
+export declare const screenPixelsToUnits: (pixels: number, options: ScreenUnitConversionOptions) => number;
+/** Converts Three.js ScreenSpaceUI plane units to SDK design-canvas pixels. */
+export declare const screenUnitsToPixels: (units: number, options: ScreenUnitConversionOptions) => number;
+/** Converts DOM client coordinates to center-origin, +Y-up SDK design pixels. */
+export declare const clientToScreenPixels: ({ point, rect, root, target, }: {
+    point: ScreenPixelPoint;
+    rect: ScreenClientRect;
+    root?: ScreenTransformRoot;
+    target?: ScreenPixelPoint;
+}) => ScreenPixelPoint;
+/** Converts SDK design pixels to DOM client coordinates. */
+export declare const screenPixelsToClient: ({ point, rect, root, target, }: {
+    point: ScreenPixelPoint;
+    rect: ScreenClientRect;
+    root?: ScreenTransformRoot;
+    target?: ScreenPixelPoint;
+}) => ScreenPixelPoint;
+/** Converts normalized viewport coordinates (top-left origin) to SDK design pixels. */
+export declare const normalizedToScreenPixels: ({ point, root, target, viewportSize, }: {
+    point: ScreenPixelPoint;
+    viewportSize: ScreenViewportSize;
+    root?: ScreenTransformRoot;
+    target?: ScreenPixelPoint;
+}) => ScreenPixelPoint;
+/** Converts SDK design pixels to normalized viewport coordinates (top-left origin). */
+export declare const screenPixelsToNormalized: ({ point, root, target, viewportSize, }: {
+    point: ScreenPixelPoint;
+    viewportSize: ScreenViewportSize;
+    root?: ScreenTransformRoot;
+    target?: ScreenPixelPoint;
+}) => ScreenPixelPoint;
+/** Maps source-media pixel coordinates through viewport fit/crop and optional mirroring. */
+export declare const mediaToScreenPixels: ({ layout, mirrored, point, root, target, }: {
+    point: ScreenPixelPoint;
+    layout: XRMediaLayout;
+    mirrored?: boolean;
+    root?: ScreenTransformRoot;
+    target?: ScreenPixelPoint;
+}) => ScreenPixelPoint;
+/** Maps SDK design pixels back into source-media pixel coordinates. */
+export declare const screenPixelsToMedia: ({ layout, mirrored, point, root, target, }: {
+    point: ScreenPixelPoint;
+    layout: XRMediaLayout;
+    mirrored?: boolean;
+    root?: ScreenTransformRoot;
+    target?: ScreenPixelPoint;
+}) => ScreenPixelPoint;
+/** Projects a world position into center-origin, +Y-up SDK design pixels. */
+export declare const worldToScreenPixels: ({ camera, point, root, target, viewportSize, }: {
+    point: Vector3Like;
+    camera: Camera;
+    viewportSize: ScreenViewportSize;
+    root?: ScreenTransformRoot;
+    target?: ProjectedScreenPixelPoint;
+}) => ProjectedScreenPixelPoint;
+/** Casts a ray from center-origin, +Y-up SDK design pixels into the 3D scene. */
+export declare const screenPointToRay: ({ camera, point, root, target, viewportSize, }: {
+    point: ScreenPixelPoint;
+    camera: Camera;
+    viewportSize: ScreenViewportSize;
+    root?: ScreenTransformRoot;
+    target?: Ray;
+}) => Ray;

package/dist/screen2d/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export * from './material-runtime';
+export * from './texture';
+export * from './transform';
+export * from './screenTransform';
+export * from './coordinates';
+export * from './smoothing';

package/dist/screen2d/material-runtime.d.ts

@@ -0,0 +1,32 @@
+import { Material } from './types';
+export type MaterialDepthFunction = "never" | "always" | "less" | "lessEqual" | "equal" | "greaterEqual" | "greater" | "notEqual";
+export type MaterialCullMode = "none" | "front" | "back" | "double";
+export type MaterialColorMask = {
+    red: boolean;
+    green: boolean;
+    blue: boolean;
+    alpha: boolean;
+};
+export type MaterialStencilState = {
+    enabled: boolean;
+    reference?: number;
+    mask?: number;
+    writeMask?: number;
+};
+export type MaterialPass = {
+    name?: string;
+    depthTest: boolean;
+    depthWrite: boolean;
+    depthFunction: MaterialDepthFunction;
+    cullMode: MaterialCullMode;
+    colorMask: MaterialColorMask;
+    stencil: MaterialStencilState;
+    renderQueue: number;
+};
+export type MaterialRuntime = {
+    material: Material;
+    passes: MaterialPass[];
+};
+export declare const DEFAULT_MATERIAL_COLOR_MASK: MaterialColorMask;
+export declare const createDefaultMaterialPass: (material: Material, overrides?: Partial<MaterialPass>) => MaterialPass;
+export declare const createMaterialRuntime: (material: Material, passOverrides?: Partial<MaterialPass>) => MaterialRuntime;

package/dist/screen2d/screenTransform.d.ts

@@ -0,0 +1,47 @@
+export type ScreenTransform2DSettings = {
+    enabled: boolean;
+    position: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+        height: number;
+    };
+    pivot: [number, number];
+    rotation: number;
+    scale2D: {
+        x: number;
+        y: number;
+    };
+    referencePixelsPerUnit: number;
+    renderOrder: number;
+    overlay: boolean;
+    visible: boolean;
+    showTransformGuides: boolean;
+};
+export type ScreenTransformRoot = {
+    width: number;
+    height: number;
+};
+export type ResolvedScreenTransform2D = {
+    center: [number, number, number];
+    size: [number, number, number];
+    rotation: [number, number, number];
+    pivotOffset: [number, number, number];
+    aspect: number;
+};
+export declare const DEFAULT_SCREEN_TRANSFORM_ROOT: ScreenTransformRoot;
+export declare const DEFAULT_REFERENCE_PIXELS_PER_UNIT = 32;
+export declare const DEFAULT_PIXEL_SNAP_INCREMENT = 0.5;
+export declare const DEFAULT_SCREEN_TRANSFORM_2D: ScreenTransform2DSettings;
+export declare const resolveScreenTransform2D: ({ transform, parentSize, root, snapIncrement, }: {
+    transform: ScreenTransform2DSettings;
+    parentSize: {
+        width: number;
+        height: number;
+    };
+    root?: ScreenTransformRoot;
+    snapIncrement?: number;
+}) => ResolvedScreenTransform2D;
+export declare const mergeScreenTransform2D: (transform?: Partial<ScreenTransform2DSettings>) => ScreenTransform2DSettings;

package/dist/screen2d/smoothing.d.ts

@@ -0,0 +1,5 @@
+import { Vector2, Vector3 } from 'three';
+/** Frame-rate-independent exponential smoothing. */
+export declare const smoothNumber: (current: number, target: number, rate: number, deltaSeconds: number) => number;
+export declare const smoothVector2: (current: Vector2, target: Vector2, rate: number, deltaSeconds: number, out?: Vector2) => Vector2;
+export declare const smoothVector3: (current: Vector3, target: Vector3, rate: number, deltaSeconds: number, out?: Vector3) => Vector3;

package/dist/screen2d/texture.d.ts

@@ -0,0 +1,10 @@
+import { TextureSource } from './types';
+import type * as THREE from "three";
+export type TextureDimensions = {
+    width: number;
+    height: number;
+};
+export declare const getTextureDimensions: (texture: THREE.Texture | null | undefined) => TextureDimensions | null;
+export declare const getTextureAspect: (texture: THREE.Texture | null | undefined) => number;
+export declare const getTextureSourceDimensions: (source: TextureSource) => TextureDimensions | null;
+export declare const resolveTextureSource: (source: TextureSource | string | THREE.Texture | null | undefined) => TextureSource;

package/dist/screen2d/transform.d.ts

@@ -0,0 +1,25 @@
+import { ScreenAnchorEdges } from '../components/ScreenSpaceUI/ScreenTransform';
+import { ScreenCanvasSize, ScreenCoordinateSpace, ScreenTransform2D } from './types';
+export declare const DEFAULT_SCREEN_CANVAS_SIZE: ScreenCanvasSize;
+export type ResolveScreenRectInput = {
+    coordinateSpace?: ScreenCoordinateSpace;
+    canvasSize?: ScreenCanvasSize;
+    position?: [number, number];
+    size?: [number, number];
+    fallbackAnchors?: ScreenAnchorEdges;
+};
+export declare const pivot01ToSignedPivot: (pivot?: [number, number]) => [number, number];
+export declare const basicTransformToAnchoredRect: ({ position, size, }: Pick<ScreenTransform2D, "position" | "size">) => {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
+export declare const canvasTransformToAnchoredRect: ({ position, size, canvasSize, }: Pick<ScreenTransform2D, "position" | "size" | "canvasSize">) => {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
+export declare const resolveScreenRectAnchors: ({ coordinateSpace, canvasSize, position, size, fallbackAnchors, }: ResolveScreenRectInput) => ScreenAnchorEdges;
+export declare const screenTransform2DToAnchors: (transform: ScreenTransform2D) => ScreenAnchorEdges;