opal-js_wrap-three 0.1.1 → 0.1.2

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

@@ -0,0 +1,436 @@
+(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.CCDIKSolver = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.CCDIKSolver = 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; }
+
+  var _q = new _three.Quaternion();
+
+  var _targetPos = new _three.Vector3();
+
+  var _targetVec = new _three.Vector3();
+
+  var _effectorPos = new _three.Vector3();
+
+  var _effectorVec = new _three.Vector3();
+
+  var _linkPos = new _three.Vector3();
+
+  var _invLinkQ = new _three.Quaternion();
+
+  var _linkScale = new _three.Vector3();
+
+  var _axis = new _three.Vector3();
+
+  var _vector = new _three.Vector3();
+
+  var _matrix = new _three.Matrix4();
+  /**
+   * CCD Algorithm
+   *  - https://sites.google.com/site/auraliusproject/ccd-algorithm
+   *
+   * // ik parameter example
+   * //
+   * // target, effector, index in links are bone index in skeleton.bones.
+   * // the bones relation should be
+   * // <-- parent                                  child -->
+   * // links[ n ], links[ n - 1 ], ..., links[ 0 ], effector
+   * iks = [ {
+   *	target: 1,
+   *	effector: 2,
+   *	links: [ { index: 5, limitation: new Vector3( 1, 0, 0 ) }, { index: 4, enabled: false }, { index : 3 } ],
+   *	iteration: 10,
+   *	minAngle: 0.0,
+   *	maxAngle: 1.0,
+   * } ];
+   */
+
+
+  var CCDIKSolver = /*#__PURE__*/function () {
+    /**
+     * @param {THREE.SkinnedMesh} mesh
+     * @param {Array<Object>} iks
+     */
+    function CCDIKSolver(mesh) {
+      var iks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
+      _classCallCheck(this, CCDIKSolver);
+
+      this.mesh = mesh;
+      this.iks = iks;
+
+      this._valid();
+    }
+    /**
+     * Update all IK bones.
+     *
+     * @return {CCDIKSolver}
+     */
+
+
+    _createClass(CCDIKSolver, [{
+      key: "update",
+      value: function update() {
+        var iks = this.iks;
+
+        for (var i = 0, il = iks.length; i < il; i++) {
+          this.updateOne(iks[i]);
+        }
+
+        return this;
+      }
+      /**
+       * Update one IK bone
+       *
+       * @param {Object} ik parameter
+       * @return {CCDIKSolver}
+       */
+
+    }, {
+      key: "updateOne",
+      value: function updateOne(ik) {
+        var bones = this.mesh.skeleton.bones; // for reference overhead reduction in loop
+
+        var math = Math;
+        var effector = bones[ik.effector];
+        var target = bones[ik.target]; // don't use getWorldPosition() here for the performance
+        // because it calls updateMatrixWorld( true ) inside.
+
+        _targetPos.setFromMatrixPosition(target.matrixWorld);
+
+        var links = ik.links;
+        var iteration = ik.iteration !== undefined ? ik.iteration : 1;
+
+        for (var i = 0; i < iteration; i++) {
+          var rotated = false;
+
+          for (var j = 0, jl = links.length; j < jl; j++) {
+            var link = bones[links[j].index]; // skip this link and following links.
+            // this skip is used for MMD performance optimization.
+
+            if (links[j].enabled === false) break;
+            var limitation = links[j].limitation;
+            var rotationMin = links[j].rotationMin;
+            var rotationMax = links[j].rotationMax; // don't use getWorldPosition/Quaternion() here for the performance
+            // because they call updateMatrixWorld( true ) inside.
+
+            link.matrixWorld.decompose(_linkPos, _invLinkQ, _linkScale);
+
+            _invLinkQ.invert();
+
+            _effectorPos.setFromMatrixPosition(effector.matrixWorld); // work in link world
+
+
+            _effectorVec.subVectors(_effectorPos, _linkPos);
+
+            _effectorVec.applyQuaternion(_invLinkQ);
+
+            _effectorVec.normalize();
+
+            _targetVec.subVectors(_targetPos, _linkPos);
+
+            _targetVec.applyQuaternion(_invLinkQ);
+
+            _targetVec.normalize();
+
+            var angle = _targetVec.dot(_effectorVec);
+
+            if (angle > 1.0) {
+              angle = 1.0;
+            } else if (angle < -1.0) {
+              angle = -1.0;
+            }
+
+            angle = math.acos(angle); // skip if changing angle is too small to prevent vibration of bone
+            // Refer to http://www20.atpages.jp/katwat/three.js_r58/examples/mytest37/mmd.three.js
+
+            if (angle < 1e-5) continue;
+
+            if (ik.minAngle !== undefined && angle < ik.minAngle) {
+              angle = ik.minAngle;
+            }
+
+            if (ik.maxAngle !== undefined && angle > ik.maxAngle) {
+              angle = ik.maxAngle;
+            }
+
+            _axis.crossVectors(_effectorVec, _targetVec);
+
+            _axis.normalize();
+
+            _q.setFromAxisAngle(_axis, angle);
+
+            link.quaternion.multiply(_q); // TODO: re-consider the limitation specification
+
+            if (limitation !== undefined) {
+              var c = link.quaternion.w;
+              if (c > 1.0) c = 1.0;
+              var c2 = math.sqrt(1 - c * c);
+              link.quaternion.set(limitation.x * c2, limitation.y * c2, limitation.z * c2, c);
+            }
+
+            if (rotationMin !== undefined) {
+              link.rotation.setFromVector3(link.rotation.toVector3(_vector).max(rotationMin));
+            }
+
+            if (rotationMax !== undefined) {
+              link.rotation.setFromVector3(link.rotation.toVector3(_vector).min(rotationMax));
+            }
+
+            link.updateMatrixWorld(true);
+            rotated = true;
+          }
+
+          if (!rotated) break;
+        }
+
+        return this;
+      }
+      /**
+       * Creates Helper
+       *
+       * @return {CCDIKHelper}
+       */
+
+    }, {
+      key: "createHelper",
+      value: function createHelper() {
+        return new CCDIKHelper(this.mesh, this.mesh.geometry.userData.MMD.iks);
+      } // private methods
+
+    }, {
+      key: "_valid",
+      value: function _valid() {
+        var iks = this.iks;
+        var bones = this.mesh.skeleton.bones;
+
+        for (var i = 0, il = iks.length; i < il; i++) {
+          var ik = iks[i];
+          var effector = bones[ik.effector];
+          var links = ik.links;
+          var link0 = void 0,
+              link1 = void 0;
+          link0 = effector;
+
+          for (var j = 0, jl = links.length; j < jl; j++) {
+            link1 = bones[links[j].index];
+
+            if (link0.parent !== link1) {
+              console.warn('THREE.CCDIKSolver: bone ' + link0.name + ' is not the child of bone ' + link1.name);
+            }
+
+            link0 = link1;
+          }
+        }
+      }
+    }]);
+
+    return CCDIKSolver;
+  }();
+
+  _exports.CCDIKSolver = CCDIKSolver;
+
+  function getPosition(bone, matrixWorldInv) {
+    return _vector.setFromMatrixPosition(bone.matrixWorld).applyMatrix4(matrixWorldInv);
+  }
+
+  function setPositionOfBoneToAttributeArray(array, index, bone, matrixWorldInv) {
+    var v = getPosition(bone, matrixWorldInv);
+    array[index * 3 + 0] = v.x;
+    array[index * 3 + 1] = v.y;
+    array[index * 3 + 2] = v.z;
+  }
+  /**
+   * Visualize IK bones
+   *
+   * @param {SkinnedMesh} mesh
+   * @param {Array<Object>} iks
+   */
+
+
+  var CCDIKHelper = /*#__PURE__*/function (_Object3D) {
+    _inherits(CCDIKHelper, _Object3D);
+
+    var _super = _createSuper(CCDIKHelper);
+
+    function CCDIKHelper(mesh) {
+      var _this;
+
+      var iks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
+      _classCallCheck(this, CCDIKHelper);
+
+      _this = _super.call(this);
+      _this.root = mesh;
+      _this.iks = iks;
+
+      _this.matrix.copy(mesh.matrixWorld);
+
+      _this.matrixAutoUpdate = false;
+      _this.sphereGeometry = new _three.SphereGeometry(0.25, 16, 8);
+      _this.targetSphereMaterial = new _three.MeshBasicMaterial({
+        color: new _three.Color(0xff8888),
+        depthTest: false,
+        depthWrite: false,
+        transparent: true
+      });
+      _this.effectorSphereMaterial = new _three.MeshBasicMaterial({
+        color: new _three.Color(0x88ff88),
+        depthTest: false,
+        depthWrite: false,
+        transparent: true
+      });
+      _this.linkSphereMaterial = new _three.MeshBasicMaterial({
+        color: new _three.Color(0x8888ff),
+        depthTest: false,
+        depthWrite: false,
+        transparent: true
+      });
+      _this.lineMaterial = new _three.LineBasicMaterial({
+        color: new _three.Color(0xff0000),
+        depthTest: false,
+        depthWrite: false,
+        transparent: true
+      });
+
+      _this._init();
+
+      return _this;
+    }
+    /**
+     * Updates IK bones visualization.
+     */
+
+
+    _createClass(CCDIKHelper, [{
+      key: "updateMatrixWorld",
+      value: function updateMatrixWorld(force) {
+        var mesh = this.root;
+
+        if (this.visible) {
+          var offset = 0;
+          var iks = this.iks;
+          var bones = mesh.skeleton.bones;
+
+          _matrix.copy(mesh.matrixWorld).invert();
+
+          for (var i = 0, il = iks.length; i < il; i++) {
+            var ik = iks[i];
+            var targetBone = bones[ik.target];
+            var effectorBone = bones[ik.effector];
+            var targetMesh = this.children[offset++];
+            var effectorMesh = this.children[offset++];
+            targetMesh.position.copy(getPosition(targetBone, _matrix));
+            effectorMesh.position.copy(getPosition(effectorBone, _matrix));
+
+            for (var j = 0, jl = ik.links.length; j < jl; j++) {
+              var link = ik.links[j];
+              var linkBone = bones[link.index];
+              var linkMesh = this.children[offset++];
+              linkMesh.position.copy(getPosition(linkBone, _matrix));
+            }
+
+            var line = this.children[offset++];
+            var array = line.geometry.attributes.position.array;
+            setPositionOfBoneToAttributeArray(array, 0, targetBone, _matrix);
+            setPositionOfBoneToAttributeArray(array, 1, effectorBone, _matrix);
+
+            for (var _j = 0, _jl = ik.links.length; _j < _jl; _j++) {
+              var _link = ik.links[_j];
+              var _linkBone = bones[_link.index];
+              setPositionOfBoneToAttributeArray(array, _j + 2, _linkBone, _matrix);
+            }
+
+            line.geometry.attributes.position.needsUpdate = true;
+          }
+        }
+
+        this.matrix.copy(mesh.matrixWorld);
+
+        _get(_getPrototypeOf(CCDIKHelper.prototype), "updateMatrixWorld", this).call(this, force);
+      } // private method
+
+    }, {
+      key: "_init",
+      value: function _init() {
+        var scope = this;
+        var iks = this.iks;
+
+        function createLineGeometry(ik) {
+          var geometry = new _three.BufferGeometry();
+          var vertices = new Float32Array((2 + ik.links.length) * 3);
+          geometry.setAttribute('position', new _three.BufferAttribute(vertices, 3));
+          return geometry;
+        }
+
+        function createTargetMesh() {
+          return new _three.Mesh(scope.sphereGeometry, scope.targetSphereMaterial);
+        }
+
+        function createEffectorMesh() {
+          return new _three.Mesh(scope.sphereGeometry, scope.effectorSphereMaterial);
+        }
+
+        function createLinkMesh() {
+          return new _three.Mesh(scope.sphereGeometry, scope.linkSphereMaterial);
+        }
+
+        function createLine(ik) {
+          return new _three.Line(createLineGeometry(ik), scope.lineMaterial);
+        }
+
+        for (var i = 0, il = iks.length; i < il; i++) {
+          var ik = iks[i];
+          this.add(createTargetMesh());
+          this.add(createEffectorMesh());
+
+          for (var j = 0, jl = ik.links.length; j < jl; j++) {
+            this.add(createLinkMesh());
+          }
+
+          this.add(createLine(ik));
+        }
+      }
+    }]);
+
+    return CCDIKHelper;
+  }(_three.Object3D);
+});