@wonderlandengine/ar-provider-zappar 1.0.0

package/dist/src/world-tracking-mode-zappar.d.ts

@@ -0,0 +1,17 @@
+/// <reference path="../../src/types/global.d.ts" />
+import { Component } from '@wonderlandengine/api';
+import { TrackingMode } from '@wonderlandengine/ar-tracking';
+import { ZapparProvider } from './zappar-provider.js';
+/**
+ * SLAM tracking implementation backed by Zappar.
+ */
+export declare class WorldTracking_Zappar extends TrackingMode {
+    private readonly _cameraTransform;
+    constructor(provider: ZapparProvider, component: Component);
+    init(): void;
+    startSession(): void;
+    endSession(): void;
+    getCameraTransformWorld(): ArrayLike<number> | null;
+    getCameraProjectionMatrix(out: Float32Array): boolean;
+    update(): void;
+}

package/dist/src/world-tracking-mode-zappar.js

@@ -0,0 +1,46 @@
+/// <reference path="./types/global.d.ts" />
+import { quat2 } from 'gl-matrix';
+import { TrackingMode } from '@wonderlandengine/ar-tracking';
+/**
+ * SLAM tracking implementation backed by Zappar.
+ */
+export class WorldTracking_Zappar extends TrackingMode {
+    _cameraTransform = quat2.create();
+    constructor(provider, component) {
+        super(provider, component);
+    }
+    init() {
+        const input = this.component.object.getComponent('input');
+        if (input) {
+            // Camera pose will be driven by the AR tracking implementation.
+            input.active = false;
+        }
+    }
+    startSession() {
+        void this.provider.startSession();
+    }
+    endSession() {
+        void this.provider.endSession();
+    }
+    getCameraTransformWorld() {
+        const provider = this.provider;
+        return provider.hasSlamTrackingState ? this._cameraTransform : null;
+    }
+    getCameraProjectionMatrix(out) {
+        const provider = this.provider;
+        const projection = provider.slamProjectionMatrix;
+        if (!projection)
+            return false;
+        out.set(projection);
+        return true;
+    }
+    update() {
+        const provider = this.provider;
+        const pose = provider.slamCameraPoseMatrix;
+        if (!pose)
+            return;
+        // Zappar's THREE.js wrapper treats pipeline.cameraPose*(...) matrices as a camera world transform.
+        // Wonderland stores transforms as dual quaternions (8 floats): [rotation quat, translation dual part].
+        quat2.fromMat4(this._cameraTransform, pose);
+    }
+}

package/dist/src/zappar-module.d.ts

@@ -0,0 +1,5 @@
+export type ZapparNamespace = typeof import('@zappar/zappar');
+type ZapparCore = typeof import('@zappar/zappar/lib/zappar.js');
+export declare function loadZappar(): Promise<ZapparNamespace>;
+export declare function setOptions(opts: Parameters<ZapparCore['setOptions']>[0]): Promise<void>;
+export {};

package/dist/src/zappar-module.js

@@ -0,0 +1,43 @@
+function ensureEditorWindow() {
+    if (typeof window !== 'undefined')
+        return;
+    if (typeof WL_EDITOR === 'undefined' || !WL_EDITOR)
+        return;
+    const globalObject = globalThis;
+    if (!globalObject.window) {
+        globalObject.window = globalObject;
+    }
+    const ensuredWindow = globalObject.window;
+    if (!ensuredWindow.location) {
+        ensuredWindow.location = { href: '' };
+    }
+}
+let zapparPromise = null;
+let zapparCorePromise = null;
+export function loadZappar() {
+    if (!zapparPromise) {
+        zapparPromise = (async () => {
+            ensureEditorWindow();
+            return import('@zappar/zappar');
+        })();
+    }
+    return zapparPromise;
+}
+async function loadZapparCore() {
+    if (!zapparCorePromise) {
+        zapparCorePromise = (async () => {
+            ensureEditorWindow();
+            return import('@zappar/zappar/lib/zappar.js');
+        })();
+    }
+    return zapparCorePromise;
+}
+export async function setOptions(opts) {
+    const [core, main] = await Promise.all([loadZapparCore(), loadZappar()]);
+    core.setOptions(opts);
+    /* If the main module also has setOptions (it might be re-exported), call it too.
+     * This helps if the bundler has duplicated the zappar module instance. */
+    if (main.setOptions && main.setOptions !== core.setOptions) {
+        main.setOptions(opts);
+    }
+}

package/dist/src/zappar-provider.d.ts

