math-rust-lib 0.2.0 → 0.2.1

package/math_rust_lib_bg.js

@@ -0,0 +1,729 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+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();
+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 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));
+
+export 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 {Vec3}
+     */
+    get_position() {
+        const ret = wasm.mat4_get_position(this.__wbg_ptr);
+        return Vec3.__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;
+    }
+    /**
+     * @returns {Mat4}
+     */
+    inverse() {
+        const ret = wasm.mat4_inverse(this.__wbg_ptr);
+        return Mat4.__wrap(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;
+
+export 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;
+
+export 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;
+
+/**
+ * @param {Vec3} a
+ * @param {Vec3} b
+ * @returns {Vec3}
+ */
+export 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);
+}
+
+/**
+ * @param {number} t
+ * @returns {number}
+ */
+export function ease_in_out(t) {
+    const ret = wasm.ease_in_out(t);
+    return ret;
+}
+
+/**
+ * @param {Vec3} start
+ * @param {Vec3} end
+ * @param {number} t
+ * @returns {Vec3}
+ */
+export 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);
+}
+
+export function __wbg___wbindgen_throw_dd24417ed36fc46e(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+export function __wbg_new_from_slice_41e2764a343e3cb1(arg0, arg1) {
+    const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
+    return ret;
+};
+
+export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+};
+
+export function __wbindgen_init_externref_table() {
+    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);
+};