@bezlepkin/nativescript-ar/ar-common.d.ts

NativeScript Augmented Reality plugin. ARKit on iOS and (with the help of Sceneform) ARCore on Android.

import { Color, ImageSource, ContentView, EventData, View } from "@nativescript/core";
export declare type ARDebugLevel = "NONE" | "WORLD_ORIGIN" | "FEATURE_POINTS" | "PHYSICS_SHAPES";
export declare type ARTrackingMode = "WORLD" | "IMAGE" | "FACE";
export interface ARNode {
    id: string;
    position: ARPosition;
    scale?: number | ARScale;
    rotation?: ARRotation;
    ios?: any;
    android?: any;
    remove(): void;
}
export interface ARNodeInteraction {
    touchPosition: ARDimensions2D;
    node: ARCommonNode;
}
export interface ARCommonNode extends ARNode {
    draggingEnabled?: boolean;
    rotatingEnabled?: boolean;
    scalingEnabled?: boolean;
    moveTo?(to: ARPosition): void;
    moveBy?(by: ARPosition): void;
    rotateBy?(by: ARRotation, animated?: boolean): void;
    scaleBy?(by: number | ARScale): void;
    scaleTo?(to: number | ARScale): void;
    getPosition(): ARPosition;
    getWorldPosition(): ARPosition;
    setWorldPosition(to: ARPosition): void;
    getDistanceTo(otherPosition: ARPosition): number;
    onTap(touchPosition: ARDimensions2D): void;
    onLongPress(touchPosition: ARDimensions2D): void;
    onPan(touchPosition: ARDimensions2D): void;
    setVisible(visible: boolean): void;
    lookAtWorldPosition(worldPos: ARPosition): void;
    lookAtPosition(localPos: ARPosition): void;
    lookAtNode(node: ARCommonNode): void;
    getPositionOnScreen(): ARDimensions2D;
}
export interface ARVideoNode extends ARCommonNode {
    play(): void;
    pause(): void;
    isPlaying(): boolean;
}
export interface ARAddOptions {
    position: ARPosition;
    scale?: number | ARScale;
    rotation?: ARRotation;
    mass?: number;
    onTap?: (interaction: ARNodeInteraction) => void;
    onLongPress?: (interaction: ARNodeInteraction) => void;
    draggingEnabled?: boolean;
    rotatingEnabled?: boolean;
    scalingEnabled?: boolean;
    parentNode?: ARNode;
}
export declare type ARMaterialWrapMode = "Clamp" | "Repeat" | "ClampToBorder" | "Mirror";
export interface ARMaterialProperty {
    contents: string;
    wrapMode?: ARMaterialWrapMode;
}
export interface ARMaterial {
    diffuse?: string | Color | ARMaterialProperty;
    roughness?: string | Color | ARMaterialProperty;
    metalness?: string | Color | ARMaterialProperty;
    normal?: string | Color | ARMaterialProperty;
    specular?: string | Color | ARMaterialProperty;
    emission?: string | Color | ARMaterialProperty;
    transparency?: number;
    lightingModel?: "PHYSICALLY_BASED" | "CONSTANT";
}
export interface ARAddGeometryOptions extends ARAddOptions {
    materials?: Array<string | Color | ARMaterial>;
}
export interface ARUIViewOptions extends ARAddOptions {
    chamferRadius?: number;
    dimensions?: number | ARDimensions2D;
    view: View;
}
export interface ARAddImageOptions extends ARAddOptions {
    image: string | ImageSource;
    dimensions?: ARDimensions2D;
}
export interface ARAddModelOptions extends ARAddGeometryOptions {
    name: string;
    childNodeName?: string;
}
export interface ARAddVideoOptions extends ARAddOptions {
    video: any;
    loop?: boolean;
    play?: boolean;
    dimensions?: ARDimensions2D;
}
export interface ARAddBoxOptions extends ARAddGeometryOptions {
    dimensions: number | ARDimensions;
    chamferRadius?: number;
}
export interface ARAddPlaneOptions extends ARAddGeometryOptions {
    dimensions: number | ARDimensions2D;
}
export interface ARAddSphereOptions extends ARAddGeometryOptions {
    radius: number;
    segmentCount?: number;
}
export interface ARAddTextOptions extends ARAddGeometryOptions {
    text: string;
    depth?: number;
}
export interface ARAddTubeOptions extends ARAddGeometryOptions {
    innerRadius: number;
    outerRadius: number;
    height: number;
    radialSegmentCount?: number;
    heightSegmentCount?: number;
}
export interface ARPlane extends ARNode {
}
export interface AREventData extends EventData {
    object: AR;
}
export interface ARLoadedEventData extends AREventData {
    ios?: any;
    android?: any;
}
export interface ARPlaneTappedEventData extends AREventData {
    position: ARPosition;
}
export interface ARSceneTappedEventData extends AREventData {
    position: ARPosition;
}
export interface ARPlaneDetectedEventData extends AREventData {
    plane: ARPlane;
}
export interface ARTrackingImageDetectedEventData extends AREventData {
    position: ARPosition;
    size: ARSize;
    imageName: string;
    imageTrackingActions: ARImageTrackingActions;
}
export declare type ARTrackingFaceEventType = "FOUND" | "UPDATED" | "LOST";
export declare type ARPlaneDetectionOrientation = "NONE" | "HORIZONTAL" | "VERTICAL";
export interface ARTrackingFaceEventData extends AREventData {
    eventType: ARTrackingFaceEventType;
    properties?: {
        eyeBlinkLeft: number;
        eyeBlinkRight: number;
        jawOpen: number;
        lookAtPoint: ARPosition;
        mouthFunnel: number;
        mouthSmileLeft: number;
        mouthSmileRight: number;
        tongueOut: number;
    };
    faceTrackingActions?: ARFaceTrackingActions;
}
export interface ARFaceTrackingActions {
    addModel(options: ARAddModelOptions): Promise<ARCommonNode>;
    addText(options: ARAddTextOptions): Promise<ARCommonNode>;
    addUIView(options: ARUIViewOptions): Promise<ARCommonNode>;
}
export interface ARImageTrackingOptions {
    image: string;
    width?: number;
    name?: string;
    onDetectedImage?: (args: ARTrackingImageDetectedEventData) => void;
}
export interface ARImageTrackingActions {
    playVideo(url: string, loop?: boolean): void;
    stopVideoLoop(): void;
    addBox(options: ARAddBoxOptions): Promise<ARCommonNode>;
    addModel(options: ARAddModelOptions): Promise<ARCommonNode>;
    addImage(options: ARAddImageOptions): Promise<ARCommonNode>;
    addUIView(options: ARUIViewOptions): Promise<ARCommonNode>;
    addNode(options: ARAddOptions): Promise<ARCommonNode>;
}
export declare class ARDimensions {
    x: number;
    y: number;
    z: number;
    constructor(x: number, y: number, z: number);
}
export declare class ARDimensions2D {
    x: number;
    y: number;
    constructor(x: number, y: number);
}
export declare class ARSize {
    width: number;
    height: number;
    constructor(width: number, height: number);
}
export declare class ARScale extends ARDimensions {
}
export declare class ARPosition extends ARDimensions {
}
export declare class ARRotation extends ARDimensions {
}
export declare abstract class AR extends ContentView {
    static arLoadedEvent: string;
    static sceneTappedEvent: string;
    static planeDetectedEvent: string;
    static planeTappedEvent: string;
    static trackingImageDetectedEvent: string;
    static trackingFaceDetectedEvent: string;
    faceMaterial: string;
    planeMaterial: string;
    planeOpacity: number;
    planeDetection: ARPlaneDetectionOrientation;
    showStatistics: boolean;
    trackingMode: ARTrackingMode;
    trackingImagesBundle: string;
    static isSupported(): boolean;
    static isImageTrackingSupported(): boolean;
    static isFaceTrackingSupported(): boolean;
    abstract reset(): void;
    abstract addNode(options: ARAddOptions): Promise<ARCommonNode>;
    abstract addPlane(options: ARAddPlaneOptions): Promise<ARCommonNode>;
    abstract addModel(options: ARAddModelOptions): Promise<ARCommonNode>;
    abstract trackImage(options: ARImageTrackingOptions): void;
    abstract addVideo(options: ARAddVideoOptions): Promise<ARVideoNode>;
    abstract addImage(options: ARAddImageOptions): Promise<ARCommonNode>;
    abstract addBox(options: ARAddBoxOptions): Promise<ARCommonNode>;
    abstract addSphere(options: ARAddSphereOptions): Promise<ARCommonNode>;
    abstract addText(options: ARAddTextOptions): Promise<ARCommonNode>;
    abstract addTube(options: ARAddTubeOptions): Promise<ARCommonNode>;
    abstract addUIView(options: ARUIViewOptions): Promise<ARCommonNode>;
    abstract setPlaneDetection(to: ARPlaneDetectionOrientation): void;
    abstract toggleStatistics(on: boolean): void;
    abstract togglePlaneVisibility(on: boolean): void;
    abstract getCameraPosition(): ARPosition;
    abstract getCameraRotation(): ARRotation;
    abstract setDebugLevel(to: ARDebugLevel): void;
    abstract grabScreenshot(): Promise<ImageSource>;
    abstract startRecordingVideo(): Promise<boolean>;
    abstract stopRecordingVideo(): Promise<string>;
}