@@ -0,0 +1,115 @@
+/// <reference path="../../src/types/global.d.ts" />
+/// <reference types="webxr" />
+import { Component, Emitter } from '@wonderlandengine/api';
+import { mat4 } from 'gl-matrix';
+import { ARProvider, ARSession, ITrackingMode, ImageScanningEvent, TrackingType } from '@wonderlandengine/ar-tracking';
+import { loadZappar } from './zappar-module.js';
+import type { FaceMesh, FaceTracker, ImageTracker, Pipeline } from '@zappar/zappar';
+type ZapparImageTargetType = 'flat' | 'cylindrical' | 'conical';
+export interface ZapparImageTargetOptions {
+    name: string;
+    type?: ZapparImageTargetType;
+    physicalWidthInMeters?: number;
+    metadata?: unknown;
+}
+interface ZapparImageTargetDescriptor {
+    name: string;
+    type: ZapparImageTargetType;
+    geometry: ImageScanningEvent['imageTargets'][0]['geometry'];
+    properties: ImageScanningEvent['imageTargets'][0]['properties'];
+    metadata: unknown;
+}
+/**
+ * ARProvider implementation backed by the Zappar Universal AR JavaScript SDK.
+ */
+export declare class ZapparProvider extends ARProvider {
+    private static _cvWorkerConfigured;
+    private static _cvWorker;
+    /** Mirror Zappar THREE.js `CameraPoseMode` for SLAM pose output. */
+    slamPoseMode: 'default' | 'attitude' | 'anchor-origin';
+    private _xrSession;
+    private _gl;
+    private _zappar;
+    private pipeline;
+    private cameraSource;
+    private instantTracker;
+    private _faceTracker;
+    private _faceMesh;
+    private _faceResourcesPromise;
+    private _imageTracker;
+    private _imageTargetDescriptors;
+    private readonly _imageTargetsChanged;
+    private cameraStarted;
+    private hasInitializedAnchor;
+    private _anchorWarmupFramesRemaining;
+    private preRenderRegistered;
+    private _slamStateValid;
+    private readonly _slamProjectionMatrix;
+    private readonly _slamAnchorMatrix;
+    private _slamFrameNumber;
+    private _videoTextureUnit;
+    private _videoTextureProgram;
+    private _videoTextureUniform;
+    private _videoTextureTransformUniform;
+    private _videoTextureBindErrorLogged;
+    private _missingCameraTextureFrames;
+    private _missingCameraTextureWarningLogged;
+    private readonly _slamCameraMatrix;
+    private readonly _slamCameraPosition;
+    private readonly _slamCameraRotation;
+    private readonly _debugCameraPosition;
+    private readonly _debugAnchorPosition;
+    private readonly _debugCameraPositionDelta;
+    private readonly _debugAnchorPositionDelta;
+    private _debugLastSampleFrameNumber;
+    private readonly _debugLastSampleCameraPosition;
+    private readonly _debugLastSampleAnchorPosition;
+    private _zapparDebugLogIntervalId;
+    private _preRenderErrorLogged;
+    static Name: string;
+    get name(): string;
+    get supportsInstantTracking(): boolean;
+    get onImageTargetsChanged(): Emitter<void[]>;
+    get xrSession(): XRSession | null;
+    static registerTrackingProviderWithARSession(arSession: ARSession): ZapparProvider;
+    private constructor();
+    startSession(): Promise<void>;
+    private startZapparDebugLogging;
+    private stopZapparDebugLogging;
+    private ensureZapparLoaded;
+    /** Used by tracking modes that need the Zappar namespace. */
+    ensureZapparNamespace(): Promise<Awaited<ReturnType<typeof loadZappar>>>;
+    private configureCvWorkerIfNeeded;
+    private ensurePipeline;
+    getPipeline(): Pipeline;
+    ensureFaceResources(): Promise<void>;
+    getFaceTracker(): FaceTracker;
+    getFaceMesh(): FaceMesh;
+    ensureImageTracker(): ImageTracker;
+    registerImageTarget(source: string | ArrayBuffer, options: ZapparImageTargetOptions): Promise<void>;
+    private _inferImageTargetType;
+    private _buildImageTargetGeometry;
+    getImageScanningEvent(): ImageScanningEvent;
+    getImageTargetDescriptors(): ReadonlyArray<ZapparImageTargetDescriptor>;
+    getImageTargetDescriptor(index: number): ZapparImageTargetDescriptor | undefined;
+    private ensureCameraRunning;
+    private onVisibilityChange;
+    private onPreRender;
+    /** Latest projection matrix for the SLAM camera (valid only if {@link hasSlamTrackingState} is true). */
+    get slamProjectionMatrix(): Readonly<Float32Array> | null;
+    /** Latest camera pose matrix for the SLAM camera (valid only if {@link hasSlamTrackingState} is true). */
+    get slamCameraPoseMatrix(): Readonly<mat4> | null;
+    /** Latest anchor pose matrix (valid only if {@link hasSlamTrackingState} is true). */
+    get slamAnchorPoseMatrix(): Readonly<mat4> | null;
+    get hasSlamTrackingState(): boolean;
+    get slamFrameNumber(): number;
+    private bindVideoTextureForSkyMaterial;
+    updateTracking(): void;
+    endSession(): Promise<void>;
+    load(): Promise<void>;
+    /** Whether this provider supports given tracking type */
+    supports(type: TrackingType): boolean;
+    /** Create a tracking implementation */
+    createTracking(type: TrackingType, component: Component): ITrackingMode;
+}
+export {};