opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/animation/MMDPhysics.js

@@ -0,0 +1,1183 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.MMDPhysics = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.MMDPhysics = void 0;
+
+  function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+
+  function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  /**
+   * Dependencies
+   *  - Ammo.js https://github.com/kripken/ammo.js
+   *
+   * MMDPhysics calculates physics with Ammo(Bullet based JavaScript Physics engine)
+   * for MMD model loaded by MMDLoader.
+   *
+   * TODO
+   *  - Physics in Worker
+   */
+
+  /* global Ammo */
+  var MMDPhysics = /*#__PURE__*/function () {
+    /**
+     * @param {THREE.SkinnedMesh} mesh
+     * @param {Array<Object>} rigidBodyParams
+     * @param {Array<Object>} (optional) constraintParams
+     * @param {Object} params - (optional)
+     * @param {Number} params.unitStep - Default is 1 / 65.
+     * @param {Integer} params.maxStepNum - Default is 3.
+     * @param {Vector3} params.gravity - Default is ( 0, - 9.8 * 10, 0 )
+     */
+    function MMDPhysics(mesh, rigidBodyParams) {
+      var constraintParams = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+      var params = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+
+      _classCallCheck(this, MMDPhysics);
+
+      if (typeof Ammo === 'undefined') {
+        throw new Error('THREE.MMDPhysics: Import ammo.js https://github.com/kripken/ammo.js');
+      }
+
+      this.manager = new ResourceManager();
+      this.mesh = mesh;
+      /*
+       * I don't know why but 1/60 unitStep easily breaks models
+       * so I set it 1/65 so far.
+       * Don't set too small unitStep because
+       * the smaller unitStep can make the performance worse.
+       */
+
+      this.unitStep = params.unitStep !== undefined ? params.unitStep : 1 / 65;
+      this.maxStepNum = params.maxStepNum !== undefined ? params.maxStepNum : 3;
+      this.gravity = new _three.Vector3(0, -9.8 * 10, 0);
+      if (params.gravity !== undefined) this.gravity.copy(params.gravity);
+      this.world = params.world !== undefined ? params.world : null; // experimental
+
+      this.bodies = [];
+      this.constraints = [];
+
+      this._init(mesh, rigidBodyParams, constraintParams);
+    }
+    /**
+     * Advances Physics calculation and updates bones.
+     *
+     * @param {Number} delta - time in second
+     * @return {MMDPhysics}
+     */
+
+
+    _createClass(MMDPhysics, [{
+      key: "update",
+      value: function update(delta) {
+        var manager = this.manager;
+        var mesh = this.mesh; // rigid bodies and constrains are for
+        // mesh's world scale (1, 1, 1).
+        // Convert to (1, 1, 1) if it isn't.
+
+        var isNonDefaultScale = false;
+        var position = manager.allocThreeVector3();
+        var quaternion = manager.allocThreeQuaternion();
+        var scale = manager.allocThreeVector3();
+        mesh.matrixWorld.decompose(position, quaternion, scale);
+
+        if (scale.x !== 1 || scale.y !== 1 || scale.z !== 1) {
+          isNonDefaultScale = true;
+        }
+
+        var parent;
+
+        if (isNonDefaultScale) {
+          parent = mesh.parent;
+          if (parent !== null) mesh.parent = null;
+          scale.copy(this.mesh.scale);
+          mesh.scale.set(1, 1, 1);
+          mesh.updateMatrixWorld(true);
+        } // calculate physics and update bones
+
+
+        this._updateRigidBodies();
+
+        this._stepSimulation(delta);
+
+        this._updateBones(); // restore mesh if converted above
+
+
+        if (isNonDefaultScale) {
+          if (parent !== null) mesh.parent = parent;
+          mesh.scale.copy(scale);
+        }
+
+        manager.freeThreeVector3(scale);
+        manager.freeThreeQuaternion(quaternion);
+        manager.freeThreeVector3(position);
+        return this;
+      }
+      /**
+       * Resets rigid bodies transorm to current bone's.
+       *
+       * @return {MMDPhysics}
+       */
+
+    }, {
+      key: "reset",
+      value: function reset() {
+        for (var i = 0, il = this.bodies.length; i < il; i++) {
+          this.bodies[i].reset();
+        }
+
+        return this;
+      }
+      /**
+       * Warm ups Rigid bodies. Calculates cycles steps.
+       *
+       * @param {Integer} cycles
+       * @return {MMDPhysics}
+       */
+
+    }, {
+      key: "warmup",
+      value: function warmup(cycles) {
+        for (var i = 0; i < cycles; i++) {
+          this.update(1 / 60);
+        }
+
+        return this;
+      }
+      /**
+       * Sets gravity.
+       *
+       * @param {Vector3} gravity
+       * @return {MMDPhysicsHelper}
+       */
+
+    }, {
+      key: "setGravity",
+      value: function setGravity(gravity) {
+        this.world.setGravity(new Ammo.btVector3(gravity.x, gravity.y, gravity.z));
+        this.gravity.copy(gravity);
+        return this;
+      }
+      /**
+       * Creates MMDPhysicsHelper
+       *
+       * @return {MMDPhysicsHelper}
+       */
+
+    }, {
+      key: "createHelper",
+      value: function createHelper() {
+        return new MMDPhysicsHelper(this.mesh, this);
+      } // private methods
+
+    }, {
+      key: "_init",
+      value: function _init(mesh, rigidBodyParams, constraintParams) {
+        var manager = this.manager; // rigid body/constraint parameters are for
+        // mesh's default world transform as position(0, 0, 0),
+        // quaternion(0, 0, 0, 1) and scale(0, 0, 0)
+
+        var parent = mesh.parent;
+        if (parent !== null) parent = null;
+        var currentPosition = manager.allocThreeVector3();
+        var currentQuaternion = manager.allocThreeQuaternion();
+        var currentScale = manager.allocThreeVector3();
+        currentPosition.copy(mesh.position);
+        currentQuaternion.copy(mesh.quaternion);
+        currentScale.copy(mesh.scale);
+        mesh.position.set(0, 0, 0);
+        mesh.quaternion.set(0, 0, 0, 1);
+        mesh.scale.set(1, 1, 1);
+        mesh.updateMatrixWorld(true);
+
+        if (this.world === null) {
+          this.world = this._createWorld();
+          this.setGravity(this.gravity);
+        }
+
+        this._initRigidBodies(rigidBodyParams);
+
+        this._initConstraints(constraintParams);
+
+        if (parent !== null) mesh.parent = parent;
+        mesh.position.copy(currentPosition);
+        mesh.quaternion.copy(currentQuaternion);
+        mesh.scale.copy(currentScale);
+        mesh.updateMatrixWorld(true);
+        this.reset();
+        manager.freeThreeVector3(currentPosition);
+        manager.freeThreeQuaternion(currentQuaternion);
+        manager.freeThreeVector3(currentScale);
+      }
+    }, {
+      key: "_createWorld",
+      value: function _createWorld() {
+        var config = new Ammo.btDefaultCollisionConfiguration();
+        var dispatcher = new Ammo.btCollisionDispatcher(config);
+        var cache = new Ammo.btDbvtBroadphase();
+        var solver = new Ammo.btSequentialImpulseConstraintSolver();
+        var world = new Ammo.btDiscreteDynamicsWorld(dispatcher, cache, solver, config);
+        return world;
+      }
+    }, {
+      key: "_initRigidBodies",
+      value: function _initRigidBodies(rigidBodies) {
+        for (var i = 0, il = rigidBodies.length; i < il; i++) {
+          this.bodies.push(new RigidBody(this.mesh, this.world, rigidBodies[i], this.manager));
+        }
+      }
+    }, {
+      key: "_initConstraints",
+      value: function _initConstraints(constraints) {
+        for (var i = 0, il = constraints.length; i < il; i++) {
+          var params = constraints[i];
+          var bodyA = this.bodies[params.rigidBodyIndex1];
+          var bodyB = this.bodies[params.rigidBodyIndex2];
+          this.constraints.push(new Constraint(this.mesh, this.world, bodyA, bodyB, params, this.manager));
+        }
+      }
+    }, {
+      key: "_stepSimulation",
+      value: function _stepSimulation(delta) {
+        var unitStep = this.unitStep;
+        var stepTime = delta;
+        var maxStepNum = (delta / unitStep | 0) + 1;
+
+        if (stepTime < unitStep) {
+          stepTime = unitStep;
+          maxStepNum = 1;
+        }
+
+        if (maxStepNum > this.maxStepNum) {
+          maxStepNum = this.maxStepNum;
+        }
+
+        this.world.stepSimulation(stepTime, maxStepNum, unitStep);
+      }
+    }, {
+      key: "_updateRigidBodies",
+      value: function _updateRigidBodies() {
+        for (var i = 0, il = this.bodies.length; i < il; i++) {
+          this.bodies[i].updateFromBone();
+        }
+      }
+    }, {
+      key: "_updateBones",
+      value: function _updateBones() {
+        for (var i = 0, il = this.bodies.length; i < il; i++) {
+          this.bodies[i].updateBone();
+        }
+      }
+    }]);
+
+    return MMDPhysics;
+  }();
+  /**
+   * This manager's responsibilies are
+   *
+   * 1. manage Ammo.js and Three.js object resources and
+   *    improve the performance and the memory consumption by
+   *    reusing objects.
+   *
+   * 2. provide simple Ammo object operations.
+   */
+
+
+  _exports.MMDPhysics = MMDPhysics;
+
+  var ResourceManager = /*#__PURE__*/function () {
+    function ResourceManager() {
+      _classCallCheck(this, ResourceManager);
+
+      // for Three.js
+      this.threeVector3s = [];
+      this.threeMatrix4s = [];
+      this.threeQuaternions = [];
+      this.threeEulers = []; // for Ammo.js
+
+      this.transforms = [];
+      this.quaternions = [];
+      this.vector3s = [];
+    }
+
+    _createClass(ResourceManager, [{
+      key: "allocThreeVector3",
+      value: function allocThreeVector3() {
+        return this.threeVector3s.length > 0 ? this.threeVector3s.pop() : new _three.Vector3();
+      }
+    }, {
+      key: "freeThreeVector3",
+      value: function freeThreeVector3(v) {
+        this.threeVector3s.push(v);
+      }
+    }, {
+      key: "allocThreeMatrix4",
+      value: function allocThreeMatrix4() {
+        return this.threeMatrix4s.length > 0 ? this.threeMatrix4s.pop() : new _three.Matrix4();
+      }
+    }, {
+      key: "freeThreeMatrix4",
+      value: function freeThreeMatrix4(m) {
+        this.threeMatrix4s.push(m);
+      }
+    }, {
+      key: "allocThreeQuaternion",
+      value: function allocThreeQuaternion() {
+        return this.threeQuaternions.length > 0 ? this.threeQuaternions.pop() : new _three.Quaternion();
+      }
+    }, {
+      key: "freeThreeQuaternion",
+      value: function freeThreeQuaternion(q) {
+        this.threeQuaternions.push(q);
+      }
+    }, {
+      key: "allocThreeEuler",
+      value: function allocThreeEuler() {
+        return this.threeEulers.length > 0 ? this.threeEulers.pop() : new _three.Euler();
+      }
+    }, {
+      key: "freeThreeEuler",
+      value: function freeThreeEuler(e) {
+        this.threeEulers.push(e);
+      }
+    }, {
+      key: "allocTransform",
+      value: function allocTransform() {
+        return this.transforms.length > 0 ? this.transforms.pop() : new Ammo.btTransform();
+      }
+    }, {
+      key: "freeTransform",
+      value: function freeTransform(t) {
+        this.transforms.push(t);
+      }
+    }, {
+      key: "allocQuaternion",
+      value: function allocQuaternion() {
+        return this.quaternions.length > 0 ? this.quaternions.pop() : new Ammo.btQuaternion();
+      }
+    }, {
+      key: "freeQuaternion",
+      value: function freeQuaternion(q) {
+        this.quaternions.push(q);
+      }
+    }, {
+      key: "allocVector3",
+      value: function allocVector3() {
+        return this.vector3s.length > 0 ? this.vector3s.pop() : new Ammo.btVector3();
+      }
+    }, {
+      key: "freeVector3",
+      value: function freeVector3(v) {
+        this.vector3s.push(v);
+      }
+    }, {
+      key: "setIdentity",
+      value: function setIdentity(t) {
+        t.setIdentity();
+      }
+    }, {
+      key: "getBasis",
+      value: function getBasis(t) {
+        var q = this.allocQuaternion();
+        t.getBasis().getRotation(q);
+        return q;
+      }
+    }, {
+      key: "getBasisAsMatrix3",
+      value: function getBasisAsMatrix3(t) {
+        var q = this.getBasis(t);
+        var m = this.quaternionToMatrix3(q);
+        this.freeQuaternion(q);
+        return m;
+      }
+    }, {
+      key: "getOrigin",
+      value: function getOrigin(t) {
+        return t.getOrigin();
+      }
+    }, {
+      key: "setOrigin",
+      value: function setOrigin(t, v) {
+        t.getOrigin().setValue(v.x(), v.y(), v.z());
+      }
+    }, {
+      key: "copyOrigin",
+      value: function copyOrigin(t1, t2) {
+        var o = t2.getOrigin();
+        this.setOrigin(t1, o);
+      }
+    }, {
+      key: "setBasis",
+      value: function setBasis(t, q) {
+        t.setRotation(q);
+      }
+    }, {
+      key: "setBasisFromMatrix3",
+      value: function setBasisFromMatrix3(t, m) {
+        var q = this.matrix3ToQuaternion(m);
+        this.setBasis(t, q);
+        this.freeQuaternion(q);
+      }
+    }, {
+      key: "setOriginFromArray3",
+      value: function setOriginFromArray3(t, a) {
+        t.getOrigin().setValue(a[0], a[1], a[2]);
+      }
+    }, {
+      key: "setOriginFromThreeVector3",
+      value: function setOriginFromThreeVector3(t, v) {
+        t.getOrigin().setValue(v.x, v.y, v.z);
+      }
+    }, {
+      key: "setBasisFromArray3",
+      value: function setBasisFromArray3(t, a) {
+        var thQ = this.allocThreeQuaternion();
+        var thE = this.allocThreeEuler();
+        thE.set(a[0], a[1], a[2]);
+        this.setBasisFromThreeQuaternion(t, thQ.setFromEuler(thE));
+        this.freeThreeEuler(thE);
+        this.freeThreeQuaternion(thQ);
+      }
+    }, {
+      key: "setBasisFromThreeQuaternion",
+      value: function setBasisFromThreeQuaternion(t, a) {
+        var q = this.allocQuaternion();
+        q.setX(a.x);
+        q.setY(a.y);
+        q.setZ(a.z);
+        q.setW(a.w);
+        this.setBasis(t, q);
+        this.freeQuaternion(q);
+      }
+    }, {
+      key: "multiplyTransforms",
+      value: function multiplyTransforms(t1, t2) {
+        var t = this.allocTransform();
+        this.setIdentity(t);
+        var m1 = this.getBasisAsMatrix3(t1);
+        var m2 = this.getBasisAsMatrix3(t2);
+        var o1 = this.getOrigin(t1);
+        var o2 = this.getOrigin(t2);
+        var v1 = this.multiplyMatrix3ByVector3(m1, o2);
+        var v2 = this.addVector3(v1, o1);
+        this.setOrigin(t, v2);
+        var m3 = this.multiplyMatrices3(m1, m2);
+        this.setBasisFromMatrix3(t, m3);
+        this.freeVector3(v1);
+        this.freeVector3(v2);
+        return t;
+      }
+    }, {
+      key: "inverseTransform",
+      value: function inverseTransform(t) {
+        var t2 = this.allocTransform();
+        var m1 = this.getBasisAsMatrix3(t);
+        var o = this.getOrigin(t);
+        var m2 = this.transposeMatrix3(m1);
+        var v1 = this.negativeVector3(o);
+        var v2 = this.multiplyMatrix3ByVector3(m2, v1);
+        this.setOrigin(t2, v2);
+        this.setBasisFromMatrix3(t2, m2);
+        this.freeVector3(v1);
+        this.freeVector3(v2);
+        return t2;
+      }
+    }, {
+      key: "multiplyMatrices3",
+      value: function multiplyMatrices3(m1, m2) {
+        var m3 = [];
+        var v10 = this.rowOfMatrix3(m1, 0);
+        var v11 = this.rowOfMatrix3(m1, 1);
+        var v12 = this.rowOfMatrix3(m1, 2);
+        var v20 = this.columnOfMatrix3(m2, 0);
+        var v21 = this.columnOfMatrix3(m2, 1);
+        var v22 = this.columnOfMatrix3(m2, 2);
+        m3[0] = this.dotVectors3(v10, v20);
+        m3[1] = this.dotVectors3(v10, v21);
+        m3[2] = this.dotVectors3(v10, v22);
+        m3[3] = this.dotVectors3(v11, v20);
+        m3[4] = this.dotVectors3(v11, v21);
+        m3[5] = this.dotVectors3(v11, v22);
+        m3[6] = this.dotVectors3(v12, v20);
+        m3[7] = this.dotVectors3(v12, v21);
+        m3[8] = this.dotVectors3(v12, v22);
+        this.freeVector3(v10);
+        this.freeVector3(v11);
+        this.freeVector3(v12);
+        this.freeVector3(v20);
+        this.freeVector3(v21);
+        this.freeVector3(v22);
+        return m3;
+      }
+    }, {
+      key: "addVector3",
+      value: function addVector3(v1, v2) {
+        var v = this.allocVector3();
+        v.setValue(v1.x() + v2.x(), v1.y() + v2.y(), v1.z() + v2.z());
+        return v;
+      }
+    }, {
+      key: "dotVectors3",
+      value: function dotVectors3(v1, v2) {
+        return v1.x() * v2.x() + v1.y() * v2.y() + v1.z() * v2.z();
+      }
+    }, {
+      key: "rowOfMatrix3",
+      value: function rowOfMatrix3(m, i) {
+        var v = this.allocVector3();
+        v.setValue(m[i * 3 + 0], m[i * 3 + 1], m[i * 3 + 2]);
+        return v;
+      }
+    }, {
+      key: "columnOfMatrix3",
+      value: function columnOfMatrix3(m, i) {
+        var v = this.allocVector3();
+        v.setValue(m[i + 0], m[i + 3], m[i + 6]);
+        return v;
+      }
+    }, {
+      key: "negativeVector3",
+      value: function negativeVector3(v) {
+        var v2 = this.allocVector3();
+        v2.setValue(-v.x(), -v.y(), -v.z());
+        return v2;
+      }
+    }, {
+      key: "multiplyMatrix3ByVector3",
+      value: function multiplyMatrix3ByVector3(m, v) {
+        var v4 = this.allocVector3();
+        var v0 = this.rowOfMatrix3(m, 0);
+        var v1 = this.rowOfMatrix3(m, 1);
+        var v2 = this.rowOfMatrix3(m, 2);
+        var x = this.dotVectors3(v0, v);
+        var y = this.dotVectors3(v1, v);
+        var z = this.dotVectors3(v2, v);
+        v4.setValue(x, y, z);
+        this.freeVector3(v0);
+        this.freeVector3(v1);
+        this.freeVector3(v2);
+        return v4;
+      }
+    }, {
+      key: "transposeMatrix3",
+      value: function transposeMatrix3(m) {
+        var m2 = [];
+        m2[0] = m[0];
+        m2[1] = m[3];
+        m2[2] = m[6];
+        m2[3] = m[1];
+        m2[4] = m[4];
+        m2[5] = m[7];
+        m2[6] = m[2];
+        m2[7] = m[5];
+        m2[8] = m[8];
+        return m2;
+      }
+    }, {
+      key: "quaternionToMatrix3",
+      value: function quaternionToMatrix3(q) {
+        var m = [];
+        var x = q.x();
+        var y = q.y();
+        var z = q.z();
+        var w = q.w();
+        var xx = x * x;
+        var yy = y * y;
+        var zz = z * z;
+        var xy = x * y;
+        var yz = y * z;
+        var zx = z * x;
+        var xw = x * w;
+        var yw = y * w;
+        var zw = z * w;
+        m[0] = 1 - 2 * (yy + zz);
+        m[1] = 2 * (xy - zw);
+        m[2] = 2 * (zx + yw);
+        m[3] = 2 * (xy + zw);
+        m[4] = 1 - 2 * (zz + xx);
+        m[5] = 2 * (yz - xw);
+        m[6] = 2 * (zx - yw);
+        m[7] = 2 * (yz + xw);
+        m[8] = 1 - 2 * (xx + yy);
+        return m;
+      }
+    }, {
+      key: "matrix3ToQuaternion",
+      value: function matrix3ToQuaternion(m) {
+        var t = m[0] + m[4] + m[8];
+        var s, x, y, z, w;
+
+        if (t > 0) {
+          s = Math.sqrt(t + 1.0) * 2;
+          w = 0.25 * s;
+          x = (m[7] - m[5]) / s;
+          y = (m[2] - m[6]) / s;
+          z = (m[3] - m[1]) / s;
+        } else if (m[0] > m[4] && m[0] > m[8]) {
+          s = Math.sqrt(1.0 + m[0] - m[4] - m[8]) * 2;
+          w = (m[7] - m[5]) / s;
+          x = 0.25 * s;
+          y = (m[1] + m[3]) / s;
+          z = (m[2] + m[6]) / s;
+        } else if (m[4] > m[8]) {
+          s = Math.sqrt(1.0 + m[4] - m[0] - m[8]) * 2;
+          w = (m[2] - m[6]) / s;
+          x = (m[1] + m[3]) / s;
+          y = 0.25 * s;
+          z = (m[5] + m[7]) / s;
+        } else {
+          s = Math.sqrt(1.0 + m[8] - m[0] - m[4]) * 2;
+          w = (m[3] - m[1]) / s;
+          x = (m[2] + m[6]) / s;
+          y = (m[5] + m[7]) / s;
+          z = 0.25 * s;
+        }
+
+        var q = this.allocQuaternion();
+        q.setX(x);
+        q.setY(y);
+        q.setZ(z);
+        q.setW(w);
+        return q;
+      }
+    }]);
+
+    return ResourceManager;
+  }();
+  /**
+   * @param {THREE.SkinnedMesh} mesh
+   * @param {Ammo.btDiscreteDynamicsWorld} world
+   * @param {Object} params
+   * @param {ResourceManager} manager
+   */
+
+
+  var RigidBody = /*#__PURE__*/function () {
+    function RigidBody(mesh, world, params, manager) {
+      _classCallCheck(this, RigidBody);
+
+      this.mesh = mesh;
+      this.world = world;
+      this.params = params;
+      this.manager = manager;
+      this.body = null;
+      this.bone = null;
+      this.boneOffsetForm = null;
+      this.boneOffsetFormInverse = null;
+
+      this._init();
+    }
+    /**
+     * Resets rigid body transform to the current bone's.
+     *
+     * @return {RigidBody}
+     */
+
+
+    _createClass(RigidBody, [{
+      key: "reset",
+      value: function reset() {
+        this._setTransformFromBone();
+
+        return this;
+      }
+      /**
+       * Updates rigid body's transform from the current bone.
+       *
+       * @return {RidigBody}
+       */
+
+    }, {
+      key: "updateFromBone",
+      value: function updateFromBone() {
+        if (this.params.boneIndex !== -1 && this.params.type === 0) {
+          this._setTransformFromBone();
+        }
+
+        return this;
+      }
+      /**
+       * Updates bone from the current ridid body's transform.
+       *
+       * @return {RidigBody}
+       */
+
+    }, {
+      key: "updateBone",
+      value: function updateBone() {
+        if (this.params.type === 0 || this.params.boneIndex === -1) {
+          return this;
+        }
+
+        this._updateBoneRotation();
+
+        if (this.params.type === 1) {
+          this._updateBonePosition();
+        }
+
+        this.bone.updateMatrixWorld(true);
+
+        if (this.params.type === 2) {
+          this._setPositionFromBone();
+        }
+
+        return this;
+      } // private methods
+
+    }, {
+      key: "_init",
+      value: function _init() {
+        function generateShape(p) {
+          switch (p.shapeType) {
+            case 0:
+              return new Ammo.btSphereShape(p.width);
+
+            case 1:
+              return new Ammo.btBoxShape(new Ammo.btVector3(p.width, p.height, p.depth));
+
+            case 2:
+              return new Ammo.btCapsuleShape(p.width, p.height);
+
+            default:
+              throw 'unknown shape type ' + p.shapeType;
+          }
+        }
+
+        var manager = this.manager;
+        var params = this.params;
+        var bones = this.mesh.skeleton.bones;
+        var bone = params.boneIndex === -1 ? new _three.Bone() : bones[params.boneIndex];
+        var shape = generateShape(params);
+        var weight = params.type === 0 ? 0 : params.weight;
+        var localInertia = manager.allocVector3();
+        localInertia.setValue(0, 0, 0);
+
+        if (weight !== 0) {
+          shape.calculateLocalInertia(weight, localInertia);
+        }
+
+        var boneOffsetForm = manager.allocTransform();
+        manager.setIdentity(boneOffsetForm);
+        manager.setOriginFromArray3(boneOffsetForm, params.position);
+        manager.setBasisFromArray3(boneOffsetForm, params.rotation);
+        var vector = manager.allocThreeVector3();
+        var boneForm = manager.allocTransform();
+        manager.setIdentity(boneForm);
+        manager.setOriginFromThreeVector3(boneForm, bone.getWorldPosition(vector));
+        var form = manager.multiplyTransforms(boneForm, boneOffsetForm);
+        var state = new Ammo.btDefaultMotionState(form);
+        var info = new Ammo.btRigidBodyConstructionInfo(weight, state, shape, localInertia);
+        info.set_m_friction(params.friction);
+        info.set_m_restitution(params.restitution);
+        var body = new Ammo.btRigidBody(info);
+
+        if (params.type === 0) {
+          body.setCollisionFlags(body.getCollisionFlags() | 2);
+          /*
+           * It'd be better to comment out this line though in general I should call this method
+           * because I'm not sure why but physics will be more like MMD's
+           * if I comment out.
+           */
+
+          body.setActivationState(4);
+        }
+
+        body.setDamping(params.positionDamping, params.rotationDamping);
+        body.setSleepingThresholds(0, 0);
+        this.world.addRigidBody(body, 1 << params.groupIndex, params.groupTarget);
+        this.body = body;
+        this.bone = bone;
+        this.boneOffsetForm = boneOffsetForm;
+        this.boneOffsetFormInverse = manager.inverseTransform(boneOffsetForm);
+        manager.freeVector3(localInertia);
+        manager.freeTransform(form);
+        manager.freeTransform(boneForm);
+        manager.freeThreeVector3(vector);
+      }
+    }, {
+      key: "_getBoneTransform",
+      value: function _getBoneTransform() {
+        var manager = this.manager;
+        var p = manager.allocThreeVector3();
+        var q = manager.allocThreeQuaternion();
+        var s = manager.allocThreeVector3();
+        this.bone.matrixWorld.decompose(p, q, s);
+        var tr = manager.allocTransform();
+        manager.setOriginFromThreeVector3(tr, p);
+        manager.setBasisFromThreeQuaternion(tr, q);
+        var form = manager.multiplyTransforms(tr, this.boneOffsetForm);
+        manager.freeTransform(tr);
+        manager.freeThreeVector3(s);
+        manager.freeThreeQuaternion(q);
+        manager.freeThreeVector3(p);
+        return form;
+      }
+    }, {
+      key: "_getWorldTransformForBone",
+      value: function _getWorldTransformForBone() {
+        var manager = this.manager;
+        var tr = this.body.getCenterOfMassTransform();
+        return manager.multiplyTransforms(tr, this.boneOffsetFormInverse);
+      }
+    }, {
+      key: "_setTransformFromBone",
+      value: function _setTransformFromBone() {
+        var manager = this.manager;
+
+        var form = this._getBoneTransform(); // TODO: check the most appropriate way to set
+        //this.body.setWorldTransform( form );
+
+
+        this.body.setCenterOfMassTransform(form);
+        this.body.getMotionState().setWorldTransform(form);
+        manager.freeTransform(form);
+      }
+    }, {
+      key: "_setPositionFromBone",
+      value: function _setPositionFromBone() {
+        var manager = this.manager;
+
+        var form = this._getBoneTransform();
+
+        var tr = manager.allocTransform();
+        this.body.getMotionState().getWorldTransform(tr);
+        manager.copyOrigin(tr, form); // TODO: check the most appropriate way to set
+        //this.body.setWorldTransform( tr );
+
+        this.body.setCenterOfMassTransform(tr);
+        this.body.getMotionState().setWorldTransform(tr);
+        manager.freeTransform(tr);
+        manager.freeTransform(form);
+      }
+    }, {
+      key: "_updateBoneRotation",
+      value: function _updateBoneRotation() {
+        var manager = this.manager;
+
+        var tr = this._getWorldTransformForBone();
+
+        var q = manager.getBasis(tr);
+        var thQ = manager.allocThreeQuaternion();
+        var thQ2 = manager.allocThreeQuaternion();
+        var thQ3 = manager.allocThreeQuaternion();
+        thQ.set(q.x(), q.y(), q.z(), q.w());
+        thQ2.setFromRotationMatrix(this.bone.matrixWorld);
+        thQ2.conjugate();
+        thQ2.multiply(thQ); //this.bone.quaternion.multiply( thQ2 );
+
+        thQ3.setFromRotationMatrix(this.bone.matrix); // Renormalizing quaternion here because repeatedly transforming
+        // quaternion continuously accumulates floating point error and
+        // can end up being overflow. See #15335
+
+        this.bone.quaternion.copy(thQ2.multiply(thQ3).normalize());
+        manager.freeThreeQuaternion(thQ);
+        manager.freeThreeQuaternion(thQ2);
+        manager.freeThreeQuaternion(thQ3);
+        manager.freeQuaternion(q);
+        manager.freeTransform(tr);
+      }
+    }, {
+      key: "_updateBonePosition",
+      value: function _updateBonePosition() {
+        var manager = this.manager;
+
+        var tr = this._getWorldTransformForBone();
+
+        var thV = manager.allocThreeVector3();
+        var o = manager.getOrigin(tr);
+        thV.set(o.x(), o.y(), o.z());
+
+        if (this.bone.parent) {
+          this.bone.parent.worldToLocal(thV);
+        }
+
+        this.bone.position.copy(thV);
+        manager.freeThreeVector3(thV);
+        manager.freeTransform(tr);
+      }
+    }]);
+
+    return RigidBody;
+  }(); //
+
+
+  var Constraint = /*#__PURE__*/function () {
+    /**
+     * @param {THREE.SkinnedMesh} mesh
+     * @param {Ammo.btDiscreteDynamicsWorld} world
+     * @param {RigidBody} bodyA
+     * @param {RigidBody} bodyB
+     * @param {Object} params
+     * @param {ResourceManager} manager
+     */
+    function Constraint(mesh, world, bodyA, bodyB, params, manager) {
+      _classCallCheck(this, Constraint);
+
+      this.mesh = mesh;
+      this.world = world;
+      this.bodyA = bodyA;
+      this.bodyB = bodyB;
+      this.params = params;
+      this.manager = manager;
+      this.constraint = null;
+
+      this._init();
+    } // private method
+
+
+    _createClass(Constraint, [{
+      key: "_init",
+      value: function _init() {
+        var manager = this.manager;
+        var params = this.params;
+        var bodyA = this.bodyA;
+        var bodyB = this.bodyB;
+        var form = manager.allocTransform();
+        manager.setIdentity(form);
+        manager.setOriginFromArray3(form, params.position);
+        manager.setBasisFromArray3(form, params.rotation);
+        var formA = manager.allocTransform();
+        var formB = manager.allocTransform();
+        bodyA.body.getMotionState().getWorldTransform(formA);
+        bodyB.body.getMotionState().getWorldTransform(formB);
+        var formInverseA = manager.inverseTransform(formA);
+        var formInverseB = manager.inverseTransform(formB);
+        var formA2 = manager.multiplyTransforms(formInverseA, form);
+        var formB2 = manager.multiplyTransforms(formInverseB, form);
+        var constraint = new Ammo.btGeneric6DofSpringConstraint(bodyA.body, bodyB.body, formA2, formB2, true);
+        var lll = manager.allocVector3();
+        var lul = manager.allocVector3();
+        var all = manager.allocVector3();
+        var aul = manager.allocVector3();
+        lll.setValue(params.translationLimitation1[0], params.translationLimitation1[1], params.translationLimitation1[2]);
+        lul.setValue(params.translationLimitation2[0], params.translationLimitation2[1], params.translationLimitation2[2]);
+        all.setValue(params.rotationLimitation1[0], params.rotationLimitation1[1], params.rotationLimitation1[2]);
+        aul.setValue(params.rotationLimitation2[0], params.rotationLimitation2[1], params.rotationLimitation2[2]);
+        constraint.setLinearLowerLimit(lll);
+        constraint.setLinearUpperLimit(lul);
+        constraint.setAngularLowerLimit(all);
+        constraint.setAngularUpperLimit(aul);
+
+        for (var i = 0; i < 3; i++) {
+          if (params.springPosition[i] !== 0) {
+            constraint.enableSpring(i, true);
+            constraint.setStiffness(i, params.springPosition[i]);
+          }
+        }
+
+        for (var _i = 0; _i < 3; _i++) {
+          if (params.springRotation[_i] !== 0) {
+            constraint.enableSpring(_i + 3, true);
+            constraint.setStiffness(_i + 3, params.springRotation[_i]);
+          }
+        }
+        /*
+         * Currently(10/31/2016) official ammo.js doesn't support
+         * btGeneric6DofSpringConstraint.setParam method.
+         * You need custom ammo.js (add the method into idl) if you wanna use.
+         * By setting this parameter, physics will be more like MMD's
+         */
+
+
+        if (constraint.setParam !== undefined) {
+          for (var _i2 = 0; _i2 < 6; _i2++) {
+            // this parameter is from http://www20.atpages.jp/katwat/three.js_r58/examples/mytest37/mmd.three.js
+            constraint.setParam(2, 0.475, _i2);
+          }
+        }
+
+        this.world.addConstraint(constraint, true);
+        this.constraint = constraint;
+        manager.freeTransform(form);
+        manager.freeTransform(formA);
+        manager.freeTransform(formB);
+        manager.freeTransform(formInverseA);
+        manager.freeTransform(formInverseB);
+        manager.freeTransform(formA2);
+        manager.freeTransform(formB2);
+        manager.freeVector3(lll);
+        manager.freeVector3(lul);
+        manager.freeVector3(all);
+        manager.freeVector3(aul);
+      }
+    }]);
+
+    return Constraint;
+  }(); //
+
+
+  var _position = new _three.Vector3();
+
+  var _quaternion = new _three.Quaternion();
+
+  var _scale = new _three.Vector3();
+
+  var _matrixWorldInv = new _three.Matrix4();
+
+  var MMDPhysicsHelper = /*#__PURE__*/function (_Object3D) {
+    _inherits(MMDPhysicsHelper, _Object3D);
+
+    var _super = _createSuper(MMDPhysicsHelper);
+
+    /**
+     * Visualize Rigid bodies
+     *
+     * @param {THREE.SkinnedMesh} mesh
+     * @param {Physics} physics
+     */
+    function MMDPhysicsHelper(mesh, physics) {
+      var _this;
+
+      _classCallCheck(this, MMDPhysicsHelper);
+
+      _this = _super.call(this);
+      _this.root = mesh;
+      _this.physics = physics;
+
+      _this.matrix.copy(mesh.matrixWorld);
+
+      _this.matrixAutoUpdate = false;
+      _this.materials = [];
+
+      _this.materials.push(new _three.MeshBasicMaterial({
+        color: new _three.Color(0xff8888),
+        wireframe: true,
+        depthTest: false,
+        depthWrite: false,
+        opacity: 0.25,
+        transparent: true
+      }));
+
+      _this.materials.push(new _three.MeshBasicMaterial({
+        color: new _three.Color(0x88ff88),
+        wireframe: true,
+        depthTest: false,
+        depthWrite: false,
+        opacity: 0.25,
+        transparent: true
+      }));
+
+      _this.materials.push(new _three.MeshBasicMaterial({
+        color: new _three.Color(0x8888ff),
+        wireframe: true,
+        depthTest: false,
+        depthWrite: false,
+        opacity: 0.25,
+        transparent: true
+      }));
+
+      _this._init();
+
+      return _this;
+    }
+    /**
+     * Updates Rigid Bodies visualization.
+     */
+
+
+    _createClass(MMDPhysicsHelper, [{
+      key: "updateMatrixWorld",
+      value: function updateMatrixWorld(force) {
+        var mesh = this.root;
+
+        if (this.visible) {
+          var bodies = this.physics.bodies;
+
+          _matrixWorldInv.copy(mesh.matrixWorld).decompose(_position, _quaternion, _scale).compose(_position, _quaternion, _scale.set(1, 1, 1)).invert();
+
+          for (var i = 0, il = bodies.length; i < il; i++) {
+            var body = bodies[i].body;
+            var child = this.children[i];
+            var tr = body.getCenterOfMassTransform();
+            var origin = tr.getOrigin();
+            var rotation = tr.getRotation();
+            child.position.set(origin.x(), origin.y(), origin.z()).applyMatrix4(_matrixWorldInv);
+            child.quaternion.setFromRotationMatrix(_matrixWorldInv).multiply(_quaternion.set(rotation.x(), rotation.y(), rotation.z(), rotation.w()));
+          }
+        }
+
+        this.matrix.copy(mesh.matrixWorld).decompose(_position, _quaternion, _scale).compose(_position, _quaternion, _scale.set(1, 1, 1));
+
+        _get(_getPrototypeOf(MMDPhysicsHelper.prototype), "updateMatrixWorld", this).call(this, force);
+      } // private method
+
+    }, {
+      key: "_init",
+      value: function _init() {
+        var bodies = this.physics.bodies;
+
+        function createGeometry(param) {
+          switch (param.shapeType) {
+            case 0:
+              return new _three.SphereGeometry(param.width, 16, 8);
+
+            case 1:
+              return new _three.BoxGeometry(param.width * 2, param.height * 2, param.depth * 2, 8, 8, 8);
+
+            case 2:
+              return new createCapsuleGeometry(param.width, param.height, 16, 8);
+
+            default:
+              return null;
+          }
+        } // copy from http://www20.atpages.jp/katwat/three.js_r58/examples/mytest37/mytest37.js?ver=20160815
+
+
+        function createCapsuleGeometry(radius, cylinderHeight, segmentsRadius, segmentsHeight) {
+          var geometry = new _three.CylinderGeometry(radius, radius, cylinderHeight, segmentsRadius, segmentsHeight, true);
+          var upperSphere = new _three.Mesh(new _three.SphereGeometry(radius, segmentsRadius, segmentsHeight, 0, Math.PI * 2, 0, Math.PI / 2));
+          var lowerSphere = new _three.Mesh(new _three.SphereGeometry(radius, segmentsRadius, segmentsHeight, 0, Math.PI * 2, Math.PI / 2, Math.PI / 2));
+          upperSphere.position.set(0, cylinderHeight / 2, 0);
+          lowerSphere.position.set(0, -cylinderHeight / 2, 0);
+          upperSphere.updateMatrix();
+          lowerSphere.updateMatrix();
+          geometry.merge(upperSphere.geometry, upperSphere.matrix);
+          geometry.merge(lowerSphere.geometry, lowerSphere.matrix);
+          return geometry;
+        }
+
+        for (var i = 0, il = bodies.length; i < il; i++) {
+          var param = bodies[i].params;
+          this.add(new _three.Mesh(createGeometry(param), this.materials[param.type]));
+        }
+      }
+    }]);
+
+    return MMDPhysicsHelper;
+  }(_three.Object3D);
+});