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

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

package/lib/additional.d.ts

@@ -15,6 +15,7 @@ export interface Additional {
     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;
+    draw_axis(gl: WebGLRenderingContext, projectionMatrix: Float32Array, cameraMatrix: Float32Array, targetMatrix: Float32Array): void;
     image_tracker_target_image(o: zappar_image_tracker_t, indx: number): HTMLImageElement | undefined;
     face_mesh_load_default(o: zappar_face_mesh_t): Promise<void>;
     face_mesh_load_default_face(o: zappar_face_mesh_t, fillMouth: boolean, fillEyeL: boolean, fillEyeR: boolean): Promise<void>;

package/lib/deserializer.d.ts

@@ -1,4 +1,4 @@
-import { barcode_format_t, face_landmark_name_t, instant_world_tracker_transform_orientation_t, log_level_t } from "./gen/zappar-native";
+import { barcode_format_t, face_landmark_name_t, instant_world_tracker_transform_orientation_t, transform_orientation_t, log_level_t, plane_orientation_t, anchor_status_t } from "./gen/zappar-native";
 interface Message {
     int: () => number;
     float: () => number;
@@ -17,6 +17,9 @@ interface Message {
     barcodeFormat: () => barcode_format_t;
     faceLandmarkName: () => face_landmark_name_t;
     instantTrackerTransformOrientation: () => instant_world_tracker_transform_orientation_t;
+    transformOrientation: () => transform_orientation_t;
+    planeOrientation: () => plane_orientation_t;
+    anchorStatus: () => anchor_status_t;
     logLevel: () => log_level_t;
 }
 export declare class MessageDeserializer {

package/lib/deserializer.js

@@ -94,6 +94,9 @@ export class MessageDeserializer {
             barcodeFormat: () => this._i32View[this._startOffset++],
             faceLandmarkName: () => this._i32View[this._startOffset++],
             instantTrackerTransformOrientation: () => this._i32View[this._startOffset++],
+            transformOrientation: () => this._i32View[this._startOffset++],
+            planeOrientation: () => this._i32View[this._startOffset++],
+            anchorStatus: () => this._i32View[this._startOffset++],
             logLevel: () => this._i32View[this._startOffset++],
         };
     }

package/lib/drawgrid.js

@@ -100,8 +100,8 @@ 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)) {
+    vec2 pixels = 500.0 * vTextureCoord + 0.5;
+    if ((int(mod(pixels.x, 50.0)) == 0) || (int(mod(pixels.y, 50.0)) == 0)) {
         gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
     } else {
         discard;

package/lib/drawpolygon.d.ts

@@ -0,0 +1,5 @@
+export declare class PolygonDraw {
+    private _vbo;
+    private _generate;
+    drawPolygon(gl: WebGLRenderingContext, projectionMatrix: Float32Array, cameraMatrix: Float32Array, targetMatrix: Float32Array, points: Float32Array): void;
+}

package/lib/drawpolygon.js

@@ -0,0 +1,94 @@
+import { compileShader, linkProgram } from "./shader";
+let shader;
+export class PolygonDraw {
+    _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;
+    }
+    drawPolygon(gl, projectionMatrix, cameraMatrix, targetMatrix, points) {
+        let shader = getShader(gl);
+        let v = this._generate(gl, points);
+        gl.disable(gl.DEPTH_TEST);
+        gl.disable(gl.SCISSOR_TEST);
+        gl.disable(gl.CULL_FACE);
+        gl.disable(gl.STENCIL_TEST);
+        gl.disable(gl.BLEND);
+        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, 2, gl.FLOAT, false, 0, 0);
+        gl.enableVertexAttribArray(shader.attr_position);
+        gl.drawArrays(gl.LINE_LOOP, 0, points.length / 2);
+        gl.disableVertexAttribArray(shader.attr_position);
+        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 vec2 position;
+
+void main()
+{
+    gl_Position = projMatrix * cameraMatrix * modelViewMatrix * vec4(position.x, 0.0, position.y, 1.0);
+}`;
+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
+
+void main()
+{
+    gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
+}`;
+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"),
+    };
+    return shader;
+}

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

@@ -5,10 +5,16 @@ export { face_landmark_name_t } from "./zappar-native";
 export { frame_pixel_format_t } from "./zappar-native";
 import { instant_world_tracker_transform_orientation_t } from "./zappar-native";
 export { instant_world_tracker_transform_orientation_t } from "./zappar-native";
+import { transform_orientation_t } from "./zappar-native";
+export { transform_orientation_t } from "./zappar-native";
+import { plane_orientation_t } from "./zappar-native";
+export { plane_orientation_t } from "./zappar-native";
 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";
+import { anchor_status_t } from "./zappar-native";
+export { anchor_status_t } from "./zappar-native";
 export { camera_profile_t } from "./zappar-native";
 export declare type zappar_pipeline_t = number & {
     _: 'zappar_pipeline_t';
@@ -43,6 +49,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 {
     log_level(): log_level_t;
     log_level_set(level: log_level_t): void;
@@ -123,13 +132,23 @@ export interface zappar {
     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;
@@ -142,4 +161,12 @@ export interface zappar {
     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-bridge.js

@@ -2,7 +2,10 @@ export { barcode_format_t } from "./zappar-native";
 export { face_landmark_name_t } from "./zappar-native";
 export { frame_pixel_format_t } from "./zappar-native";
 export { instant_world_tracker_transform_orientation_t } from "./zappar-native";
+export { transform_orientation_t } from "./zappar-native";
+export { plane_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 { anchor_status_t } from "./zappar-native";
 export { camera_profile_t } from "./zappar-native";

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

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