isard 0.6.1 → 0.7.0

package/dist/wasm/isard.js

@@ -417,13 +417,14 @@ export class Engine {
         wasm.engine_preload(this.__wbg_ptr, lon, lat, zoom, pitch, bearing);
     }
     /**
-     * Screen point (CSS pixels) of a ground position, undefined behind the camera
+     * Screen point (CSS pixels) of a ground position, or `height` metres above it, undefined behind the camera
      * @param {number} lon
      * @param {number} lat
+     * @param {number | null} [height]
      * @returns {[x: number, y: number] | undefined}
      */
-    project(lon, lat) {
-        const ret = wasm.engine_project(this.__wbg_ptr, lon, lat);
+    project(lon, lat, height) {
+        const ret = wasm.engine_project(this.__wbg_ptr, lon, lat, !isLikeNone(height), isLikeNone(height) ? 0 : height);
         return ret;
     }
     /**
@@ -1006,20 +1007,23 @@ export class Engine {
      * (16 at most): longitude, latitude (degrees), metres above the ground, range (metres), then to look one way
      * only heading, tilt, angles of view across and up (degrees), the heading NaN to look all around. What some
      * observer sees is tinted with `visible`, what is hidden from all those that reach it with `hidden` (RGB 0-1),
-     * at `opacity`
+     * at `opacity`; `outline` (RGB 0-1, or empty) the color of the cones' edges drawn in 3D
      * @param {Float64Array} observers
      * @param {Float32Array} visible
      * @param {Float32Array} hidden
      * @param {number} opacity
+     * @param {Float32Array} outline
      */
-    setViewshed(observers, visible, hidden, opacity) {
+    setViewshed(observers, visible, hidden, opacity, outline) {
         const ptr0 = passArrayF64ToWasm0(observers, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArrayF32ToWasm0(visible, wasm.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
         const ptr2 = passArrayF32ToWasm0(hidden, wasm.__wbindgen_malloc);
         const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.engine_setViewshed(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, opacity);
+        const ptr3 = passArrayF32ToWasm0(outline, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_setViewshed(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, opacity, ptr3, len3);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -1039,6 +1043,30 @@ export class Engine {
         const ret = wasm.engine_stats(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * The height above the relief (metres) of the top of what stands at a position (degrees): a roof, a mesh, 0 on
+     * the bare ground; undefined where nothing of the last frame is there. The scene is drawn from above into a single
+     * pixel and read back (a stall, cheap: one pixel to fill)
+     * @param {number} lon
+     * @param {number} lat
+     * @returns {any}
+     */
+    surfaceAt(lon, lat) {
+        const ret = wasm.engine_surfaceAt(this.__wbg_ptr, lon, lat);
+        return ret;
+    }
+    /**
+     * What is drawn under a screen point (CSS pixels): longitude, latitude and its height above the relief (metres),
+     * on a roof, a wall or a mesh as on the ground; undefined where nothing was drawn. The scene is drawn again and
+     * read back (a stall): for clicks and drags
+     * @param {number} x
+     * @param {number} y
+     * @returns {[lon: number, lat: number, height: number] | undefined}
+     */
+    surface(x, y) {
+        const ret = wasm.engine_surface(this.__wbg_ptr, x, y);
+        return ret;
+    }
     /**
      * Compressed texture formats of the GPU (their WebGL extensions get enabled), for the KTX2 transcoding
      * @returns {TextureFormats}
@@ -1117,6 +1145,18 @@ export class Engine {
         const len0 = WASM_VECTOR_LEN;
         wasm.engine_updateIconAtlas(this.__wbg_ptr, x, y, width, height, ptr0, len0);
     }
+    /**
+     * Tiles a raster layer wants for the view of the last frame, three numbers per tile (z, x, y), the nearest to
+     * the eye first: the level each area of the ground is drawn at, for the labels of a vector style to follow it
+     * @param {number} id
+     * @returns {Uint32Array}
+     */
+    wantedTiles(id) {
+        const ret = wasm.engine_wantedTiles(this.__wbg_ptr, id);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
     /**
      * @param {number} delta
      * @param {number} x

package/dist/wasm/isard_core.d.ts

@@ -175,9 +175,9 @@ export class Engine {
      */
     preload(lon: number, lat: number, zoom: number, pitch: number, bearing: number): void;
     /**
-     * Screen point (CSS pixels) of a ground position, undefined behind the camera
+     * Screen point (CSS pixels) of a ground position, or `height` metres above it, undefined behind the camera
      */
-    project(lon: number, lat: number): [x: number, y: number] | undefined;
+    project(lon: number, lat: number, height?: number | null): [x: number, y: number] | undefined;
     removeExtrusionBatch(id: number, key: number): void;
     removeLayer(id: number): void;
     render(): boolean;
@@ -362,14 +362,26 @@ export class Engine {
      * (16 at most): longitude, latitude (degrees), metres above the ground, range (metres), then to look one way
      * only heading, tilt, angles of view across and up (degrees), the heading NaN to look all around. What some
      * observer sees is tinted with `visible`, what is hidden from all those that reach it with `hidden` (RGB 0-1),
-     * at `opacity`
+     * at `opacity`; `outline` (RGB 0-1, or empty) the color of the cones' edges drawn in 3D
      */
-    setViewshed(observers: Float64Array, visible: Float32Array, hidden: Float32Array, opacity: number): void;
+    setViewshed(observers: Float64Array, visible: Float32Array, hidden: Float32Array, opacity: number, outline: Float32Array): void;
     setZoomRange(min: number, max: number): void;
     /**
      * Tile counters of the raster layers, for diagnostics
      */
     stats(): RasterLayerStats[];
+    /**
+     * The height above the relief (metres) of the top of what stands at a position (degrees): a roof, a mesh, 0 on
+     * the bare ground; undefined where nothing of the last frame is there. The scene is drawn from above into a single
+     * pixel and read back (a stall, cheap: one pixel to fill)
+     */
+    surfaceAt(lon: number, lat: number): any;
+    /**
+     * What is drawn under a screen point (CSS pixels): longitude, latitude and its height above the relief (metres),
+     * on a roof, a wall or a mesh as on the ground; undefined where nothing was drawn. The scene is drawn again and
+     * read back (a stall): for clicks and drags
+     */
+    surface(x: number, y: number): [lon: number, lat: number, height: number] | undefined;
     /**
      * A region of the first page of the glyph atlas: `width` × `height` bytes at (`x`, `y`)
      */
@@ -386,6 +398,11 @@ export class Engine {
      * A region of the icon atlas: `width` × `height` RGBA texels (premultiplied) at (`x`, `y`)
      */
     updateIconAtlas(x: number, y: number, width: number, height: number, data: Uint8Array): void;
+    /**
+     * Tiles a raster layer wants for the view of the last frame, three numbers per tile (z, x, y), the nearest to
+     * the eye first: the level each area of the ground is drawn at, for the labels of a vector style to follow it
+     */
+    wantedTiles(id: number): Uint32Array;
     zoomAt(delta: number, x: number, y: number): void;
 }
 
@@ -417,7 +434,7 @@ export interface InitOutput {
     readonly engine_pick: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
     readonly engine_pollPick: (a: number) => any;
     readonly engine_preload: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-    readonly engine_project: (a: number, b: number, c: number) => any;
+    readonly engine_project: (a: number, b: number, c: number, d: number, e: number) => any;
     readonly engine_removeExtrusionBatch: (a: number, b: number, c: number) => void;
     readonly engine_removeLayer: (a: number, b: number) => void;
     readonly engine_render: (a: number) => number;
@@ -461,13 +478,16 @@ export interface InitOutput {
     readonly engine_setSymbolLayer: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
     readonly engine_setSymbols: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
     readonly engine_setTerrain: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
-    readonly engine_setViewshed: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
+    readonly engine_setViewshed: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
     readonly engine_setZoomRange: (a: number, b: number, c: number) => void;
     readonly engine_stats: (a: number) => any;
+    readonly engine_surface: (a: number, b: number, c: number) => any;
+    readonly engine_surfaceAt: (a: number, b: number, c: number) => any;
     readonly engine_updateGlyphAtlas: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly engine_updateGlyphPage: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly engine_updateGroundTexture: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => [number, number];
     readonly engine_updateIconAtlas: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly engine_wantedTiles: (a: number, b: number) => [number, number];
     readonly engine_zoomAt: (a: number, b: number, c: number, d: number) => void;
     readonly wasm_bindgen_2e566c63402fe7fa___convert__closures_____invoke___js_sys_b1e1c29ba6b0e6b3___Function_fn_wasm_bindgen_2e566c63402fe7fa___JsValue_____wasm_bindgen_2e566c63402fe7fa___sys__Undefined___js_sys_b1e1c29ba6b0e6b3___Function_fn_wasm_bindgen_2e566c63402fe7fa___JsValue_____wasm_bindgen_2e566c63402fe7fa___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
     readonly wasm_bindgen_2e566c63402fe7fa___convert__closures_____invoke___wasm_bindgen_2e566c63402fe7fa___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_2e566c63402fe7fa___JsError___true_: (a: number, b: number, c: any) => [number, number];

package/dist/wasm/isard_core.js

@@ -335,13 +335,14 @@ export class Engine {
         wasm.engine_preload(this.__wbg_ptr, lon, lat, zoom, pitch, bearing);
     }
     /**
-     * Screen point (CSS pixels) of a ground position, undefined behind the camera
+     * Screen point (CSS pixels) of a ground position, or `height` metres above it, undefined behind the camera
      * @param {number} lon
      * @param {number} lat
+     * @param {number | null} [height]
      * @returns {[x: number, y: number] | undefined}
      */
-    project(lon, lat) {
-        const ret = wasm.engine_project(this.__wbg_ptr, lon, lat);
+    project(lon, lat, height) {
+        const ret = wasm.engine_project(this.__wbg_ptr, lon, lat, !isLikeNone(height), isLikeNone(height) ? 0 : height);
         return ret;
     }
     /**
@@ -877,20 +878,23 @@ export class Engine {
      * (16 at most): longitude, latitude (degrees), metres above the ground, range (metres), then to look one way
      * only heading, tilt, angles of view across and up (degrees), the heading NaN to look all around. What some
      * observer sees is tinted with `visible`, what is hidden from all those that reach it with `hidden` (RGB 0-1),
-     * at `opacity`
+     * at `opacity`; `outline` (RGB 0-1, or empty) the color of the cones' edges drawn in 3D
      * @param {Float64Array} observers
      * @param {Float32Array} visible
      * @param {Float32Array} hidden
      * @param {number} opacity
+     * @param {Float32Array} outline
      */
-    setViewshed(observers, visible, hidden, opacity) {
+    setViewshed(observers, visible, hidden, opacity, outline) {
         const ptr0 = passArrayF64ToWasm0(observers, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArrayF32ToWasm0(visible, wasm.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
         const ptr2 = passArrayF32ToWasm0(hidden, wasm.__wbindgen_malloc);
         const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.engine_setViewshed(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, opacity);
+        const ptr3 = passArrayF32ToWasm0(outline, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_setViewshed(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, opacity, ptr3, len3);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -910,6 +914,30 @@ export class Engine {
         const ret = wasm.engine_stats(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * The height above the relief (metres) of the top of what stands at a position (degrees): a roof, a mesh, 0 on
+     * the bare ground; undefined where nothing of the last frame is there. The scene is drawn from above into a single
+     * pixel and read back (a stall, cheap: one pixel to fill)
+     * @param {number} lon
+     * @param {number} lat
+     * @returns {any}
+     */
+    surfaceAt(lon, lat) {
+        const ret = wasm.engine_surfaceAt(this.__wbg_ptr, lon, lat);
+        return ret;
+    }
+    /**
+     * What is drawn under a screen point (CSS pixels): longitude, latitude and its height above the relief (metres),
+     * on a roof, a wall or a mesh as on the ground; undefined where nothing was drawn. The scene is drawn again and
+     * read back (a stall): for clicks and drags
+     * @param {number} x
+     * @param {number} y
+     * @returns {[lon: number, lat: number, height: number] | undefined}
+     */
+    surface(x, y) {
+        const ret = wasm.engine_surface(this.__wbg_ptr, x, y);
+        return ret;
+    }
     /**
      * A region of the first page of the glyph atlas: `width` × `height` bytes at (`x`, `y`)
      * @param {number} x
@@ -971,6 +999,18 @@ export class Engine {
         const len0 = WASM_VECTOR_LEN;
         wasm.engine_updateIconAtlas(this.__wbg_ptr, x, y, width, height, ptr0, len0);
     }
+    /**
+     * Tiles a raster layer wants for the view of the last frame, three numbers per tile (z, x, y), the nearest to
+     * the eye first: the level each area of the ground is drawn at, for the labels of a vector style to follow it
+     * @param {number} id
+     * @returns {Uint32Array}
+     */
+    wantedTiles(id) {
+        const ret = wasm.engine_wantedTiles(this.__wbg_ptr, id);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
     /**
      * @param {number} delta
      * @param {number} x
@@ -1621,6 +1661,10 @@ function __wbg_get_imports() {
             const ret = Array.of(arg0, arg1);
             return ret;
         },
+        __wbg_of_dde0b9d3265685ee: function(arg0, arg1, arg2) {
+            const ret = Array.of(arg0, arg1, arg2);
+            return ret;
+        },
         __wbg_performance_d0d7b03fc649b694: function(arg0) {
             const ret = arg0.performance;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isard",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "A WebGL2 map engine for large, interactive data layers, labels and 3D Tiles over raster or vector basemaps (Rust core in WebAssembly)",
   "license": "MIT",
   "author": "Kevin Graff",