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

package/dist/components/HandTracking2D/HandVisual.d.ts

@@ -0,0 +1,12 @@
+import { HandTracking2DHandFrame, HandTracking2DPoint, HandTracking2DSettings } from '../../hand/handTracking2d';
+type RenderedHand = HandTracking2DHandFrame & {
+    key: string;
+    points: HandTracking2DPoint[];
+};
+export declare function HandVisual({ hand, index, settings, aspectScale, }: {
+    hand: RenderedHand;
+    index: number;
+    settings: HandTracking2DSettings;
+    aspectScale: number;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,5 @@
+import { HandTracking2DSettings } from '../../hand/handTracking2d';
+export type HandTracking2DProps = {
+    settings?: HandTracking2DSettings;
+};
+export declare const HandTracking2D: ({ settings, }: HandTracking2DProps) => import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,5 @@
+import { HandTracking2DControllerSettings } from '../../hand/handTracking2dController';
+export type HandTracking2DControllerProps = {
+    settings?: HandTracking2DControllerSettings;
+};
+export declare const HandTracking2DController: ({ settings, }: HandTracking2DControllerProps) => import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,6 @@
+import { HandTracking3DRenderedHandFrame, HandTracking3DSettings } from '../../hand/handTracking3d';
+export type HandTracking3DProps = {
+    settings?: HandTracking3DSettings;
+    onHandsChange?: (hands: HandTracking3DRenderedHandFrame[]) => void;
+};
+export declare const HandTracking3D: ({ settings, onHandsChange, }: HandTracking3DProps) => import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,20 @@
+import { Transform3DSettings } from '../Transform3D';
+export type LightType = "ambient" | "directional" | "point" | "spot";
+export type LightSettings = {
+    enabled: boolean;
+    type: LightType;
+    color: string;
+    intensity: number;
+    castShadow: boolean;
+    distance: number;
+    angle: number;
+    penumbra: number;
+    decay: number;
+    showHelper: boolean;
+};
+export declare const DEFAULT_LIGHT_SETTINGS: LightSettings;
+export type LightObjectProps = {
+    settings: LightSettings;
+    transform: Transform3DSettings;
+};
+export declare const LightObject: ({ settings, transform }: LightObjectProps) => import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,23 @@
+import { Object3D } from 'three';
+export type LookAtSettings = {
+    enabled: boolean;
+    targetObjectId: string | null;
+    mode: "point" | "direction";
+    inheritChildren: boolean;
+    offsetRotation: {
+        x: number;
+        y: number;
+        z: number;
+    };
+};
+export type LookAtProps = {
+    target: Object3D | null;
+    settings: LookAtSettings;
+    children: React.ReactNode;
+};
+export declare const applyLookAt: ({ source, target, settings, }: {
+    source: Object3D;
+    target: Object3D | null;
+    settings: LookAtSettings;
+}) => boolean;
+export declare const LookAt: ({ target, settings, children }: LookAtProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,58 @@
+import { Blending, DepthModes, Side } from 'three';
+export type MeshRendererMesh = "cube" | "sphere" | "plane";
+export type MeshRendererMaterialType = "standard" | "basic";
+export type MeshRendererShadowMode = "off" | "cast" | "receive" | "castReceive";
+export type MeshRendererDepthFunction = "never" | "less" | "equal" | "lessEqual" | "greater" | "notEqual" | "greaterEqual" | "always";
+export type MeshRendererCullMode = "back" | "front" | "off";
+export type MeshRendererBlendMode = "normal" | "additive" | "subtractive" | "multiply" | "none";
+export type MeshRendererRenderState = {
+    depthTest: boolean;
+    depthWrite: boolean;
+    depthFunc: MeshRendererDepthFunction;
+    colorWrite: boolean;
+    colorMask: {
+        r: boolean;
+        g: boolean;
+        b: boolean;
+        a: boolean;
+    };
+    cullMode: MeshRendererCullMode;
+    blendMode: MeshRendererBlendMode;
+    polygonOffset: {
+        enabled: boolean;
+        factor: number;
+        units: number;
+    };
+};
+export type MeshRendererSettings = {
+    enabled: boolean;
+    mesh: MeshRendererMesh;
+    /** Optional GLTF/GLB asset URL. When set, renders the imported asset instead of a primitive. */
+    assetUrl?: string;
+    assetNodeName?: string;
+    material: {
+        type: MeshRendererMaterialType;
+        color: string;
+        opacity: number;
+        wireframe: boolean;
+        roughness: number;
+        metalness: number;
+        renderState?: Partial<Omit<MeshRendererRenderState, "colorMask" | "polygonOffset"> & {
+            colorMask: Partial<MeshRendererRenderState["colorMask"]>;
+            polygonOffset: Partial<MeshRendererRenderState["polygonOffset"]>;
+        }>;
+    };
+    shadowMode: MeshRendererShadowMode;
+    visible: boolean;
+};
+export type MeshRendererProps = {
+    value: MeshRendererSettings;
+    renderOrder?: number;
+};
+export declare const DEFAULT_MESH_RENDERER: MeshRendererSettings;
+export declare const DEFAULT_MESH_RENDERER_RENDER_STATE: MeshRendererRenderState;
+export declare const normalizeMeshRendererRenderState: (renderState?: MeshRendererSettings["material"]["renderState"]) => MeshRendererRenderState;
+export declare const getThreeDepthFunction: (depthFunc: MeshRendererDepthFunction) => DepthModes;
+export declare const getThreeSide: (cullMode: MeshRendererCullMode) => Side;
+export declare const getThreeBlending: (blendMode: MeshRendererBlendMode) => Blending;
+export declare const MeshRenderer: ({ renderOrder, value }: MeshRendererProps) => import("react/jsx-runtime").JSX.Element | null;

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

@@ -1,13 +1,7 @@
 import { PerspectiveCameraProps } from '@react-three/fiber';
 /**
- * @deprecated Use @react-three/drei's PerspectiveCamera directly for the new unified architecture.
- * This component is kept for backwards compatibility with old examples.
- *
- * For new projects, use:
- * ```tsx
- * import { PerspectiveCamera } from '@react-three/drei';
- * <PerspectiveCamera makeDefault position={[0, 0, 5]} fov={45} />
- * ```
+ * @deprecated Import PerspectiveCamera directly from @react-three/drei.
+ * Retained for backwards compatibility with existing SDK consumers.
  */
 export declare const PerspectiveCamera: (props: PerspectiveCameraProps & {
     makeDefault?: boolean;

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

@@ -0,0 +1,47 @@
+import { Object3D, Vector3 } from 'three';
+export type PinToMeshOrientation = "none" | "position" | "positionAndDirection";
+export type PinToMeshVector3 = {
+    x: number;
+    y: number;
+    z: number;
+};
+export type PinToMeshSettings = {
+    enabled: boolean;
+    targetObjectId: string | null;
+    orientation: PinToMeshOrientation;
+    uv: {
+        x: number;
+        y: number;
+    };
+    vertexNormal: boolean;
+    offsetSpace: "local" | "world";
+    offsetPosition: PinToMeshVector3;
+    offsetRotation: PinToMeshVector3;
+};
+export declare const DEFAULT_PIN_TO_MESH: PinToMeshSettings;
+export type PinToMeshProps = {
+    target: Object3D | null;
+    settings: PinToMeshSettings;
+    children: React.ReactNode;
+};
+/** Resolve a UV coordinate to the first matching mesh triangle in world space. */
+export declare const resolvePinSurface: (target: Object3D, uv: {
+    x: number;
+    y: number;
+}, useVertexNormal?: boolean) => {
+    position: Vector3;
+    normal: Vector3;
+};
+export type ApplyPinToMeshOptions = {
+    source: Object3D;
+    surface: {
+        position: Vector3;
+        normal: Vector3;
+    };
+    settings: Pick<PinToMeshSettings, "offsetPosition" | "offsetRotation" | "offsetSpace" | "orientation">;
+};
+export declare const resetPinnedObject: (source: Object3D) => void;
+export declare const applyPinToMeshTransform: ({ settings, source, surface }: ApplyPinToMeshOptions) => void;
+export declare const PinToMesh: ({ target, settings, children }: PinToMeshProps) => import('react').ReactElement<{
+    ref: import('react').RefObject<Object3D<import('three').Object3DEventMap>>;
+}, string | import('react').JSXElementConstructor<any>>;

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

@@ -0,0 +1,6 @@
+import { PropsWithChildren } from 'react';
+export type RenderGroupLayerProps = PropsWithChildren & {
+    layer?: number;
+};
+/** Assigns every renderable descendant to one camera layer. */
+export declare const RenderGroupLayer: ({ children, layer }: RenderGroupLayerProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+import { SceneComponent, SceneObjectId, SceneObjectStore } from '../../scene-object';
+export type SceneObjectRendererProps = {
+    objectId: SceneObjectId;
+    store: SceneObjectStore;
+    editorMode?: boolean;
+    /** Stable renderer sorting value, normally supplied by createRenderPlan(). */
+    renderOrder?: number;
+    /** Camera layer used by SequentialRenderPasses for guaranteed group composition. */
+    renderLayer?: number;
+    onComponentChange?: (component: SceneComponent) => void;
+    fallback?: (message: string) => ReactNode;
+    /** Internal: descendants already share an ancestor ScreenSpaceUI plane. */
+    insideScreenSpaceUI?: boolean;
+};
+export declare const SceneObjectRenderer: ({ editorMode, fallback, insideScreenSpaceUI, objectId, onComponentChange, renderLayer, renderOrder, store, }: SceneObjectRendererProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/components/Screen2D/ScreenTransformFrame.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+import { ScreenTransformGuideLayer } from '../ScreenSpaceUI';
+import { ScreenTransform2DSettings } from '../../screen2d';
+export type ScreenTransformFrameProps = {
+    transform: ScreenTransform2DSettings;
+    guideLayer: ScreenTransformGuideLayer;
+    guideColor: string;
+    onChange?: (next: ScreenTransform2DSettings) => void;
+    children: ReactNode;
+};
+export declare function ScreenTransformFrame({ transform, guideLayer, guideColor, onChange, children, }: ScreenTransformFrameProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Screen2D/ScreenTransformHelpers.d.ts

@@ -0,0 +1,19 @@
+import { ResolvedScreenTransform2D, ScreenTransform2DSettings } from '../../screen2d';
+export declare const snapHalfPixel: (value: number) => number;
+export declare const clamp01: (value: number) => number;
+export declare function resolveScreenTransformDesignScale(viewportSize: {
+    width: number;
+    height: number;
+}): number;
+export declare function resolveScreenTransformUnitScale({ resolved, transform, }: {
+    resolved: ResolvedScreenTransform2D;
+    transform: ScreenTransform2DSettings;
+}): number;
+export declare function resolveScreenTransformControlScale({ parent, resolved, transform, }: {
+    parent: {
+        width: number;
+        height: number;
+    };
+    resolved: ResolvedScreenTransform2D;
+    transform: ScreenTransform2DSettings;
+}): [number, number, number];

package/dist/components/Screen2D/ScreenTransformInteraction.d.ts

@@ -0,0 +1,18 @@
+import { ScreenTransformControlHandle } from '../ScreenSpaceUI/ScreenTransformGuide';
+import { ScreenTransform2DSettings } from '../../screen2d';
+export type ScreenTransformDragState = {
+    handle: ScreenTransformControlHandle;
+    startX: number;
+    startY: number;
+    startPointerDesign: {
+        x: number;
+        y: number;
+    };
+    startTransform: ScreenTransform2DSettings;
+};
+export declare function applyScreenTransformDrag({ drag, clientX, clientY, designScale, }: {
+    drag: ScreenTransformDragState;
+    clientX: number;
+    clientY: number;
+    designScale: number;
+}): ScreenTransform2DSettings;

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

@@ -0,0 +1,5 @@
+export { ScreenTransformFrame } from './ScreenTransformFrame';
+export type { ScreenTransformFrameProps } from './ScreenTransformFrame';
+export { applyScreenTransformDrag } from './ScreenTransformInteraction';
+export type { ScreenTransformDragState } from './ScreenTransformInteraction';
+export { clamp01, resolveScreenTransformControlScale, resolveScreenTransformDesignScale, resolveScreenTransformUnitScale, snapHalfPixel, } from './ScreenTransformHelpers';

package/dist/components/ScreenGlass/defaults.d.ts

@@ -0,0 +1,3 @@
+import { ScreenGlassSettings } from './types';
+export declare const DEFAULT_SCREEN_GLASS: ScreenGlassSettings;
+export declare const normalizeScreenGlass: (value?: Partial<ScreenGlassSettings>) => ScreenGlassSettings;

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

@@ -0,0 +1,5 @@
+import { DEFAULT_SCREEN_GLASS, normalizeScreenGlass } from './defaults';
+import { ScreenGlassMaterialProps } from './types';
+export type { ScreenGlassMaterialProps, ScreenGlassSettings } from './types';
+export { DEFAULT_SCREEN_GLASS, normalizeScreenGlass };
+export declare const ScreenGlassMaterial: ({ opacity, value }: ScreenGlassMaterialProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/ScreenGlass/shaders.d.ts

@@ -0,0 +1,2 @@
+export declare const screenGlassVertexShader = "\n  varying vec2 vPosition;\n  void main() {\n    vPosition = position.xy;\n    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n  }\n";
+export declare const screenGlassFragmentShader = "\n  uniform vec3 tint;\n  uniform float opacity;\n  uniform float frost;\n  uniform float highlight;\n  varying vec2 vPosition;\n\n  void main() {\n    float grain = fract(sin(dot(vPosition * 997.0, vec2(12.9898, 78.233))) * 43758.5453);\n    float sheen = smoothstep(0.15, 0.85, 1.0 - (vPosition.x + vPosition.y + 1.0) * 0.5);\n    vec3 frosted = mix(tint, vec3(1.0), frost * (0.18 + grain * 0.08));\n    vec3 color = mix(frosted, vec3(1.0), sheen * highlight * 0.32);\n    gl_FragColor = vec4(color, opacity);\n  }\n";

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

@@ -0,0 +1,10 @@
+export type ScreenGlassSettings = {
+    tint: string;
+    opacity: number;
+    frost: number;
+    highlight: number;
+};
+export type ScreenGlassMaterialProps = {
+    value: ScreenGlassSettings;
+    opacity?: number;
+};

package/dist/components/ScreenGradient/defaults.d.ts

@@ -0,0 +1,5 @@
+import { ScreenGradientSettings, ScreenGradientStop } from './types';
+export declare const MAX_SCREEN_GRADIENT_STOPS = 8;
+export declare const DEFAULT_SCREEN_GRADIENT: ScreenGradientSettings;
+export declare const normalizeScreenGradientStops: (stops: ScreenGradientStop[]) => ScreenGradientStop[];
+export declare const normalizeScreenGradient: (value?: Partial<ScreenGradientSettings>) => ScreenGradientSettings;

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

@@ -0,0 +1,5 @@
+import { DEFAULT_SCREEN_GRADIENT, MAX_SCREEN_GRADIENT_STOPS, normalizeScreenGradient, normalizeScreenGradientStops } from './defaults';
+import { ScreenGradientMaterialProps } from './types';
+export type { ScreenGradientMaterialProps, ScreenGradientSettings, ScreenGradientStop, ScreenGradientType, } from './types';
+export { DEFAULT_SCREEN_GRADIENT, MAX_SCREEN_GRADIENT_STOPS, normalizeScreenGradient, normalizeScreenGradientStops, };
+export declare const ScreenGradientMaterial: ({ opacity, value }: ScreenGradientMaterialProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/ScreenGradient/shaders.d.ts

@@ -0,0 +1,2 @@
+export declare const screenGradientVertexShader = "\n  varying vec2 vPosition;\n  void main() {\n    vPosition = position.xy;\n    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n  }\n";
+export declare const screenGradientFragmentShader = "\n  #define MAX_STOPS 8\n  uniform vec3 stopColors[MAX_STOPS];\n  uniform float stopOffsets[MAX_STOPS];\n  uniform int stopCount;\n  uniform int gradientType;\n  uniform vec2 direction;\n  uniform vec2 center;\n  uniform float radius;\n  uniform float angleOffset;\n  uniform float opacity;\n  varying vec2 vPosition;\n\n  vec3 sampleGradient(float amount) {\n    vec3 color = stopColors[0];\n    for (int index = 1; index < MAX_STOPS; index++) {\n      if (index >= stopCount) break;\n      if (amount <= stopOffsets[index]) {\n        float width = max(0.0001, stopOffsets[index] - stopOffsets[index - 1]);\n        return mix(stopColors[index - 1], stopColors[index], clamp((amount - stopOffsets[index - 1]) / width, 0.0, 1.0));\n      }\n      color = stopColors[index];\n    }\n    return color;\n  }\n\n  void main() {\n    vec2 delta = vPosition - center;\n    float amount;\n    if (gradientType == 1) {\n      amount = clamp(length(delta) / radius, 0.0, 1.0);\n    } else if (gradientType == 2) {\n      amount = fract(atan(delta.y, delta.x) / 6.28318530718 + 0.5 + angleOffset);\n    } else {\n      amount = clamp(dot(delta, direction) + 0.5, 0.0, 1.0);\n    }\n    gl_FragColor = vec4(sampleGradient(amount), opacity);\n  }\n";

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

@@ -0,0 +1,19 @@
+export type ScreenGradientType = "linear" | "radial" | "angular";
+export type ScreenGradientStop = {
+    offset: number;
+    color: string;
+};
+export type ScreenGradientSettings = {
+    type: ScreenGradientType;
+    stops: ScreenGradientStop[];
+    angle: number;
+    center: {
+        x: number;
+        y: number;
+    };
+    radius: number;
+};
+export type ScreenGradientMaterialProps = {
+    value: ScreenGradientSettings;
+    opacity?: number;
+};

package/dist/components/ScreenImage/ScreenImage.d.ts

@@ -0,0 +1,4 @@
+import { default as defaultScreenImageUrl } from './assets/Default_square_image.png';
+import { ScreenImageProps } from './types';
+export declare function ScreenImage({ anchors, coordinateSpace, canvasSize, position, size, offsets, pivot, rotation, transform, onScreenTransformChange, transformGuideLayer, ...bodyProps }: ScreenImageProps): import("react/jsx-runtime").JSX.Element | null;
+export { defaultScreenImageUrl };

package/dist/components/ScreenImage/components/DynamicTextureSync.d.ts

@@ -0,0 +1,9 @@
+import type * as THREE from "three";
+export declare function DynamicTextureSync({ materialTexture, sourceTexture, onSourceSizeChange, }: {
+    materialTexture: THREE.Texture;
+    sourceTexture: THREE.Texture;
+    onSourceSizeChange: (size: {
+        width: number;
+        height: number;
+    }) => void;
+}): null;

package/dist/components/ScreenImage/components/ScreenImageBody.d.ts

@@ -0,0 +1,9 @@
+import { ScreenImageProps } from '../types';
+type ScreenImageBodyProps = Omit<ScreenImageProps, "anchors" | "coordinateSpace" | "canvasSize" | "position" | "size" | "offsets" | "pivot" | "transform"> & {
+    layoutSize?: {
+        width: number;
+        height: number;
+    };
+};
+export declare function ScreenImageBody({ name, source, src, fit, stretchMode, materialType, blendMode, backdropTexture: providedBackdropTexture, rotation, opacity, color, flipX, flipY, renderOrder, transparent, alphaTest, overlay, visible, layoutSize, }: ScreenImageBodyProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ScreenImage/components/ScreenImageFrame.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+import { ScreenAnchorEdges, ScreenOffsetEdges } from '../../ScreenSpaceUI';
+export declare function ScreenImageFrame({ anchors, offsets, pivot, rotation, children, }: {
+    anchors: ScreenAnchorEdges;
+    offsets: ScreenOffsetEdges;
+    pivot: [number, number];
+    rotation: number;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/ScreenImage/components/ScreenImageTransformFrame.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+import { ScreenTransformGuideLayer } from '../../ScreenSpaceUI';
+import { ScreenTransform2DSettings } from '../../../screen2d';
+export declare function ScreenImageTransformFrame({ transform, guideLayer, onChange, children, }: {
+    transform: ScreenTransform2DSettings;
+    guideLayer: ScreenTransformGuideLayer;
+    onChange?: (next: ScreenTransform2DSettings) => void;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/ScreenImage/fit.d.ts

@@ -0,0 +1,52 @@
+export type ScreenImageFit = "stretch" | "contain" | "cover";
+export type ScreenImageStretchMode = "fit" | "fitWidth" | "fitHeight" | "center" | "stretch" | "fill" | "fillAndCut";
+export type ScreenImageFittedRectInput = {
+    rectSize: {
+        width: number;
+        height: number;
+    };
+    textureSize?: {
+        width: number;
+        height: number;
+    };
+    textureAspect?: number;
+    stretchMode?: ScreenImageStretchMode;
+    fit?: ScreenImageFit;
+    flipX?: boolean;
+    flipY?: boolean;
+};
+export type ScreenImageFittedRect = {
+    rectAspect: number;
+    textureAspect: number;
+    scale: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+        height: number;
+    };
+    uvRepeat: {
+        x: number;
+        y: number;
+    };
+    uvOffset: {
+        x: number;
+        y: number;
+    };
+};
+export type ScreenImageFitResolution = {
+    meshScale: [number, number, number];
+    guideScale: [number, number, number];
+    repeat: [number, number];
+    offset: [number, number];
+};
+export declare const resolveScreenImageStretchMode: (stretchMode: ScreenImageStretchMode | undefined, fit: ScreenImageFit | undefined) => ScreenImageStretchMode;
+export declare const computeScreenImageFitResolution: (stretchMode: ScreenImageStretchMode, rectAspect: number, textureAspect: number, flipX: boolean, flipY: boolean, rectSize?: {
+    width: number;
+    height: number;
+}, textureSize?: {
+    width: number;
+    height: number;
+}) => ScreenImageFitResolution;
+export declare const computeScreenImageFittedRect: ({ rectSize, textureSize, textureAspect: providedTextureAspect, stretchMode, fit, flipX, flipY, }: ScreenImageFittedRectInput) => ScreenImageFittedRect;

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

@@ -0,0 +1,8 @@
+export { ScreenImage, defaultScreenImageUrl } from './ScreenImage';
+export { screenImageBlendModeOptions } from './utils/ScreenImageConstants';
+export { resolveBlendProps } from './materials/ScreenImageBlendMaterial';
+export type { ScreenImageBlendMode, ScreenImageMaterialType, ScreenImageProps } from './types';
+export type { ScreenImageSource } from './source';
+export { getScreenImageTextureAspect, getScreenImageTextureSize, resolveScreenImageSource, } from './source';
+export { computeScreenImageFitResolution, computeScreenImageFittedRect, resolveScreenImageStretchMode, } from './fit';
+export type { ScreenImageFit, ScreenImageFittedRect, ScreenImageFittedRectInput, ScreenImageStretchMode, } from './fit';

package/dist/components/ScreenImage/materials/ScreenImageBlendMaterial.d.ts

@@ -0,0 +1,9 @@
+import { ScreenImageBlendMode } from '../types';
+import * as THREE from "three";
+export declare const ADVANCED_BLEND_MODES: Set<ScreenImageBlendMode>;
+export type AdvancedBlendMode = Extract<ScreenImageBlendMode, "overlay" | "softLight" | "hardLight" | "difference" | "exclusion">;
+export declare const advancedBlendModeIndices: Record<AdvancedBlendMode, number>;
+export type BlendMaterialProps = Partial<Pick<THREE.Material, "blending" | "blendSrc" | "blendDst" | "blendEquation">>;
+export declare const resolveBlendProps: (mode: ScreenImageBlendMode) => BlendMaterialProps;
+export declare const advancedBlendVertexShader = "\nvarying vec2 vUv;\nvoid main(){vUv=uv;gl_Position=projectionMatrix*modelViewMatrix*vec4(position,1.0);}";
+export declare const advancedBlendFragmentShader = "\nuniform sampler2D imageMap;uniform sampler2D backdropMap;uniform vec2 resolution;\nuniform vec3 tint;uniform float opacity;uniform float alphaTest;uniform int blendMode;varying vec2 vUv;\nfloat overlayChannel(float b,float s){return b<.5?2.*b*s:1.-2.*(1.-b)*(1.-s);}\nfloat hardLightChannel(float b,float s){return s<.5?2.*b*s:1.-2.*(1.-b)*(1.-s);}\nfloat softLightChannel(float b,float s){return s<.5?b-(1.-2.*s)*b*(1.-b):b+(2.*s-1.)*(sqrt(max(b,0.))-b);}\nvec3 applyAdvancedBlend(vec3 b,vec3 s){\nif(blendMode==0)return vec3(overlayChannel(b.r,s.r),overlayChannel(b.g,s.g),overlayChannel(b.b,s.b));\nif(blendMode==1)return vec3(softLightChannel(b.r,s.r),softLightChannel(b.g,s.g),softLightChannel(b.b,s.b));\nif(blendMode==2)return vec3(hardLightChannel(b.r,s.r),hardLightChannel(b.g,s.g),hardLightChannel(b.b,s.b));\nif(blendMode==3)return abs(b-s);return b+s-2.*b*s;}\nvoid main(){vec4 image=texture2D(imageMap,vUv)*vec4(tint,opacity);if(image.a<=alphaTest)discard;\nvec2 uv=gl_FragCoord.xy/max(resolution,vec2(1.));vec3 base=texture2D(backdropMap,uv).rgb;\nvec3 mixed=applyAdvancedBlend(base,image.rgb);gl_FragColor=vec4(mix(base,mixed,image.a),1.);}";

package/dist/components/ScreenImage/materials/ScreenImageMatcap.d.ts

@@ -0,0 +1,3 @@
+import * as THREE from "three";
+/** Creates the internally owned procedural matcap used by ScreenImage. */
+export declare const createMatcapTexture: () => THREE.CanvasTexture;

package/dist/components/ScreenImage/source.d.ts

@@ -0,0 +1,16 @@
+import type * as THREE from "three";
+export type ScreenImageSource = {
+    kind: "default";
+} | {
+    kind: "image";
+    src: string;
+} | {
+    kind: "texture";
+    texture: THREE.Texture;
+};
+export declare const resolveScreenImageSource: (source: ScreenImageSource | undefined, src: string | undefined) => ScreenImageSource;
+export declare const getScreenImageTextureSize: (texture: THREE.Texture) => {
+    width: number;
+    height: number;
+};
+export declare const getScreenImageTextureAspect: (texture: THREE.Texture) => number;

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

@@ -0,0 +1,37 @@
+import { ScreenAnchorEdges, ScreenOffsetEdges, ScreenTransformGuideLayer } from '../ScreenSpaceUI';
+import { ScreenCanvasSize, ScreenCoordinateSpace, ScreenTransform2DSettings } from '../../screen2d';
+import { ScreenImageFit, ScreenImageStretchMode } from './fit';
+import { ScreenImageSource } from './source';
+import type * as THREE from "three";
+export type ScreenImageMaterialType = "unlit" | "standardPBR" | "matcap";
+export type ScreenImageBlendMode = "normal" | "add" | "subtract" | "multiply" | "screen" | "lighten" | "darken" | "overlay" | "softLight" | "hardLight" | "difference" | "exclusion";
+export type ScreenImageProps = {
+    name?: string;
+    source?: ScreenImageSource;
+    src?: string;
+    anchors?: ScreenAnchorEdges;
+    coordinateSpace?: ScreenCoordinateSpace;
+    canvasSize?: ScreenCanvasSize;
+    position?: [number, number];
+    size?: [number, number];
+    rotation?: number;
+    offsets?: ScreenOffsetEdges;
+    pivot?: [number, number];
+    transform?: Partial<ScreenTransform2DSettings>;
+    onScreenTransformChange?: (next: ScreenTransform2DSettings) => void;
+    transformGuideLayer?: ScreenTransformGuideLayer;
+    fit?: ScreenImageFit;
+    stretchMode?: ScreenImageStretchMode;
+    materialType?: ScreenImageMaterialType;
+    blendMode?: ScreenImageBlendMode;
+    backdropTexture?: THREE.Texture | null;
+    opacity?: number;
+    color?: THREE.ColorRepresentation;
+    flipX?: boolean;
+    flipY?: boolean;
+    renderOrder?: number;
+    transparent?: boolean;
+    alphaTest?: number;
+    overlay?: boolean;
+    visible?: boolean;
+};

package/dist/components/ScreenImage/utils/ScreenImageConstants.d.ts

@@ -0,0 +1,9 @@
+import { ScreenAnchorEdges, ScreenOffsetEdges } from '../../ScreenSpaceUI';
+import { ScreenImageBlendMode } from '../types';
+export declare const DEFAULT_SCREEN_IMAGE_ANCHORS: Required<ScreenAnchorEdges>;
+export declare const DEFAULT_SCREEN_IMAGE_OFFSET: ScreenOffsetEdges;
+export declare const DEFAULT_SCREEN_IMAGE_PIVOT: [number, number];
+export declare const screenImageBlendModeOptions: Array<{
+    label: string;
+    value: ScreenImageBlendMode;
+}>;

package/dist/components/ScreenImage/utils/ScreenImageHelpers.d.ts

@@ -0,0 +1,4 @@
+import { ScreenAnchorEdges } from '../../ScreenSpaceUI';
+import { ScreenCanvasSize, ScreenCoordinateSpace } from '../../../screen2d';
+export declare const toScreenTransformPivot: (pivot: [number, number]) => [number, number];
+export declare const resolveScreenImageAnchors: (anchors: ScreenAnchorEdges | undefined, coordinateSpace: ScreenCoordinateSpace | undefined, canvasSize: ScreenCanvasSize | undefined, position: [number, number] | undefined, size: [number, number] | undefined) => ScreenAnchorEdges;

package/dist/components/ScreenShape/geometry.d.ts

@@ -0,0 +1,5 @@
+import { ScreenShapeSettings } from './types';
+import * as THREE from "three";
+export type ScreenShapePoint = [number, number, number];
+export declare const buildScreenShapePath: (settings: ScreenShapeSettings) => ScreenShapePoint[];
+export declare const createScreenShapeFill: (points: ScreenShapePoint[]) => THREE.Shape;

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

@@ -0,0 +1,5 @@
+import { ScreenShapeProps, ScreenShapeSettings, ScreenShapeSettingsInput } from './types';
+export type { ScreenShapeKind, ScreenShapeProps, ScreenShapeSettings, ScreenShapeSettingsInput, } from './types';
+export declare const DEFAULT_SCREEN_SHAPE_SETTINGS: ScreenShapeSettings;
+export declare const mergeScreenShapeSettings: (settings?: ScreenShapeSettingsInput) => ScreenShapeSettings;
+export declare const ScreenShape: ({ name, onScreenTransformChange, renderOrder, settings: partialSettings, transform: partialTransform, transformGuideLayer, visible, }: ScreenShapeProps) => import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,41 @@
+import { ScreenTransformGuideLayer } from '../ScreenSpaceUI';
+import { ScreenTransform2DSettings } from '../../screen2d';
+import { ScreenGradientSettings } from '../ScreenGradient';
+import { ScreenGlassSettings } from '../ScreenGlass';
+export type ScreenShapeKind = "circle" | "ellipse" | "rectangle" | "roundedRectangle" | "polygon" | "star" | "line";
+export type ScreenShapeSettings = {
+    kind: ScreenShapeKind;
+    fillColor: string;
+    fillOpacity: number;
+    fillMode: "solid" | "gradient" | "glass";
+    gradient: ScreenGradientSettings;
+    glass: ScreenGlassSettings;
+    strokeColor: string;
+    strokeOpacity: number;
+    strokeWidth: number;
+    cornerRadius: number;
+    sides: number;
+    innerRadiusRatio: number;
+    dashed: boolean;
+    lineStart: {
+        x: number;
+        y: number;
+    };
+    lineEnd: {
+        x: number;
+        y: number;
+    };
+};
+export type ScreenShapeSettingsInput = Omit<Partial<ScreenShapeSettings>, "gradient" | "glass"> & {
+    gradient?: Partial<ScreenGradientSettings>;
+    glass?: Partial<ScreenGlassSettings>;
+};
+export type ScreenShapeProps = {
+    name?: string;
+    settings?: ScreenShapeSettingsInput;
+    transform?: Partial<ScreenTransform2DSettings>;
+    onScreenTransformChange?: (next: ScreenTransform2DSettings) => void;
+    transformGuideLayer?: ScreenTransformGuideLayer;
+    renderOrder?: number;
+    visible?: boolean;
+};

package/dist/components/ScreenSpaceUI/ScreenTransformGuide.d.ts

@@ -0,0 +1,15 @@
+import { ThreeEvent } from '@react-three/fiber';
+export type ScreenTransformControlHandle = "move" | "pivot" | "rotateTopLeft" | "rotateTopRight" | "rotateBottomLeft" | "rotateBottomRight" | "top" | "bottom" | "left" | "right" | "topLeft" | "topRight" | "bottomLeft" | "bottomRight";
+export type ScreenTransformGuideProps = {
+    color?: string;
+    controlScale?: [number, number, number];
+    handleColor?: string;
+    onHandlePointerDown?: (handle: ScreenTransformControlHandle, event: ThreeEvent<PointerEvent>) => void;
+    opacity?: number;
+    pivot?: [number, number];
+    pivotScale?: [number, number, number];
+    renderOrder?: number;
+    showSideHandles?: boolean;
+    thickness?: number;
+};
+export declare const ScreenTransformGuide: ({ color, controlScale, handleColor, onHandlePointerDown, opacity, pivot, pivotScale, renderOrder, showSideHandles, thickness, }: ScreenTransformGuideProps) => import("react/jsx-runtime").JSX.Element;