math-rust-lib 0.1.0 → 0.1.1

package/math_rust_lib.d.ts

@@ -24,10 +24,19 @@ export class Mat4 {
 export class Quat {
   free(): void;
   [Symbol.dispose](): void;
+  static from_euler(rot_x: number, rot_y: number, rot_z: number): Quat;
+  rotate_vec(v: Vec3): Vec3;
   to_euler_angles(): Vec3;
+  static from_unit_vectors(vec_from: Vec3, vec_to: Vec3, epsilon: number): Quat;
+  static rotation_yaw_pitch_roll(yaw: number, pitch: number, roll: number): Quat;
+  static from_unit_vectors_to_ref(vec_from: Vec3, vec_to: Vec3, result: Quat, epsilon: number): Quat;
   constructor(x: number, y: number, z: number, w: number);
+  set(x: number, y: number, z: number): Quat;
   clone(): Quat;
+  static slerp(a: Quat, b: Quat, t: number): Quat;
+  static identity(): Quat;
   multiply(other: Quat): Quat;
+  normalize(): Quat;
   x: number;
   y: number;
   z: number;

package/math_rust_lib.js

@@ -312,6 +312,26 @@ class Quat {
     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}
      */
@@ -319,6 +339,42 @@ class Quat {
         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
@@ -331,6 +387,17 @@ class Quat {
         QuatFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {Quat}
+     */
+    set(x, y, z) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.quat_set(ptr, x, y, z);
+        return Quat.__wrap(ret);
+    }
     /**
      * @returns {Quat}
      */
@@ -338,6 +405,25 @@ class Quat {
         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}
@@ -348,6 +434,14 @@ class Quat {
         const ret = wasm.quat_multiply(this.__wbg_ptr, ptr0);
         return Quat.__wrap(ret);
     }
+    /**
+     * @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;
@@ -374,40 +468,40 @@ class Vec3 {
      * @returns {number}
      */
     get x() {
-        const ret = wasm.__wbg_get_quat_x(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_vec3_x(this.__wbg_ptr);
         return ret;
     }
     /**
      * @param {number} arg0
      */
     set x(arg0) {
-        wasm.__wbg_set_quat_x(this.__wbg_ptr, arg0);
+        wasm.__wbg_set_vec3_x(this.__wbg_ptr, arg0);
     }
     /**
      * @returns {number}
      */
     get y() {
-        const ret = wasm.__wbg_get_quat_y(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_vec3_y(this.__wbg_ptr);
         return ret;
     }
     /**
      * @param {number} arg0
      */
     set y(arg0) {
-        wasm.__wbg_set_quat_y(this.__wbg_ptr, arg0);
+        wasm.__wbg_set_vec3_y(this.__wbg_ptr, arg0);
     }
     /**
      * @returns {number}
      */
     get z() {
-        const ret = wasm.__wbg_get_quat_z(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_vec3_z(this.__wbg_ptr);
         return ret;
     }
     /**
      * @param {number} arg0
      */
     set z(arg0) {
-        wasm.__wbg_set_quat_z(this.__wbg_ptr, arg0);
+        wasm.__wbg_set_vec3_z(this.__wbg_ptr, arg0);
     }
     /**
      * @returns {number}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-rust-lib",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "files": [
     "math_rust_lib_bg.wasm",
     "math_rust_lib.js",