@zappar/zappar-cv 3.0.1-alpha.15 → 3.0.1-alpha.17

package/lib/gen/zappar-cwrap.js

@@ -237,27 +237,64 @@ export function getRuntimeObject(mod) {
     let world_tracker_quality_wrapped = mod.cwrap("zappar_world_tracker_quality", "number", [
         "number"
     ]);
-    let world_tracker_plane_detection_enabled_wrapped = mod.cwrap("zappar_world_tracker_plane_detection_enabled", "number", [
+    let world_tracker_horizontal_plane_detection_enabled_wrapped = mod.cwrap("zappar_world_tracker_horizontal_plane_detection_enabled", "number", [
         "number"
     ]);
-    let world_tracker_plane_detection_enabled_set_wrapped = mod.cwrap("zappar_world_tracker_plane_detection_enabled_set", null, [
+    let world_tracker_horizontal_plane_detection_enabled_set_wrapped = mod.cwrap("zappar_world_tracker_horizontal_plane_detection_enabled_set", null, [
         "number",
         "number"
     ]);
-    let world_tracker_plane_count_wrapped = mod.cwrap("zappar_world_tracker_plane_count", "number", [
+    let world_tracker_vertical_plane_detection_enabled_wrapped = mod.cwrap("zappar_world_tracker_vertical_plane_detection_enabled", "number", [
         "number"
     ]);
-    let world_tracker_plane_pose_raw_wrapped = mod.cwrap("zappar_world_tracker_plane_pose_raw", "number", [
+    let world_tracker_vertical_plane_detection_enabled_set_wrapped = mod.cwrap("zappar_world_tracker_vertical_plane_detection_enabled_set", null, [
         "number",
         "number"
     ]);
-    let world_tracker_world_anchor_valid_wrapped = mod.cwrap("zappar_world_tracker_world_anchor_valid", "number", [
+    let world_tracker_plane_anchor_count_wrapped = mod.cwrap("zappar_world_tracker_plane_anchor_count", "number", [
+        "number"
+    ]);
+    let world_tracker_plane_anchor_id_wrapped = mod.cwrap("zappar_world_tracker_plane_anchor_id", "string", [
+        "number",
+        "number"
+    ]);
+    let world_tracker_plane_anchor_pose_raw_wrapped = mod.cwrap("zappar_world_tracker_plane_anchor_pose_raw", "number", [
+        "number",
+        "number"
+    ]);
+    let world_tracker_plane_anchor_status_wrapped = mod.cwrap("zappar_world_tracker_plane_anchor_status", "number", [
+        "number",
+        "number"
+    ]);
+    let world_tracker_plane_anchor_polygon_data_size_wrapped = mod.cwrap("zappar_world_tracker_plane_anchor_polygon_data_size", "number", [
+        "number",
+        "number"
+    ]);
+    let world_tracker_plane_anchor_polygon_data_wrapped = mod.cwrap("zappar_world_tracker_plane_anchor_polygon_data", "number", [
+        "number",
+        "number"
+    ]);
+    let world_tracker_plane_anchor_polygon_version_wrapped = mod.cwrap("zappar_world_tracker_plane_anchor_polygon_version", "number", [
+        "number",
+        "number"
+    ]);
+    let world_tracker_plane_anchor_orientation_wrapped = mod.cwrap("zappar_world_tracker_plane_anchor_orientation", "number", [
+        "number",
+        "number"
+    ]);
+    let world_tracker_world_anchor_status_wrapped = mod.cwrap("zappar_world_tracker_world_anchor_status", "number", [
+        "number"
+    ]);
+    let world_tracker_world_anchor_id_wrapped = mod.cwrap("zappar_world_tracker_world_anchor_id", "string", [
         "number"
     ]);
     let world_tracker_world_anchor_pose_raw_wrapped = mod.cwrap("zappar_world_tracker_world_anchor_pose_raw", "number", [
         "number"
     ]);
-    let world_tracker_ground_anchor_valid_wrapped = mod.cwrap("zappar_world_tracker_ground_anchor_valid", "number", [
+    let world_tracker_ground_anchor_id_wrapped = mod.cwrap("zappar_world_tracker_ground_anchor_id", "string", [
+        "number"
+    ]);
+    let world_tracker_ground_anchor_status_wrapped = mod.cwrap("zappar_world_tracker_ground_anchor_status", "number", [
         "number"
     ]);
     let world_tracker_ground_anchor_pose_raw_wrapped = mod.cwrap("zappar_world_tracker_ground_anchor_pose_raw", "number", [
@@ -298,6 +335,29 @@ export function getRuntimeObject(mod) {
     let world_tracker_projections_data_wrapped = mod.cwrap("zappar_world_tracker_projections_data", "number", [
         "number"
     ]);
+    let custom_anchor_create_wrapped = mod.cwrap("zappar_custom_anchor_create", "number", ["number", "number", "string"]);
+    let custom_anchor_destroy_wrapped = mod.cwrap("zappar_custom_anchor_destroy", null, ["number"]);
+    let custom_anchor_status_wrapped = mod.cwrap("zappar_custom_anchor_status", "number", [
+        "number"
+    ]);
+    let custom_anchor_enabled_set_wrapped = mod.cwrap("zappar_custom_anchor_enabled_set", null, [
+        "number",
+        "number"
+    ]);
+    let custom_anchor_enabled_wrapped = mod.cwrap("zappar_custom_anchor_enabled", "number", [
+        "number"
+    ]);
+    let custom_anchor_pose_raw_wrapped = mod.cwrap("zappar_custom_anchor_pose_raw", "number", [
+        "number"
+    ]);
+    let custom_anchor_pose_set_from_camera_offset_raw_wrapped = mod.cwrap("zappar_custom_anchor_pose_set_from_camera_offset_raw", null, [
+        "number",
+        "number", "number", "number", "number"
+    ]);
+    let custom_anchor_pose_set_from_anchor_offset_wrapped = mod.cwrap("zappar_custom_anchor_pose_set_from_anchor_offset", null, [
+        "number",
+        "string", "number", "number", "number", "number"
+    ]);
     let dataArrayArgLength = 32;
     let dataArrayArg = mod._malloc(dataArrayArgLength);
     let floatDataArrayArgLength = 16 * 4;
@@ -784,31 +844,78 @@ export function getRuntimeObject(mod) {
             let ret = world_tracker_quality_wrapped(o);
             return ret;
         },
-        world_tracker_plane_detection_enabled: (o) => {
-            let ret = world_tracker_plane_detection_enabled_wrapped(o);
+        world_tracker_horizontal_plane_detection_enabled: (o) => {
+            let ret = world_tracker_horizontal_plane_detection_enabled_wrapped(o);
+            ret = ret === 1;
+            return ret;
+        },
+        world_tracker_horizontal_plane_detection_enabled_set: (o, horizontal_plane_detection_enabled) => {
+            let arg_horizontal_plane_detection_enabled = horizontal_plane_detection_enabled ? 1 : 0;
+            let ret = world_tracker_horizontal_plane_detection_enabled_set_wrapped(o, arg_horizontal_plane_detection_enabled);
+            return ret;
+        },
+        world_tracker_vertical_plane_detection_enabled: (o) => {
+            let ret = world_tracker_vertical_plane_detection_enabled_wrapped(o);
             ret = ret === 1;
             return ret;
         },
-        world_tracker_plane_detection_enabled_set: (o, plane_detection_enabled) => {
-            let arg_plane_detection_enabled = plane_detection_enabled ? 1 : 0;
-            let ret = world_tracker_plane_detection_enabled_set_wrapped(o, arg_plane_detection_enabled);
+        world_tracker_vertical_plane_detection_enabled_set: (o, vertical_plane_detection_enabled) => {
+            let arg_vertical_plane_detection_enabled = vertical_plane_detection_enabled ? 1 : 0;
+            let ret = world_tracker_vertical_plane_detection_enabled_set_wrapped(o, arg_vertical_plane_detection_enabled);
+            return ret;
+        },
+        world_tracker_plane_anchor_count: (o) => {
+            let ret = world_tracker_plane_anchor_count_wrapped(o);
             return ret;
         },
-        world_tracker_plane_count: (o) => {
-            let ret = world_tracker_plane_count_wrapped(o);
+        world_tracker_plane_anchor_id: (o, indx) => {
+            let arg_indx = indx;
+            let ret = world_tracker_plane_anchor_id_wrapped(o, arg_indx);
             return ret;
         },
-        world_tracker_plane_pose_raw: (o, indx) => {
+        world_tracker_plane_anchor_pose_raw: (o, indx) => {
             let arg_indx = indx;
-            let ret = world_tracker_plane_pose_raw_wrapped(o, arg_indx);
+            let ret = world_tracker_plane_anchor_pose_raw_wrapped(o, arg_indx);
             let ab = new Float32Array(16);
             ab.set(mod.HEAPF32.subarray(ret / 4, 16 + ret / 4));
             ret = ab;
             return ret;
         },
-        world_tracker_world_anchor_valid: (o) => {
-            let ret = world_tracker_world_anchor_valid_wrapped(o);
-            ret = ret === 1;
+        world_tracker_plane_anchor_status: (o, indx) => {
+            let arg_indx = indx;
+            let ret = world_tracker_plane_anchor_status_wrapped(o, arg_indx);
+            return ret;
+        },
+        world_tracker_plane_anchor_polygon_data_size: (o, indx) => {
+            let arg_indx = indx;
+            let ret = world_tracker_plane_anchor_polygon_data_size_wrapped(o, arg_indx);
+            return ret;
+        },
+        world_tracker_plane_anchor_polygon_data: (o, indx) => {
+            let arg_indx = indx;
+            let ret = world_tracker_plane_anchor_polygon_data_wrapped(o, arg_indx);
+            let retsize = world_tracker_plane_anchor_polygon_data_size_wrapped(o, indx);
+            let ab = new Float32Array(retsize);
+            ab.set(mod.HEAPF32.subarray(ret / 4, retsize + ret / 4));
+            ret = ab;
+            return ret;
+        },
+        world_tracker_plane_anchor_polygon_version: (o, indx) => {
+            let arg_indx = indx;
+            let ret = world_tracker_plane_anchor_polygon_version_wrapped(o, arg_indx);
+            return ret;
+        },
+        world_tracker_plane_anchor_orientation: (o, indx) => {
+            let arg_indx = indx;
+            let ret = world_tracker_plane_anchor_orientation_wrapped(o, arg_indx);
+            return ret;
+        },
+        world_tracker_world_anchor_status: (o) => {
+            let ret = world_tracker_world_anchor_status_wrapped(o);
+            return ret;
+        },
+        world_tracker_world_anchor_id: (o) => {
+            let ret = world_tracker_world_anchor_id_wrapped(o);
             return ret;
         },
         world_tracker_world_anchor_pose_raw: (o) => {
@@ -818,9 +925,12 @@ export function getRuntimeObject(mod) {
             ret = ab;
             return ret;
         },
-        world_tracker_ground_anchor_valid: (o) => {
-            let ret = world_tracker_ground_anchor_valid_wrapped(o);
-            ret = ret === 1;
+        world_tracker_ground_anchor_id: (o) => {
+            let ret = world_tracker_ground_anchor_id_wrapped(o);
+            return ret;
+        },
+        world_tracker_ground_anchor_status: (o) => {
+            let ret = world_tracker_ground_anchor_status_wrapped(o);
             return ret;
         },
         world_tracker_ground_anchor_pose_raw: (o) => {
@@ -890,5 +1000,52 @@ export function getRuntimeObject(mod) {
             ret = ab;
             return ret;
         },
+        custom_anchor_create: (pipeline, worldtracker, id) => {
+            let arg_pipeline = pipeline;
+            let arg_worldtracker = worldtracker;
+            let arg_id = id;
+            return custom_anchor_create_wrapped(arg_pipeline, arg_worldtracker, arg_id);
+        },
+        custom_anchor_destroy: () => {
+            custom_anchor_destroy_wrapped();
+        },
+        custom_anchor_status: (o) => {
+            let ret = custom_anchor_status_wrapped(o);
+            return ret;
+        },
+        custom_anchor_enabled_set: (o, enabled) => {
+            let arg_enabled = enabled ? 1 : 0;
+            let ret = custom_anchor_enabled_set_wrapped(o, arg_enabled);
+            return ret;
+        },
+        custom_anchor_enabled: (o) => {
+            let ret = custom_anchor_enabled_wrapped(o);
+            ret = ret === 1;
+            return ret;
+        },
+        custom_anchor_pose_raw: (o) => {
+            let ret = custom_anchor_pose_raw_wrapped(o);
+            let ab = new Float32Array(16);
+            ab.set(mod.HEAPF32.subarray(ret / 4, 16 + ret / 4));
+            ret = ab;
+            return ret;
+        },
+        custom_anchor_pose_set_from_camera_offset_raw: (o, x, y, z, orientation) => {
+            let arg_x = x;
+            let arg_y = y;
+            let arg_z = z;
+            let arg_orientation = orientation;
+            let ret = custom_anchor_pose_set_from_camera_offset_raw_wrapped(o, arg_x, arg_y, arg_z, arg_orientation);
+            return ret;
+        },
+        custom_anchor_pose_set_from_anchor_offset: (o, anchor_id, x, y, z, orientation) => {
+            let arg_anchor_id = anchor_id;
+            let arg_x = x;
+            let arg_y = y;
+            let arg_z = z;
+            let arg_orientation = orientation;
+            let ret = custom_anchor_pose_set_from_anchor_offset_wrapped(o, arg_anchor_id, arg_x, arg_y, arg_z, arg_orientation);
+            return ret;
+        },
     };
 }

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

@@ -40,6 +40,12 @@ export declare enum instant_world_tracker_transform_orientation_t {
     MINUS_Z_HEADING = 5,
     UNCHANGED = 6
 }
+export declare enum transform_orientation_t {
+    UNCHANGED = 0,
+    WORLD = 1,
+    PARENT = 2,
+    Z_TOWARDS_CAMERA = 3
+}
 export declare enum log_level_t {
     LOG_LEVEL_NONE = 0,
     LOG_LEVEL_ERROR = 1,
@@ -64,7 +70,17 @@ export declare enum image_target_type_t {
 export declare enum world_tracker_quality_t {
     WORLD_TRACKER_QUALITY_INITIALIZING = 0,
     WORLD_TRACKER_QUALITY_GOOD = 1,
-    WORLD_TRACKER_QUALITY_ORIENTATION_ONLY = 2
+    WORLD_TRACKER_QUALITY_LIMITED = 2
+}
+export declare enum anchor_status_t {
+    ANCHOR_STATUS_INITIALIZING = 0,
+    ANCHOR_STATUS_TRACKING = 1,
+    ANCHOR_STATUS_PAUSED = 2,
+    ANCHOR_STATUS_STOPPED = 3
+}
+export declare enum plane_orientation_t {
+    PLANE_ORIENTATION_HORIZONTAL = 0,
+    PLANE_ORIENTATION_VERTICAL = 1
 }
 export declare enum camera_profile_t {
     DEFAULT = 0,
@@ -103,6 +119,9 @@ export declare type zappar_zapcode_tracker_t = number & {
 export declare type zappar_world_tracker_t = number & {
     _: 'zappar_world_tracker_t';
 };
+export declare type zappar_custom_anchor_t = number & {
+    _: 'zappar_custom_anchor_t';
+};
 export interface zappar_cwrap {
     log_level(): log_level_t;
     log_level_set(level: log_level_t): void;
@@ -188,13 +207,23 @@ export interface zappar_cwrap {
     world_tracker_enabled(o: zappar_world_tracker_t): boolean;
     world_tracker_enabled_set(o: zappar_world_tracker_t, enabled: boolean): void;
     world_tracker_quality(o: zappar_world_tracker_t): number;
-    world_tracker_plane_detection_enabled(o: zappar_world_tracker_t): boolean;
-    world_tracker_plane_detection_enabled_set(o: zappar_world_tracker_t, plane_detection_enabled: boolean): void;
-    world_tracker_plane_count(o: zappar_world_tracker_t): number;
-    world_tracker_plane_pose_raw(o: zappar_world_tracker_t, indx: number): Float32Array;
-    world_tracker_world_anchor_valid(o: zappar_world_tracker_t): boolean;
+    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;
+    world_tracker_vertical_plane_detection_enabled(o: zappar_world_tracker_t): boolean;
+    world_tracker_vertical_plane_detection_enabled_set(o: zappar_world_tracker_t, vertical_plane_detection_enabled: boolean): void;
+    world_tracker_plane_anchor_count(o: zappar_world_tracker_t): number;
+    world_tracker_plane_anchor_id(o: zappar_world_tracker_t, indx: number): string;
+    world_tracker_plane_anchor_pose_raw(o: zappar_world_tracker_t, indx: number): Float32Array;
+    world_tracker_plane_anchor_status(o: zappar_world_tracker_t, indx: number): anchor_status_t;
+    world_tracker_plane_anchor_polygon_data_size(o: zappar_world_tracker_t, indx: number): number;
+    world_tracker_plane_anchor_polygon_data(o: zappar_world_tracker_t, indx: number): Float32Array;
+    world_tracker_plane_anchor_polygon_version(o: zappar_world_tracker_t, indx: number): number;
+    world_tracker_plane_anchor_orientation(o: zappar_world_tracker_t, indx: number): plane_orientation_t;
+    world_tracker_world_anchor_status(o: zappar_world_tracker_t): anchor_status_t;
+    world_tracker_world_anchor_id(o: zappar_world_tracker_t): string;
     world_tracker_world_anchor_pose_raw(o: zappar_world_tracker_t): Float32Array;
-    world_tracker_ground_anchor_valid(o: zappar_world_tracker_t): boolean;
+    world_tracker_ground_anchor_id(o: zappar_world_tracker_t): string;
+    world_tracker_ground_anchor_status(o: zappar_world_tracker_t): anchor_status_t;
     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;
@@ -207,4 +236,12 @@ export interface zappar_cwrap {
     world_tracker_projections_data_enabled_set(o: zappar_world_tracker_t, projections_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;
+    custom_anchor_create(pipeline: zappar_pipeline_t, worldtracker: zappar_world_tracker_t, id: string): zappar_custom_anchor_t;
+    custom_anchor_destroy(o: zappar_custom_anchor_t): void;
+    custom_anchor_status(o: zappar_custom_anchor_t): anchor_status_t;
+    custom_anchor_enabled_set(o: zappar_custom_anchor_t, enabled: boolean): void;
+    custom_anchor_enabled(o: zappar_custom_anchor_t): boolean;
+    custom_anchor_pose_raw(o: zappar_custom_anchor_t): Float32Array;
+    custom_anchor_pose_set_from_camera_offset_raw(o: zappar_custom_anchor_t, x: number, y: number, z: number, orientation: transform_orientation_t): void;
+    custom_anchor_pose_set_from_anchor_offset(o: zappar_custom_anchor_t, anchor_id: string, x: number, y: number, z: number, orientation: transform_orientation_t): void;
 }

package/lib/gen/zappar-native.js

@@ -46,6 +46,14 @@ export var instant_world_tracker_transform_orientation_t;
     instant_world_tracker_transform_orientation_t[instant_world_tracker_transform_orientation_t["UNCHANGED"] = 6] = "UNCHANGED";
 })(instant_world_tracker_transform_orientation_t || (instant_world_tracker_transform_orientation_t = {}));
 ;
+export var transform_orientation_t;
+(function (transform_orientation_t) {
+    transform_orientation_t[transform_orientation_t["UNCHANGED"] = 0] = "UNCHANGED";
+    transform_orientation_t[transform_orientation_t["WORLD"] = 1] = "WORLD";
+    transform_orientation_t[transform_orientation_t["PARENT"] = 2] = "PARENT";
+    transform_orientation_t[transform_orientation_t["Z_TOWARDS_CAMERA"] = 3] = "Z_TOWARDS_CAMERA";
+})(transform_orientation_t || (transform_orientation_t = {}));
+;
 export var log_level_t;
 (function (log_level_t) {
     log_level_t[log_level_t["LOG_LEVEL_NONE"] = 0] = "LOG_LEVEL_NONE";
@@ -77,9 +85,23 @@ export var world_tracker_quality_t;
 (function (world_tracker_quality_t) {
     world_tracker_quality_t[world_tracker_quality_t["WORLD_TRACKER_QUALITY_INITIALIZING"] = 0] = "WORLD_TRACKER_QUALITY_INITIALIZING";
     world_tracker_quality_t[world_tracker_quality_t["WORLD_TRACKER_QUALITY_GOOD"] = 1] = "WORLD_TRACKER_QUALITY_GOOD";
-    world_tracker_quality_t[world_tracker_quality_t["WORLD_TRACKER_QUALITY_ORIENTATION_ONLY"] = 2] = "WORLD_TRACKER_QUALITY_ORIENTATION_ONLY";
+    world_tracker_quality_t[world_tracker_quality_t["WORLD_TRACKER_QUALITY_LIMITED"] = 2] = "WORLD_TRACKER_QUALITY_LIMITED";
 })(world_tracker_quality_t || (world_tracker_quality_t = {}));
 ;
+export var anchor_status_t;
+(function (anchor_status_t) {
+    anchor_status_t[anchor_status_t["ANCHOR_STATUS_INITIALIZING"] = 0] = "ANCHOR_STATUS_INITIALIZING";
+    anchor_status_t[anchor_status_t["ANCHOR_STATUS_TRACKING"] = 1] = "ANCHOR_STATUS_TRACKING";
+    anchor_status_t[anchor_status_t["ANCHOR_STATUS_PAUSED"] = 2] = "ANCHOR_STATUS_PAUSED";
+    anchor_status_t[anchor_status_t["ANCHOR_STATUS_STOPPED"] = 3] = "ANCHOR_STATUS_STOPPED";
+})(anchor_status_t || (anchor_status_t = {}));
+;
+export var plane_orientation_t;
+(function (plane_orientation_t) {
+    plane_orientation_t[plane_orientation_t["PLANE_ORIENTATION_HORIZONTAL"] = 0] = "PLANE_ORIENTATION_HORIZONTAL";
+    plane_orientation_t[plane_orientation_t["PLANE_ORIENTATION_VERTICAL"] = 1] = "PLANE_ORIENTATION_VERTICAL";
+})(plane_orientation_t || (plane_orientation_t = {}));
+;
 export var camera_profile_t;
 (function (camera_profile_t) {
     camera_profile_t[camera_profile_t["DEFAULT"] = 0] = "DEFAULT";

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

@@ -11,6 +11,7 @@ import { zappar_barcode_finder_t } from "./zappar-native";
 import { zappar_instant_world_tracker_t } from "./zappar-native";
 import { zappar_zapcode_tracker_t } from "./zappar-native";
 import { zappar_world_tracker_t } from "./zappar-native";
+import { zappar_custom_anchor_t } from "./zappar-native";
 export declare class zappar_server {
     private _impl;
     private _sender;
@@ -39,6 +40,8 @@ export declare class zappar_server {
     _zapcode_tracker_by_instance: Map<number, zappar_zapcode_tracker_t>;
     _pipeline_id_by_world_tracker_id: Map<number, number>;
     _world_tracker_by_instance: Map<number, zappar_world_tracker_t>;
+    _pipeline_id_by_custom_anchor_id: Map<number, number>;
+    _custom_anchor_by_instance: Map<number, zappar_custom_anchor_t>;
     processBuffer(b: ArrayBuffer): void;
     exploreState(): void;
 }

package/lib/gen/zappar-server.js

@@ -28,6 +28,8 @@ export class zappar_server {
         this._zapcode_tracker_by_instance = new Map();
         this._pipeline_id_by_world_tracker_id = new Map();
         this._world_tracker_by_instance = new Map();
+        this._pipeline_id_by_custom_anchor_id = new Map();
+        this._custom_anchor_by_instance = new Map();
     }
     processBuffer(b) {
         this._deserializer.setData(b);
@@ -417,7 +419,7 @@ export class zappar_server {
                     let obj = this._world_tracker_by_instance.get(clientId);
                     if (obj === undefined)
                         return;
-                    this._impl.world_tracker_plane_detection_enabled_set(obj, msg.bool());
+                    this._impl.world_tracker_horizontal_plane_detection_enabled_set(obj, msg.bool());
                     break;
                 }
                 case 49: {
@@ -425,7 +427,7 @@ export class zappar_server {
                     let obj = this._world_tracker_by_instance.get(clientId);
                     if (obj === undefined)
                         return;
-                    this._impl.world_tracker_reset(obj);
+                    this._impl.world_tracker_vertical_plane_detection_enabled_set(obj, msg.bool());
                     break;
                 }
                 case 50: {
@@ -433,10 +435,18 @@ export class zappar_server {
                     let obj = this._world_tracker_by_instance.get(clientId);
                     if (obj === undefined)
                         return;
-                    this._impl.world_tracker_tracks_data_enabled_set(obj, msg.bool());
+                    this._impl.world_tracker_reset(obj);
                     break;
                 }
                 case 51: {
+                    let clientId = msg.type();
+                    let obj = this._world_tracker_by_instance.get(clientId);
+                    if (obj === undefined)
+                        return;
+                    this._impl.world_tracker_tracks_data_enabled_set(obj, msg.bool());
+                    break;
+                }
+                case 52: {
                     let clientId = msg.type();
                     let obj = this._world_tracker_by_instance.get(clientId);
                     if (obj === undefined)
@@ -444,6 +454,51 @@ export class zappar_server {
                     this._impl.world_tracker_projections_data_enabled_set(obj, msg.bool());
                     break;
                 }
+                case 53: {
+                    let clientId = msg.type();
+                    let arg_pipeline_id = msg.type();
+                    let arg_pipeline = this._pipeline_by_instance.get(arg_pipeline_id);
+                    let arg_worldtracker_id = msg.type();
+                    let arg_worldtracker = this._world_tracker_by_instance.get(arg_worldtracker_id);
+                    let arg_id = msg.string();
+                    let handle = this._impl.custom_anchor_create(arg_pipeline, arg_worldtracker, arg_id);
+                    this._custom_anchor_by_instance.set(clientId, handle);
+                    this._pipeline_id_by_custom_anchor_id.set(clientId, arg_pipeline_id);
+                    break;
+                }
+                case 54: {
+                    let clientId = msg.type();
+                    let obj = this._custom_anchor_by_instance.get(clientId);
+                    if (obj === undefined)
+                        return;
+                    this._impl.custom_anchor_destroy(obj);
+                    this._custom_anchor_by_instance.delete(clientId);
+                    break;
+                }
+                case 55: {
+                    let clientId = msg.type();
+                    let obj = this._custom_anchor_by_instance.get(clientId);
+                    if (obj === undefined)
+                        return;
+                    this._impl.custom_anchor_enabled_set(obj, msg.bool());
+                    break;
+                }
+                case 56: {
+                    let clientId = msg.type();
+                    let obj = this._custom_anchor_by_instance.get(clientId);
+                    if (obj === undefined)
+                        return;
+                    this._impl.custom_anchor_pose_set_from_camera_offset_raw(obj, msg.float(), msg.float(), msg.float(), msg.transformOrientation());
+                    break;
+                }
+                case 57: {
+                    let clientId = msg.type();
+                    let obj = this._custom_anchor_by_instance.get(clientId);
+                    if (obj === undefined)
+                        return;
+                    this._impl.custom_anchor_pose_set_from_anchor_offset(obj, msg.string(), msg.float(), msg.float(), msg.float(), msg.transformOrientation());
+                    break;
+                }
             }
         });
     }
@@ -657,61 +712,127 @@ export class zappar_server {
             let serializer = this.serializersByPipelineId.get(pipeline);
             if (!serializer)
                 continue;
-            serializer.sendMessage(31, msg => {
+            serializer.sendMessage(40, msg => {
                 msg.type(k);
                 msg.int(this._impl.world_tracker_quality(v));
             });
             serializer.sendMessage(25, msg => {
                 msg.type(k);
-                msg.int(this._impl.world_tracker_plane_count(v));
+                msg.int(this._impl.world_tracker_plane_anchor_count(v));
             });
-            for (let i = 0; i < this._impl.world_tracker_plane_count(v); i++) {
+            for (let i = 0; i < this._impl.world_tracker_plane_anchor_count(v); i++) {
+                serializer.sendMessage(33, msg => {
+                    msg.type(k);
+                    msg.int(i);
+                    msg.string(this._impl.world_tracker_plane_anchor_id(v, i));
+                });
+            }
+            for (let i = 0; i < this._impl.world_tracker_plane_anchor_count(v); i++) {
                 serializer.sendMessage(26, msg => {
                     msg.type(k);
                     msg.int(i);
-                    msg.matrix4x4(this._impl.world_tracker_plane_pose_raw(v, i));
+                    msg.matrix4x4(this._impl.world_tracker_plane_anchor_pose_raw(v, i));
                 });
             }
-            serializer.sendMessage(27, msg => {
+            for (let i = 0; i < this._impl.world_tracker_plane_anchor_count(v); i++) {
+                serializer.sendMessage(28, msg => {
+                    msg.type(k);
+                    msg.int(i);
+                    msg.anchorStatus(this._impl.world_tracker_plane_anchor_status(v, i));
+                });
+            }
+            for (let i = 0; i < this._impl.world_tracker_plane_anchor_count(v); i++) {
+                serializer.sendMessage(29, msg => {
+                    msg.type(k);
+                    msg.int(i);
+                    msg.int(this._impl.world_tracker_plane_anchor_polygon_data_size(v, i));
+                });
+            }
+            for (let i = 0; i < this._impl.world_tracker_plane_anchor_count(v); i++) {
+                serializer.sendMessage(30, msg => {
+                    msg.type(k);
+                    msg.int(i);
+                    msg.floatArray(this._impl.world_tracker_plane_anchor_polygon_data(v, i));
+                });
+            }
+            for (let i = 0; i < this._impl.world_tracker_plane_anchor_count(v); i++) {
+                serializer.sendMessage(31, msg => {
+                    msg.type(k);
+                    msg.int(i);
+                    msg.int(this._impl.world_tracker_plane_anchor_polygon_version(v, i));
+                });
+            }
+            for (let i = 0; i < this._impl.world_tracker_plane_anchor_count(v); i++) {
+                serializer.sendMessage(32, msg => {
+                    msg.type(k);
+                    msg.int(i);
+                    msg.planeOrientation(this._impl.world_tracker_plane_anchor_orientation(v, i));
+                });
+            }
+            serializer.sendMessage(36, msg => {
                 msg.type(k);
-                msg.bool(this._impl.world_tracker_world_anchor_valid(v));
+                msg.anchorStatus(this._impl.world_tracker_world_anchor_status(v));
             });
-            serializer.sendMessage(28, msg => {
+            serializer.sendMessage(35, msg => {
+                msg.type(k);
+                msg.string(this._impl.world_tracker_world_anchor_id(v));
+            });
+            serializer.sendMessage(34, msg => {
                 msg.type(k);
                 msg.matrix4x4(this._impl.world_tracker_world_anchor_pose_raw(v));
             });
-            serializer.sendMessage(27, msg => {
+            serializer.sendMessage(38, msg => {
+                msg.type(k);
+                msg.string(this._impl.world_tracker_ground_anchor_id(v));
+            });
+            serializer.sendMessage(39, msg => {
                 msg.type(k);
-                msg.bool(this._impl.world_tracker_ground_anchor_valid(v));
+                msg.anchorStatus(this._impl.world_tracker_ground_anchor_status(v));
             });
-            serializer.sendMessage(30, msg => {
+            serializer.sendMessage(37, msg => {
                 msg.type(k);
                 msg.matrix4x4(this._impl.world_tracker_ground_anchor_pose_raw(v));
             });
-            serializer.sendMessage(34, msg => {
+            serializer.sendMessage(43, msg => {
                 msg.type(k);
                 msg.int(this._impl.world_tracker_tracks_data_size(v));
             });
-            serializer.sendMessage(33, msg => {
+            serializer.sendMessage(42, msg => {
                 msg.type(k);
                 msg.floatArray(this._impl.world_tracker_tracks_data(v));
             });
-            serializer.sendMessage(36, msg => {
+            serializer.sendMessage(45, msg => {
                 msg.type(k);
                 msg.int(this._impl.world_tracker_tracks_type_data_size(v));
             });
-            serializer.sendMessage(35, msg => {
+            serializer.sendMessage(44, msg => {
                 msg.type(k);
                 msg.ucharArray(this._impl.world_tracker_tracks_type_data(v));
             });
-            serializer.sendMessage(39, msg => {
+            serializer.sendMessage(48, msg => {
                 msg.type(k);
                 msg.int(this._impl.world_tracker_projections_data_size(v));
             });
-            serializer.sendMessage(38, msg => {
+            serializer.sendMessage(47, msg => {
                 msg.type(k);
                 msg.floatArray(this._impl.world_tracker_projections_data(v));
             });
         }
+        for (let [k, v] of this._custom_anchor_by_instance) {
+            let pipeline = this._pipeline_id_by_custom_anchor_id.get(k);
+            if (!pipeline)
+                continue;
+            let serializer = this.serializersByPipelineId.get(pipeline);
+            if (!serializer)
+                continue;
+            serializer.sendMessage(50, msg => {
+                msg.type(k);
+                msg.anchorStatus(this._impl.custom_anchor_status(v));
+            });
+            serializer.sendMessage(49, msg => {
+                msg.type(k);
+                msg.matrix4x4(this._impl.custom_anchor_pose_raw(v));
+            });
+        }
     }
 }