opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/utils/SkeletonUtils.js

@@ -0,0 +1,400 @@
+(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.SkeletonUtils = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.clone = clone;
+  _exports.findBoneTrackData = findBoneTrackData;
+  _exports.getBoneByName = getBoneByName;
+  _exports.getBones = getBones;
+  _exports.getEqualsBonesNames = getEqualsBonesNames;
+  _exports.getHelperFromSkeleton = getHelperFromSkeleton;
+  _exports.getNearestBone = getNearestBone;
+  _exports.getSkeletonOffsets = getSkeletonOffsets;
+  _exports.renameBones = renameBones;
+  _exports.retarget = retarget;
+  _exports.retargetClip = retargetClip;
+
+  function retarget(target, source) {
+    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    var pos = new _three.Vector3(),
+        quat = new _three.Quaternion(),
+        scale = new _three.Vector3(),
+        bindBoneMatrix = new _three.Matrix4(),
+        relativeMatrix = new _three.Matrix4(),
+        globalMatrix = new _three.Matrix4();
+    options.preserveMatrix = options.preserveMatrix !== undefined ? options.preserveMatrix : true;
+    options.preservePosition = options.preservePosition !== undefined ? options.preservePosition : true;
+    options.preserveHipPosition = options.preserveHipPosition !== undefined ? options.preserveHipPosition : false;
+    options.useTargetMatrix = options.useTargetMatrix !== undefined ? options.useTargetMatrix : false;
+    options.hip = options.hip !== undefined ? options.hip : 'hip';
+    options.names = options.names || {};
+    var sourceBones = source.isObject3D ? source.skeleton.bones : getBones(source),
+        bones = target.isObject3D ? target.skeleton.bones : getBones(target);
+    var bindBones, bone, name, boneTo, bonesPosition; // reset bones
+
+    if (target.isObject3D) {
+      target.skeleton.pose();
+    } else {
+      options.useTargetMatrix = true;
+      options.preserveMatrix = false;
+    }
+
+    if (options.preservePosition) {
+      bonesPosition = [];
+
+      for (var i = 0; i < bones.length; i++) {
+        bonesPosition.push(bones[i].position.clone());
+      }
+    }
+
+    if (options.preserveMatrix) {
+      // reset matrix
+      target.updateMatrixWorld();
+      target.matrixWorld.identity(); // reset children matrix
+
+      for (var _i = 0; _i < target.children.length; ++_i) {
+        target.children[_i].updateMatrixWorld(true);
+      }
+    }
+
+    if (options.offsets) {
+      bindBones = [];
+
+      for (var _i2 = 0; _i2 < bones.length; ++_i2) {
+        bone = bones[_i2];
+        name = options.names[bone.name] || bone.name;
+
+        if (options.offsets && options.offsets[name]) {
+          bone.matrix.multiply(options.offsets[name]);
+          bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
+          bone.updateMatrixWorld();
+        }
+
+        bindBones.push(bone.matrixWorld.clone());
+      }
+    }
+
+    for (var _i3 = 0; _i3 < bones.length; ++_i3) {
+      bone = bones[_i3];
+      name = options.names[bone.name] || bone.name;
+      boneTo = getBoneByName(name, sourceBones);
+      globalMatrix.copy(bone.matrixWorld);
+
+      if (boneTo) {
+        boneTo.updateMatrixWorld();
+
+        if (options.useTargetMatrix) {
+          relativeMatrix.copy(boneTo.matrixWorld);
+        } else {
+          relativeMatrix.copy(target.matrixWorld).invert();
+          relativeMatrix.multiply(boneTo.matrixWorld);
+        } // ignore scale to extract rotation
+
+
+        scale.setFromMatrixScale(relativeMatrix);
+        relativeMatrix.scale(scale.set(1 / scale.x, 1 / scale.y, 1 / scale.z)); // apply to global matrix
+
+        globalMatrix.makeRotationFromQuaternion(quat.setFromRotationMatrix(relativeMatrix));
+
+        if (target.isObject3D) {
+          var boneIndex = bones.indexOf(bone),
+              wBindMatrix = bindBones ? bindBones[boneIndex] : bindBoneMatrix.copy(target.skeleton.boneInverses[boneIndex]).invert();
+          globalMatrix.multiply(wBindMatrix);
+        }
+
+        globalMatrix.copyPosition(relativeMatrix);
+      }
+
+      if (bone.parent && bone.parent.isBone) {
+        bone.matrix.copy(bone.parent.matrixWorld).invert();
+        bone.matrix.multiply(globalMatrix);
+      } else {
+        bone.matrix.copy(globalMatrix);
+      }
+
+      if (options.preserveHipPosition && name === options.hip) {
+        bone.matrix.setPosition(pos.set(0, bone.position.y, 0));
+      }
+
+      bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
+      bone.updateMatrixWorld();
+    }
+
+    if (options.preservePosition) {
+      for (var _i4 = 0; _i4 < bones.length; ++_i4) {
+        bone = bones[_i4];
+        name = options.names[bone.name] || bone.name;
+
+        if (name !== options.hip) {
+          bone.position.copy(bonesPosition[_i4]);
+        }
+      }
+    }
+
+    if (options.preserveMatrix) {
+      // restore matrix
+      target.updateMatrixWorld(true);
+    }
+  }
+
+  function retargetClip(target, source, clip) {
+    var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    options.useFirstFramePosition = options.useFirstFramePosition !== undefined ? options.useFirstFramePosition : false;
+    options.fps = options.fps !== undefined ? options.fps : 30;
+    options.names = options.names || [];
+
+    if (!source.isObject3D) {
+      source = getHelperFromSkeleton(source);
+    }
+
+    var numFrames = Math.round(clip.duration * (options.fps / 1000) * 1000),
+        delta = 1 / options.fps,
+        convertedTracks = [],
+        mixer = new _three.AnimationMixer(source),
+        bones = getBones(target.skeleton),
+        boneDatas = [];
+    var positionOffset, bone, boneTo, boneData, name;
+    mixer.clipAction(clip).play();
+    mixer.update(0);
+    source.updateMatrixWorld();
+
+    for (var i = 0; i < numFrames; ++i) {
+      var time = i * delta;
+      retarget(target, source, options);
+
+      for (var j = 0; j < bones.length; ++j) {
+        name = options.names[bones[j].name] || bones[j].name;
+        boneTo = getBoneByName(name, source.skeleton);
+
+        if (boneTo) {
+          bone = bones[j];
+          boneData = boneDatas[j] = boneDatas[j] || {
+            bone: bone
+          };
+
+          if (options.hip === name) {
+            if (!boneData.pos) {
+              boneData.pos = {
+                times: new Float32Array(numFrames),
+                values: new Float32Array(numFrames * 3)
+              };
+            }
+
+            if (options.useFirstFramePosition) {
+              if (i === 0) {
+                positionOffset = bone.position.clone();
+              }
+
+              bone.position.sub(positionOffset);
+            }
+
+            boneData.pos.times[i] = time;
+            bone.position.toArray(boneData.pos.values, i * 3);
+          }
+
+          if (!boneData.quat) {
+            boneData.quat = {
+              times: new Float32Array(numFrames),
+              values: new Float32Array(numFrames * 4)
+            };
+          }
+
+          boneData.quat.times[i] = time;
+          bone.quaternion.toArray(boneData.quat.values, i * 4);
+        }
+      }
+
+      mixer.update(delta);
+      source.updateMatrixWorld();
+    }
+
+    for (var _i5 = 0; _i5 < boneDatas.length; ++_i5) {
+      boneData = boneDatas[_i5];
+
+      if (boneData) {
+        if (boneData.pos) {
+          convertedTracks.push(new _three.VectorKeyframeTrack('.bones[' + boneData.bone.name + '].position', boneData.pos.times, boneData.pos.values));
+        }
+
+        convertedTracks.push(new _three.QuaternionKeyframeTrack('.bones[' + boneData.bone.name + '].quaternion', boneData.quat.times, boneData.quat.values));
+      }
+    }
+
+    mixer.uncacheAction(clip);
+    return new _three.AnimationClip(clip.name, -1, convertedTracks);
+  }
+
+  function getHelperFromSkeleton(skeleton) {
+    var source = new _three.SkeletonHelper(skeleton.bones[0]);
+    source.skeleton = skeleton;
+    return source;
+  }
+
+  function getSkeletonOffsets(target, source) {
+    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    var targetParentPos = new _three.Vector3(),
+        targetPos = new _three.Vector3(),
+        sourceParentPos = new _three.Vector3(),
+        sourcePos = new _three.Vector3(),
+        targetDir = new _three.Vector2(),
+        sourceDir = new _three.Vector2();
+    options.hip = options.hip !== undefined ? options.hip : 'hip';
+    options.names = options.names || {};
+
+    if (!source.isObject3D) {
+      source = getHelperFromSkeleton(source);
+    }
+
+    var nameKeys = Object.keys(options.names),
+        nameValues = Object.values(options.names),
+        sourceBones = source.isObject3D ? source.skeleton.bones : getBones(source),
+        bones = target.isObject3D ? target.skeleton.bones : getBones(target),
+        offsets = [];
+    var bone, boneTo, name, i;
+    target.skeleton.pose();
+
+    for (i = 0; i < bones.length; ++i) {
+      bone = bones[i];
+      name = options.names[bone.name] || bone.name;
+      boneTo = getBoneByName(name, sourceBones);
+
+      if (boneTo && name !== options.hip) {
+        var boneParent = getNearestBone(bone.parent, nameKeys),
+            boneToParent = getNearestBone(boneTo.parent, nameValues);
+        boneParent.updateMatrixWorld();
+        boneToParent.updateMatrixWorld();
+        targetParentPos.setFromMatrixPosition(boneParent.matrixWorld);
+        targetPos.setFromMatrixPosition(bone.matrixWorld);
+        sourceParentPos.setFromMatrixPosition(boneToParent.matrixWorld);
+        sourcePos.setFromMatrixPosition(boneTo.matrixWorld);
+        targetDir.subVectors(new _three.Vector2(targetPos.x, targetPos.y), new _three.Vector2(targetParentPos.x, targetParentPos.y)).normalize();
+        sourceDir.subVectors(new _three.Vector2(sourcePos.x, sourcePos.y), new _three.Vector2(sourceParentPos.x, sourceParentPos.y)).normalize();
+        var laterialAngle = targetDir.angle() - sourceDir.angle();
+        var offset = new _three.Matrix4().makeRotationFromEuler(new _three.Euler(0, 0, laterialAngle));
+        bone.matrix.multiply(offset);
+        bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
+        bone.updateMatrixWorld();
+        offsets[name] = offset;
+      }
+    }
+
+    return offsets;
+  }
+
+  function renameBones(skeleton, names) {
+    var bones = getBones(skeleton);
+
+    for (var i = 0; i < bones.length; ++i) {
+      var bone = bones[i];
+
+      if (names[bone.name]) {
+        bone.name = names[bone.name];
+      }
+    }
+
+    return this;
+  }
+
+  function getBones(skeleton) {
+    return Array.isArray(skeleton) ? skeleton : skeleton.bones;
+  }
+
+  function getBoneByName(name, skeleton) {
+    for (var i = 0, bones = getBones(skeleton); i < bones.length; i++) {
+      if (name === bones[i].name) return bones[i];
+    }
+  }
+
+  function getNearestBone(bone, names) {
+    while (bone.isBone) {
+      if (names.indexOf(bone.name) !== -1) {
+        return bone;
+      }
+
+      bone = bone.parent;
+    }
+  }
+
+  function findBoneTrackData(name, tracks) {
+    var regexp = /\[(.*)\]\.(.*)/,
+        result = {
+      name: name
+    };
+
+    for (var i = 0; i < tracks.length; ++i) {
+      // 1 is track name
+      // 2 is track type
+      var trackData = regexp.exec(tracks[i].name);
+
+      if (trackData && name === trackData[1]) {
+        result[trackData[2]] = i;
+      }
+    }
+
+    return result;
+  }
+
+  function getEqualsBonesNames(skeleton, targetSkeleton) {
+    var sourceBones = getBones(skeleton),
+        targetBones = getBones(targetSkeleton),
+        bones = [];
+
+    search: for (var i = 0; i < sourceBones.length; i++) {
+      var boneName = sourceBones[i].name;
+
+      for (var j = 0; j < targetBones.length; j++) {
+        if (boneName === targetBones[j].name) {
+          bones.push(boneName);
+          continue search;
+        }
+      }
+    }
+
+    return bones;
+  }
+
+  function clone(source) {
+    var sourceLookup = new Map();
+    var cloneLookup = new Map();
+    var clone = source.clone();
+    parallelTraverse(source, clone, function (sourceNode, clonedNode) {
+      sourceLookup.set(clonedNode, sourceNode);
+      cloneLookup.set(sourceNode, clonedNode);
+    });
+    clone.traverse(function (node) {
+      if (!node.isSkinnedMesh) return;
+      var clonedMesh = node;
+      var sourceMesh = sourceLookup.get(node);
+      var sourceBones = sourceMesh.skeleton.bones;
+      clonedMesh.skeleton = sourceMesh.skeleton.clone();
+      clonedMesh.bindMatrix.copy(sourceMesh.bindMatrix);
+      clonedMesh.skeleton.bones = sourceBones.map(function (bone) {
+        return cloneLookup.get(bone);
+      });
+      clonedMesh.bind(clonedMesh.skeleton, clonedMesh.bindMatrix);
+    });
+    return clone;
+  }
+
+  function parallelTraverse(a, b, callback) {
+    callback(a, b);
+
+    for (var i = 0; i < a.children.length; i++) {
+      parallelTraverse(a.children[i], b.children[i], callback);
+    }
+  }
+});

