opengeometry 2.0.17 → 3.0.0

package/tessellation-worker.js

@@ -0,0 +1,634 @@
+function parseKernelError(text) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof value !== 'object' || value === null || !('code' in value) || !('message' in value))
+        return undefined;
+    const { code, message } = value;
+    if (typeof code !== 'string' || typeof message !== 'string' || !code || !message)
+        return undefined;
+    return { code, message, details: 'details' in value ? value.details : undefined };
+}
+
+let wasm;
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_export_2.set(idx, obj);
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); }
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_2.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+const OGTessellatorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ogtessellator_free(ptr >>> 0, 1));
+
+class OGTessellator {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OGTessellatorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ogtessellator_free(ptr, 0);
+    }
+    constructor() {
+        const ret = wasm.ogtessellator_new();
+        this.__wbg_ptr = ret >>> 0;
+        OGTessellatorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {number}
+     */
+    load(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ogtessellator_load(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * @param {number} slot
+     * @param {number} bucket
+     * @param {number} max_triangles
+     * @param {number | null} [smooth_angle]
+     * @returns {any}
+     */
+    buffers(slot, bucket, max_triangles, smooth_angle) {
+        const ret = wasm.ogtessellator_buffers(this.__wbg_ptr, slot, bucket, max_triangles, !isLikeNone(smooth_angle), isLikeNone(smooth_angle) ? 0 : smooth_angle);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {number} slot
+     * @returns {boolean}
+     */
+    drop(slot) {
+        const ret = wasm.ogtessellator_drop(this.__wbg_ptr, slot);
+        return ret !== 0;
+    }
+}
+
+(typeof FinalizationRegistry === 'undefined')
+    ? { }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ogworldgraph_free(ptr >>> 0, 1));
+
+function __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
+        const ret = arg0.buffer;
+        return ret;
+    };
+    imports.wbg.__wbg_call_672a4d21634d4a24 = function() { return handleError(function (arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.error(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
+    };
+    imports.wbg.__wbg_new_405e22f390576ce2 = function() {
+        const ret = new Object();
+        return ret;
+    };
+    imports.wbg.__wbg_new_780abee5c1739fd7 = function(arg0) {
+        const ret = new Float32Array(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_new_78c8a92080461d08 = function(arg0) {
+        const ret = new Float64Array(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
+        const ret = new Error();
+        return ret;
+    };
+    imports.wbg.__wbg_new_a12002a7f91c75be = function(arg0) {
+        const ret = new Uint8Array(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_new_e3b321dcfef89fc7 = function(arg0) {
+        const ret = new Uint32Array(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_newnoargs_105ed471475aaf50 = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_93c8e0c1a479fa1a = function(arg0, arg1, arg2) {
+        const ret = new Float64Array(arg0, arg1 >>> 0, arg2 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a = function(arg0, arg1, arg2) {
+        const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_e6b7e69acd4c7354 = function(arg0, arg1, arg2) {
+        const ret = new Float32Array(arg0, arg1 >>> 0, arg2 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_f1dead44d1fc7212 = function(arg0, arg1, arg2) {
+        const ret = new Uint32Array(arg0, arg1 >>> 0, arg2 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_set_bb8cecf6a62b9f46 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = Reflect.set(arg0, arg1, arg2);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
+        const ret = arg1.stack;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function() {
+        const ret = typeof global === 'undefined' ? null : global;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 = function() {
+        const ret = typeof globalThis === 'undefined' ? null : globalThis;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function() {
+        const ret = typeof self === 'undefined' ? null : self;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_WINDOW_5de37043a91a9c40 = function() {
+        const ret = typeof window === 'undefined' ? null : window;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbindgen_init_externref_table = function() {
+        const table = wasm.__wbindgen_export_2;
+        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);
+    };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = arg0 === undefined;
+        return ret;
+    };
+    imports.wbg.__wbindgen_memory = function() {
+        const ret = wasm.memory;
+        return ret;
+    };
+    imports.wbg.__wbindgen_number_new = function(arg0) {
+        const ret = arg0;
+        return ret;
+    };
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+
+    return imports;
+}
+
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+
+
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof 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);
+}
+
+function takePanicMessage() {
+    const message = Reflect.get(globalThis, '__opengeometryPanic');
+    Reflect.deleteProperty(globalThis, '__opengeometryPanic');
+    return typeof message === 'string' ? message : undefined;
+}
+
+function isDetails(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+class OGError extends Error {
+    code;
+    call;
+    details;
+    constructor(code, call, message, details = {}) {
+        super(message);
+        this.name = 'OGError';
+        this.code = code;
+        this.call = call;
+        this.details = isDetails(details) ? details : {};
+    }
+    toJSON() {
+        return { code: this.code, call: this.call, message: this.message, details: this.details };
+    }
+    static fromJSON(value) {
+        return new OGError(value.code, value.call, value.message, value.details);
+    }
+}
+
+const SCALARS = ['revision', 'bucket', 'achievedDeflection', 'triangles'];
+function validateDisplayBuffers(value) {
+    if (!isDisplayBuffers(value) || !hasConsistentLengths(value)) {
+        throw new OGError('WorkerFailure', 'tessellation', 'invalid display buffer structure');
+    }
+    return value;
+}
+function isDisplayBuffers(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const field = (key) => Reflect.get(value, key);
+    return field('positions') instanceof Float32Array && field('normals') instanceof Float32Array
+        && field('indices') instanceof Uint32Array && field('faceRanges') instanceof Uint32Array
+        && field('outline') instanceof Float32Array && field('edgeIds') instanceof Uint32Array
+        && field('smoothEdges') instanceof Uint8Array
+        && field('origin') instanceof Float64Array && SCALARS.every((key) => typeof field(key) === 'number');
+}
+function hasConsistentLengths(buffers) {
+    return buffers.origin.length === 3 && buffers.positions.length % 3 === 0
+        && buffers.normals.length === buffers.positions.length
+        && buffers.indices.length % 3 === 0 && buffers.indices.length <= 6_000_000
+        && buffers.outline.length % 6 === 0 && buffers.outline.length <= 12_000_000
+        && buffers.edgeIds.length === buffers.outline.length / 6 && buffers.faceRanges.length % 3 === 0;
+}
+
+class JobQueue {
+    jobs = new Map();
+    get size() {
+        return this.jobs.size;
+    }
+    push(job) {
+        const previous = this.jobs.get(job.shapeId);
+        this.jobs.set(job.shapeId, job);
+        return previous?.request;
+    }
+    cancel(shapeId, generation) {
+        const previous = this.jobs.get(shapeId);
+        if (!previous || previous.generation > generation)
+            return undefined;
+        this.jobs.delete(shapeId);
+        return previous.request;
+    }
+    next() {
+        const next = [...this.jobs.values()].sort((a, b) => a.priority - b.priority)[0];
+        if (next)
+            this.jobs.delete(next.shapeId);
+        return next;
+    }
+}
+
+const KINDS = ['init', 'snapshot', 'tessellate', 'cancel', 'drop'];
+function parseWorkerMessage(data) {
+    if (isWorkerMessage(data))
+        return data;
+    const message = problemOf(data) ?? 'invalid worker message';
+    return { request: requestOf(data), error: { code: 'InvalidParameter', message } };
+}
+function isWorkerMessage(data) {
+    return problemOf(data) === undefined;
+}
+function problemOf(data) {
+    if (typeof data !== 'object' || data === null)
+        return 'worker message is not an object';
+    const kind = Reflect.get(data, 'kind');
+    const known = KINDS.find((name) => name === kind);
+    if (known === undefined)
+        return `worker message field kind has unknown value ${String(kind)}`;
+    const checks = fieldChecks(known);
+    const extra = Object.keys(data).find((key) => !Object.hasOwn(checks, key));
+    if (extra !== undefined)
+        return `unknown worker message field ${extra}`;
+    const invalid = Object.entries(checks).find(([key, check]) => !check(Reflect.get(data, key)));
+    return invalid === undefined ? undefined : `worker message field ${invalid[0]} is missing or invalid`;
+}
+function fieldChecks(kind) {
+    switch (kind) {
+        case 'init':
+            return { kind: isKind, request: (value) => value === 0, module: (value) => value instanceof WebAssembly.Module };
+        case 'snapshot':
+            return {
+                kind: isKind, request: isFiniteNumber, shapeId: isShapeId, revision: isFiniteNumber,
+                bytes: (value) => value instanceof Uint8Array,
+            };
+        case 'tessellate':
+            return {
+                kind: isKind, request: isFiniteNumber, shapeId: isShapeId, revision: isFiniteNumber, bucket: isFiniteNumber,
+                priority: isFiniteNumber, maxTriangles: isFiniteNumber, generation: isFiniteNumber, smoothAngle: isSmoothAngle,
+            };
+        case 'cancel':
+            return { kind: isKind, shapeId: isShapeId, generation: isFiniteNumber };
+        case 'drop':
+            return { kind: isKind, shapeId: isShapeId, revision: isFiniteNumber };
+    }
+}
+function requestOf(data) {
+    const request = typeof data === 'object' && data !== null ? Reflect.get(data, 'request') : undefined;
+    return isFiniteNumber(request) ? request : undefined;
+}
+function isSmoothAngle(value) {
+    return value === undefined || (isFiniteNumber(value) && value >= 0 && value < 90);
+}
+function isKind() {
+    return true;
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function isShapeId(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+
+class SnapshotCache {
+    entries = new Map();
+    totalBytes = 0;
+    clock = 0;
+    load(key, bytes, tessellator) {
+        this.drop(key, tessellator);
+        const slot = tessellator.load(bytes);
+        this.entries.set(key, { slot, bytes: bytes.byteLength, lastUse: ++this.clock });
+        this.totalBytes += bytes.byteLength;
+    }
+    drop(key, tessellator) {
+        const old = this.entries.get(key);
+        if (!old)
+            return;
+        tessellator.drop(old.slot);
+        this.entries.delete(key);
+        this.totalBytes -= old.bytes;
+    }
+    touch(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return undefined;
+        entry.lastUse = ++this.clock;
+        return entry.slot;
+    }
+    evict(except, tessellator) {
+        const evicted = [];
+        while (this.totalBytes > 128 * 1024 * 1024) {
+            const oldest = [...this.entries.entries()]
+                .filter(([key]) => key !== except)
+                .sort((a, b) => a[1].lastUse - b[1].lastUse)[0];
+            if (!oldest)
+                break;
+            this.drop(oldest[0], tessellator);
+            evicted.push(oldest[0]);
+        }
+        return evicted;
+    }
+}
+
+let tessellator;
+let scheduled = false;
+const SNAPSHOTS = new SnapshotCache();
+const JOBS = new JobQueue();
+const CHANNEL = new MessageChannel();
+function error(value) {
+    if (value instanceof WebAssembly.RuntimeError) {
+        return { code: 'KernelPanic', message: takePanicMessage() ?? value.message, details: {} };
+    }
+    const parsed = typeof value === 'string' ? parseKernelError(value) : undefined;
+    return parsed ?? { code: 'WorkerFailure', message: String(value), details: {} };
+}
+function reply(message, transfer = []) {
+    self.postMessage(message, transfer);
+}
+function postEvicted(key) {
+    const at = key.lastIndexOf('@');
+    reply({ kind: 'evicted', shapeId: key.slice(0, at), revision: Number(key.slice(at + 1)) });
+}
+function answerSuperseded(request) {
+    if (request !== undefined)
+        reply({ request, superseded: true });
+}
+function schedule() {
+    if (scheduled || JOBS.size === 0)
+        return;
+    scheduled = true;
+    CHANNEL.port2.postMessage(null);
+}
+function run(job) {
+    const slot = SNAPSHOTS.touch(`${job.shapeId}@${String(job.revision)}`);
+    if (slot === undefined || !tessellator) {
+        reply({ request: job.request, missingSnapshot: true });
+        return;
+    }
+    try {
+        const angle = job.smoothAngle;
+        const buffers = validateDisplayBuffers(tessellator.buffers(slot, job.bucket, job.maxTriangles, angle));
+        reply({ request: job.request, ok: true, buffers }, [
+            buffers.positions.buffer, buffers.normals.buffer, buffers.indices.buffer,
+            buffers.faceRanges.buffer, buffers.outline.buffer, buffers.edgeIds.buffer, buffers.smoothEdges.buffer,
+            buffers.origin.buffer,
+        ]);
+    }
+    catch (cause) {
+        reply({ request: job.request, error: error(cause) });
+    }
+}
+CHANNEL.port1.onmessage = () => {
+    scheduled = false;
+    const next = JOBS.next();
+    if (!next)
+        return;
+    run(next);
+    schedule();
+};
+function init(module) {
+    initSync({ module });
+    tessellator = new OGTessellator();
+    reply({ request: 0, ok: true });
+}
+function handle(message, loaded) {
+    switch (message.kind) {
+        case 'snapshot': {
+            const key = `${message.shapeId}@${String(message.revision)}`;
+            SNAPSHOTS.load(key, message.bytes, loaded);
+            for (const evicted of SNAPSHOTS.evict(key, loaded))
+                postEvicted(evicted);
+            reply({ request: message.request, ok: true });
+            break;
+        }
+        case 'tessellate':
+            answerSuperseded(JOBS.push(message));
+            schedule();
+            break;
+        case 'cancel':
+            answerSuperseded(JOBS.cancel(message.shapeId, message.generation));
+            break;
+        case 'drop':
+            SNAPSHOTS.drop(`${message.shapeId}@${String(message.revision)}`, loaded);
+            break;
+    }
+}
+self.onmessage = (event) => {
+    const message = parseWorkerMessage(event.data);
+    const request = 'request' in message ? message.request : undefined;
+    try {
+        if ('error' in message)
+            reply(message);
+        else if (message.kind === 'init')
+            init(message.module);
+        else if (tessellator)
+            handle(message, tessellator);
+        else
+            reply({ request, error: { code: 'WorkerFailure', message: 'tessellation worker is not initialised' } });
+    }
+    catch (cause) {
+        reply({ request, error: error(cause) });
+    }
+};
+//# sourceMappingURL=tessellation-worker.js.map