@mocanvas/wasm 1.0.0

package/pkg/mocanvas.js

@@ -0,0 +1,505 @@
+/* @ts-self-types="./mocanvas.d.ts" */
+
+/**
+ * The engine: one scene (the current page) and one renderer.
+ */
+export class Engine {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EngineFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_engine_free(ptr, 0);
+    }
+    /**
+     * Union of all page bounds → `f32_ptr()`. Returns false if the scene is empty.
+     * @returns {boolean}
+     */
+    all_bounds() {
+        const ret = wasm.engine_all_bounds(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Union of all geometry bounds → `f32_ptr()`. Returns false if the scene is empty.
+     * @returns {boolean}
+     */
+    all_geometry_bounds() {
+        const ret = wasm.engine_all_geometry_bounds(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Apply `len` words of commands from the command buffer. Returns the number of
+     * commands applied; on a malformed stream applies what it can and records an error.
+     * @param {number} len
+     * @returns {number}
+     */
+    apply(len) {
+        const ret = wasm.engine_apply(this.__wbg_ptr, len);
+        return ret >>> 0;
+    }
+    /**
+     * Number of u32 in the batch buffer (7 per batch).
+     * @returns {number}
+     */
+    batches_len() {
+        const ret = wasm.engine_batches_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Pointer to batch records: `first_index count texture clip_minx clip_miny clip_maxx
+     * clip_maxy` (clip as f32 bits; all four zero = no clip).
+     * @returns {number}
+     */
+    batches_ptr() {
+        const ret = wasm.engine_batches_ptr(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Page bounds of a shape → `f32_ptr()` holds `minx miny maxx maxy`. Returns false if missing.
+     * @param {number} handle
+     * @returns {boolean}
+     */
+    bounds(handle) {
+        const ret = wasm.engine_bounds(this.__wbg_ptr, handle);
+        return ret !== 0;
+    }
+    /**
+     * Current capacity of the command buffer in words.
+     * @returns {number}
+     */
+    cmd_capacity() {
+        const ret = wasm.engine_cmd_capacity(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Reserve the command buffer for at least `words` u32 words and return its pointer.
+     * The host writes commands into a `Uint32Array(memory.buffer, ptr, words)` view
+     * (bit-casting floats) and then calls [`Engine::apply`].
+     * @param {number} words
+     * @returns {number}
+     */
+    cmd_ptr(words) {
+        const ret = wasm.engine_cmd_ptr(this.__wbg_ptr, words);
+        return ret >>> 0;
+    }
+    /**
+     * Shapes culled last frame.
+     * @returns {number}
+     */
+    culled_count() {
+        const ret = wasm.engine_culled_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * The default per-frame tessellation budget.
+     * @returns {number}
+     */
+    static default_tess_budget() {
+        const ret = wasm.engine_default_tess_budget();
+        return ret >>> 0;
+    }
+    /**
+     * Shapes drawn last frame.
+     * @returns {number}
+     */
+    drawn_count() {
+        const ret = wasm.engine_drawn_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Change counter.
+     * @returns {number}
+     */
+    epoch() {
+        const ret = wasm.engine_epoch(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Pointer to the small f32 result buffer.
+     * @returns {number}
+     */
+    f32_ptr() {
+        const ret = wasm.engine_f32_ptr(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Build the frame for a camera (`cx, cy` page offset, `zoom`) and viewport size in
+     * screen pixels. Afterwards read the buffers through the `*_ptr`/`*_len` getters.
+     *
+     * The buffers are page-space, so they do not depend on the camera: when the scene
+     * is unchanged and the camera has only moved a little, this reuses the previous
+     * build, leaves the buffers alone and reports [`Engine::frame_dirty`] `false` — the
+     * host can then skip re-uploading them and just redraw with the new camera uniform.
+     *
+     * `tess_budget` caps how many shapes may be tessellated in this call (0 = no cap);
+     * the rest are drawn as level-of-detail quads until a later frame catches up, with
+     * [`Engine::frame_pending`] set meanwhile.
+     * @param {number} cam_x
+     * @param {number} cam_y
+     * @param {number} zoom
+     * @param {number} vp_w
+     * @param {number} vp_h
+     * @param {number} tess_budget
+     */
+    frame(cam_x, cam_y, zoom, vp_w, vp_h, tess_budget) {
+        wasm.engine_frame(this.__wbg_ptr, cam_x, cam_y, zoom, vp_w, vp_h, tess_budget);
+    }
+    /**
+     * Whether the last [`Engine::frame`] rebuilt the buffers. When false the pointers,
+     * lengths and contents are exactly what the previous frame produced.
+     * @returns {boolean}
+     */
+    frame_dirty() {
+        const ret = wasm.engine_frame_dirty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Whether shapes are still waiting on the tessellation budget and are meanwhile
+     * drawn as quads. The host should keep scheduling frames while this is true.
+     * @returns {boolean}
+     */
+    frame_pending() {
+        const ret = wasm.engine_frame_pending(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Counter bumped on every rebuild. A host that has uploaded version `v` can skip
+     * the upload for as long as this still reads `v`.
+     * @returns {number}
+     */
+    frame_version() {
+        const ret = wasm.engine_frame_version(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Geometry-only page bounds of a shape → `f32_ptr()` holds `minx miny maxx maxy`.
+     * Same box as `bounds` without the half-stroke pad. Returns false if missing.
+     * @param {number} handle
+     * @returns {boolean}
+     */
+    geometry_bounds(handle) {
+        const ret = wasm.engine_geometry_bounds(this.__wbg_ptr, handle);
+        return ret !== 0;
+    }
+    /**
+     * Pointer to the handle result buffer.
+     * @returns {number}
+     */
+    handles_ptr() {
+        const ret = wasm.engine_handles_ptr(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Topmost shape at a page point, or 0. `filter` bits: 1 include locked, 2 include hidden, 4 hollow only.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} tolerance
+     * @param {number} filter
+     * @returns {number}
+     */
+    hit_test(x, y, tolerance, filter) {
+        const ret = wasm.engine_hit_test(this.__wbg_ptr, x, y, tolerance, filter);
+        return ret >>> 0;
+    }
+    /**
+     * Number of indices.
+     * @returns {number}
+     */
+    indices_len() {
+        const ret = wasm.engine_indices_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Pointer to u32 indices.
+     * @returns {number}
+     */
+    indices_ptr() {
+        const ret = wasm.engine_indices_ptr(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Create an empty engine.
+     */
+    constructor() {
+        const ret = wasm.engine_new();
+        this.__wbg_ptr = ret;
+        EngineFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Number of u32 in the overlay buffer (10 per entry).
+     * @returns {number}
+     */
+    overlay_len() {
+        const ret = wasm.engine_overlay_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Pointer to overlay entries (`handle x y w h rot clip_minx clip_miny clip_maxx
+     * clip_maxy`, floats as bits; clip all zero = unclipped).
+     * @returns {number}
+     */
+    overlay_ptr() {
+        const ret = wasm.engine_overlay_ptr(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Page transform of a shape → `f32_ptr()` holds `a b c d e f`. Returns false if missing.
+     * @param {number} handle
+     * @returns {boolean}
+     */
+    page_transform(handle) {
+        const ret = wasm.engine_page_transform(this.__wbg_ptr, handle);
+        return ret !== 0;
+    }
+    /**
+     * Shapes in a page box. `mode` 0 = intersects, 1 = contains. Returns count; read via `handles_ptr`.
+     * @param {number} minx
+     * @param {number} miny
+     * @param {number} maxx
+     * @param {number} maxy
+     * @param {number} mode
+     * @param {number} filter
+     * @returns {number}
+     */
+    query_box(minx, miny, maxx, maxy, mode, filter) {
+        const ret = wasm.engine_query_box(this.__wbg_ptr, minx, miny, maxx, maxy, mode, filter);
+        return ret >>> 0;
+    }
+    /**
+     * Grow the box each frame is built for by `pad` (a fraction of the viewport size)
+     * on every side, so a camera panning inside that margin reuses the build instead
+     * of re-tessellating and re-uploading. Defaults to
+     * `mocanvas_render::DEFAULT_VIEWPORT_PAD` — see `Renderer::set_viewport_pad` for
+     * the trade-off, which depends on how expensive the host's rasteriser makes
+     * geometry relative to uploads.
+     * @param {number} pad
+     */
+    set_viewport_pad(pad) {
+        wasm.engine_set_viewport_pad(this.__wbg_ptr, pad);
+    }
+    /**
+     * Number of shapes in the scene.
+     * @returns {number}
+     */
+    shape_count() {
+        const ret = wasm.engine_shape_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Take the last error message, if any.
+     * @returns {string | undefined}
+     */
+    take_error() {
+        const ret = wasm.engine_take_error(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]);
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Union of page bounds for `len` handles read from the command buffer → `f32_ptr()`.
+     * Returns false if the union is empty.
+     * @param {number} len
+     * @returns {boolean}
+     */
+    union_bounds(len) {
+        const ret = wasm.engine_union_bounds(this.__wbg_ptr, len);
+        return ret !== 0;
+    }
+    /**
+     * Number of f32 in the vertex buffer.
+     * @returns {number}
+     */
+    vertices_len() {
+        const ret = wasm.engine_vertices_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Pointer to interleaved `x y u v r g b a` f32 vertices (8 per vertex).
+     * @returns {number}
+     */
+    vertices_ptr() {
+        const ret = wasm.engine_vertices_ptr(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * The current viewport pad.
+     * @returns {number}
+     */
+    viewport_pad() {
+        const ret = wasm.engine_viewport_pad(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) Engine.prototype[Symbol.dispose] = Engine.prototype.free;
+
+/**
+ * Library version.
+ * @returns {string}
+ */
+export function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.version();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_throw_bb96b2010945f0bc: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./mocanvas_bg.js": import0,
+    };
+}
+
+const EngineFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_engine_free(ptr, 1));
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (!module.ok) {
+            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+        }
+
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('mocanvas_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };

package/pkg/mocanvas_bg.wasm.d.ts

@@ -0,0 +1,42 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_engine_free: (a: number, b: number) => void;
+export const engine_all_bounds: (a: number) => number;
+export const engine_all_geometry_bounds: (a: number) => number;
+export const engine_apply: (a: number, b: number) => number;
+export const engine_batches_len: (a: number) => number;
+export const engine_batches_ptr: (a: number) => number;
+export const engine_bounds: (a: number, b: number) => number;
+export const engine_cmd_capacity: (a: number) => number;
+export const engine_cmd_ptr: (a: number, b: number) => number;
+export const engine_culled_count: (a: number) => number;
+export const engine_default_tess_budget: () => number;
+export const engine_drawn_count: (a: number) => number;
+export const engine_epoch: (a: number) => number;
+export const engine_f32_ptr: (a: number) => number;
+export const engine_frame: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const engine_frame_dirty: (a: number) => number;
+export const engine_frame_pending: (a: number) => number;
+export const engine_frame_version: (a: number) => number;
+export const engine_geometry_bounds: (a: number, b: number) => number;
+export const engine_handles_ptr: (a: number) => number;
+export const engine_hit_test: (a: number, b: number, c: number, d: number, e: number) => number;
+export const engine_indices_len: (a: number) => number;
+export const engine_indices_ptr: (a: number) => number;
+export const engine_new: () => number;
+export const engine_overlay_len: (a: number) => number;
+export const engine_overlay_ptr: (a: number) => number;
+export const engine_page_transform: (a: number, b: number) => number;
+export const engine_query_box: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+export const engine_set_viewport_pad: (a: number, b: number) => void;
+export const engine_shape_count: (a: number) => number;
+export const engine_take_error: (a: number) => [number, number];
+export const engine_union_bounds: (a: number, b: number) => number;
+export const engine_vertices_len: (a: number) => number;
+export const engine_vertices_ptr: (a: number) => number;
+export const engine_viewport_pad: (a: number) => number;
+export const version: () => [number, number];
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;