data/lib-opal/js_wrap/three/utils/UVsDebug.js

@@ -0,0 +1,132 @@
+(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.UVsDebug = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.UVsDebug = UVsDebug;
+
+  /**
+   * tool for "unwrapping" and debugging three.js geometries UV mapping
+   *
+   * Sample usage:
+   *	document.body.appendChild( UVsDebug( new THREE.SphereGeometry( 10, 10, 10, 10 ) );
+   *
+   */
+  function UVsDebug(geometry) {
+    var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1024;
+    // handles wrapping of uv.x > 1 only
+    var abc = 'abc';
+    var a = new _three.Vector2();
+    var b = new _three.Vector2();
+    var uvs = [new _three.Vector2(), new _three.Vector2(), new _three.Vector2()];
+    var face = [];
+    var canvas = document.createElement('canvas');
+    var width = size; // power of 2 required for wrapping
+
+    var height = size;
+    canvas.width = width;
+    canvas.height = height;
+    var ctx = canvas.getContext('2d');
+    ctx.lineWidth = 1;
+    ctx.strokeStyle = 'rgb( 63, 63, 63 )';
+    ctx.textAlign = 'center'; // paint background white
+
+    ctx.fillStyle = 'rgb( 255, 255, 255 )';
+    ctx.fillRect(0, 0, width, height);
+
+    if (geometry.isGeometry) {
+      console.error('THREE.UVsDebug no longer supports Geometry. Use THREE.BufferGeometry instead.');
+      return;
+    } else {
+      var index = geometry.index;
+      var uvAttribute = geometry.attributes.uv;
+
+      if (index) {
+        // indexed geometry
+        for (var i = 0, il = index.count; i < il; i += 3) {
+          face[0] = index.getX(i);
+          face[1] = index.getX(i + 1);
+          face[2] = index.getX(i + 2);
+          uvs[0].fromBufferAttribute(uvAttribute, face[0]);
+          uvs[1].fromBufferAttribute(uvAttribute, face[1]);
+          uvs[2].fromBufferAttribute(uvAttribute, face[2]);
+          processFace(face, uvs, i / 3);
+        }
+      } else {
+        // non-indexed geometry
+        for (var _i = 0, _il = uvAttribute.count; _i < _il; _i += 3) {
+          face[0] = _i;
+          face[1] = _i + 1;
+          face[2] = _i + 2;
+          uvs[0].fromBufferAttribute(uvAttribute, face[0]);
+          uvs[1].fromBufferAttribute(uvAttribute, face[1]);
+          uvs[2].fromBufferAttribute(uvAttribute, face[2]);
+          processFace(face, uvs, _i / 3);
+        }
+      }
+    }
+
+    return canvas;
+
+    function processFace(face, uvs, index) {
+      // draw contour of face
+      ctx.beginPath();
+      a.set(0, 0);
+
+      for (var j = 0, jl = uvs.length; j < jl; j++) {
+        var uv = uvs[j];
+        a.x += uv.x;
+        a.y += uv.y;
+
+        if (j === 0) {
+          ctx.moveTo(uv.x * (width - 2) + 0.5, (1 - uv.y) * (height - 2) + 0.5);
+        } else {
+          ctx.lineTo(uv.x * (width - 2) + 0.5, (1 - uv.y) * (height - 2) + 0.5);
+        }
+      }
+
+      ctx.closePath();
+      ctx.stroke(); // calculate center of face
+
+      a.divideScalar(uvs.length); // label the face number
+
+      ctx.font = '18px Arial';
+      ctx.fillStyle = 'rgb( 63, 63, 63 )';
+      ctx.fillText(index, a.x * width, (1 - a.y) * height);
+
+      if (a.x > 0.95) {
+        // wrap x // 0.95 is arbitrary
+        ctx.fillText(index, a.x % 1 * width, (1 - a.y) * height);
+      } //
+
+
+      ctx.font = '12px Arial';
+      ctx.fillStyle = 'rgb( 191, 191, 191 )'; // label uv edge orders
+
+      for (var _j = 0, _jl = uvs.length; _j < _jl; _j++) {
+        var _uv = uvs[_j];
+        b.addVectors(a, _uv).divideScalar(2);
+        var vnum = face[_j];
+        ctx.fillText(abc[_j] + vnum, b.x * width, (1 - b.y) * height);
+
+        if (b.x > 0.95) {
+          // wrap x
+          ctx.fillText(abc[_j] + vnum, b.x % 1 * width, (1 - b.y) * height);
+        }
+      }
+    }
+  }
+});

