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

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

@@ -1,87 +1,8 @@
-import { ScreenAnchorEdges, ScreenOffsetEdges } from '../ScreenSpaceUI';
-import { ScreenCanvasSize, ScreenCoordinateSpace } from '../../screen2d';
-import { default as defaultScreenImageUrl } from './assets/Default_square_image.png';
-import * as THREE from "three";
-export type ScreenImageFit = "stretch" | "contain" | "cover";
-export type ScreenImageStretchMode = "fit" | "fitWidth" | "fitHeight" | "stretch" | "fill" | "fillAndCut";
-export type ScreenImageMaterialType = "unlit" | "standardPBR" | "matcap";
-export type ScreenImageBlendMode = "normal" | "add" | "subtract" | "multiply" | "screen" | "lighten" | "darken" | "overlay" | "softLight" | "hardLight" | "difference" | "exclusion";
-export type ScreenImageSource = {
-    kind: "default";
-} | {
-    kind: "image";
-    src: string;
-} | {
-    kind: "texture";
-    texture: THREE.Texture;
-};
-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];
-    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;
-    showFitGuides?: boolean;
-};
-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 declare const screenImageBlendModeOptions: Array<{
-    label: string;
-    value: ScreenImageBlendMode;
-}>;
-export declare const computeScreenImageFittedRect: ({ rectSize, textureSize, textureAspect: providedTextureAspect, stretchMode, fit, flipX, flipY, }: ScreenImageFittedRectInput) => ScreenImageFittedRect;
-export declare function ScreenImage({ anchors, coordinateSpace, canvasSize, position, size, offsets, pivot, rotation, ...bodyProps }: ScreenImageProps): import("react/jsx-runtime").JSX.Element;
-export { defaultScreenImageUrl };
+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,19 @@
+import type * as THREE from "three";
+export type ScreenImageSource = {
+    kind: "default";
+} | {
+    kind: "image";
+    src: string;
+} | {
+    kind: "gif";
+    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;

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

@@ -0,0 +1,9 @@
+import { ScreenTransform2DSettings } from '../../screen2d';
+export type ScreenTransformGuideLayer = "scene" | "overlay";
+export type ScreenTransformOverlayGuideProps = {
+    color?: string;
+    handleColor?: string;
+    onChange?: (next: ScreenTransform2DSettings) => void;
+    transform: ScreenTransform2DSettings;
+};
+export declare const ScreenTransformOverlayGuide: ({ color, handleColor, onChange, transform, }: ScreenTransformOverlayGuideProps) => null;

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

@@ -36,5 +36,7 @@ export type ScreenSpaceUIProps = {
  */
 export declare const ScreenSpaceUI: ({ children, depth }: ScreenSpaceUIProps) => import("react/jsx-runtime").JSX.Element;
 export { ScreenTransform } from './ScreenTransform';
+export { ScreenTransformGuide } from './ScreenTransformGuide';
+export { ScreenTransformOverlayGuide, type ScreenTransformGuideLayer, } from './ScreenTransformOverlayGuide';
 export type { ScreenTransformProps, ScreenAnchorEdges, ScreenOffsetEdges, ResolvedScreenTransform, } from './ScreenTransform';
 export { computeScreenTransform } from './ScreenTransform';

package/dist/components/ScreenText/components/ScreenTextBody.d.ts

@@ -0,0 +1,2 @@
+import { ScreenTextBodyProps } from '../types';
+export declare function ScreenTextBody(props: ScreenTextBodyProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ScreenText/components/ScreenTextTransformFrame.d.ts

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

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

@@ -0,0 +1,5 @@
+import { ScreenAnchorEdges } from '../ScreenSpaceUI';
+import { ScreenTextVerticalAlign } from './types';
+export declare const DEFAULT_SCREEN_TEXT_ASPECT = 2.5;
+export declare const SCREEN_TEXT_GUIDE_COLOR = "#38bdf8";
+export declare const SCREEN_TEXT_ANCHORS: Record<ScreenTextVerticalAlign, Required<ScreenAnchorEdges>>;

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

@@ -1,20 +1,6 @@
-import { ScreenAnchorEdges } from '../ScreenSpaceUI';
-import { TextLabelProps } from '../TextLabel';
-import { ScreenCanvasSize, ScreenCoordinateSpace, ScreenTransform2D } from '../../screen2d';
-export type ScreenTextVerticalAlign = "top" | "center" | "bottom";
-export type ScreenTextProps = Omit<TextLabelProps, "aspect" | "position" | "rotation" | "scale"> & {
-    anchors?: ScreenAnchorEdges;
-    coordinateSpace?: ScreenCoordinateSpace;
-    canvasSize?: ScreenCanvasSize;
-    offsets?: ScreenTransform2D["offsets"];
-    pivot?: [number, number];
-    position?: [number, number];
-    rotation?: number;
-    size?: [number, number];
-    transform?: ScreenTransform2D;
-    verticalAlign?: ScreenTextVerticalAlign;
-    showTransformGuides?: boolean;
-};
-export declare const SCREEN_TEXT_ANCHORS: Record<ScreenTextVerticalAlign, Required<ScreenAnchorEdges>>;
-export declare function resolveScreenTextAnchors(verticalAlign?: ScreenTextVerticalAlign): Required<ScreenAnchorEdges>;
-export declare function ScreenText({ anchors, coordinateSpace, canvasSize, offsets, pivot, position, rotation, size, transform, verticalAlign, ...textLabelProps }: ScreenTextProps): import("react/jsx-runtime").JSX.Element;
+import { ScreenTextProps } from './types';
+export { SCREEN_TEXT_ANCHORS } from './constants';
+export { resolveScreenTextAnchors } from './utils/ScreenTextHelpers';
+export { resolveScreenTextBendProps, resolveScreenTextLayoutTexture, } from './utils/ScreenTextMappings';
+export type { ScreenTextBendSettings, ScreenTextProps, ScreenTextVerticalAlign } from './types';
+export declare function ScreenText({ anchors, coordinateSpace, canvasSize, offsets, pivot, position, rotation, size, transform, screenTransform, onScreenTransformChange, transformGuideLayer, verticalAlign, ...textLabelProps }: ScreenTextProps): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,31 @@
+import { TextBendPreset, TextLabelProps } from '../TextLabel';
+import { ScreenAnchorEdges, ScreenTransformGuideLayer } from '../ScreenSpaceUI';
+import { ScreenCanvasSize, ScreenCoordinateSpace, ScreenTransform2D, ScreenTransform2DSettings } from '../../screen2d';
+export type ScreenTextVerticalAlign = "top" | "center" | "bottom";
+export type ScreenTextBendSettings = {
+    preset: TextBendPreset;
+    strength: number;
+};
+export type ScreenTextProps = Omit<TextLabelProps, "aspect" | "position" | "rotation" | "scale"> & {
+    anchors?: ScreenAnchorEdges;
+    coordinateSpace?: ScreenCoordinateSpace;
+    canvasSize?: ScreenCanvasSize;
+    offsets?: ScreenTransform2D["offsets"];
+    pivot?: [number, number];
+    position?: [number, number];
+    rotation?: number;
+    size?: [number, number];
+    transform?: ScreenTransform2D;
+    screenTransform?: Partial<ScreenTransform2DSettings>;
+    onScreenTransformChange?: (next: ScreenTransform2DSettings) => void;
+    transformGuideLayer?: ScreenTransformGuideLayer;
+    verticalAlign?: ScreenTextVerticalAlign;
+    bend?: ScreenTextBendSettings;
+    showTransformGuides?: boolean;
+};
+export type ScreenTextBodyProps = Omit<ScreenTextProps, "anchors" | "coordinateSpace" | "canvasSize" | "offsets" | "pivot" | "position" | "rotation" | "size" | "transform"> & {
+    layoutSize?: {
+        width: number;
+        height: number;
+    };
+};

package/dist/components/ScreenText/utils/ScreenTextHelpers.d.ts

@@ -0,0 +1,14 @@
+import { ScreenTextProps, ScreenTextVerticalAlign } from '../types';
+export declare function resolveScreenTextAnchors(verticalAlign?: ScreenTextVerticalAlign): Required<import('../..').ScreenAnchorEdges>;
+export declare function resolveScreenTextTransformProps({ anchors, coordinateSpace, canvasSize, position, size, transform, pivot, verticalAlign, }: Pick<ScreenTextProps, "anchors" | "coordinateSpace" | "canvasSize" | "position" | "size" | "transform" | "pivot"> & {
+    verticalAlign: ScreenTextVerticalAlign;
+}): {
+    resolvedAnchors: import('../..').ScreenAnchorEdges;
+    resolvedOffsets: {
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    } | undefined;
+    resolvedPivot: [number, number];
+};

package/dist/components/ScreenText/utils/ScreenTextMappings.d.ts

@@ -0,0 +1,17 @@
+import { TextBendPreset } from '../../TextLabel';
+import { ScreenTextBendSettings } from '../types';
+export declare function resolveScreenTextBendProps({ bend, bendPreset, bendStrength, }: {
+    bend?: ScreenTextBendSettings;
+    bendPreset?: TextBendPreset;
+    bendStrength?: number;
+}): {
+    bendPreset: TextBendPreset | undefined;
+    bendStrength: number | undefined;
+};
+export declare function resolveScreenTextLayoutTexture({ width, height, }: {
+    width: number;
+    height: number;
+}): {
+    aspect: number;
+    resolution: number;
+};

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

@@ -0,0 +1,6 @@
+export type SequentialRenderPassesProps = {
+    /** Camera layers in top-first/bottom-last hierarchy order. */
+    layers: number[];
+};
+/** Takes over R3F rendering and composes render-group layers sequentially. */
+export declare const SequentialRenderPasses: ({ layers }: SequentialRenderPassesProps) => null;