opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/loaders/BVHLoader.js

@@ -0,0 +1,365 @@
+(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.BVHLoader = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.BVHLoader = 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; }
+
+  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); }
+
+  /**
+   * Description: reads BVH files and outputs a single Skeleton and an AnimationClip
+   *
+   * Currently only supports bvh files containing a single root.
+   *
+   */
+  var BVHLoader = /*#__PURE__*/function (_Loader) {
+    _inherits(BVHLoader, _Loader);
+
+    var _super = _createSuper(BVHLoader);
+
+    function BVHLoader(manager) {
+      var _this;
+
+      _classCallCheck(this, BVHLoader);
+
+      _this = _super.call(this, manager);
+      _this.animateBonePositions = true;
+      _this.animateBoneRotations = true;
+      return _this;
+    }
+
+    _createClass(BVHLoader, [{
+      key: "load",
+      value: function load(url, onLoad, onProgress, onError) {
+        var scope = this;
+        var loader = new _three.FileLoader(scope.manager);
+        loader.setPath(scope.path);
+        loader.setRequestHeader(scope.requestHeader);
+        loader.setWithCredentials(scope.withCredentials);
+        loader.load(url, function (text) {
+          try {
+            onLoad(scope.parse(text));
+          } catch (e) {
+            if (onError) {
+              onError(e);
+            } else {
+              console.error(e);
+            }
+
+            scope.manager.itemError(url);
+          }
+        }, onProgress, onError);
+      }
+    }, {
+      key: "parse",
+      value: function parse(text) {
+        /*
+        	reads a string array (lines) from a BVH file
+        	and outputs a skeleton structure including motion data
+        		returns thee root node:
+        	{ name: '', channels: [], children: [] }
+        */
+        function readBvh(lines) {
+          // read model structure
+          if (nextLine(lines) !== 'HIERARCHY') {
+            console.error('THREE.BVHLoader: HIERARCHY expected.');
+          }
+
+          var list = []; // collects flat array of all bones
+
+          var root = readNode(lines, nextLine(lines), list); // read motion data
+
+          if (nextLine(lines) !== 'MOTION') {
+            console.error('THREE.BVHLoader: MOTION expected.');
+          } // number of frames
+
+
+          var tokens = nextLine(lines).split(/[\s]+/);
+          var numFrames = parseInt(tokens[1]);
+
+          if (isNaN(numFrames)) {
+            console.error('THREE.BVHLoader: Failed to read number of frames.');
+          } // frame time
+
+
+          tokens = nextLine(lines).split(/[\s]+/);
+          var frameTime = parseFloat(tokens[2]);
+
+          if (isNaN(frameTime)) {
+            console.error('THREE.BVHLoader: Failed to read frame time.');
+          } // read frame data line by line
+
+
+          for (var i = 0; i < numFrames; i++) {
+            tokens = nextLine(lines).split(/[\s]+/);
+            readFrameData(tokens, i * frameTime, root);
+          }
+
+          return list;
+        }
+        /*
+        	Recursively reads data from a single frame into the bone hierarchy.
+        	The passed bone hierarchy has to be structured in the same order as the BVH file.
+        	keyframe data is stored in bone.frames.
+        		- data: splitted string array (frame values), values are shift()ed so
+        	this should be empty after parsing the whole hierarchy.
+        	- frameTime: playback time for this keyframe.
+        	- bone: the bone to read frame data from.
+        */
+
+
+        function readFrameData(data, frameTime, bone) {
+          // end sites have no motion data
+          if (bone.type === 'ENDSITE') return; // add keyframe
+
+          var keyframe = {
+            time: frameTime,
+            position: new _three.Vector3(),
+            rotation: new _three.Quaternion()
+          };
+          bone.frames.push(keyframe);
+          var quat = new _three.Quaternion();
+          var vx = new _three.Vector3(1, 0, 0);
+          var vy = new _three.Vector3(0, 1, 0);
+          var vz = new _three.Vector3(0, 0, 1); // parse values for each channel in node
+
+          for (var i = 0; i < bone.channels.length; i++) {
+            switch (bone.channels[i]) {
+              case 'Xposition':
+                keyframe.position.x = parseFloat(data.shift().trim());
+                break;
+
+              case 'Yposition':
+                keyframe.position.y = parseFloat(data.shift().trim());
+                break;
+
+              case 'Zposition':
+                keyframe.position.z = parseFloat(data.shift().trim());
+                break;
+
+              case 'Xrotation':
+                quat.setFromAxisAngle(vx, parseFloat(data.shift().trim()) * Math.PI / 180);
+                keyframe.rotation.multiply(quat);
+                break;
+
+              case 'Yrotation':
+                quat.setFromAxisAngle(vy, parseFloat(data.shift().trim()) * Math.PI / 180);
+                keyframe.rotation.multiply(quat);
+                break;
+
+              case 'Zrotation':
+                quat.setFromAxisAngle(vz, parseFloat(data.shift().trim()) * Math.PI / 180);
+                keyframe.rotation.multiply(quat);
+                break;
+
+              default:
+                console.warn('THREE.BVHLoader: Invalid channel type.');
+            }
+          } // parse child nodes
+
+
+          for (var _i = 0; _i < bone.children.length; _i++) {
+            readFrameData(data, frameTime, bone.children[_i]);
+          }
+        }
+        /*
+         Recursively parses the HIERACHY section of the BVH file
+        	 - lines: all lines of the file. lines are consumed as we go along.
+         - firstline: line containing the node type and name e.g. 'JOINT hip'
+         - list: collects a flat list of nodes
+        	 returns: a BVH node including children
+        */
+
+
+        function readNode(lines, firstline, list) {
+          var node = {
+            name: '',
+            type: '',
+            frames: []
+          };
+          list.push(node); // parse node type and name
+
+          var tokens = firstline.split(/[\s]+/);
+
+          if (tokens[0].toUpperCase() === 'END' && tokens[1].toUpperCase() === 'SITE') {
+            node.type = 'ENDSITE';
+            node.name = 'ENDSITE'; // bvh end sites have no name
+          } else {
+            node.name = tokens[1];
+            node.type = tokens[0].toUpperCase();
+          }
+
+          if (nextLine(lines) !== '{') {
+            console.error('THREE.BVHLoader: Expected opening { after type & name');
+          } // parse OFFSET
+
+
+          tokens = nextLine(lines).split(/[\s]+/);
+
+          if (tokens[0] !== 'OFFSET') {
+            console.error('THREE.BVHLoader: Expected OFFSET but got: ' + tokens[0]);
+          }
+
+          if (tokens.length !== 4) {
+            console.error('THREE.BVHLoader: Invalid number of values for OFFSET.');
+          }
+
+          var offset = new _three.Vector3(parseFloat(tokens[1]), parseFloat(tokens[2]), parseFloat(tokens[3]));
+
+          if (isNaN(offset.x) || isNaN(offset.y) || isNaN(offset.z)) {
+            console.error('THREE.BVHLoader: Invalid values of OFFSET.');
+          }
+
+          node.offset = offset; // parse CHANNELS definitions
+
+          if (node.type !== 'ENDSITE') {
+            tokens = nextLine(lines).split(/[\s]+/);
+
+            if (tokens[0] !== 'CHANNELS') {
+              console.error('THREE.BVHLoader: Expected CHANNELS definition.');
+            }
+
+            var numChannels = parseInt(tokens[1]);
+            node.channels = tokens.splice(2, numChannels);
+            node.children = [];
+          } // read children
+
+
+          while (true) {
+            var line = nextLine(lines);
+
+            if (line === '}') {
+              return node;
+            } else {
+              node.children.push(readNode(lines, line, list));
+            }
+          }
+        }
+        /*
+        	recursively converts the internal bvh node structure to a Bone hierarchy
+        		source: the bvh root node
+        	list: pass an empty array, collects a flat list of all converted THREE.Bones
+        		returns the root Bone
+        */
+
+
+        function toTHREEBone(source, list) {
+          var bone = new _three.Bone();
+          list.push(bone);
+          bone.position.add(source.offset);
+          bone.name = source.name;
+
+          if (source.type !== 'ENDSITE') {
+            for (var i = 0; i < source.children.length; i++) {
+              bone.add(toTHREEBone(source.children[i], list));
+            }
+          }
+
+          return bone;
+        }
+        /*
+        	builds a AnimationClip from the keyframe data saved in each bone.
+        		bone: bvh root node
+        		returns: a AnimationClip containing position and quaternion tracks
+        */
+
+
+        function toTHREEAnimation(bones) {
+          var tracks = []; // create a position and quaternion animation track for each node
+
+          for (var i = 0; i < bones.length; i++) {
+            var bone = bones[i];
+            if (bone.type === 'ENDSITE') continue; // track data
+
+            var times = [];
+            var positions = [];
+            var rotations = [];
+
+            for (var j = 0; j < bone.frames.length; j++) {
+              var frame = bone.frames[j];
+              times.push(frame.time); // the animation system animates the position property,
+              // so we have to add the joint offset to all values
+
+              positions.push(frame.position.x + bone.offset.x);
+              positions.push(frame.position.y + bone.offset.y);
+              positions.push(frame.position.z + bone.offset.z);
+              rotations.push(frame.rotation.x);
+              rotations.push(frame.rotation.y);
+              rotations.push(frame.rotation.z);
+              rotations.push(frame.rotation.w);
+            }
+
+            if (scope.animateBonePositions) {
+              tracks.push(new _three.VectorKeyframeTrack('.bones[' + bone.name + '].position', times, positions));
+            }
+
+            if (scope.animateBoneRotations) {
+              tracks.push(new _three.QuaternionKeyframeTrack('.bones[' + bone.name + '].quaternion', times, rotations));
+            }
+          }
+
+          return new _three.AnimationClip('animation', -1, tracks);
+        }
+        /*
+        	returns the next non-empty line in lines
+        */
+
+
+        function nextLine(lines) {
+          var line; // skip empty lines
+
+          while ((line = lines.shift().trim()).length === 0) {}
+
+          return line;
+        }
+
+        var scope = this;
+        var lines = text.split(/[\r\n]+/g);
+        var bones = readBvh(lines);
+        var threeBones = [];
+        toTHREEBone(bones[0], threeBones);
+        var threeClip = toTHREEAnimation(bones);
+        return {
+          skeleton: new _three.Skeleton(threeBones),
+          clip: threeClip
+        };
+      }
+    }]);
+
+    return BVHLoader;
+  }(_three.Loader);
+
+  _exports.BVHLoader = BVHLoader;
+});