math-rust-lib 0.1.0

package/math_rust_lib.d.ts

@@ -0,0 +1,61 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class Mat4 {
+  free(): void;
+  [Symbol.dispose](): void;
+  static from_values(val: Float32Array): Mat4;
+  static perspective(fov: number, aspect: number, near: number, far: number): Mat4;
+  set_identity(): Mat4;
+  scale_in_place(sx: number, sy: number, sz: number): Mat4;
+  static to_quat_from_array(m: Float32Array, offset: number): Quat;
+  translate_in_place(tx: number, ty: number, tz: number): Mat4;
+  scale_in_place_by_vec3(scale: Vec3): Mat4;
+  constructor(val: Float32Array);
+  set(val: Float32Array): void;
+  static look_at(eye: Vec3, target: Vec3, up: Vec3): Mat4;
+  to_quat(): Quat;
+  static identity(): Mat4;
+  multiply(other: Mat4): Mat4;
+  static from_quat(x: number, y: number, z: number, w: number): Mat4;
+  readonly values: Float32Array;
+}
+
+export class Quat {
+  free(): void;
+  [Symbol.dispose](): void;
+  to_euler_angles(): Vec3;
+  constructor(x: number, y: number, z: number, w: number);
+  clone(): Quat;
+  multiply(other: Quat): Quat;
+  x: number;
+  y: number;
+  z: number;
+  w: number;
+}
+
+export class Vec3 {
+  free(): void;
+  [Symbol.dispose](): void;
+  length_squared(): number;
+  add(other: Vec3): Vec3;
+  dot(other: Vec3): number;
+  constructor(x: number, y: number, z: number);
+  set(x: number, y: number, z: number): Vec3;
+  clone(): Vec3;
+  cross(other: Vec3): Vec3;
+  scale(scalar: number): Vec3;
+  length(): number;
+  subtract(other: Vec3): Vec3;
+  to_array(): Float32Array;
+  normalize(): Vec3;
+  x: number;
+  y: number;
+  z: number;
+}
+
+export function cross(a: Vec3, b: Vec3): Vec3;
+
+export function ease_in_out(t: number): number;
+
+export function lerp(start: Vec3, end: Vec3, t: number): Vec3;

package/math_rust_lib.js

@@ -0,0 +1,593 @@
+
+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} 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 {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);
+    }
+    /**
+     * @returns {Vec3}
+     */
+    to_euler_angles() {
+        const ret = wasm.quat_to_euler_angles(this.__wbg_ptr);
+        return Vec3.__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;
+    }
+    /**
+     * @returns {Quat}
+     */
+    clone() {
+        const ret = wasm.quat_clone(this.__wbg_ptr);
+        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);
+    }
+}
+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_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}
+     */
+    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;
+
+wasm.__wbindgen_start();

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "math-rust-lib",
+  "version": "0.1.0",
+  "files": [
+    "math_rust_lib_bg.wasm",
+    "math_rust_lib.js",
+    "math_rust_lib.d.ts"
+  ],
+  "main": "math_rust_lib.js",
+  "types": "math_rust_lib.d.ts"
+}