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

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.16/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.16/zappar-cv.zip](https://libs.zappar.com/zappar-cv/3.0.1-alpha.16/zappar-cv.zip)

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

@@ -127,6 +127,9 @@ export interface zappar {
     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_plane_visible(o: zappar_world_tracker_t, indx: number): boolean;
+    world_tracker_plane_polygon_data_size(o: zappar_world_tracker_t, indx: number): number;
+    world_tracker_plane_polygon_data(o: zappar_world_tracker_t, indx: number): Float32Array;
     world_tracker_world_anchor_valid(o: zappar_world_tracker_t): boolean;
     world_tracker_world_anchor_pose_raw(o: zappar_world_tracker_t): Float32Array;
     world_tracker_ground_anchor_valid(o: zappar_world_tracker_t): boolean;

package/lib/gen/zappar-client.js

@@ -683,6 +683,9 @@ export class zappar_client {
                     plane_detection_enabled: true,
                     plane_count: 0,
                     plane_pose: [],
+                    plane_visible: [],
+                    plane_polygon_data: [],
+                    plane_polygon_data_size: [],
                     world_anchor_valid: false,
                     world_anchor_pose: new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]),
                     ground_anchor_valid: false,
@@ -761,6 +764,24 @@ export class zappar_client {
                     throw new Error("This object has been destroyed");
                 return s.plane_pose[indx];
             },
+            world_tracker_plane_visible: (o, indx) => {
+                let s = this._world_tracker_state_by_instance.get(o);
+                if (!s)
+                    throw new Error("This object has been destroyed");
+                return s.plane_visible[indx];
+            },
+            world_tracker_plane_polygon_data_size: (o, indx) => {
+                let s = this._world_tracker_state_by_instance.get(o);
+                if (!s)
+                    throw new Error("This object has been destroyed");
+                return s.plane_polygon_data_size[indx];
+            },
+            world_tracker_plane_polygon_data: (o, indx) => {
+                let s = this._world_tracker_state_by_instance.get(o);
+                if (!s)
+                    throw new Error("This object has been destroyed");
+                return s.plane_polygon_data[indx];
+            },
             world_tracker_world_anchor_valid: (o) => {
                 let s = this._world_tracker_state_by_instance.get(o);
                 if (!s)
@@ -1059,7 +1080,7 @@ export class zappar_client {
                     inst.anchor_pose[indx] = msg.matrix4x4();
                     break;
                 }
-                case 31: {
+                case 34: {
                     let handle = msg.type();
                     let inst = this._world_tracker_state_by_instance.get(handle);
                     if (!inst)
@@ -1089,7 +1110,8 @@ export class zappar_client {
                     let inst = this._world_tracker_state_by_instance.get(handle);
                     if (!inst)
                         return;
-                    inst.world_anchor_valid = msg.bool();
+                    let indx = msg.int();
+                    inst.plane_visible[indx] = msg.bool();
                     break;
                 }
                 case 28: {
@@ -1097,10 +1119,20 @@ export class zappar_client {
                     let inst = this._world_tracker_state_by_instance.get(handle);
                     if (!inst)
                         return;
-                    inst.world_anchor_pose = msg.matrix4x4();
+                    let indx = msg.int();
+                    inst.plane_polygon_data_size[indx] = msg.int();
                     break;
                 }
-                case 27: {
+                case 29: {
+                    let handle = msg.type();
+                    let inst = this._world_tracker_state_by_instance.get(handle);
+                    if (!inst)
+                        return;
+                    let indx = msg.int();
+                    inst.plane_polygon_data[indx] = msg.floatArray();
+                    break;
+                }
+                case 30: {
                     let handle = msg.type();
                     let inst = this._world_tracker_state_by_instance.get(handle);
                     if (!inst)
@@ -1108,7 +1140,23 @@ export class zappar_client {
                     inst.world_anchor_valid = msg.bool();
                     break;
                 }
+                case 31: {
+                    let handle = msg.type();
+                    let inst = this._world_tracker_state_by_instance.get(handle);
+                    if (!inst)
+                        return;
+                    inst.world_anchor_pose = msg.matrix4x4();
+                    break;
+                }
                 case 30: {
+                    let handle = msg.type();
+                    let inst = this._world_tracker_state_by_instance.get(handle);
+                    if (!inst)
+                        return;
+                    inst.world_anchor_valid = msg.bool();
+                    break;
+                }
+                case 33: {
                     let handle = msg.type();
                     let inst = this._world_tracker_state_by_instance.get(handle);
                     if (!inst)
@@ -1116,7 +1164,7 @@ export class zappar_client {
                     inst.ground_anchor_pose = msg.matrix4x4();
                     break;
                 }
-                case 34: {
+                case 37: {
                     let handle = msg.type();
                     let inst = this._world_tracker_state_by_instance.get(handle);
                     if (!inst)
@@ -1124,7 +1172,7 @@ export class zappar_client {
                     inst.tracks_data_size = msg.int();
                     break;
                 }
-                case 33: {
+                case 36: {
                     let handle = msg.type();
                     let inst = this._world_tracker_state_by_instance.get(handle);
                     if (!inst)
@@ -1132,7 +1180,7 @@ export class zappar_client {
                     inst.tracks_data = msg.floatArray();
                     break;
                 }
-                case 36: {
+                case 39: {
                     let handle = msg.type();
                     let inst = this._world_tracker_state_by_instance.get(handle);
                     if (!inst)
@@ -1140,7 +1188,7 @@ export class zappar_client {
                     inst.tracks_type_data_size = msg.int();
                     break;
                 }
-                case 35: {
+                case 38: {
                     let handle = msg.type();
                     let inst = this._world_tracker_state_by_instance.get(handle);
                     if (!inst)
@@ -1148,7 +1196,7 @@ export class zappar_client {
                     inst.tracks_type_data = msg.ucharArray();
                     break;
                 }
-                case 39: {
+                case 42: {
                     let handle = msg.type();
                     let inst = this._world_tracker_state_by_instance.get(handle);
                     if (!inst)
@@ -1156,7 +1204,7 @@ export class zappar_client {
                     inst.projections_data_size = msg.int();
                     break;
                 }
-                case 38: {
+                case 41: {
                     let handle = msg.type();
                     let inst = this._world_tracker_state_by_instance.get(handle);
                     if (!inst)

package/lib/gen/zappar-cwrap.js

@@ -251,6 +251,18 @@ export function getRuntimeObject(mod) {
         "number",
         "number"
     ]);
+    let world_tracker_plane_visible_wrapped = mod.cwrap("zappar_world_tracker_plane_visible", "number", [
+        "number",
+        "number"
+    ]);
+    let world_tracker_plane_polygon_data_size_wrapped = mod.cwrap("zappar_world_tracker_plane_polygon_data_size", "number", [
+        "number",
+        "number"
+    ]);
+    let world_tracker_plane_polygon_data_wrapped = mod.cwrap("zappar_world_tracker_plane_polygon_data", "number", [
+        "number",
+        "number"
+    ]);
     let world_tracker_world_anchor_valid_wrapped = mod.cwrap("zappar_world_tracker_world_anchor_valid", "number", [
         "number"
     ]);
@@ -806,6 +818,26 @@ export function getRuntimeObject(mod) {
             ret = ab;
             return ret;
         },
+        world_tracker_plane_visible: (o, indx) => {
+            let arg_indx = indx;
+            let ret = world_tracker_plane_visible_wrapped(o, arg_indx);
+            ret = ret === 1;
+            return ret;
+        },
+        world_tracker_plane_polygon_data_size: (o, indx) => {
+            let arg_indx = indx;
+            let ret = world_tracker_plane_polygon_data_size_wrapped(o, arg_indx);
+            return ret;
+        },
+        world_tracker_plane_polygon_data: (o, indx) => {
+            let arg_indx = indx;
+            let ret = world_tracker_plane_polygon_data_wrapped(o, arg_indx);
+            let retsize = world_tracker_plane_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_world_anchor_valid: (o) => {
             let ret = world_tracker_world_anchor_valid_wrapped(o);
             ret = ret === 1;

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

@@ -192,6 +192,9 @@ export interface zappar_cwrap {
     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_plane_visible(o: zappar_world_tracker_t, indx: number): boolean;
+    world_tracker_plane_polygon_data_size(o: zappar_world_tracker_t, indx: number): number;
+    world_tracker_plane_polygon_data(o: zappar_world_tracker_t, indx: number): Float32Array;
     world_tracker_world_anchor_valid(o: zappar_world_tracker_t): boolean;
     world_tracker_world_anchor_pose_raw(o: zappar_world_tracker_t): Float32Array;
     world_tracker_ground_anchor_valid(o: zappar_world_tracker_t): boolean;

package/lib/gen/zappar-server.js

@@ -657,7 +657,7 @@ export class zappar_server {
             let serializer = this.serializersByPipelineId.get(pipeline);
             if (!serializer)
                 continue;
-            serializer.sendMessage(31, msg => {
+            serializer.sendMessage(34, msg => {
                 msg.type(k);
                 msg.int(this._impl.world_tracker_quality(v));
             });
@@ -672,43 +672,64 @@ export class zappar_server {
                     msg.matrix4x4(this._impl.world_tracker_plane_pose_raw(v, i));
                 });
             }
-            serializer.sendMessage(27, msg => {
+            for (let i = 0; i < this._impl.world_tracker_plane_count(v); i++) {
+                serializer.sendMessage(27, msg => {
+                    msg.type(k);
+                    msg.int(i);
+                    msg.bool(this._impl.world_tracker_plane_visible(v, i));
+                });
+            }
+            for (let i = 0; i < this._impl.world_tracker_plane_count(v); i++) {
+                serializer.sendMessage(28, msg => {
+                    msg.type(k);
+                    msg.int(i);
+                    msg.int(this._impl.world_tracker_plane_polygon_data_size(v, i));
+                });
+            }
+            for (let i = 0; i < this._impl.world_tracker_plane_count(v); i++) {
+                serializer.sendMessage(29, msg => {
+                    msg.type(k);
+                    msg.int(i);
+                    msg.floatArray(this._impl.world_tracker_plane_polygon_data(v, i));
+                });
+            }
+            serializer.sendMessage(30, msg => {
                 msg.type(k);
                 msg.bool(this._impl.world_tracker_world_anchor_valid(v));
             });
-            serializer.sendMessage(28, msg => {
+            serializer.sendMessage(31, msg => {
                 msg.type(k);
                 msg.matrix4x4(this._impl.world_tracker_world_anchor_pose_raw(v));
             });
-            serializer.sendMessage(27, msg => {
+            serializer.sendMessage(30, msg => {
                 msg.type(k);
                 msg.bool(this._impl.world_tracker_ground_anchor_valid(v));
             });
-            serializer.sendMessage(30, msg => {
+            serializer.sendMessage(33, msg => {
                 msg.type(k);
                 msg.matrix4x4(this._impl.world_tracker_ground_anchor_pose_raw(v));
             });
-            serializer.sendMessage(34, msg => {
+            serializer.sendMessage(37, msg => {
                 msg.type(k);
                 msg.int(this._impl.world_tracker_tracks_data_size(v));
             });
-            serializer.sendMessage(33, msg => {
+            serializer.sendMessage(36, msg => {
                 msg.type(k);
                 msg.floatArray(this._impl.world_tracker_tracks_data(v));
             });
-            serializer.sendMessage(36, msg => {
+            serializer.sendMessage(39, msg => {
                 msg.type(k);
                 msg.int(this._impl.world_tracker_tracks_type_data_size(v));
             });
-            serializer.sendMessage(35, msg => {
+            serializer.sendMessage(38, msg => {
                 msg.type(k);
                 msg.ucharArray(this._impl.world_tracker_tracks_type_data(v));
             });
-            serializer.sendMessage(39, msg => {
+            serializer.sendMessage(42, msg => {
                 msg.type(k);
                 msg.int(this._impl.world_tracker_projections_data_size(v));
             });
-            serializer.sendMessage(38, msg => {
+            serializer.sendMessage(41, msg => {
                 msg.type(k);
                 msg.floatArray(this._impl.world_tracker_projections_data(v));
             });

package/lib/gen/zappar.d.ts

@@ -209,8 +209,11 @@ export interface zappar {
     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_plane_visible(o: zappar_world_tracker_t, indx: number): boolean;
     world_tracker_plane_pose_camera_relative(o: zappar_world_tracker_t, indx: number, mirror: boolean): Float32Array;
     world_tracker_plane_pose(o: zappar_world_tracker_t, indx: number, camera_pose: Float32Array, mirror: boolean): Float32Array;
+    world_tracker_plane_polygon_data_size(o: zappar_world_tracker_t, indx: number): number;
+    world_tracker_plane_polygon_data(o: zappar_world_tracker_t, indx: number): Float32Array;
     world_tracker_world_anchor_valid(o: zappar_world_tracker_t): boolean;
     world_tracker_world_anchor_pose_raw(o: zappar_world_tracker_t): Float32Array;
     world_tracker_world_anchor_pose_camera_relative(o: zappar_world_tracker_t, mirror: boolean): Float32Array;

package/lib/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "3.0.1-alpha.15";
+export declare const VERSION = "3.0.1-alpha.16";

package/lib/version.js

@@ -1 +1 @@
-export const VERSION = "3.0.1-alpha.15";
+export const VERSION = "3.0.1-alpha.16";