@mocanvas/wasm 1.0.0

package/pkg/mocanvas.d.ts

@@ -0,0 +1,243 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * The engine: one scene (the current page) and one renderer.
+ */
+export class Engine {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Union of all page bounds → `f32_ptr()`. Returns false if the scene is empty.
+     */
+    all_bounds(): boolean;
+    /**
+     * Union of all geometry bounds → `f32_ptr()`. Returns false if the scene is empty.
+     */
+    all_geometry_bounds(): boolean;
+    /**
+     * 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.
+     */
+    apply(len: number): number;
+    /**
+     * Number of u32 in the batch buffer (7 per batch).
+     */
+    batches_len(): number;
+    /**
+     * 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).
+     */
+    batches_ptr(): number;
+    /**
+     * Page bounds of a shape → `f32_ptr()` holds `minx miny maxx maxy`. Returns false if missing.
+     */
+    bounds(handle: number): boolean;
+    /**
+     * Current capacity of the command buffer in words.
+     */
+    cmd_capacity(): number;
+    /**
+     * 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`].
+     */
+    cmd_ptr(words: number): number;
+    /**
+     * Shapes culled last frame.
+     */
+    culled_count(): number;
+    /**
+     * The default per-frame tessellation budget.
+     */
+    static default_tess_budget(): number;
+    /**
+     * Shapes drawn last frame.
+     */
+    drawn_count(): number;
+    /**
+     * Change counter.
+     */
+    epoch(): number;
+    /**
+     * Pointer to the small f32 result buffer.
+     */
+    f32_ptr(): number;
+    /**
+     * 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.
+     */
+    frame(cam_x: number, cam_y: number, zoom: number, vp_w: number, vp_h: number, tess_budget: number): void;
+    /**
+     * Whether the last [`Engine::frame`] rebuilt the buffers. When false the pointers,
+     * lengths and contents are exactly what the previous frame produced.
+     */
+    frame_dirty(): boolean;
+    /**
+     * 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.
+     */
+    frame_pending(): boolean;
+    /**
+     * Counter bumped on every rebuild. A host that has uploaded version `v` can skip
+     * the upload for as long as this still reads `v`.
+     */
+    frame_version(): number;
+    /**
+     * 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.
+     */
+    geometry_bounds(handle: number): boolean;
+    /**
+     * Pointer to the handle result buffer.
+     */
+    handles_ptr(): number;
+    /**
+     * Topmost shape at a page point, or 0. `filter` bits: 1 include locked, 2 include hidden, 4 hollow only.
+     */
+    hit_test(x: number, y: number, tolerance: number, filter: number): number;
+    /**
+     * Number of indices.
+     */
+    indices_len(): number;
+    /**
+     * Pointer to u32 indices.
+     */
+    indices_ptr(): number;
+    /**
+     * Create an empty engine.
+     */
+    constructor();
+    /**
+     * Number of u32 in the overlay buffer (10 per entry).
+     */
+    overlay_len(): number;
+    /**
+     * 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).
+     */
+    overlay_ptr(): number;
+    /**
+     * Page transform of a shape → `f32_ptr()` holds `a b c d e f`. Returns false if missing.
+     */
+    page_transform(handle: number): boolean;
+    /**
+     * Shapes in a page box. `mode` 0 = intersects, 1 = contains. Returns count; read via `handles_ptr`.
+     */
+    query_box(minx: number, miny: number, maxx: number, maxy: number, mode: number, filter: number): number;
+    /**
+     * 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.
+     */
+    set_viewport_pad(pad: number): void;
+    /**
+     * Number of shapes in the scene.
+     */
+    shape_count(): number;
+    /**
+     * Take the last error message, if any.
+     */
+    take_error(): string | undefined;
+    /**
+     * Union of page bounds for `len` handles read from the command buffer → `f32_ptr()`.
+     * Returns false if the union is empty.
+     */
+    union_bounds(len: number): boolean;
+    /**
+     * Number of f32 in the vertex buffer.
+     */
+    vertices_len(): number;
+    /**
+     * Pointer to interleaved `x y u v r g b a` f32 vertices (8 per vertex).
+     */
+    vertices_ptr(): number;
+    /**
+     * The current viewport pad.
+     */
+    viewport_pad(): number;
+}
+
+/**
+ * Library version.
+ */
+export function version(): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_engine_free: (a: number, b: number) => void;
+    readonly engine_all_bounds: (a: number) => number;
+    readonly engine_all_geometry_bounds: (a: number) => number;
+    readonly engine_apply: (a: number, b: number) => number;
+    readonly engine_batches_len: (a: number) => number;
+    readonly engine_batches_ptr: (a: number) => number;
+    readonly engine_bounds: (a: number, b: number) => number;
+    readonly engine_cmd_capacity: (a: number) => number;
+    readonly engine_cmd_ptr: (a: number, b: number) => number;
+    readonly engine_culled_count: (a: number) => number;
+    readonly engine_default_tess_budget: () => number;
+    readonly engine_drawn_count: (a: number) => number;
+    readonly engine_epoch: (a: number) => number;
+    readonly engine_f32_ptr: (a: number) => number;
+    readonly engine_frame: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly engine_frame_dirty: (a: number) => number;
+    readonly engine_frame_pending: (a: number) => number;
+    readonly engine_frame_version: (a: number) => number;
+    readonly engine_geometry_bounds: (a: number, b: number) => number;
+    readonly engine_handles_ptr: (a: number) => number;
+    readonly engine_hit_test: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly engine_indices_len: (a: number) => number;
+    readonly engine_indices_ptr: (a: number) => number;
+    readonly engine_new: () => number;
+    readonly engine_overlay_len: (a: number) => number;
+    readonly engine_overlay_ptr: (a: number) => number;
+    readonly engine_page_transform: (a: number, b: number) => number;
+    readonly engine_query_box: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly engine_set_viewport_pad: (a: number, b: number) => void;
+    readonly engine_shape_count: (a: number) => number;
+    readonly engine_take_error: (a: number) => [number, number];
+    readonly engine_union_bounds: (a: number, b: number) => number;
+    readonly engine_vertices_len: (a: number) => number;
+    readonly engine_vertices_ptr: (a: number) => number;
+    readonly engine_viewport_pad: (a: number) => number;
+    readonly version: () => [number, number];
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;