dcre-native 0.1.0

High-performance Rust core for DCRE Mesh
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128


let imports = {};
imports['__wbindgen_placeholder__'] = module.exports;

function getStringFromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    return decodeText(ptr, 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();
function decodeText(ptr, len) {
    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
}

const LatticeFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_lattice_free(ptr >>> 0, 1));

class Lattice {
    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        LatticeFinalization.unregister(this);
        return ptr;
    }
    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_lattice_free(ptr, 0);
    }
    /**
     * @param {number} row
     * @param {number} col
     * @returns {number}
     */
    get(row, col) {
        const ret = wasm.lattice_get(this.__wbg_ptr, row, col);
        return ret;
    }
    /**
     * @param {number} width
     * @param {number} height
     * @param {number} modulus
     */
    constructor(width, height, modulus) {
        const ret = wasm.lattice_new(width, height, modulus);
        this.__wbg_ptr = ret >>> 0;
        LatticeFinalization.register(this, this.__wbg_ptr, this);
        return this;
    }
    /**
     * @param {number} row
     * @param {number} col
     * @param {number} value
     */
    set(row, col, value) {
        wasm.lattice_set(this.__wbg_ptr, row, col, value);
    }
    /**
     * @returns {number}
     */
    width() {
        const ret = wasm.lattice_width(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * Optimized Lattice Evolution
     *
     * Applies the DCRE matrix [[2, 1], [1, 1]] to 2x2 blocks in a checkerboard pattern.
     * This implementation is single-threaded O(N^2) but allocation-free.
     */
    evolve() {
        wasm.lattice_evolve(this.__wbg_ptr);
    }
    /**
     * @returns {number}
     */
    height() {
        const ret = wasm.lattice_height(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
     * @returns {number}
     */
    modulus() {
        const ret = wasm.lattice_modulus(this.__wbg_ptr);
        return ret;
    }
    /**
     * Access memory directly from JS for zero-copy
     * @returns {number}
     */
    cells_ptr() {
        const ret = wasm.lattice_cells_ptr(this.__wbg_ptr);
        return ret >>> 0;
    }
}
if (Symbol.dispose) Lattice.prototype[Symbol.dispose] = Lattice.prototype.free;
exports.Lattice = Lattice;

exports.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
    throw new Error(getStringFromWasm0(arg0, arg1));
};

exports.__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);
};

const wasmPath = `${__dirname}/dcre_native_bg.wasm`;
const wasmBytes = require('fs').readFileSync(wasmPath);
const wasmModule = new WebAssembly.Module(wasmBytes);
const wasm = exports.__wasm = new WebAssembly.Instance(wasmModule, imports).exports;

wasm.__wbindgen_start();