@zappar/zappar-cv 3.6.0 → 3.7.0

package/README.md

@@ -18,8 +18,8 @@ npm i @zappar/zappar-cv
 
 You can use our CDN from within your HTML:
 ```
-<script src="https://libs.zappar.com/zappar-cv/3.6.0/zappar-cv.js"></script>
+<script src="https://libs.zappar.com/zappar-cv/3.7.0/zappar-cv.js"></script>
 ```
 
 Or you can download and host our standalone JavaScript bundle:
-[https://libs.zappar.com/zappar-cv/3.6.0/zappar-cv.zip](https://libs.zappar.com/zappar-cv/3.6.0/zappar-cv.zip)
+[https://libs.zappar.com/zappar-cv/3.7.0/zappar-cv.zip](https://libs.zappar.com/zappar-cv/3.7.0/zappar-cv.zip)

package/lib/additional.d.ts

@@ -7,6 +7,7 @@ export interface PermissionRequestUIOptions {
     title?: string;
     description?: string;
     button?: string;
+    ignoreUserActivation?: boolean;
 }
 export interface PermissionDeniedUIOptions {
     title?: string;

package/lib/bridged-world-tracker.js

@@ -1,5 +1,5 @@
 import { BridgedCameraSource } from "./bridged-camera-source";
-import { anchor_status_t, plane_orientation_t } from "./gen/zappar";
+import { anchor_status_t, plane_orientation_t, world_scale_mode_t } from "./gen/zappar";
 import { Pipeline } from "./pipeline";
 const _emptyUint8Array = new Uint8Array(0);
 export class BridgedWorldTracker {
@@ -217,6 +217,13 @@ export class BridgedWorldTracker {
                 let s = this._getWtState(o);
                 return this._emptyArray;
             },
+            world_tracker_scale_mode_set: (o, mode) => {
+                // Stub - no-op
+            },
+            world_tracker_scale_mode: (o) => {
+                // Stub - no-op
+                return world_scale_mode_t.DEFAULT;
+            },
             // #### custom_anchor ####
             custom_anchor_create: (pipeline, worldtracker, id) => {
                 let newId = (this._latestId++);

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

@@ -3,9 +3,10 @@ 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;
+import { WebXRCameraSource } from "./webxr-camera-source";
+export declare type CameraSourceType = CameraSource | MSTPCameraSource | ImageBitmapCameraSource | BridgedCameraSource | WebXRCameraSource;
 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;
+export declare function createCameraSource(p: zappar_pipeline_t, deviceId: string, preferWebXrCamera?: boolean): zappar_camera_source_t;

package/lib/camera-source-map.js

@@ -4,6 +4,7 @@ import { ImageBitmapCameraSource } from "./imagebitmap-camera-source";
 import { zcout } from "./loglevel";
 import { MSTPCameraSource } from "./mstp-camera-source";
 import { profile } from "./profile";
+import { WebXRCameraSource } from "./webxr-camera-source";
 let latest = 1;
 let byId = new Map();
 export function getNextCameraSourceId() {
@@ -18,9 +19,11 @@ export function getCameraSource(id) {
 export function deleteCameraSource(id) {
     byId.delete(id);
 }
-export function createCameraSource(p, deviceId) {
+export function createCameraSource(p, deviceId, preferWebXrCamera) {
     let ret = getNextCameraSourceId();
-    if (BridgedCameraSource.IsSupported() && deviceId === CameraSource.DEFAULT_DEVICE_ID)
+    if (preferWebXrCamera && WebXRCameraSource.IsSupported() && deviceId === CameraSource.DEFAULT_DEVICE_ID)
+        setCameraSourceId(ret, new WebXRCameraSource(ret, p));
+    else if (BridgedCameraSource.IsSupported() && deviceId === CameraSource.DEFAULT_DEVICE_ID)
         setCameraSourceId(ret, new BridgedCameraSource(ret, p, deviceId));
     else if (profile.preferMediaStreamTrackProcessorCamera &&
         'MediaStreamTrackProcessor' in window &&

package/lib/image-blit-gl.d.ts

@@ -0,0 +1,16 @@
+export declare class ImageBlitGl {
+    private _gl;
+    private _sharedContext;
+    private _isWebGL2;
+    private _instancedArraysExtension;
+    private _program;
+    private _vertexBuffer;
+    constructor(_gl: WebGL2RenderingContext | WebGLRenderingContext, _sharedContext?: boolean);
+    resetGLContext(): void;
+    destroy(): void;
+    doBlit(): void;
+    private _getVertexAttribState;
+    private _resetVertexAttribState;
+    private _setGlobalState;
+    private _prepareContext;
+}

package/lib/image-blit-gl.js

@@ -0,0 +1,212 @@
+import { compileShader, linkProgram } from "./shader";
+import { zcout } from "./loglevel";
+import { getSharedTracer } from "./tracing/sharedtracer";
+// Some no-op tracing helpers for concise code and good dead code removal in bundlers
+let tracer = null;
+let traceStart = (name) => { };
+let traceEnd = () => { };
+if (!(typeof Z_TRACING)) {
+    tracer = getSharedTracer();
+    traceStart = (name) => { tracer.start(name); };
+    traceEnd = () => { tracer.end(); };
+}
+export class ImageBlitGl {
+    // If _sharedContext is true we will assert the required state
+    // before each draw and reset previous state when complete
+    constructor(_gl, _sharedContext = true) {
+        this._gl = _gl;
+        this._sharedContext = _sharedContext;
+        this._isWebGL2 = false;
+        this._program = null;
+        this._vertexBuffer = null;
+        this._isWebGL2 = _gl.getParameter(_gl.VERSION).indexOf("WebGL 2") >= 0;
+        if (!this._isWebGL2) {
+            this._instancedArraysExtension = this._gl.getExtension("ANGLE_instanced_arrays");
+        }
+    }
+    resetGLContext() {
+        this._program = null;
+        this._vertexBuffer = null;
+    }
+    destroy() {
+        this.resetGLContext();
+    }
+    doBlit() {
+        var _a;
+        const gl = this._gl;
+        const gl2 = gl; // Must check _isWebGL2 before use
+        let previousState;
+        if (this._sharedContext) {
+            previousState = {
+                enabledScissorTest: gl.isEnabled(gl.SCISSOR_TEST),
+                enabledDepthTest: gl.isEnabled(gl.DEPTH_TEST),
+                enabledBlend: gl.isEnabled(gl.BLEND),
+                enabledCullFace: gl.isEnabled(gl.CULL_FACE),
+                enabledStencilTest: gl.isEnabled(gl.STENCIL_TEST),
+                program: gl.getParameter(gl.CURRENT_PROGRAM),
+                boundArrayBuffer: gl.getParameter(gl.ARRAY_BUFFER_BINDING),
+                posAttribState: this._getVertexAttribState(gl, 0)
+            };
+        }
+        // We've stored all the GL state we will need to restore, so this is the
+        // first moment we can initialize our WebGL objects safely
+        if (!this._program)
+            this._prepareContext();
+        if (!this._program || !this._vertexBuffer) {
+            // Didn't fully initialize our WebGL objects, bail out but reset the bits we may have changed
+            if (this._sharedContext && previousState) {
+                this._resetVertexAttribState(gl, 0, previousState.posAttribState);
+                gl.bindBuffer(gl.ARRAY_BUFFER, previousState.boundArrayBuffer);
+                gl.useProgram(previousState.program);
+            }
+            return;
+        }
+        if (this._sharedContext) {
+            // This state is initially set in _prepareContext so we
+            // only need to reset it if _sharedContext is true
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._vertexBuffer);
+            gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+            if (this._isWebGL2) {
+                gl2.vertexAttribDivisor(0, 0);
+            }
+            else {
+                (_a = this._instancedArraysExtension) === null || _a === void 0 ? void 0 : _a.vertexAttribDivisorANGLE(0, 0);
+            }
+            gl.enableVertexAttribArray(0);
+            this._setGlobalState(gl);
+            gl.useProgram(this._program);
+        }
+        // Do the drawing...
+        gl.clear(gl.COLOR_BUFFER_BIT);
+        gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+        // Reset the state
+        if (this._sharedContext && previousState) {
+            if (previousState.enabledBlend)
+                gl.enable(gl.BLEND);
+            if (previousState.enabledCullFace)
+                gl.enable(gl.CULL_FACE);
+            if (previousState.enabledDepthTest)
+                gl.enable(gl.DEPTH_TEST);
+            if (previousState.enabledScissorTest)
+                gl.enable(gl.SCISSOR_TEST);
+            if (previousState.enabledStencilTest)
+                gl.enable(gl.STENCIL_TEST);
+            this._resetVertexAttribState(gl, 0, previousState.posAttribState);
+            gl.bindBuffer(gl.ARRAY_BUFFER, previousState.boundArrayBuffer);
+            gl.useProgram(previousState.program);
+        }
+    }
+    _getVertexAttribState(gl, index) {
+        let divisor = 0;
+        if (this._isWebGL2) {
+            traceStart("getWebGL2Divisor");
+            divisor = gl.getVertexAttrib(index, gl.VERTEX_ATTRIB_ARRAY_DIVISOR);
+            traceEnd();
+        }
+        else if (this._instancedArraysExtension) {
+            traceStart("getExtDivisor");
+            divisor = gl.getVertexAttrib(index, this._instancedArraysExtension.VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE);
+            traceEnd();
+        }
+        return {
+            size: gl.getVertexAttrib(index, gl.VERTEX_ATTRIB_ARRAY_SIZE),
+            type: gl.getVertexAttrib(index, gl.VERTEX_ATTRIB_ARRAY_TYPE),
+            normalized: gl.getVertexAttrib(index, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED),
+            stride: gl.getVertexAttrib(index, gl.VERTEX_ATTRIB_ARRAY_STRIDE),
+            offset: gl.getVertexAttribOffset(index, gl.VERTEX_ATTRIB_ARRAY_POINTER),
+            bufferBinding: gl.getVertexAttrib(index, gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING),
+            enabled: gl.getVertexAttrib(index, gl.VERTEX_ATTRIB_ARRAY_ENABLED),
+            divisor
+        };
+    }
+    _resetVertexAttribState(gl, index, state) {
+        gl.bindBuffer(gl.ARRAY_BUFFER, state.bufferBinding);
+        gl.vertexAttribPointer(index, state.size, state.type, state.normalized, state.stride, state.offset);
+        if (state.divisor != 0) {
+            if (this._isWebGL2) {
+                gl.vertexAttribDivisor(index, state.divisor);
+            }
+            else if (this._instancedArraysExtension) {
+                this._instancedArraysExtension.vertexAttribDivisorANGLE(index, state.divisor);
+            }
+        }
+        if (!state.enabled)
+            gl.disableVertexAttribArray(index);
+    }
+    _setGlobalState(gl) {
+        gl.disable(gl.SCISSOR_TEST);
+        gl.disable(gl.DEPTH_TEST);
+        gl.disable(gl.BLEND);
+        gl.disable(gl.CULL_FACE);
+        gl.disable(gl.STENCIL_TEST);
+    }
+    _prepareContext() {
+        var _a;
+        const gl = this._gl;
+        gl.clearColor(0.5, 0.5, 1.0, 1.0);
+        let vertexData = new Float32Array([
+            -1.0, -1.0,
+            -1.0, 1.0,
+            1.0, -1.0,
+            1.0, 1.0
+        ]);
+        this._vertexBuffer = gl.createBuffer();
+        if (!this._vertexBuffer) {
+            zcout("Couldn't create vertex buffer");
+            return;
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._vertexBuffer);
+        gl.bufferData(gl.ARRAY_BUFFER, vertexData, gl.STATIC_DRAW);
+        gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+        if (this._isWebGL2) {
+            gl.vertexAttribDivisor(0, 0);
+        }
+        else {
+            (_a = this._instancedArraysExtension) === null || _a === void 0 ? void 0 : _a.vertexAttribDivisorANGLE(0, 0);
+        }
+        gl.enableVertexAttribArray(0);
+        let err = gl.getError();
+        if (err != gl.NO_ERROR) {
+            zcout(`Error setting up vertex buffer in ImageBlitGl::_prepareContext(): 0x${err.toString(16)}`);
+            return;
+        }
+        ;
+        const program = gl.createProgram();
+        if (!program) {
+            zcout("Couldn't create program");
+            return;
+        }
+        const blitVsSource = `
+            attribute vec4 aPosition;
+            varying highp vec2 vUV;
+
+            void main(void) {
+              gl_Position = aPosition;
+              vUV = 0.5 * (aPosition.xy + vec2(1.0, 1.0));
+            }
+        `;
+        const blitFsSource = `
+          varying highp vec2 vUV;
+          uniform sampler2D uTexture;
+
+          void main(void) {
+            gl_FragColor = texture2D(uTexture, vUV);
+          }
+        `;
+        let vertexShader = compileShader(gl, gl.VERTEX_SHADER, blitVsSource);
+        let fragmentShader = compileShader(gl, gl.FRAGMENT_SHADER, blitFsSource);
+        gl.attachShader(program, vertexShader);
+        gl.attachShader(program, fragmentShader);
+        gl.bindAttribLocation(program, 0, "aPosition");
+        linkProgram(gl, program);
+        let uTextureLoc = gl.getUniformLocation(program, "uTexture");
+        gl.useProgram(program);
+        gl.uniform1i(uTextureLoc, 0);
+        err = gl.getError();
+        if (err != gl.NO_ERROR) {
+            zcout(`Error in ImageBlitGl::_prepareContext(): 0x${err.toString(16)}`);
+        }
+        this._program = program;
+        this._setGlobalState(gl);
+    }
+}

package/lib/image-process-gl.d.ts

@@ -30,7 +30,9 @@ export declare class ImageProcessGL {
     resetGLContext(): void;
     destroy(): void;
     uploadFrame(texture: WebGLTexture, img: HTMLVideoElement | HTMLImageElement | ImageBitmap, rotation: number, fc: boolean, cp: camera_profile_t): void;
+    uploadFrameForSize(texture: WebGLTexture, img: HTMLVideoElement | HTMLImageElement | ImageBitmap, rotation: number, fc: boolean, dataWidth: number, dataHeight: number): void;
     readFrame(texture: WebGLTexture, pixels: ArrayBuffer, cp: camera_profile_t): ProcessedFrame;
+    readFrameForSize(texture: WebGLTexture, pixels: ArrayBuffer, dataWidth: number, dataHeight: number): ProcessedFrame;
     private _updateTransforms;
     private _getCameraUvTransform;
     private _getFramebuffer;

package/lib/image-process-gl.js

@@ -34,6 +34,10 @@ export class ImageProcessGL {
         this.resetGLContext();
     }
     uploadFrame(texture, img, rotation, fc, cp) {
+        const [dataWidth, dataHeight] = profile.getDataSize(cp);
+        this.uploadFrameForSize(texture, img, rotation, fc, dataWidth, dataHeight);
+    }
+    uploadFrameForSize(texture, img, rotation, fc, dataWidth, dataHeight) {
         let gl = this._gl;
         const glStateManager = GLStateManager.get(gl);
         glStateManager.push();
@@ -75,7 +79,6 @@ export class ImageProcessGL {
         if (videoHeight > videoWidth)
             videoHeight = [videoWidth, videoWidth = videoHeight][0];
         this._updateTransforms(rotation, fc);
-        const [dataWidth, dataHeight] = profile.getDataSize(cp);
         let framebuffer = this._getFramebuffer(gl, dataWidth / 4, dataHeight);
         let vbo = this._getVertexBuffer(gl);
         let ibo = this._getIndexBuffer(gl);
@@ -169,10 +172,13 @@ export class ImageProcessGL {
             gl.enable(gl.STENCIL_TEST);
     }
     readFrame(texture, pixels, cp) {
+        const [dataWidth, dataHeight] = profile.getDataSize(cp);
+        return this.readFrameForSize(texture, pixels, dataWidth, dataHeight);
+    }
+    readFrameForSize(texture, pixels, dataWidth, dataHeight) {
         let gl = this._gl;
         let pixelsView = new Uint8Array(pixels);
         const previousBoundFramebuffer = gl.getParameter(gl.FRAMEBUFFER_BINDING);
-        const [dataWidth, dataHeight] = profile.getDataSize(cp);
         let framebuffer = this._getFramebuffer(gl, dataWidth / 4, dataHeight);
         gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
         gl.readPixels(0, 0, this._framebufferWidth, this._framebufferHeight, gl.RGBA, gl.UNSIGNED_BYTE, pixelsView);

package/lib/native.js

@@ -13,7 +13,7 @@ import { drawPlane } from "./drawplane";
 import { cameraRotationForScreenOrientation, projectionMatrixFromModelAndSize } from "./cameramodel";
 import { mat4, vec3 } from "gl-matrix";
 import { launchCeresWorkers, launchWorker, messageManager } from "./worker-client";
-import { permissionRequestUI, permissionGrantedAll, permissionGrantedCamera, permissionGrantedMotion, permissionDeniedAny, permissionDeniedCamera, permissionDeniedMotion, permissionRequestMotion, permissionRequestCamera, permissionRequestAll, permissionDeniedUI } from "./permission";
+import { permissionRequestUI, permissionGrantedAll, permissionGrantedCamera, permissionGrantedMotion, permissionDeniedAny, permissionDeniedCamera, permissionDeniedMotion, permissionRequestMotion, permissionRequestCamera, permissionRequestAll, permissionDeniedUI, setWebXRSupported } from "./permission";
 import { createFaceMesh, destroyFaceMesh, getFaceMesh } from "./facemesh";
 import { Pipeline, applyScreenCounterRotation } from "./pipeline";
 import { CameraSource } from "./camera-source";
@@ -32,6 +32,8 @@ import { drawAxis } from "./drawaxis";
 import { BridgedWorldTracker } from "./bridged-world-tracker";
 import { BridgedD3Tracker } from "./bridged-d3-tracker";
 import { BridgedCameraSource } from "./bridged-camera-source";
+import { WebXRCameraSource } from "./webxr-camera-source";
+import { WebXRWorldTracker } from "./webxr-world-tracker";
 let client;
 const pipelineByWorldTracker = new Map();
 const _temporaryMatrix = mat4.create();
@@ -52,6 +54,12 @@ export function initialize(opts) {
     });
     const uid = getUID();
     let hasPersistedUID = false;
+    let preferWebXRCamera = window.location.href.indexOf("_webxrcamera") >= 0;
+    if ((opts === null || opts === void 0 ? void 0 : opts.preferWebXRCamera) !== undefined)
+        preferWebXRCamera = opts.preferWebXRCamera;
+    if (preferWebXRCamera && WebXRCameraSource.IsSupported()) {
+        setWebXRSupported(true);
+    }
     let hasSetID = false;
     try {
         /** @ts-ignore */
@@ -173,10 +181,13 @@ export function initialize(opts) {
         }
     });
     const customAnchors = new Map();
-    // Override world tracking functions if the bridge is available
+    // Override world tracking functions if WebXR or the bridge is available
     let bridgedWtApi;
     let bridgedD3Api;
-    if (BridgedWorldTracker.IsSupported()) {
+    if (preferWebXRCamera && WebXRCameraSource.IsSupported()) {
+        bridgedWtApi = WebXRWorldTracker.SharedInstance();
+    }
+    else if (BridgedWorldTracker.IsSupported()) {
         bridgedWtApi = BridgedWorldTracker.SharedInstance();
         bridgedD3Api = BridgedD3Tracker.SharedInstance();
     }
@@ -240,7 +251,7 @@ export function initialize(opts) {
                 mat4.multiply(res, res, scale);
             }
             return res;
-        } }), bridgedWtImpl), bridgedD3Impl), { loaded: () => loaded, camera_default_device_id: userFacing => userFacing ? CameraSource.USER_DEFAULT_DEVICE_ID : CameraSource.DEFAULT_DEVICE_ID, camera_source_create: (p, deviceId) => createCameraSource(p, deviceId), camera_source_destroy: cam => { var _a; return (_a = getCameraSource(cam)) === null || _a === void 0 ? void 0 : _a.destroy(); }, camera_source_pause: cam => { var _a; return (_a = getCameraSource(cam)) === null || _a === void 0 ? void 0 : _a.pause(); }, camera_source_start: cam => { var _a; return (_a = getCameraSource(cam)) === null || _a === void 0 ? void 0 : _a.start(); }, camera_source_profile_set: (cam, p) => { var _a; return (_a = getCameraSource(cam)) === null || _a === void 0 ? void 0 : _a.setProfile(p); }, camera_count: () => 2, camera_id: indx => indx === 0 ? CameraSource.DEFAULT_DEVICE_ID : CameraSource.USER_DEFAULT_DEVICE_ID, camera_name: indx => indx === 0 ? "Rear-facing Camera" : "User-facing Camera", camera_user_facing: indx => indx !== 0, pose_from_raw: (raw_pose, mirror) => {
+        } }), bridgedWtImpl), bridgedD3Impl), { loaded: () => loaded, camera_default_device_id: userFacing => userFacing ? CameraSource.USER_DEFAULT_DEVICE_ID : CameraSource.DEFAULT_DEVICE_ID, camera_source_create: (p, deviceId) => createCameraSource(p, deviceId, preferWebXRCamera), camera_source_destroy: cam => { var _a; return (_a = getCameraSource(cam)) === null || _a === void 0 ? void 0 : _a.destroy(); }, camera_source_pause: cam => { var _a; return (_a = getCameraSource(cam)) === null || _a === void 0 ? void 0 : _a.pause(); }, camera_source_start: cam => { var _a; return (_a = getCameraSource(cam)) === null || _a === void 0 ? void 0 : _a.start(); }, camera_source_profile_set: (cam, p) => { var _a; return (_a = getCameraSource(cam)) === null || _a === void 0 ? void 0 : _a.setProfile(p); }, camera_count: () => 2, camera_id: indx => indx === 0 ? CameraSource.DEFAULT_DEVICE_ID : CameraSource.USER_DEFAULT_DEVICE_ID, camera_name: indx => indx === 0 ? "Rear-facing Camera" : "User-facing Camera", camera_user_facing: indx => indx !== 0, pose_from_raw: (raw_pose, mirror) => {
             let res = applyScreenCounterRotation(undefined, raw_pose);
             if (mirror) {
                 let scale = mat4.create();

package/lib/options.d.ts

@@ -1,5 +1,6 @@
 export interface Options {
     worker?: Worker;
+    preferWebXRCamera?: boolean;
     ceresWorker0?: Worker;
     ceresWorker1?: Worker;
 }

package/lib/permission.d.ts

@@ -1,5 +1,5 @@
 import { PermissionDeniedUIOptions, PermissionRequestUIOptions } from "./additional";
-export declare function permissionGrantedCamera(): boolean;
+export declare function permissionGrantedCamera(): any;
 export declare function permissionGrantedMotion(): boolean;
 export declare function permissionDeniedCamera(): boolean;
 export declare function permissionDeniedMotion(): boolean;
@@ -10,3 +10,4 @@ export declare function permissionRequestCamera(): Promise<void>;
 export declare function permissionRequestMotion(): Promise<false | undefined>;
 export declare function permissionRequestUI(options?: PermissionRequestUIOptions): Promise<boolean>;
 export declare function permissionDeniedUI(options?: PermissionDeniedUIOptions): void;
+export declare function setWebXRSupported(supported: boolean): void;

package/lib/permission.js

@@ -11,6 +11,7 @@ import { UAParser } from "ua-parser-js";
 import { STRINGS, tr } from "./tr";
 import { BridgedCameraSource } from "./bridged-camera-source";
 let parser = new UAParser();
+let _isWebXRSupported = false;
 let _permissionGrantedCamera = false;
 let _permissionGrantedMotion = false;
 let _permissionDeniedCamera = false;
@@ -31,12 +32,18 @@ function checkForCameraPermission() {
     });
 }
 checkForCameraPermission();
-export function permissionGrantedCamera() { return _permissionGrantedCamera; }
+export function permissionGrantedCamera() {
+    var _a;
+    if (_isWebXRSupported) {
+        return _permissionGrantedCamera && ((_a = navigator.userActivation) === null || _a === void 0 ? void 0 : _a.isActive);
+    }
+    return _permissionGrantedCamera;
+}
 export function permissionGrantedMotion() { return _permissionGrantedMotion; }
 export function permissionDeniedCamera() { return _permissionDeniedCamera; }
 export function permissionDeniedMotion() { return _permissionDeniedMotion; }
 export function permissionDeniedAny() { return _permissionDeniedCamera || _permissionDeniedMotion; }
-export function permissionGrantedAll() { return _permissionGrantedCamera && _permissionGrantedMotion; }
+export function permissionGrantedAll() { return permissionGrantedCamera() && _permissionGrantedMotion; }
 export function permissionRequestAll() {
     return __awaiter(this, void 0, void 0, function* () {
         yield permissionRequestMotion();
@@ -81,10 +88,10 @@ export function permissionRequestMotion() {
     });
 }
 export function permissionRequestUI(options) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     return __awaiter(this, void 0, void 0, function* () {
         yield checkForCameraPermission();
-        if (permissionGrantedAll()) {
+        if (permissionGrantedAll() && !(options === null || options === void 0 ? void 0 : options.ignoreUserActivation)) {
             return true;
         }
         let div = document.createElement("div");
@@ -166,6 +173,8 @@ export function permissionRequestUI(options) {
             });
         }
         try {
+            if (_isWebXRSupported && !((_d = navigator.userActivation) === null || _d === void 0 ? void 0 : _d.isActive))
+                throw new Error("WebXR - need user interaction");
             return yield attempt();
         }
         catch (err) {
@@ -297,3 +306,6 @@ function permissionDeniedUIChrome(options) {
     let button = div.querySelector("#zappar-permission-reload-button");
     button === null || button === void 0 ? void 0 : button.addEventListener("click", () => window.location.reload());
 }
+export function setWebXRSupported(supported) {
+    _isWebXRSupported = supported;
+}

package/lib/profile.js

@@ -11,9 +11,9 @@ export let profile = {
     showGyroPermissionsWarningIfNecessary: false,
     showSafariPermissionsResetIfNecessary: false,
     requestHighFrameRate: false,
-    videoWidth: 640,
-    videoHeight: 480,
-    getDataSize: (p) => p === camera_profile_t.HIGH ? [640, 480] : [320, 240],
+    videoWidth: 1280,
+    videoHeight: 720,
+    getDataSize: (p) => p === camera_profile_t.HIGH ? [640, 360] : [320, 180],
     videoElementInDOM: false,
     preferMediaStreamTrackProcessorCamera: false,
     preferImageBitmapCamera: false,

package/lib/src/additional.d.ts

@@ -7,6 +7,7 @@ export interface PermissionRequestUIOptions {
     title?: string;
     description?: string;
     button?: string;
+    ignoreUserActivation?: boolean;
 }
 export interface PermissionDeniedUIOptions {
     title?: string;

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

@@ -3,9 +3,10 @@ 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;
+import { WebXRCameraSource } from "./webxr-camera-source";
+export declare type CameraSourceType = CameraSource | MSTPCameraSource | ImageBitmapCameraSource | BridgedCameraSource | WebXRCameraSource;
 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;
+export declare function createCameraSource(p: zappar_pipeline_t, deviceId: string, preferWebXrCamera?: boolean): zappar_camera_source_t;

package/lib/src/image-blit-gl.d.ts

@@ -0,0 +1,16 @@
+export declare class ImageBlitGl {
+    private _gl;
+    private _sharedContext;
+    private _isWebGL2;
+    private _instancedArraysExtension;
+    private _program;
+    private _vertexBuffer;
+    constructor(_gl: WebGL2RenderingContext | WebGLRenderingContext, _sharedContext?: boolean);
+    resetGLContext(): void;
+    destroy(): void;
+    doBlit(): void;
+    private _getVertexAttribState;
+    private _resetVertexAttribState;
+    private _setGlobalState;
+    private _prepareContext;
+}

package/lib/src/image-process-gl.d.ts

@@ -30,7 +30,9 @@ export declare class ImageProcessGL {
     resetGLContext(): void;
     destroy(): void;
     uploadFrame(texture: WebGLTexture, img: HTMLVideoElement | HTMLImageElement | ImageBitmap, rotation: number, fc: boolean, cp: camera_profile_t): void;
+    uploadFrameForSize(texture: WebGLTexture, img: HTMLVideoElement | HTMLImageElement | ImageBitmap, rotation: number, fc: boolean, dataWidth: number, dataHeight: number): void;
     readFrame(texture: WebGLTexture, pixels: ArrayBuffer, cp: camera_profile_t): ProcessedFrame;
+    readFrameForSize(texture: WebGLTexture, pixels: ArrayBuffer, dataWidth: number, dataHeight: number): ProcessedFrame;
     private _updateTransforms;
     private _getCameraUvTransform;
     private _getFramebuffer;

package/lib/src/options.d.ts

@@ -1,5 +1,6 @@
 export interface Options {
     worker?: Worker;
+    preferWebXRCamera?: boolean;
     ceresWorker0?: Worker;
     ceresWorker1?: Worker;
 }

package/lib/src/permission.d.ts

@@ -1,5 +1,5 @@
 import { PermissionDeniedUIOptions, PermissionRequestUIOptions } from "./additional";
-export declare function permissionGrantedCamera(): boolean;
+export declare function permissionGrantedCamera(): any;
 export declare function permissionGrantedMotion(): boolean;
 export declare function permissionDeniedCamera(): boolean;
 export declare function permissionDeniedMotion(): boolean;
@@ -10,3 +10,4 @@ export declare function permissionRequestCamera(): Promise<void>;
 export declare function permissionRequestMotion(): Promise<false | undefined>;
 export declare function permissionRequestUI(options?: PermissionRequestUIOptions): Promise<boolean>;
 export declare function permissionDeniedUI(options?: PermissionDeniedUIOptions): void;
+export declare function setWebXRSupported(supported: boolean): void;

package/lib/src/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "3.6.0";
+export declare const VERSION = "3.7.0";

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

@@ -0,0 +1,79 @@
+import { anchor_status_t, world_tracker_quality_t, camera_profile_t, zappar_camera_source_t, zappar_pipeline_t, zappar_custom_anchor_t } from "./gen/zappar";
+import { CameraFrameInfo, Source } from "./source";
+export interface WebXRPlaneAnchorData {
+    id: string;
+    horizontal: boolean;
+    status: anchor_status_t;
+    pose: Float32Array;
+    boundary: Float32Array;
+    boundaryVersion: number;
+}
+export interface WebXRCustomAnchorData {
+    id: number;
+    status: anchor_status_t;
+    pose: Float32Array;
+    poseVersion: number;
+}
+export interface WebXRWTData {
+    world_anchor_status: anchor_status_t;
+    world_anchor_pose: Float32Array;
+    ground_anchor_status: anchor_status_t;
+    ground_anchor_pose: Float32Array;
+    plane_anchors: WebXRPlaneAnchorData[];
+    custom_anchors: WebXRCustomAnchorData[];
+    quality: world_tracker_quality_t;
+}
+export interface WebXRWTOptions {
+    horizontalPlaneDetection: boolean;
+    verticalPlaneDetection: boolean;
+}
+export declare class WebXRCameraSource extends Source {
+    private _impl;
+    private _pipeline;
+    sessionNumber: number;
+    private _isPaused;
+    private _xrSession;
+    private _xrLocalSpace;
+    private _xrViewerSpace;
+    private _xrGlBinding;
+    private _xrWebGLLayer;
+    private _offscreenCanvas;
+    private _offscreenContext;
+    private _imageBlitGl;
+    private _latestFrame;
+    private _latestWtData;
+    private _wtOptions;
+    private _lastFrameTime;
+    private _cameraToDeviceTransform;
+    private _cameraModel;
+    private _rawCameraModel;
+    private _profile;
+    private _permissionRequestShown;
+    private _planeHitTestSource;
+    private _customAnchorSetRequests;
+    private _customAnchors;
+    static IsSupported(): boolean;
+    constructor(_impl: zappar_camera_source_t, _pipeline: zappar_pipeline_t);
+    destroy(): void;
+    setProfile(p: camera_profile_t): void;
+    private _stop;
+    pause(): void;
+    start(): void;
+    optionsUpdated(options: WebXRWTOptions): void;
+    resetTracking(): void;
+    getFrame(currentlyProcessing: boolean): void;
+    private _syncCamera;
+    private _onXRFrame;
+    private _onXREnd;
+    private _hasStartedOrientation;
+    private _lastTimestamp;
+    private _deviceMotionListener;
+    private _startDeviceOrientation;
+    private _startDeviceMotion;
+    private _stopDeviceMotion;
+    uploadGL(info: CameraFrameInfo): void;
+    setCustomAnchorPose(o: zappar_custom_anchor_t, version: number, pose: Float32Array): Promise<void>;
+    deleteCustomAnchor(o: zappar_custom_anchor_t): Promise<void>;
+    private _updateCameraModel;
+    private _isPlaneVertical;
+}