math-rust-lib 0.1.3 → 0.2.1

package/math_rust_lib.js

@@ -1,719 +1,5 @@
-
-let imports = {};
-imports['__wbindgen_placeholder__'] = module.exports;
-
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-}
-
-function getArrayF32FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
-}
-
-let cachedFloat32ArrayMemory0 = null;
-function getFloat32ArrayMemory0() {
-    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
-        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
-    }
-    return cachedFloat32ArrayMemory0;
-}
-
-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;
-}
-
-function passArrayF32ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 4, 4) >>> 0;
-    getFloat32ArrayMemory0().set(arg, ptr / 4);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_externrefs.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
-}
-
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-cachedTextDecoder.decode();
-function decodeText(ptr, len) {
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
-let WASM_VECTOR_LEN = 0;
-
-const Mat4Finalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_mat4_free(ptr >>> 0, 1));
-
-const QuatFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_quat_free(ptr >>> 0, 1));
-
-const Vec3Finalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_vec3_free(ptr >>> 0, 1));
-
-class Mat4 {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Mat4.prototype);
-        obj.__wbg_ptr = ptr;
-        Mat4Finalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        Mat4Finalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_mat4_free(ptr, 0);
-    }
-    /**
-     * @param {Float32Array} val
-     * @returns {Mat4}
-     */
-    static from_values(val) {
-        const ptr0 = passArrayF32ToWasm0(val, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.mat4_from_values(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Mat4.__wrap(ret[0]);
-    }
-    /**
-     * @param {number} fov
-     * @param {number} aspect
-     * @param {number} near
-     * @param {number} far
-     * @returns {Mat4}
-     */
-    static perspective(fov, aspect, near, far) {
-        const ret = wasm.mat4_perspective(fov, aspect, near, far);
-        return Mat4.__wrap(ret);
-    }
-    /**
-     * @returns {Mat4}
-     */
-    set_identity() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.mat4_set_identity(ptr);
-        return Mat4.__wrap(ret);
-    }
-    /**
-     * @param {number} sx
-     * @param {number} sy
-     * @param {number} sz
-     * @returns {Mat4}
-     */
-    scale_in_place(sx, sy, sz) {
-        const ret = wasm.mat4_scale_in_place(this.__wbg_ptr, sx, sy, sz);
-        return Mat4.__wrap(ret);
-    }
-    /**
-     * @param {Float32Array} m
-     * @param {number} offset
-     * @returns {Quat}
-     */
-    static to_quat_from_array(m, offset) {
-        const ptr0 = passArrayF32ToWasm0(m, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.mat4_to_quat_from_array(ptr0, len0, offset);
-        return Quat.__wrap(ret);
-    }
-    /**
-     * @param {number} tx
-     * @param {number} ty
-     * @param {number} tz
-     * @returns {Mat4}
-     */
-    translate_in_place(tx, ty, tz) {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.mat4_translate_in_place(ptr, tx, ty, tz);
-        return Mat4.__wrap(ret);
-    }
-    /**
-     * @param {Vec3} position
-     * @param {Quat} rotation
-     * @returns {Mat4}
-     */
-    static from_position_rotation(position, rotation) {
-        _assertClass(position, Vec3);
-        _assertClass(rotation, Quat);
-        const ret = wasm.mat4_from_position_rotation(position.__wbg_ptr, rotation.__wbg_ptr);
-        return Mat4.__wrap(ret);
-    }
-    /**
-     * @param {Vec3} scale
-     * @returns {Mat4}
-     */
-    scale_in_place_by_vec3(scale) {
-        _assertClass(scale, Vec3);
-        var ptr0 = scale.__destroy_into_raw();
-        const ret = wasm.mat4_scale_in_place_by_vec3(this.__wbg_ptr, ptr0);
-        return Mat4.__wrap(ret);
-    }
-    /**
-     * @param {Vec3} position
-     * @param {Quat} rotation
-     * @param {Mat4} result
-     */
-    static from_position_rotation_to_ref(position, rotation, result) {
-        _assertClass(position, Vec3);
-        _assertClass(rotation, Quat);
-        _assertClass(result, Mat4);
-        wasm.mat4_from_position_rotation_to_ref(position.__wbg_ptr, rotation.__wbg_ptr, result.__wbg_ptr);
-    }
-    /**
-     * @param {Float32Array} val
-     */
-    constructor(val) {
-        const ptr0 = passArrayF32ToWasm0(val, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.mat4_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
-        Mat4Finalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @param {Float32Array} val
-     */
-    set(val) {
-        const ptr = this.__destroy_into_raw();
-        const ptr0 = passArrayF32ToWasm0(val, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.mat4_set(ptr, ptr0, len0);
-    }
-    /**
-     * @returns {Float32Array}
-     */
-    get values() {
-        const ret = wasm.mat4_values(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @param {Vec3} eye
-     * @param {Vec3} target
-     * @param {Vec3} up
-     * @returns {Mat4}
-     */
-    static look_at(eye, target, up) {
-        _assertClass(eye, Vec3);
-        var ptr0 = eye.__destroy_into_raw();
-        _assertClass(target, Vec3);
-        var ptr1 = target.__destroy_into_raw();
-        _assertClass(up, Vec3);
-        var ptr2 = up.__destroy_into_raw();
-        const ret = wasm.mat4_look_at(ptr0, ptr1, ptr2);
-        return Mat4.__wrap(ret);
-    }
-    /**
-     * @returns {Quat}
-     */
-    to_quat() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.mat4_to_quat(ptr);
-        return Quat.__wrap(ret);
-    }
-    /**
-     * @returns {Mat4}
-     */
-    static identity() {
-        const ret = wasm.mat4_identity();
-        return Mat4.__wrap(ret);
-    }
-    /**
-     * @param {Mat4} other
-     * @returns {Mat4}
-     */
-    multiply(other) {
-        _assertClass(other, Mat4);
-        var ptr0 = other.__destroy_into_raw();
-        const ret = wasm.mat4_multiply(this.__wbg_ptr, ptr0);
-        return Mat4.__wrap(ret);
-    }
-    /**
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     * @param {number} w
-     * @returns {Mat4}
-     */
-    static from_quat(x, y, z, w) {
-        const ret = wasm.mat4_from_quat(x, y, z, w);
-        return Mat4.__wrap(ret);
-    }
-}
-if (Symbol.dispose) Mat4.prototype[Symbol.dispose] = Mat4.prototype.free;
-exports.Mat4 = Mat4;
-
-class Quat {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Quat.prototype);
-        obj.__wbg_ptr = ptr;
-        QuatFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        QuatFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_quat_free(ptr, 0);
-    }
-    /**
-     * @returns {number}
-     */
-    get x() {
-        const ret = wasm.__wbg_get_quat_x(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @param {number} arg0
-     */
-    set x(arg0) {
-        wasm.__wbg_set_quat_x(this.__wbg_ptr, arg0);
-    }
-    /**
-     * @returns {number}
-     */
-    get y() {
-        const ret = wasm.__wbg_get_quat_y(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @param {number} arg0
-     */
-    set y(arg0) {
-        wasm.__wbg_set_quat_y(this.__wbg_ptr, arg0);
-    }
-    /**
-     * @returns {number}
-     */
-    get z() {
-        const ret = wasm.__wbg_get_quat_z(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @param {number} arg0
-     */
-    set z(arg0) {
-        wasm.__wbg_set_quat_z(this.__wbg_ptr, arg0);
-    }
-    /**
-     * @returns {number}
-     */
-    get w() {
-        const ret = wasm.__wbg_get_quat_w(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @param {number} arg0
-     */
-    set w(arg0) {
-        wasm.__wbg_set_quat_w(this.__wbg_ptr, arg0);
-    }
-    /**
-     * @param {number} rot_x
-     * @param {number} rot_y
-     * @param {number} rot_z
-     * @returns {Quat}
-     */
-    static from_euler(rot_x, rot_y, rot_z) {
-        const ret = wasm.quat_from_euler(rot_x, rot_y, rot_z);
-        return Quat.__wrap(ret);
-    }
-    /**
-     * @param {Vec3} v
-     * @returns {Vec3}
-     */
-    rotate_vec(v) {
-        _assertClass(v, Vec3);
-        var ptr0 = v.__destroy_into_raw();
-        const ret = wasm.quat_rotate_vec(this.__wbg_ptr, ptr0);
-        return Vec3.__wrap(ret);
-    }
-    /**
-     * @returns {Vec3}
-     */
-    to_euler_angles() {
-        const ret = wasm.quat_to_euler_angles(this.__wbg_ptr);
-        return Vec3.__wrap(ret);
-    }
-    /**
-     * @param {Vec3} vec_from
-     * @param {Vec3} vec_to
-     * @param {number} epsilon
-     * @returns {Quat}
-     */
-    static from_unit_vectors(vec_from, vec_to, epsilon) {
-        _assertClass(vec_from, Vec3);
-        _assertClass(vec_to, Vec3);
-        const ret = wasm.quat_from_unit_vectors(vec_from.__wbg_ptr, vec_to.__wbg_ptr, epsilon);
-        return Quat.__wrap(ret);
-    }
-    /**
-     * @param {number} yaw
-     * @param {number} pitch
-     * @param {number} roll
-     * @returns {Quat}
-     */
-    static rotation_yaw_pitch_roll(yaw, pitch, roll) {
-        const ret = wasm.quat_rotation_yaw_pitch_roll(yaw, pitch, roll);
-        return Quat.__wrap(ret);
-    }
-    /**
-     * @param {Vec3} vec_from
-     * @param {Vec3} vec_to
-     * @param {Quat} result
-     * @param {number} epsilon
-     * @returns {Quat}
-     */
-    static from_unit_vectors_to_ref(vec_from, vec_to, result, epsilon) {
-        _assertClass(vec_from, Vec3);
-        _assertClass(vec_to, Vec3);
-        _assertClass(result, Quat);
-        const ret = wasm.quat_from_unit_vectors_to_ref(vec_from.__wbg_ptr, vec_to.__wbg_ptr, result.__wbg_ptr, epsilon);
-        return Quat.__wrap(ret);
-    }
-    /**
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     * @param {number} w
-     */
-    constructor(x, y, z, w) {
-        const ret = wasm.quat_new(x, y, z, w);
-        this.__wbg_ptr = ret >>> 0;
-        QuatFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     * @param {number} w
-     * @returns {Quat}
-     */
-    set(x, y, z, w) {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.quat_set(ptr, x, y, z, w);
-        return Quat.__wrap(ret);
-    }
-    /**
-     * @returns {Quat}
-     */
-    clone() {
-        const ret = wasm.quat_clone(this.__wbg_ptr);
-        return Quat.__wrap(ret);
-    }
-    /**
-     * @param {Quat} a
-     * @param {Quat} b
-     * @param {number} t
-     * @returns {Quat}
-     */
-    static slerp(a, b, t) {
-        _assertClass(a, Quat);
-        _assertClass(b, Quat);
-        const ret = wasm.quat_slerp(a.__wbg_ptr, b.__wbg_ptr, t);
-        return Quat.__wrap(ret);
-    }
-    /**
-     * @returns {Quat}
-     */
-    static identity() {
-        const ret = wasm.quat_identity();
-        return Quat.__wrap(ret);
-    }
-    /**
-     * @param {Quat} other
-     * @returns {Quat}
-     */
-    multiply(other) {
-        _assertClass(other, Quat);
-        var ptr0 = other.__destroy_into_raw();
-        const ret = wasm.quat_multiply(this.__wbg_ptr, ptr0);
-        return Quat.__wrap(ret);
-    }
-    /**
-     * @returns {Float32Array}
-     */
-    to_array() {
-        const ret = wasm.quat_to_array(this.__wbg_ptr);
-        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-    /**
-     * @returns {Quat}
-     */
-    normalize() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.quat_normalize(ptr);
-        return Quat.__wrap(ret);
-    }
-}
-if (Symbol.dispose) Quat.prototype[Symbol.dispose] = Quat.prototype.free;
-exports.Quat = Quat;
-
-class Vec3 {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Vec3.prototype);
-        obj.__wbg_ptr = ptr;
-        Vec3Finalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        Vec3Finalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_vec3_free(ptr, 0);
-    }
-    /**
-     * @returns {number}
-     */
-    get x() {
-        const ret = wasm.__wbg_get_vec3_x(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @param {number} arg0
-     */
-    set x(arg0) {
-        wasm.__wbg_set_vec3_x(this.__wbg_ptr, arg0);
-    }
-    /**
-     * @returns {number}
-     */
-    get y() {
-        const ret = wasm.__wbg_get_vec3_y(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @param {number} arg0
-     */
-    set y(arg0) {
-        wasm.__wbg_set_vec3_y(this.__wbg_ptr, arg0);
-    }
-    /**
-     * @returns {number}
-     */
-    get z() {
-        const ret = wasm.__wbg_get_vec3_z(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @param {number} arg0
-     */
-    set z(arg0) {
-        wasm.__wbg_set_vec3_z(this.__wbg_ptr, arg0);
-    }
-    /**
-     * @returns {number}
-     */
-    length_squared() {
-        const ret = wasm.vec3_length_squared(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @param {Vec3} other
-     * @returns {Vec3}
-     */
-    add(other) {
-        _assertClass(other, Vec3);
-        var ptr0 = other.__destroy_into_raw();
-        const ret = wasm.vec3_add(this.__wbg_ptr, ptr0);
-        return Vec3.__wrap(ret);
-    }
-    /**
-     * @param {Vec3} other
-     * @returns {number}
-     */
-    dot(other) {
-        _assertClass(other, Vec3);
-        var ptr0 = other.__destroy_into_raw();
-        const ret = wasm.vec3_dot(this.__wbg_ptr, ptr0);
-        return ret;
-    }
-    /**
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     */
-    constructor(x, y, z) {
-        const ret = wasm.vec3_new(x, y, z);
-        this.__wbg_ptr = ret >>> 0;
-        Vec3Finalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     * @returns {Vec3}
-     */
-    set(x, y, z) {
-        const ret = wasm.vec3_set(this.__wbg_ptr, x, y, z);
-        return Vec3.__wrap(ret);
-    }
-    /**
-     * @returns {Vec3}
-     */
-    clone() {
-        const ret = wasm.vec3_clone(this.__wbg_ptr);
-        return Vec3.__wrap(ret);
-    }
-    /**
-     * @param {Vec3} other
-     * @returns {Vec3}
-     */
-    cross(other) {
-        _assertClass(other, Vec3);
-        var ptr0 = other.__destroy_into_raw();
-        const ret = wasm.vec3_cross(this.__wbg_ptr, ptr0);
-        return Vec3.__wrap(ret);
-    }
-    /**
-     * @param {number} scalar
-     * @returns {Vec3}
-     */
-    scale(scalar) {
-        const ret = wasm.vec3_scale(this.__wbg_ptr, scalar);
-        return Vec3.__wrap(ret);
-    }
-    /**
-     * @returns {number}
-     */
-    length() {
-        const ret = wasm.vec3_length(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @param {Vec3} other
-     * @returns {Vec3}
-     */
-    subtract(other) {
-        _assertClass(other, Vec3);
-        var ptr0 = other.__destroy_into_raw();
-        const ret = wasm.vec3_subtract(this.__wbg_ptr, ptr0);
-        return Vec3.__wrap(ret);
-    }
-    /**
-     * @returns {Float32Array}
-     */
-    to_array() {
-        const ret = wasm.vec3_to_array(this.__wbg_ptr);
-        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-    /**
-     * @returns {Vec3}
-     */
-    normalize() {
-        const ret = wasm.vec3_normalize(this.__wbg_ptr);
-        return Vec3.__wrap(ret);
-    }
-}
-if (Symbol.dispose) Vec3.prototype[Symbol.dispose] = Vec3.prototype.free;
-exports.Vec3 = Vec3;
-
-/**
- * @param {Vec3} a
- * @param {Vec3} b
- * @returns {Vec3}
- */
-function cross(a, b) {
-    _assertClass(a, Vec3);
-    var ptr0 = a.__destroy_into_raw();
-    _assertClass(b, Vec3);
-    var ptr1 = b.__destroy_into_raw();
-    const ret = wasm.cross(ptr0, ptr1);
-    return Vec3.__wrap(ret);
-}
-exports.cross = cross;
-
-/**
- * @param {number} t
- * @returns {number}
- */
-function ease_in_out(t) {
-    const ret = wasm.ease_in_out(t);
-    return ret;
-}
-exports.ease_in_out = ease_in_out;
-
-/**
- * @param {Vec3} start
- * @param {Vec3} end
- * @param {number} t
- * @returns {Vec3}
- */
-function lerp(start, end, t) {
-    _assertClass(start, Vec3);
-    var ptr0 = start.__destroy_into_raw();
-    _assertClass(end, Vec3);
-    var ptr1 = end.__destroy_into_raw();
-    const ret = wasm.lerp(ptr0, ptr1, t);
-    return Vec3.__wrap(ret);
-}
-exports.lerp = lerp;
-
-exports.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
-};
-
-exports.__wbg_new_from_slice_41e2764a343e3cb1 = function(arg0, arg1) {
-    const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
-    return ret;
-};
-
-exports.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
-    // Cast intrinsic for `Ref(String) -> Externref`.
-    const ret = getStringFromWasm0(arg0, arg1);
-    return ret;
-};
-
-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}/math_rust_lib_bg.wasm`;
-const wasmBytes = require('fs').readFileSync(wasmPath);
-const wasmModule = new WebAssembly.Module(wasmBytes);
-const wasm = exports.__wasm = new WebAssembly.Instance(wasmModule, imports).exports;
-
+import * as wasm from "./math_rust_lib_bg.wasm";
+export * from "./math_rust_lib_bg.js";
+import { __wbg_set_wasm } from "./math_rust_lib_bg.js";
+__wbg_set_wasm(wasm);
 wasm.__wbindgen_start();