data/lib-opal/js_wrap/three/utils/WorkerPool.js

@@ -0,0 +1,130 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports);
+    global.WorkerPool = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.WorkerPool = void 0;
+
+  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; }
+
+  /**
+   * @author Deepkolos / https://github.com/deepkolos
+   */
+  var WorkerPool = /*#__PURE__*/function () {
+    function WorkerPool() {
+      var pool = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 4;
+
+      _classCallCheck(this, WorkerPool);
+
+      this.pool = pool;
+      this.queue = [];
+      this.workers = [];
+      this.workersResolve = [];
+      this.workerStatus = 0;
+    }
+
+    _createClass(WorkerPool, [{
+      key: "_initWorker",
+      value: function _initWorker(workerId) {
+        if (!this.workers[workerId]) {
+          var worker = this.workerCreator();
+          worker.addEventListener('message', this._onMessage.bind(this, workerId));
+          this.workers[workerId] = worker;
+        }
+      }
+    }, {
+      key: "_getIdleWorker",
+      value: function _getIdleWorker() {
+        for (var i = 0; i < this.pool; i++) {
+          if (!(this.workerStatus & 1 << i)) return i;
+        }
+
+        return -1;
+      }
+    }, {
+      key: "_onMessage",
+      value: function _onMessage(workerId, msg) {
+        var resolve = this.workersResolve[workerId];
+        resolve && resolve(msg);
+
+        if (this.queue.length) {
+          var _this$queue$shift = this.queue.shift(),
+              _resolve = _this$queue$shift.resolve,
+              _msg = _this$queue$shift.msg,
+              transfer = _this$queue$shift.transfer;
+
+          this.workersResolve[workerId] = _resolve;
+          this.workers[workerId].postMessage(_msg, transfer);
+        } else {
+          this.workerStatus ^= 1 << workerId;
+        }
+      }
+    }, {
+      key: "setWorkerCreator",
+      value: function setWorkerCreator(workerCreator) {
+        this.workerCreator = workerCreator;
+      }
+    }, {
+      key: "setWorkerLimit",
+      value: function setWorkerLimit(pool) {
+        this.pool = pool;
+      }
+    }, {
+      key: "postMessage",
+      value: function postMessage(msg, transfer) {
+        var _this = this;
+
+        return new Promise(function (resolve) {
+          var workerId = _this._getIdleWorker();
+
+          if (workerId !== -1) {
+            _this._initWorker(workerId);
+
+            _this.workerStatus |= 1 << workerId;
+            _this.workersResolve[workerId] = resolve;
+
+            _this.workers[workerId].postMessage(msg, transfer);
+          } else {
+            _this.queue.push({
+              resolve: resolve,
+              msg: msg,
+              transfer: transfer
+            });
+          }
+        });
+      }
+    }, {
+      key: "dispose",
+      value: function dispose() {
+        this.workers.forEach(function (worker) {
+          return worker.terminate();
+        });
+        this.workersResolve.length = 0;
+        this.workers.length = 0;
+        this.queue.length = 0;
+        this.workerStatus = 0;
+      }
+    }]);
+
+    return WorkerPool;
+  }();
+
+  _exports.WorkerPool = WorkerPool;
+});