@zappar/zappar-cv 3.0.1-beta.1 → 3.0.1-beta.11

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

package/lib/additional.d.ts

@@ -23,8 +23,6 @@ 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;
     draw_axis(gl: WebGLRenderingContext, projectionMatrix: Float32Array, cameraMatrix: Float32Array, targetMatrix: Float32Array): void;

package/lib/cameramodel.d.ts

@@ -1,2 +1,2 @@
-export declare function projectionMatrix(params: Float32Array, screenWidth: number, screenHeight: number, near?: number, far?: number): Float32Array;
+export declare function projectionMatrixFromModelAndSize(params: Float32Array, cameraDataWidth: number, cameraDataHeight: number, screenWidth: number, screenHeight: number, near?: number, far?: number): Float32Array;
 export declare function cameraRotationForScreenOrientation(isUserFacing: boolean): number;

package/lib/cameramodel.js

@@ -1,8 +1,8 @@
 import { mat4, vec3 } from "gl-matrix";
 import { profile } from "./profile";
-export function projectionMatrix(params, screenWidth, screenHeight, near = 0.01, far = 100.0) {
-    let cam_x = params[2] * 2;
-    let cam_y = params[3] * 2;
+export function projectionMatrixFromModelAndSize(params, cameraDataWidth, cameraDataHeight, screenWidth, screenHeight, near = 0.01, far = 100.0) {
+    let cam_x = cameraDataWidth;
+    let cam_y = cameraDataHeight;
     let projection = mat4.create();
     mat4.frustum(projection, near * (-0.5 - params[2]) / params[0], near * (cam_x - 0.5 - params[2]) / params[0], near * (cam_y - 0.5 - params[3]) / params[1], near * (-0.5 - params[3]) / params[1], near, far);
     // Flip camera y axis (before any other transformations) - converts from

package/lib/drawpointswithtype.d.ts

@@ -3,7 +3,7 @@ export declare class PointsWithTypeDraw {
     private _vbo;
     private _typebo;
     private _shader;
-    constructor(_gl: WebGL2RenderingContext);
+    constructor(_gl: WebGLRenderingContext);
     dispose(): void;
     private _generate;
     private _generateTypes;

package/lib/drawpointswithtype.js

@@ -64,7 +64,7 @@ export class PointsWithTypeDraw {
         gl.vertexAttribPointer(shader.attr_position, 2, gl.FLOAT, false, 0, 0);
         gl.enableVertexAttribArray(shader.attr_position);
         gl.bindBuffer(gl.ARRAY_BUFFER, typebo);
-        gl.vertexAttribIPointer(shader.attr_type, 1, gl.UNSIGNED_BYTE, 0, 0);
+        gl.vertexAttribPointer(shader.attr_type, 1, gl.UNSIGNED_BYTE, false, 0, 0);
         gl.enableVertexAttribArray(shader.attr_type);
         gl.drawArrays(gl.POINTS, 0, points.length / 2);
         gl.disableVertexAttribArray(shader.attr_type);
@@ -112,37 +112,35 @@ export class PointsWithTypeDraw {
         return this._shader;
     }
 }
-let vertexShaderSrc = `#version 300 es
-
-in vec2 pos;
-in uint aType;
+let vertexShaderSrc = `
+attribute vec2 pos;
+attribute float aType;
 uniform mat4 skinTexTransform;
 uniform float pointSize;
 
-out vec4 vColor;
+varying vec4 vColor;
 
 void main()
 {
     gl_Position = skinTexTransform * vec4(pos, 0.0, 1.0);
     vColor = vec4(1.0, 0.0, 0.0, 1.0);
-    if (aType == 1u) {
+    if (aType == 1.0) {
         vColor = vec4(1.0, 0.7, 0.0, 1.0);
-    } else if (aType >= 4u) {
+    } else if (aType >= 4.0) {
         vColor = vec4(0.0, 0.0, 1.0, 1.0);
-    } else if (aType > 1u) {
+    } else if (aType > 1.0) {
         vColor = vec4(0.0, 1.0, 0.0, 1.0);
     }
     gl_PointSize = pointSize;
 }`;
-let fragmentShaderSrc = `#version 300 es
+let fragmentShaderSrc = `
 precision highp float;
 
-in vec4 vColor;
-out vec4 outColor;
+varying vec4 vColor;
 
 void main()
 {
-    outColor = vColor;
+    gl_FragColor = vColor;
 }`;
 function cameraRotationForScreenOrientation() {
     if (window.screen.orientation && !profile.forceWindowOrientation) {

package/lib/drawquad.d.ts

@@ -0,0 +1,2 @@
+export declare function disposeDrawQuad(): void;
+export declare function drawQuad(gl: WebGLRenderingContext, projectionMatrix: Float32Array, modelviewMatrix: Float32Array, color: Float32Array): void;

package/lib/drawquad.js

@@ -0,0 +1,99 @@
+import { compileShader, linkProgram } from "./shader";
+let shader;
+let vbo;
+export function disposeDrawQuad() {
+    shader = undefined;
+    vbo = 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.5, 0,
+        -0.5, -0.5, 0,
+        0.5, 0.5, 0,
+        0.5, -0.5, 0
+    ];
+    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;
+}
+export function drawQuad(gl, projectionMatrix, modelviewMatrix, color) {
+    let shader = getShader(gl);
+    let v = generate(gl);
+    gl.useProgram(shader.prog);
+    gl.uniformMatrix4fv(shader.unif_projection, false, projectionMatrix);
+    gl.uniformMatrix4fv(shader.unif_modelView, false, modelviewMatrix);
+    gl.uniform4fv(shader.unif_color, color);
+    gl.bindBuffer(gl.ARRAY_BUFFER, v);
+    gl.vertexAttribPointer(shader.attr_position, 3, gl.FLOAT, false, 3 * 4, 0);
+    gl.enableVertexAttribArray(shader.attr_position);
+    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+    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 modelViewMatrix;
+attribute vec4 position;
+
+void main()
+{
+    gl_Position = projMatrix * modelViewMatrix * position;
+}`;
+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 vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}`;
+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_projection = gl.getUniformLocation(prog, "projMatrix");
+    if (!unif_projection)
+        throw new Error("Unable to get uniform location projMatrix");
+    let unif_modelView = gl.getUniformLocation(prog, "modelViewMatrix");
+    if (!unif_modelView)
+        throw new Error("Unable to get uniform location modelViewMatrix");
+    let unif_color = gl.getUniformLocation(prog, "color");
+    if (!unif_color)
+        throw new Error("Unable to get uniform location color");
+    shader = {
+        prog,
+        unif_modelView,
+        unif_projection,
+        unif_color,
+        attr_position: gl.getAttribLocation(prog, "position"),
+    };
+    return shader;
+}

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

@@ -61,6 +61,8 @@ export interface zappar {
     pipeline_frame_update(o: zappar_pipeline_t): void;
     pipeline_frame_number(o: zappar_pipeline_t): number;
     pipeline_camera_model(o: zappar_pipeline_t): Float32Array;
+    pipeline_camera_data_width(o: zappar_pipeline_t): number;
+    pipeline_camera_data_height(o: zappar_pipeline_t): number;
     pipeline_camera_frame_user_data(o: zappar_pipeline_t): number;
     pipeline_camera_frame_submit(o: zappar_pipeline_t, data: ArrayBuffer, width: number, height: number, user_data: number, camera_to_device_transform: Float32Array, camera_model: Float32Array, user_facing: boolean, timestampSeconds: number): void;
     pipeline_camera_frame_camera_attitude(o: zappar_pipeline_t): Float32Array;
@@ -164,9 +166,10 @@ export interface zappar {
     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_version(o: zappar_custom_anchor_t): number;
     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;
+    custom_anchor_pose_set(o: zappar_custom_anchor_t, pose: Float32Array): void;
+    custom_anchor_pose_set_with_parent(o: zappar_custom_anchor_t, pose: Float32Array, anchor_id: string): void;
 }