@zappar/zappar-cv 3.3.0-beta.1 → 3.4.0-beta.0

package/lib/gen/zappar.d.ts

@@ -96,7 +96,7 @@ export interface zappar {
     pipeline_camera_pose_with_attitude(o: zappar_pipeline_t, mirror: boolean): Float32Array;
     pipeline_camera_pose_with_origin(o: zappar_pipeline_t, pose: Float32Array): Float32Array;
     pipeline_camera_frame_user_data(o: zappar_pipeline_t): number;
-    pipeline_camera_frame_submit(o: zappar_pipeline_t, data: ArrayBuffer, width: number, height: number, user_data: number, camera_to_device_transform: Float32Array, camera_model: Float32Array, user_facing: boolean, timestampSeconds: number): void;
+    pipeline_camera_frame_submit(o: zappar_pipeline_t, data: ArrayBuffer, width: number, height: number, user_data: number, camera_to_device_transform: Float32Array, camera_model: Float32Array, user_facing: boolean, timestampMicroseconds: number): void;
     pipeline_camera_frame_camera_attitude(o: zappar_pipeline_t): Float32Array;
     pipeline_camera_frame_device_attitude(o: zappar_pipeline_t): Float32Array;
     pipeline_camera_frame_user_facing(o: zappar_pipeline_t): boolean;
@@ -107,6 +107,7 @@ export interface zappar {
     pipeline_motion_rotation_rate_submit_int(o: zappar_pipeline_t, time: number, interval: number, x: number, y: number, z: number): void;
     pipeline_motion_attitude_submit(o: zappar_pipeline_t, time: number, x: number, y: number, z: number): void;
     pipeline_motion_attitude_submit_int(o: zappar_pipeline_t, time: number, interval: number, x: number, y: number, z: number): void;
+    pipeline_motion_relative_orientation_submit_int(o: zappar_pipeline_t, time: number, interval: number, x: number, y: number, z: number, w: number): void;
     pipeline_motion_attitude_matrix_submit(o: zappar_pipeline_t, mat: Float32Array): void;
     pipeline_sequence_record_start(o: zappar_pipeline_t, expected_frames: number): void;
     pipeline_sequence_record_stop(o: zappar_pipeline_t): void;
@@ -218,6 +219,7 @@ export interface zappar {
     world_tracker_destroy(o: zappar_world_tracker_t): void;
     world_tracker_enabled(o: zappar_world_tracker_t): boolean;
     world_tracker_enabled_set(o: zappar_world_tracker_t, enabled: boolean): void;
+    world_tracker_session_number(o: zappar_world_tracker_t): number;
     world_tracker_quality(o: zappar_world_tracker_t): number;
     world_tracker_horizontal_plane_detection_enabled(o: zappar_world_tracker_t): boolean;
     world_tracker_horizontal_plane_detection_enabled_set(o: zappar_world_tracker_t, horizontal_plane_detection_enabled: boolean): void;

package/lib/html-element-source.js

@@ -87,7 +87,6 @@ export class HTMLElementSource extends Source {
         }
     }
     getFrame(currentlyProcessing) {
-        var _a;
         let pipeline = Pipeline.get(this._pipeline);
         if (!pipeline)
             return;
@@ -102,7 +101,8 @@ export class HTMLElementSource extends Source {
             let info = this._processFrame(gl, this._cameraToScreenRotation, currentlyProcessing);
             if (info) {
                 let token = pipeline.registerToken(info);
-                pipeline.sendDataToWorker(info.data || new ArrayBuffer(0), token, info.dataWidth, info.dataHeight, info.userFacing, info.cameraToDevice, info.cameraModel, (_a = this._frameTime) !== null && _a !== void 0 ? _a : performance.now());
+                // Use -1 for frame time for now since iOS accuracy is not good enough
+                pipeline.sendDataToWorker(info.data || new ArrayBuffer(0), token, info.dataWidth, info.dataHeight, info.userFacing, info.cameraToDevice, info.cameraModel, -1); // this._frameTime ?? (performance.now() * 1000));
                 info.data = undefined;
             }
         }
@@ -116,9 +116,8 @@ export class HTMLElementSource extends Source {
         if (!(video === null || video === void 0 ? void 0 : video.requestVideoFrameCallback))
             return;
         video.requestVideoFrameCallback((time, metadata) => {
-            var _a;
             if (typeof metadata === 'object')
-                this._frameTime = ((_a = metadata.captureTime) !== null && _a !== void 0 ? _a : -1) / 1000.0;
+                this._frameTime = metadata.captureTime ? metadata.captureTime * 1000.0 : undefined;
             if (typeof metadata === 'object' && typeof metadata.presentedFrames === 'number') {
                 if (this._lastPresentedFrames === metadata.presentedFrames) {
                     console.log('Avoided identical frame');

package/lib/index-standalone.js

@@ -1,5 +1,5 @@
 import { initialize as init } from "./index";
 export * from "./index";
 export function initialize(opts) {
-    return init(Object.assign(Object.assign({}, opts), { worker: (opts === null || opts === void 0 ? void 0 : opts.worker) || new (require("worker-loader?inline=fallback!./worker").default)(), ceresWorker: (opts === null || opts === void 0 ? void 0 : opts.ceresWorker) || new (require("worker-loader?inline=fallback&filename=zappar-cv-ceres.worker.js!./ceres-worker").default)() }));
+    return init(Object.assign(Object.assign({}, opts), { worker: (opts === null || opts === void 0 ? void 0 : opts.worker) || new (require("worker-loader?inline=fallback!./worker").default)(), ceresWorker0: (opts === null || opts === void 0 ? void 0 : opts.ceresWorker0) || new (require("worker-loader?inline=fallback&filename=zappar-cv-ceres.worker.js!./ceres-worker").default)(), ceresWorker1: (opts === null || opts === void 0 ? void 0 : opts.ceresWorker1) || new (require("worker-loader?inline=fallback&filename=zappar-cv-ceres.worker.js!./ceres-worker").default)() }));
 }

package/lib/mstp-camera-source.d.ts

@@ -14,6 +14,7 @@ export declare class MSTPCameraSource extends Source {
     private _accelerometer?;
     private _linearAcceleration?;
     private _gyroscope?;
+    private _relativeOrientation?;
     constructor(_impl: zappar_camera_source_t, _pipeline: zappar_pipeline_t, _deviceId: string);
     destroy(): void;
     private _stop;
@@ -36,6 +37,8 @@ export declare class MSTPCameraSource extends Source {
     private _linearAccelerationReading;
     private _lastGyroscopeReading;
     private _gyroscopeReading;
+    private _lastReleativeOrientationReading;
+    private _relativeOrientationReading;
     private _stopDeviceMotion;
     uploadGL(info: CameraFrameInfo): void;
 }

package/lib/mstp-camera-source.js

@@ -105,6 +105,19 @@ export class MSTPCameraSource extends Source {
             pipeline.motionRotationRateSubmit(timestamp, -this._gyroscope.x, -this._gyroscope.y, -this._gyroscope.z);
             pipeline.motionRotationRateSubmitInt(timestamp, interval, this._gyroscope.x * 180 / Math.PI, this._gyroscope.y * 180 / Math.PI, this._gyroscope.z * 180 / Math.PI);
         };
+        this._lastReleativeOrientationReading = -1;
+        this._relativeOrientationReading = () => {
+            var _a;
+            if (!this._relativeOrientation || this._relativeOrientation.quaternion === undefined)
+                return;
+            let pipeline = Pipeline.get(this._pipeline);
+            if (!pipeline)
+                return;
+            const timestamp = (_a = this._relativeOrientation.timestamp) !== null && _a !== void 0 ? _a : performance.now();
+            const interval = this._lastReleativeOrientationReading > -1 ? timestamp - this._lastReleativeOrientationReading : 30;
+            this._lastReleativeOrientationReading = timestamp;
+            pipeline.motionRelativeOrientationSubmitInt(timestamp, interval, this._relativeOrientation.quaternion[0], this._relativeOrientation.quaternion[1], this._relativeOrientation.quaternion[2], this._relativeOrientation.quaternion[3]);
+        };
         zcout("Using MSTP camera source");
     }
     destroy() {
@@ -275,6 +288,7 @@ export class MSTPCameraSource extends Source {
             this._accelerometer = new Accelerometer({ frequency: 60 });
             this._linearAcceleration = new LinearAccelerationSensor({ frequency: 60 });
             this._gyroscope = new Gyroscope({ frequency: 60 });
+            this._relativeOrientation = new RelativeOrientationSensor({ frequency: 60 });
             // throw new Error();
             this._accelerometer.addEventListener('reading', this._accelerometerReading);
             this._accelerometer.start();
@@ -282,6 +296,8 @@ export class MSTPCameraSource extends Source {
             this._linearAcceleration.start();
             this._gyroscope.addEventListener('reading', this._gyroscopeReading);
             this._gyroscope.start();
+            this._relativeOrientation.addEventListener('reading', this._relativeOrientationReading);
+            this._relativeOrientation.start();
         }
         catch (err) {
             window.addEventListener("devicemotion", this._deviceMotionListener, false);
@@ -303,6 +319,11 @@ export class MSTPCameraSource extends Source {
             this._gyroscope.removeEventListener('reading', this._gyroscopeReading);
             delete this._gyroscope;
         }
+        if (this._relativeOrientation) {
+            this._relativeOrientation.stop();
+            this._relativeOrientation.removeEventListener('reading', this._relativeOrientationReading);
+            delete this._relativeOrientation;
+        }
         window.removeEventListener("devicemotion", this._deviceMotionListener);
     }
     uploadGL(info) {

package/lib/native.js

@@ -12,7 +12,7 @@ import { zappar_client } from "./gen/zappar-client";
 import { drawPlane } from "./drawplane";
 import { cameraRotationForScreenOrientation, projectionMatrixFromModelAndSize } from "./cameramodel";
 import { mat4, vec3 } from "gl-matrix";
-import { launchCeresWorker, launchWorker, messageManager } from "./worker-client";
+import { launchCeresWorkers, launchWorker, messageManager } from "./worker-client";
 import { permissionRequestUI, permissionGrantedAll, permissionGrantedCamera, permissionGrantedMotion, permissionDeniedAny, permissionDeniedCamera, permissionDeniedMotion, permissionRequestMotion, permissionRequestCamera, permissionRequestAll, permissionDeniedUI } from "./permission";
 import { createFaceMesh, destroyFaceMesh, getFaceMesh } from "./facemesh";
 import { Pipeline, applyScreenCounterRotation } from "./pipeline";
@@ -111,7 +111,7 @@ export function initialize(opts) {
                 break;
             }
             case "setupCeresWorker": {
-                launchCeresWorker(msg.port, opts === null || opts === void 0 ? void 0 : opts.ceresWorker);
+                launchCeresWorkers(msg.port0, msg.port1, opts === null || opts === void 0 ? void 0 : opts.ceresWorker0, opts === null || opts === void 0 ? void 0 : opts.ceresWorker1);
                 break;
             }
             case "_z_datadownload": {
@@ -315,8 +315,17 @@ export function initialize(opts) {
                 zcwarn("attempting to call custom_anchor_pose_raw on a destroyed zappar_custom_anchor_t");
                 return mat4.create();
             }
-            if (entry.expectedPoseVersion <= client.custom_anchor_pose_version(o))
+            if (entry.sessionNumber < client.world_tracker_session_number(entry.wt)) {
+                // Anchor was set in a previous session, so equivalent to having been reset
+                // Status will be reported as STOPPED, report pose the same as world_anchor
+                const world_anchor_raw = client.world_tracker_world_anchor_pose_raw(entry.wt).slice();
+                return world_anchor_raw;
+            }
+            // Report underlying pose if version matches expectation
+            if (entry.expectedPoseVersion == client.custom_anchor_pose_version(o)) {
                 return wtImpl.custom_anchor_pose_raw(o);
+            }
+            // Use an offset from world anchor until the right pose version is reported
             const world_anchor_raw = client.world_tracker_world_anchor_pose_raw(entry.wt).slice();
             const ret = mat4.create();
             mat4.multiply(ret, world_anchor_raw, entry.poseRelativeToWorldAnchor);
@@ -327,10 +336,13 @@ export function initialize(opts) {
                 zcwarn("attempting to call custom_anchor_status on a destroyed zappar_custom_anchor_t");
                 return anchor_status_t.ANCHOR_STATUS_STOPPED;
             }
-            if (entry.expectedPoseVersion === 0)
+            if (entry.sessionNumber < client.world_tracker_session_number(entry.wt)) {
                 return anchor_status_t.ANCHOR_STATUS_STOPPED;
-            if (entry.expectedPoseVersion <= client.custom_anchor_pose_version(o))
+            }
+            // Underlying status if the version and session match 
+            if (entry.expectedPoseVersion == client.custom_anchor_pose_version(o)) {
                 return wtImpl.custom_anchor_status(o);
+            }
             return anchor_status_t.ANCHOR_STATUS_INITIALIZING;
         }, custom_anchor_pose_camera_relative: (o, mirror) => {
             let res = applyScreenCounterRotation(undefined, client.custom_anchor_pose_raw(o));
@@ -353,7 +365,7 @@ export function initialize(opts) {
             return res;
         }, custom_anchor_create: (p, wt, id) => {
             const ret = wtImpl.custom_anchor_create(p, wt, id);
-            customAnchors.set(ret, { id, wt, expectedPoseVersion: 0, poseRelativeToWorldAnchor: mat4.create() });
+            customAnchors.set(ret, { id, wt, sessionNumber: -1, expectedPoseVersion: 0, poseRelativeToWorldAnchor: mat4.create() });
             return ret;
         }, custom_anchor_id: (o) => {
             var _a;
@@ -525,6 +537,7 @@ export function initialize(opts) {
                 zcwarn("attempting to call custom_anchor_pose_set on a destroyed zappar_custom_anchor_t");
                 return;
             }
+            entry.sessionNumber = client.world_tracker_session_number(entry.wt);
             entry.expectedPoseVersion++;
             mat4.copy(entry.poseRelativeToWorldAnchor, pose);
             wtImpl.custom_anchor_pose_set(o, pose);
@@ -534,6 +547,7 @@ export function initialize(opts) {
                 zcwarn("attempting to call custom_anchor_pose_set_with_parent on a destroyed zappar_custom_anchor_t");
                 return;
             }
+            entry.sessionNumber = client.world_tracker_session_number(entry.wt);
             entry.expectedPoseVersion++;
             mat4.copy(entry.poseRelativeToWorldAnchor, pose);
             wtImpl.custom_anchor_pose_set_with_parent(o, pose, anchor_id);
@@ -865,14 +879,6 @@ export function initialize(opts) {
             const ret = wtImpl.world_tracker_create(pipeline);
             pipelineByWorldTracker.set(ret, pipeline);
             return ret;
-        }, world_tracker_reset: (wt) => {
-            for (const entry of customAnchors.values()) {
-                if (entry.wt === wt) {
-                    mat4.identity(entry.poseRelativeToWorldAnchor);
-                    entry.expectedPoseVersion = 0;
-                }
-            }
-            wtImpl.world_tracker_reset(wt);
         }, world_tracker_points_data_matrix: (wt, screenWidth, screenHeight, mirror) => {
             const pipeline = pipelineByWorldTracker.get(wt);
             if (pipeline === undefined || !client)

package/lib/options.d.ts

@@ -1,4 +1,5 @@
 export interface Options {
     worker?: Worker;
-    ceresWorker?: Worker;
+    ceresWorker0?: Worker;
+    ceresWorker1?: Worker;
 }

package/lib/pipeline.d.ts

@@ -75,6 +75,7 @@ export declare class Pipeline {
     motionAccelerometerWithGravitySubmitInt(timestamp: number, interval: number, x: number, y: number, z: number): void;
     motionRotationRateSubmitInt(timestamp: number, interval: number, x: number, y: number, z: number): void;
     motionAttitudeSubmitInt(timestamp: number, interval: number, x: number, y: number, z: number): void;
+    motionRelativeOrientationSubmitInt(timestamp: number, interval: number, x: number, y: number, z: number, w: number): void;
     motionRotationRateSubmit(timestamp: number, x: number, y: number, z: number): void;
     motionAttitudeSubmit(timestamp: number, x: number, y: number, z: number): void;
     motionAttitudeMatrix(m: Float32Array): void;

package/lib/pipeline.js

@@ -444,6 +444,19 @@ export class Pipeline {
         };
         this._mgr.postOutgoingMessage(msg, []);
     }
+    motionRelativeOrientationSubmitInt(timestamp, interval, x, y, z, w) {
+        var _a;
+        (_a = this._sequenceRecorder) === null || _a === void 0 ? void 0 : _a.appendAttitudeInt(timestamp, interval, x, y, z);
+        const msg = {
+            t: 'sensorDataC2S',
+            sensor: 'relative_orientation',
+            interval,
+            timestamp,
+            x, y, z, w,
+            p: this._impl
+        };
+        this._mgr.postOutgoingMessage(msg, []);
+    }
     motionRotationRateSubmit(timestamp, x, y, z) {
         var _a;
         if (!this._sequenceRecordDeviceAttitudeMatrices)

package/lib/profile.js

@@ -1,6 +1,5 @@
 import * as UAParser from "ua-parser-js";
 import { camera_profile_t } from "./gen/zappar-native";
-import { AndroidBridgeMessageHandler } from "./android-bridge-message-handler";
 export var EmbeddedVideoImplementation;
 (function (EmbeddedVideoImplementation) {
     EmbeddedVideoImplementation[EmbeddedVideoImplementation["OBJECT_URL"] = 0] = "OBJECT_URL";
@@ -16,7 +15,7 @@ export let profile = {
     videoHeight: 480,
     getDataSize: (p) => p === camera_profile_t.HIGH ? [640, 480] : [320, 240],
     videoElementInDOM: false,
-    preferMediaStreamTrackProcessorCamera: !AndroidBridgeMessageHandler.IsSupported(),
+    preferMediaStreamTrackProcessorCamera: false,
     preferImageBitmapCamera: false,
     ios164CameraSelection: false,
     relyOnConstraintsForCameraSelection: false,

package/lib/src/additional.d.ts

@@ -0,0 +1,49 @@
+import { CameraFrameData, CameraFrameDataRGB } from "./camera-frame-data";
+import { zappar_face_mesh_t, zappar_face_tracker_t, zappar_world_tracker_t, zappar_pipeline_t, zappar_image_tracker_t, zappar_sequence_source_t } from "./gen/zappar";
+export declare type zappar_html_element_source_t = number & {
+    _: 'zappar_html_element_source_t';
+};
+export interface PermissionRequestUIOptions {
+    title?: string;
+    description?: string;
+    button?: string;
+}
+export interface PermissionDeniedUIOptions {
+    title?: string;
+    descriptionIOS?: string;
+    descriptionChrome?: string;
+    description?: string;
+    button?: string;
+}
+export interface Additional {
+    pipeline_gl_context_set(pipeline: zappar_pipeline_t, gl: WebGLRenderingContext, texturePool?: WebGLTexture[]): void;
+    pipeline_gl_context_lost(pipeline: zappar_pipeline_t): void;
+    pipeline_draw_face(pipeline: zappar_pipeline_t, projectionMatrix: Float32Array, cameraMatrix: Float32Array, targetMatrix: Float32Array, o: zappar_face_mesh_t): void;
+    pipeline_draw_image_target_preview(pipeline: zappar_pipeline_t, projectionMatrix: Float32Array, cameraMatrix: Float32Array, targetMatrix: Float32Array, o: zappar_image_tracker_t, indx: number): void;
+    pipeline_draw_face_project(pipeline: zappar_pipeline_t, drawwMatrix: Float32Array, vertices: Float32Array, uvMatrix: Float32Array, uvs: Float32Array, indices: Uint16Array, texture: WebGLTexture): void;
+    pipeline_camera_frame_data_raw_enabled_set(pipeline: zappar_pipeline_t, enabled: boolean): void;
+    pipeline_camera_frame_data_raw(pipeline: zappar_pipeline_t): Promise<CameraFrameData | undefined>;
+    pipeline_camera_frame_data_rgb_enabled_set(pipeline: zappar_pipeline_t, enabled: boolean): void;
+    pipeline_camera_frame_data_rgb(pipeline: zappar_pipeline_t): CameraFrameDataRGB | undefined;
+    draw_plane(gl: WebGLRenderingContext, projectionMatrix: Float32Array, cameraMatrix: Float32Array, targetMatrix: Float32Array, texture: string): void;
+    draw_grid(gl: WebGLRenderingContext, projectionMatrix: Float32Array, cameraMatrix: Float32Array, targetMatrix: Float32Array): void;
+    draw_axis(gl: WebGLRenderingContext, projectionMatrix: Float32Array, cameraMatrix: Float32Array, targetMatrix: Float32Array): void;
+    image_tracker_target_image(o: zappar_image_tracker_t, indx: number): HTMLImageElement | undefined;
+    face_mesh_load_default(o: zappar_face_mesh_t): Promise<void>;
+    face_mesh_load_default_face(o: zappar_face_mesh_t, fillMouth: boolean, fillEyeL: boolean, fillEyeR: boolean): Promise<void>;
+    face_mesh_load_default_full_head_simplified(o: zappar_face_mesh_t, fillMouth: boolean, fillEyeL: boolean, fillEyeR: boolean, fillNeck: boolean): Promise<void>;
+    face_tracker_model_load_default(o: zappar_face_tracker_t): Promise<void>;
+    pipeline_camera_frame_draw_gl(pipeline: zappar_pipeline_t, screenWidth: number, screenHeight: number, mirror?: boolean): void;
+    permission_request_ui_promise(options?: PermissionRequestUIOptions): Promise<boolean>;
+    permission_denied_ui(options?: PermissionDeniedUIOptions): void;
+    html_element_source_create(pipeline: zappar_pipeline_t, element: HTMLVideoElement | HTMLImageElement): zappar_html_element_source_t;
+    html_element_source_start(o: zappar_html_element_source_t): void;
+    html_element_source_pause(o: zappar_html_element_source_t): void;
+    html_element_source_destroy(o: zappar_html_element_source_t): void;
+    browser_incompatible: () => boolean;
+    browser_incompatible_ui: () => void;
+    sequence_source_time_set: (o: zappar_sequence_source_t, ms: number) => void;
+    cookies_permitted: (p: boolean) => void;
+    world_tracker_points_data_matrix(wt: zappar_world_tracker_t, screenWidth: number, screenHeight: number, mirror: boolean): Float32Array;
+    in_app_clip: () => boolean;
+}

package/lib/src/android-bridge-message-handler.d.ts

@@ -0,0 +1,15 @@
+export declare class AndroidBridgeMessageHandler {
+    private _nativePort;
+    private _messageId;
+    private _replyResolvers;
+    private _queuedMessages;
+    static IsSupported(): boolean;
+    private static _instance;
+    static SharedInstance(): AndroidBridgeMessageHandler;
+    postMessage(message: string): Promise<any>;
+    private _processMessage;
+    private _processStringMessage;
+    private _processArrayBufferMessage;
+    private _initRequested;
+    private _initPort;
+}

package/lib/src/array-from-string.d.ts

@@ -0,0 +1,2 @@
+export declare function Uint16ArrayFromString(array: Uint16Array, str: string): void;
+export declare function ArrayBufferFromString(ab: ArrayBuffer, str: string): void;

package/lib/src/bridged-camera-source.d.ts

@@ -0,0 +1,53 @@
+import { camera_profile_t, zappar_camera_source_t, zappar_pipeline_t } from "./gen/zappar";
+import { CameraFrameInfo, Source } from "./source";
+import { zappar_custom_anchor_t } from "./gen/zappar-native";
+export interface BridgeOptions {
+    worldTracking?: boolean;
+    horizontalPlaneDetection?: boolean;
+    verticalPlaneDetection?: boolean;
+    tracksData?: boolean;
+    projectionsData?: boolean;
+    meshAnchors?: boolean;
+    d3?: boolean;
+    d3MaxResolution?: boolean;
+}
+export declare class BridgedCameraSource extends Source {
+    private _impl;
+    private _pipeline;
+    private _deviceId;
+    static DEFAULT_DEVICE_ID: string;
+    private _messageHandler;
+    private _isPaused;
+    private _cameraToScreenRotation;
+    private _cameraToDeviceTransform;
+    private _cameraModel;
+    private _profile;
+    private _textureSizes;
+    private _yuvConversion;
+    private _decodeBuffers;
+    private _options;
+    private static _resetCount;
+    private _isAndroid;
+    static IsSupported(): boolean;
+    constructor(_impl: zappar_camera_source_t, _pipeline: zappar_pipeline_t, _deviceId: string);
+    destroy(): void;
+    pause(): void;
+    start(): void;
+    getFrame(currentlyProcessing: boolean): void;
+    private _frameInFlight;
+    private _processFrame;
+    uploadGL(info: CameraFrameInfo): void;
+    recycle(info: CameraFrameInfo): void;
+    setProfile(p: camera_profile_t): void;
+    private _anchorPoseFloat32;
+    private _anchorPoseUint16;
+    setCustomAnchorPose(anchor: zappar_custom_anchor_t, pose_version: number, pose: Float32Array): void;
+    resetTracking(): void;
+    private _convertToBitmask;
+    optionsUpdated(options: BridgeOptions): void;
+    private _lastTimestamp;
+    private _deviceMotionListener;
+    private _deviceOrientationListener;
+    private _startDeviceMotion;
+    private _stopDeviceMotion;
+}

package/lib/src/bridged-d3-tracker.d.ts

@@ -0,0 +1,18 @@
+import { BridgeOptions } from "./bridged-camera-source";
+import { Pipeline } from "./pipeline";
+import { Zappar } from ".";
+export declare class BridgedD3Tracker {
+    static IsSupported(): boolean;
+    private static _sharedInstance;
+    static SharedInstance(): BridgedD3Tracker;
+    private _latestId;
+    private _d3StateById;
+    private _identityPose;
+    private _emptyArray;
+    private _getD3State;
+    private _getD3DataFromPipeline;
+    private _getD3Data;
+    private _notifyOptionsUpdated;
+    getCombinedOptionsForPipeline(p: Pipeline): BridgeOptions;
+    impl: Partial<Zappar>;
+}

package/lib/src/bridged-message-parser.d.ts

@@ -0,0 +1,12 @@
+import { BridgedMessage } from "./bridged-message";
+export declare const BridgeArrayBufferHeader_u32: number;
+export interface ParsedBridgeArrayBuffer {
+    replyID: number;
+    json: BridgedMessage;
+    uint8ArrayForBinaryBufferOffset: (offset: number, length: number) => Uint8Array;
+    uint32ArrayForBinaryBufferOffset: (offset: number, length: number) => Uint32Array;
+    floatArrayForBinaryBufferOffset: (offset: number, length: number) => Float32Array;
+}
+export declare function hasBridgeArrayBufferHeader(str: string): boolean;
+export declare function replyIdFromBridgeArrayBuffer(str: string): number;
+export declare function parseBridgeArrayBuffer(ab: ArrayBuffer): ParsedBridgeArrayBuffer | undefined;

package/lib/src/bridged-message.d.ts

@@ -0,0 +1,79 @@
+import { anchor_status_t, world_tracker_quality_t } from './gen/zappar-native';
+import { UvLayout } from './yuv-conversion-gl';
+export interface WTData {
+    session_number?: number;
+    world_anchor_status: anchor_status_t;
+    world_anchor_pose: Float32Array | number[];
+    ground_anchor_status: anchor_status_t;
+    ground_anchor_pose: Float32Array | number[];
+    plane_anchors: PlaneAnchorData[];
+    custom_anchors: CustomAnchorData[];
+    mesh_anchors: MeshAnchorData[];
+    quality: world_tracker_quality_t;
+}
+export interface PlaneAnchorData {
+    id: string;
+    horizontal: boolean;
+    status: anchor_status_t;
+    pose: Float32Array | number[];
+    boundary: Float32Array | number[];
+    boundaryVersion: number;
+}
+export interface CustomAnchorData {
+    id: number;
+    status: anchor_status_t;
+    pose: Float32Array | number[];
+    poseVersion: number;
+}
+export interface D3Data {
+    worldToCamera: Float32Array | number[];
+    detections: D3Detection[];
+}
+export interface D3Detection {
+    id: string;
+    type: number;
+    qr?: string;
+    dense?: number;
+    worldPoses: (Float32Array | number[])[];
+    landmarks: Float32Array | number[];
+    scale: number;
+}
+export interface MeshAnchorData {
+    id: string;
+    pose: Float32Array | number[];
+    status: anchor_status_t;
+    vertices: {
+        binaryOffset: number;
+        binaryLength: number;
+        offset: number;
+        stride: number;
+        count: number;
+        format: number;
+        componentsPerVector: number;
+    };
+    indices: {
+        binaryOffset: number;
+        binaryLength: number;
+        bytesPerIndex: number;
+        indexCountPerPrimitive: number;
+        count: number;
+        primitiveType: number;
+    };
+}
+export interface BridgedMessage {
+    frameNo: number;
+    cameraModel: Float32Array | [number, number, number, number, number, number];
+    dataWidth: number;
+    dataHeight: number;
+    dataBinaryBufferOffset: number;
+    dataBinaryBufferLength: number;
+    yWidth: number;
+    yHeight: number;
+    uvWidth: number;
+    uvHeight: number;
+    uvLayout?: UvLayout;
+    previewBinaryBufferOffset: number;
+    previewBinaryBufferLength: number;
+    wtData: WTData;
+    d3Data?: D3Data;
+}

package/lib/src/bridged-world-tracker.d.ts

@@ -0,0 +1,21 @@
+import { Zappar } from ".";
+import { BridgeOptions } from "./bridged-camera-source";
+import { Pipeline } from "./pipeline";
+export declare class BridgedWorldTracker {
+    static IsSupported(): boolean;
+    private static _sharedInstance;
+    static SharedInstance(): BridgedWorldTracker;
+    private _latestId;
+    private _wtStateById;
+    private _anchorStateById;
+    private _identityPose;
+    private _emptyArray;
+    private _getWtState;
+    private _getAnchorState;
+    private _getWtDataFromPipeline;
+    private _getWtData;
+    private _getFrameData;
+    private _notifyOptionsUpdated;
+    getCombinedOptionsForPipeline(p: Pipeline): BridgeOptions;
+    impl: Partial<Zappar>;
+}

package/lib/src/camera-frame-data.d.ts

@@ -0,0 +1,10 @@
+export interface BaseFrameData {
+    width: number;
+    height: number;
+}
+export interface CameraFrameData extends BaseFrameData {
+    data: ArrayBuffer;
+}
+export interface CameraFrameDataRGB extends BaseFrameData {
+    frame: ImageBitmap | any | ImageData;
+}

package/lib/src/camera-source-map.d.ts

@@ -0,0 +1,11 @@
+import { BridgedCameraSource } from "./bridged-camera-source";
+import { CameraSource } from "./camera-source";
+import { zappar_camera_source_t, zappar_pipeline_t } from "./gen/zappar";
+import { ImageBitmapCameraSource } from "./imagebitmap-camera-source";
+import { MSTPCameraSource } from "./mstp-camera-source";
+export declare type CameraSourceType = CameraSource | MSTPCameraSource | ImageBitmapCameraSource | BridgedCameraSource;
+export declare function getNextCameraSourceId(): zappar_camera_source_t;
+export declare function setCameraSourceId(id: zappar_camera_source_t, c: CameraSourceType): void;
+export declare function getCameraSource(id: zappar_camera_source_t): CameraSourceType | undefined;
+export declare function deleteCameraSource(id: zappar_camera_source_t): void;
+export declare function createCameraSource(p: zappar_pipeline_t, deviceId: string): zappar_camera_source_t;

package/lib/src/camera-source.d.ts

@@ -0,0 +1,28 @@
+import { zappar_camera_source_t, zappar_pipeline_t } from "./gen/zappar";
+import { HTMLElementSource } from "./html-element-source";
+export declare class CameraSource extends HTMLElementSource {
+    private _impl;
+    private _deviceId;
+    static USER_DEFAULT_DEVICE_ID: string;
+    static DEFAULT_DEVICE_ID: string;
+    private _currentStream;
+    private _activeDeviceId;
+    private _explicitUserCameraId;
+    private _explicitEnvironmentCameraId;
+    constructor(_impl: zappar_camera_source_t, pipeline: zappar_pipeline_t, _deviceId: string);
+    destroy(): void;
+    private _stop;
+    pause(): void;
+    start(): void;
+    private _getConstraints;
+    getFrame(allowRead: boolean): void;
+    private _getUserMedia;
+    private _syncCamera;
+    private _hasStartedOrientation;
+    private _lastTimestamp;
+    private _deviceMotionListener;
+    private _deviceOrientationListener;
+    private _startDeviceOrientation;
+    private _startDeviceMotion;
+    private _stopDeviceMotion;
+}

package/lib/src/cameramodel.d.ts

@@ -0,0 +1,2 @@
+export declare function projectionMatrixFromModelAndSize(params: Float32Array, cameraDataWidth: number, cameraDataHeight: number, screenWidth: number, screenHeight: number, near?: number, far?: number): Float32Array;
+export declare function cameraRotationForScreenOrientation(isUserFacing: boolean): number;

package/lib/src/ceres-worker.d.ts

@@ -0,0 +1 @@
+export declare function launchCeresWorker(wasmUrl: string, module: WebAssembly.Module, port: MessagePort, instance: number): Promise<void>;

package/lib/src/compatibility.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    incompatible: () => boolean;
+    incompatible_ui: () => void;
+};
+export default _default;

package/lib/src/data-download.d.ts

@@ -0,0 +1,8 @@
+import type * as ZNM from "./zappar-cv";
+export interface DataDownloadAPI {
+    data_download_clear: () => void;
+    data_download_size: () => number;
+    data_download: () => number;
+    data_should_record_set: (v: number) => void;
+}
+export declare function getDataDownloadAPI(mod: ZNM.Module): DataDownloadAPI;