@zappar/zappar-cv 3.0.0-beta.7 → 3.0.1-alpha.10

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.0.0-beta.7/zappar-cv.js"></script>
+<script src="https://libs.zappar.com/zappar-cv/3.0.1-alpha.10/zappar-cv.js"></script>
 ```
 
 Or you can download and host our standalone JavaScript bundle:
-[https://libs.zappar.com/zappar-cv/3.0.0-beta.7/zappar-cv.zip](https://libs.zappar.com/zappar-cv/3.0.0-beta.7/zappar-cv.zip)
+[https://libs.zappar.com/zappar-cv/3.0.1-alpha.10/zappar-cv.zip](https://libs.zappar.com/zappar-cv/3.0.1-alpha.10/zappar-cv.zip)

package/lib/additional.d.ts

@@ -1,5 +1,5 @@
 import { CameraFrameData } from "./camera-frame-data";
-import { zappar_face_mesh_t, zappar_face_tracker_t, zappar_pipeline_t, zappar_image_tracker_t, zappar_sequence_source_t } from "./gen/zappar";
+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';
 };
@@ -11,7 +11,10 @@ export interface Additional {
     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_width(pipeline: zappar_pipeline_t): number;
+    pipeline_camera_frame_data_height(pipeline: zappar_pipeline_t): number;
     draw_plane(gl: WebGLRenderingContext, projectionMatrix: Float32Array, cameraMatrix: Float32Array, targetMatrix: Float32Array, texture: string): void;
+    draw_grid(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>;
@@ -27,4 +30,5 @@ export interface Additional {
     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;
 }

package/lib/camera-source.js

@@ -35,11 +35,15 @@ export class CameraSource extends HTMLElementSource {
             if (!pipeline)
                 return;
             let timeStamp = (ev.timeStamp !== undefined && ev.timeStamp !== null) ? ev.timeStamp : performance.now();
-            let interval = ev.interval * profile.intervalMultiplier;
-            if (this._lastTimestamp > -1 && !profile.trustSensorIntervals) {
-                interval = Math.max(timeStamp - this._lastTimestamp, interval);
+            const interval = ev.interval * profile.intervalMultiplier;
+            if (profile.trustSensorIntervals) {
+                if (this._lastTimestamp === -1)
+                    this._lastTimestamp = timeStamp;
+                else {
+                    this._lastTimestamp += interval;
+                    timeStamp = this._lastTimestamp;
+                }
             }
-            this._lastTimestamp = timeStamp;
             if (ev.acceleration !== null &&
                 ev.acceleration.x !== null &&
                 ev.acceleration.y !== null &&

package/lib/ceres-worker.d.ts

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

package/lib/ceres-worker.js

@@ -0,0 +1,67 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { getWorkerMessageAPI } from "./worker-messages";
+import * as ZNM from "./zappar-cv";
+const ctx = self;
+let launchHandler = (evt) => {
+    if (evt && evt.data && evt.data.t === "wasm") {
+        let url = location.href.startsWith("blob") ? evt.data.url : new URL("./zappar-cv.wasm", import.meta.url).toString();
+        launchCeresWorker(url, evt.data.module, evt.data.port);
+        ctx.removeEventListener("message", launchHandler);
+    }
+};
+ctx.addEventListener("message", launchHandler);
+export function launchCeresWorker(wasmUrl, module, port) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let mod = ZNM.default({
+            locateFile: (path, prefix) => {
+                if (path.endsWith("zappar-cv.wasm")) {
+                    return wasmUrl;
+                }
+                return prefix + path;
+            },
+            instantiateWasm: (imports, successCallback) => {
+                const instance = new WebAssembly.Instance(module, imports);
+                successCallback(instance);
+                return instance.exports;
+            },
+            onRuntimeInitialized: () => {
+                const ceres_worker = mod.cwrap('ceres_worker', null, []);
+                const messageAPI = getWorkerMessageAPI(mod);
+                port.addEventListener('message', evt => {
+                    if (evt.data.t !== 'msgsend')
+                        return;
+                    const data = evt.data.data;
+                    const reference = evt.data.reference;
+                    const ptr = mod._malloc(data.byteLength);
+                    mod.HEAPU8.set(data, ptr);
+                    messageAPI.worker_message_receive(reference, data.byteLength, ptr);
+                    mod._free(ptr);
+                    ceres_worker();
+                    const toSend = messageAPI.worker_message_send_count();
+                    for (let i = 0; i < toSend; i++) {
+                        const reference = messageAPI.worker_message_send_reference(i);
+                        const dataSize = messageAPI.worker_message_send_data_size(i);
+                        const dataPtr = messageAPI.worker_message_send_data(i);
+                        const data = mod.HEAPU8.slice(dataPtr, dataPtr + dataSize);
+                        port.postMessage({
+                            t: 'msgrec',
+                            data,
+                            reference
+                        }, [data.buffer]);
+                    }
+                    messageAPI.worker_message_send_clear();
+                });
+                port.start();
+            }
+        });
+    });
+}
+;

package/lib/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;

package/lib/data-download.js

@@ -0,0 +1,8 @@
+export function getDataDownloadAPI(mod) {
+    return {
+        data_download_clear: mod.cwrap("data_download_clear", null, []),
+        data_download_size: mod.cwrap("data_download_size", "number", []),
+        data_download: mod.cwrap("data_download", "number", []),
+        data_should_record_set: mod.cwrap("data_should_record_set", null, ["number"]),
+    };
+}

package/lib/deserializer.d.ts

@@ -8,6 +8,7 @@ interface Message {
     type: () => number;
     matrix4x4: () => Float32Array;
     matrix3x3: () => Float32Array;
+    floatArray: () => Float32Array;
     identityCoefficients: () => Float32Array;
     expressionCoefficients: () => Float32Array;
     cameraModel: () => Float32Array;

package/lib/deserializer.js

@@ -40,6 +40,13 @@ export class MessageDeserializer {
                     this._startOffset++;
                 return ret.buffer;
             },
+            floatArray: () => {
+                let len = this._i32View[this._startOffset++];
+                let ret = new Float32Array(len);
+                ret.set(this._f32View.subarray(this._startOffset, this._startOffset + len));
+                this._startOffset += len;
+                return ret;
+            },
             matrix4x4: () => {
                 let len = this._i32View[this._startOffset++];
                 let ret = new Float32Array(len);

package/lib/direct.js

@@ -13,6 +13,8 @@ import { messageManager as workerMessageManager } from "./worker-server";
 export let messageManager = new MsgManager();
 export function launchWorker(wasm) {
     return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetch(new URL("./zappar-cv.wasm", import.meta.url).toString());
+        const module = yield WebAssembly.compileStreaming(response);
         messageManager.onOutgoingMessage.bind(() => {
             let msgs = messageManager.getOutgoingMessages();
             for (let msg of msgs)
@@ -23,6 +25,6 @@ export function launchWorker(wasm) {
             for (let msg of msgs)
                 messageManager.postIncomingMessage(msg.msg);
         });
-        launchWorkerServer(wasm);
+        launchWorkerServer(wasm, module, 0);
     });
 }

package/lib/drawgrid.d.ts

@@ -0,0 +1,2 @@
+export declare function disposeDrawGrid(): void;
+export declare function drawGrid(gl: WebGLRenderingContext, projectionMatrix: Float32Array, cameraMatrix: Float32Array, targetMatrix: Float32Array): void;

package/lib/drawgrid.js

@@ -0,0 +1,136 @@
+import { compileShader, linkProgram } from "./shader";
+let shader;
+let vbo;
+let uvbo;
+export function disposeDrawGrid() {
+    shader = undefined;
+    vbo = undefined;
+    uvbo = undefined;
+}
+function generate(gl) {
+    if (vbo)
+        return vbo;
+    vbo = gl.createBuffer();
+    if (!vbo)
+        throw new Error("Unable to create buffer object");
+    let coords = [
+        -0.5, 0, 0.5,
+        -0.5, 0, -0.5,
+        0.5, 0, 0.5,
+        0.5, 0, -0.5
+    ];
+    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
+    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(coords), gl.STATIC_DRAW);
+    gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    return vbo;
+}
+function generateUVBO(gl) {
+    if (uvbo)
+        return uvbo;
+    uvbo = gl.createBuffer();
+    if (!uvbo)
+        throw new Error("Unable to create buffer object");
+    let coords = [
+        0, 1,
+        0, 0,
+        1, 1,
+        1, 0
+    ];
+    gl.bindBuffer(gl.ARRAY_BUFFER, uvbo);
+    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(coords), gl.STATIC_DRAW);
+    gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    return uvbo;
+}
+export function drawGrid(gl, projectionMatrix, cameraMatrix, targetMatrix) {
+    let shader = getShader(gl);
+    let v = generate(gl);
+    let uvbo = generateUVBO(gl);
+    gl.disable(gl.DEPTH_TEST);
+    gl.useProgram(shader.prog);
+    gl.uniformMatrix4fv(shader.unif_proj, false, projectionMatrix);
+    gl.uniformMatrix4fv(shader.unif_camera, false, cameraMatrix);
+    gl.uniformMatrix4fv(shader.unif_matrix, false, targetMatrix);
+    gl.bindBuffer(gl.ARRAY_BUFFER, v);
+    gl.vertexAttribPointer(shader.attr_position, 3, gl.FLOAT, false, 3 * 4, 0);
+    gl.enableVertexAttribArray(shader.attr_position);
+    gl.bindBuffer(gl.ARRAY_BUFFER, uvbo);
+    gl.vertexAttribPointer(shader.attr_textureCoord, 2, gl.FLOAT, false, 2 * 4, 0);
+    gl.enableVertexAttribArray(shader.attr_textureCoord);
+    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+    gl.disableVertexAttribArray(shader.attr_position);
+    gl.disableVertexAttribArray(shader.attr_textureCoord);
+    gl.bindBuffer(gl.ARRAY_BUFFER, null);
+}
+let vertexShaderSrc = `
+#ifndef GL_ES
+#define highp
+#define mediump
+#define lowp
+#endif
+
+uniform mat4 projMatrix;
+uniform mat4 cameraMatrix;
+uniform mat4 modelViewMatrix;
+attribute vec4 position;
+attribute vec2 textureCoord;
+
+varying highp vec2 vTextureCoord;
+
+void main()
+{
+    gl_Position = projMatrix * cameraMatrix * modelViewMatrix * position;
+    vTextureCoord = textureCoord;
+}`;
+let fragmentShaderSrc = `
+#define highp mediump
+#ifdef GL_ES
+    // define default precision for float, vec, mat.
+    precision highp float;
+#else
+#define highp
+#define mediump
+#define lowp
+#endif
+
+varying highp vec2 vTextureCoord;
+uniform sampler2D skinSampler;
+
+void main()
+{
+    vec2 pixels = 100.0 * vTextureCoord + 0.5;
+    if ((int(mod(pixels.x, 10.0)) == 0) || (int(mod(pixels.y, 10.0)) == 0)) {
+        gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
+    } else {
+        discard;
+    }
+}`;
+function getShader(gl) {
+    if (shader)
+        return shader;
+    let prog = gl.createProgram();
+    if (!prog)
+        throw new Error("Unable to create program");
+    let vertexShader = compileShader(gl, gl.VERTEX_SHADER, vertexShaderSrc);
+    let fragmentShader = compileShader(gl, gl.FRAGMENT_SHADER, fragmentShaderSrc);
+    gl.attachShader(prog, vertexShader);
+    gl.attachShader(prog, fragmentShader);
+    linkProgram(gl, prog);
+    let unif_proj = gl.getUniformLocation(prog, "projMatrix");
+    if (!unif_proj)
+        throw new Error("Unable to get uniform location projMatrix");
+    let unif_matrix = gl.getUniformLocation(prog, "modelViewMatrix");
+    if (!unif_matrix)
+        throw new Error("Unable to get uniform location modelViewMatrix");
+    let unif_camera = gl.getUniformLocation(prog, "cameraMatrix");
+    if (!unif_camera)
+        throw new Error("Unable to get uniform location cameraMatrix");
+    shader = {
+        prog,
+        unif_matrix,
+        unif_proj,
+        unif_camera,
+        attr_position: gl.getAttribLocation(prog, "position"),
+        attr_textureCoord: gl.getAttribLocation(prog, "textureCoord")
+    };
+    return shader;
+}

package/lib/drawpoints.d.ts

@@ -0,0 +1,11 @@
+export declare class PointsDraw {
+    private _gl;
+    private _vbo;
+    private _shader;
+    constructor(_gl: WebGLRenderingContext);
+    dispose(): void;
+    private _generate;
+    drawPoints(screenWidth: number, screenHeight: number, dataWidth: number, dataHeight: number, points: Float32Array, mirror: boolean, color: [number, number, number], pointSize: number): void;
+    private _getCameraShader;
+}
+export declare function getPointsDataMatrix(frameWidth: number, frameHeight: number, screenWidth: number, screenHeight: number, mirror: boolean): Float32Array;

package/lib/drawpoints.js

@@ -0,0 +1,180 @@
+import { profile } from "./profile";
+import { compileShader, linkProgram } from "./shader";
+import { mat4 } from "gl-matrix";
+let identity = mat4.create();
+export class PointsDraw {
+    constructor(_gl) {
+        this._gl = _gl;
+    }
+    dispose() {
+        if (this._vbo)
+            this._gl.deleteBuffer(this._vbo);
+        this._vbo = undefined;
+        if (this._shader)
+            this._gl.deleteProgram(this._shader.prog);
+        this._shader = undefined;
+    }
+    _generate(gl, points) {
+        if (!this._vbo)
+            this._vbo = gl.createBuffer();
+        if (!this._vbo)
+            throw new Error("Unable to create buffer object");
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._vbo);
+        gl.bufferData(gl.ARRAY_BUFFER, points, gl.DYNAMIC_DRAW);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return this._vbo;
+    }
+    drawPoints(screenWidth, screenHeight, dataWidth, dataHeight, points, mirror, color, pointSize) {
+        if (points.length === 0)
+            return; // points = new Float32Array([0, 1, 0, 1]);
+        let gl = this._gl;
+        const reenableDepthTest = gl.isEnabled(gl.DEPTH_TEST);
+        const reenableScissorTest = gl.isEnabled(gl.SCISSOR_TEST);
+        const reenableCullFace = gl.isEnabled(gl.CULL_FACE);
+        const reenableStencilTest = gl.isEnabled(gl.STENCIL_TEST);
+        const reenableBlend = gl.isEnabled(gl.BLEND);
+        const previousBoundTexture = gl.getParameter(gl.TEXTURE_BINDING_2D);
+        const previousBoundFramebuffer = gl.getParameter(gl.FRAMEBUFFER_BINDING);
+        const previousProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        const previousActiveTexture = gl.getParameter(gl.ACTIVE_TEXTURE);
+        gl.disable(gl.DEPTH_TEST);
+        gl.disable(gl.SCISSOR_TEST);
+        gl.disable(gl.CULL_FACE);
+        gl.disable(gl.STENCIL_TEST);
+        gl.disable(gl.BLEND);
+        let shader = this._getCameraShader(gl);
+        let vbo = this._generate(gl, points);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.useProgram(shader.prog);
+        gl.uniform3f(shader.unif_color, color[0], color[1], color[2]);
+        gl.uniform1f(shader.unif_pointSize, pointSize);
+        gl.uniformMatrix4fv(shader.unif_skinTexTransform, false, getPointsDataMatrix(dataWidth, dataHeight, screenWidth, screenHeight, mirror));
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
+        gl.vertexAttribPointer(shader.attr_position, 2, gl.FLOAT, false, 0, 0);
+        gl.enableVertexAttribArray(shader.attr_position);
+        gl.drawArrays(gl.POINTS, 0, points.length / 2);
+        gl.disableVertexAttribArray(shader.attr_position);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, previousBoundFramebuffer);
+        gl.useProgram(previousProgram);
+        gl.bindTexture(gl.TEXTURE_2D, previousBoundTexture);
+        gl.activeTexture(previousActiveTexture);
+        if (reenableBlend)
+            gl.enable(gl.BLEND);
+        if (reenableCullFace)
+            gl.enable(gl.CULL_FACE);
+        if (reenableDepthTest)
+            gl.enable(gl.DEPTH_TEST);
+        if (reenableScissorTest)
+            gl.enable(gl.SCISSOR_TEST);
+        if (reenableStencilTest)
+            gl.enable(gl.STENCIL_TEST);
+    }
+    _getCameraShader(gl) {
+        if (this._shader)
+            return this._shader;
+        let prog = gl.createProgram();
+        if (!prog)
+            throw new Error("Unable to create program");
+        let vertexShader = compileShader(gl, gl.VERTEX_SHADER, vertexShaderSrc);
+        let fragmentShader = compileShader(gl, gl.FRAGMENT_SHADER, fragmentShaderSrc);
+        gl.attachShader(prog, vertexShader);
+        gl.attachShader(prog, fragmentShader);
+        linkProgram(gl, prog);
+        let unif_skinTexTransform = gl.getUniformLocation(prog, "skinTexTransform");
+        if (!unif_skinTexTransform)
+            throw new Error("Unable to get uniform location skinTexTransform");
+        let unif_color = gl.getUniformLocation(prog, "color");
+        if (!unif_color)
+            throw new Error("Unable to get uniform location color");
+        let unif_pointSize = gl.getUniformLocation(prog, "pointSize");
+        if (!unif_pointSize)
+            throw new Error("Unable to get uniform location pointSize");
+        this._shader = {
+            prog,
+            unif_skinTexTransform,
+            unif_color,
+            unif_pointSize,
+            attr_position: gl.getAttribLocation(prog, "position"),
+        };
+        return this._shader;
+    }
+}
+let vertexShaderSrc = `
+#ifndef GL_ES
+#define highp
+#define mediump
+#define lowp
+#endif
+
+attribute vec2 position;
+uniform mat4 skinTexTransform;
+uniform float pointSize;
+
+void main()
+{
+    gl_Position = skinTexTransform * vec4(position, 0.0, 1.0);
+    // gl_Position = vec4(position.x * 0.0, position.y * 0.0, 0.0, 1.0);
+    gl_PointSize = pointSize;
+}`;
+let fragmentShaderSrc = `
+#define highp mediump
+#ifdef GL_ES
+    // define default precision for float, vec, mat.
+    precision highp float;
+#else
+#define highp
+#define mediump
+#define lowp
+#endif
+
+uniform vec3 color;
+
+void main()
+{
+    gl_FragColor = vec4(color, 1.0);
+}`;
+function cameraRotationForScreenOrientation() {
+    if (window.screen.orientation && !profile.forceWindowOrientation) {
+        switch (window.screen.orientation.type) {
+            case "portrait-primary":
+                return 270;
+            case "landscape-secondary":
+                return 180;
+            case "portrait-secondary":
+                return 90;
+            default:
+                return 0;
+        }
+    }
+    else if (window.orientation !== undefined) {
+        switch (window.orientation) {
+            case 0: return 270;
+            case 90: return 0;
+            case 180: return 90;
+            case -90: return 180;
+        }
+    }
+    return 0;
+}
+export function getPointsDataMatrix(frameWidth, frameHeight, screenWidth, screenHeight, mirror) {
+    let ret = mat4.create();
+    let trans = mat4.create();
+    // Translate to centre UV coords
+    mat4.fromTranslation(trans, [-0.5 * frameWidth, -0.5 * frameHeight, 0]);
+    mat4.multiply(ret, trans, ret);
+    mat4.fromScaling(trans, [2 / frameWidth, 2 / -frameHeight, 1]);
+    mat4.multiply(ret, trans, ret);
+    if (mirror) {
+        mat4.fromScaling(trans, [-1, 1, 1]);
+        mat4.multiply(ret, trans, ret);
+    }
+    let screenAspect = screenWidth > screenHeight ? (screenWidth / screenHeight) : (screenHeight / screenWidth);
+    let frameAspect = frameWidth / frameHeight;
+    mat4.fromScaling(trans, [1, screenAspect / frameAspect, 1]);
+    mat4.multiply(ret, trans, ret);
+    // Apply rotation back into ZCV's landscape space
+    mat4.fromRotation(trans, cameraRotationForScreenOrientation() * Math.PI / 180.0, [0, 0, 1]);
+    mat4.multiply(ret, trans, ret);
+    return ret;
+}

package/lib/gen/zappar-bridge.d.ts

@@ -9,6 +9,7 @@ import { log_level_t } from "./zappar-native";
 export { log_level_t } from "./zappar-native";
 export { image_target_type_t } from "./zappar-native";
 export { world_tracker_quality_t } from "./zappar-native";
+export { camera_profile_t } from "./zappar-native";
 export declare type zappar_pipeline_t = number & {
     _: 'zappar_pipeline_t';
 };
@@ -36,6 +37,9 @@ export declare type zappar_barcode_finder_t = number & {
 export declare type zappar_instant_world_tracker_t = number & {
     _: 'zappar_instant_world_tracker_t';
 };
+export declare type zappar_zapcode_tracker_t = number & {
+    _: 'zappar_zapcode_tracker_t';
+};
 export declare type zappar_world_tracker_t = number & {
     _: 'zappar_world_tracker_t';
 };
@@ -105,6 +109,15 @@ export interface zappar {
     instant_world_tracker_enabled(o: zappar_instant_world_tracker_t): boolean;
     instant_world_tracker_anchor_pose_raw(o: zappar_instant_world_tracker_t): Float32Array;
     instant_world_tracker_anchor_pose_set_from_camera_offset_raw(o: zappar_instant_world_tracker_t, x: number, y: number, z: number, orientation: instant_world_tracker_transform_orientation_t): void;
+    zapcode_tracker_create(pipeline: zappar_pipeline_t): zappar_zapcode_tracker_t;
+    zapcode_tracker_destroy(o: zappar_zapcode_tracker_t): void;
+    zapcode_tracker_target_load_from_memory(o: zappar_zapcode_tracker_t, data: ArrayBuffer): void;
+    zapcode_tracker_target_loaded_version(o: zappar_zapcode_tracker_t): number;
+    zapcode_tracker_enabled(o: zappar_zapcode_tracker_t): boolean;
+    zapcode_tracker_enabled_set(o: zappar_zapcode_tracker_t, enabled: boolean): void;
+    zapcode_tracker_anchor_count(o: zappar_zapcode_tracker_t): number;
+    zapcode_tracker_anchor_id(o: zappar_zapcode_tracker_t, indx: number): string;
+    zapcode_tracker_anchor_pose_raw(o: zappar_zapcode_tracker_t, indx: number): Float32Array;
     world_tracker_create(pipeline: zappar_pipeline_t): zappar_world_tracker_t;
     world_tracker_destroy(o: zappar_world_tracker_t): void;
     world_tracker_enabled(o: zappar_world_tracker_t): boolean;
@@ -117,4 +130,11 @@ export interface zappar {
     world_tracker_ground_anchor_valid(o: zappar_world_tracker_t): boolean;
     world_tracker_ground_anchor_pose_raw(o: zappar_world_tracker_t): Float32Array;
     world_tracker_reset(o: zappar_world_tracker_t): void;
+    world_tracker_tracks_data_enabled(o: zappar_world_tracker_t): boolean;
+    world_tracker_tracks_data_enabled_set(o: zappar_world_tracker_t, tracks_data_enabled: boolean): void;
+    world_tracker_tracks_data_size(o: zappar_world_tracker_t): number;
+    world_tracker_tracks_data(o: zappar_world_tracker_t): Float32Array;
+    world_tracker_projections_data_enabled_set(o: zappar_world_tracker_t, tracks_data_enabled: boolean): void;
+    world_tracker_projections_data_size(o: zappar_world_tracker_t): number;
+    world_tracker_projections_data(o: zappar_world_tracker_t): Float32Array;
 }

package/lib/gen/zappar-bridge.js

@@ -5,3 +5,4 @@ export { instant_world_tracker_transform_orientation_t } from "./zappar-native";
 export { log_level_t } from "./zappar-native";
 export { image_target_type_t } from "./zappar-native";
 export { world_tracker_quality_t } from "./zappar-native";
+export { camera_profile_t } from "./zappar-native";

package/lib/gen/zappar-client.d.ts

@@ -17,6 +17,7 @@ export declare class zappar_client {
     private _face_landmark_state_by_instance;
     private _barcode_finder_state_by_instance;
     private _instant_world_tracker_state_by_instance;
+    private _zapcode_tracker_state_by_instance;
     private _world_tracker_state_by_instance;
     impl: zappar;
     processMessages(a: ArrayBuffer): void;