Update avatar proto code

Author: Avaer Kazmer

proto/Armature.js

@@ -1,10 +1,8 @@
 // Armature.js -- base skeleton abstraction across a well-known joint topology (independent of mesh)
 
-import { _decoupledSkeletonClone } from './armature.utils.js';
+import { _decoupledSkeletonClone } from './utils.js';
 import remapJointNames from './remapJointNames.js';
-import { NamedJointWrappers } from './NamedJointWrappers.js';
-import { AutoIKChain, walkBoneChain } from './AutoIKChain.js';
-import SkeletonMetrics from './SkeletonMetrics.js';
+import { SpaceHelper } from './experiments.js';
 
 class Armature {
   static get version() { return '0.0.0a'; }
@@ -36,15 +34,6 @@ class Armature {
     Object.assign(this, new NamedJointWrappers(skeleton, idNames));
   }
 
-  walk(a, b, silent = false) {
-    var bc = walkBoneChain(this.get(a), this.get(b));
-    if (!silent && !bc.valid) {
-        debugger;
-        throw new Error('bad chain: '+[a,b].join('=>'));
-    }
-    return bc;
-  }
-  
   // experimental support for "tearing off" subskeleton chains
   virtualSegment(from, to) {
     var container = {
@@ -143,6 +132,131 @@ class Armature {
   }
 };
 
-export default Armature;
 export { Armature };
-try { Object.assign(self, { Armature }); } catch(e) {}
+try { Object.assign(self, { Armature }); } catch(e) {}
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// NamedJointWrappers.js -- wraps a set of skeleton joints with SpaceHelper instances
+
+class NamedJointWrappers {
+	constructor(skeleton, map, biasmap) {
+    if (skeleton.skeleton) skeleton = skeleton.skeleton;
+    biasmap = biasmap || {};
+    this.keys = Object.keys(map);
+		for (var name in map) {
+			var boneName = map[name];
+      if (boneName === 'Armature') {
+        this[name] = new SpaceHelper(skeleton.getBoneByName('Hips').parent, { boneName: boneName });
+      } else {
+        this[name] = new SpaceHelper(skeleton.getBoneByName(boneName), { boneName: boneName });
+      }
+      this[name].bias = biasmap[name] || biasmap[boneName];
+		}
+	}
+  toString() { return `[NamedJointWrappers ${this.keys}]`; }
+};
+
+export { NamedJointWrappers };
+try { Object.assign(self, { NamedJointWrappers }); } catch(e) {}
+
+// ---------------------------------------------------------------------------
+// SkeletonMetrics.js -- calculates various metrics about a given THREE Skeleton
+
+class SkeletonMetrics {
+  static get version() { return '0.0.0'; }
+  get scale() {
+    return this.eyeHeight/1.6 * this.bones.Hips.parent.scale.x;
+  }
+  constructor(skeleton) {
+    this.skeleton = skeleton;
+    this.bones = this.skeleton.bones.reduce((out, b) => {
+      out[b.name] = b;
+      return out;
+    }, {});
+    this.boneNames = this.skeleton.bones.map((b)=>b.name);
+  }
+  get(name, fallback) {
+    var b = name instanceof THREE.Bone ? name : this.bones[name] || this.bones[fallback];
+    if (!b) throw new Error('!b:'+[name,fallback||'']);
+    return b;
+  }
+
+  _pos(bone, target) { return bone.getWorldPosition(target); }
+  _rot(bone, target) { return bone.getWorldQuaternion(target); }
+  pos(name, fallback) {
+    return this._pos(this.get(name, fallback), new THREE.Vector3());
+  }
+  rot(name, fallback) {
+    return this._rot(this.get(name, fallback), new THREE.Quaternion());
+  }
+  centroid(names) {
+    var center = new THREE.Vector3();
+    for (let name of names) center.add(this.pos(name));
+    return center.divideScalar(names.length);
+  }
+  // maybe LeftToeBase? or if lowest joint in skeleton is epsilon of zero, take feet to be at zero?
+  get feet() { return this.pos('LeftFoot').add(this.pos('RightFoot')).multiplyScalar(.5); }
+  get midEyes() { return this.pos('LeftEye').add(this.pos('RightEye')).multiplyScalar(.5); }
+  get midHead() {
+    var pt = this.pos('LeftEye').add(this.pos('RightEye')).multiplyScalar(.5);
+    pt.z = this.pos('Head').z;
+    return pt;
+  }
+
+  get headTop() { return this.pos('HeadTop_End', 'Head'); }
+  get headPivot() { return this.pos('Head'); }
+  get head() { return this.pos('Head'); }
+  get hips() { return this.pos('Hips'); }
+
+  get armLength() { return this.pos('LeftShoulder').sub(this.pos('LeftHand')).length(); }
+  get legLength() { return this.pos('LeftUpLeg').sub(this.pos('LeftToeBase', 'LeftFoot')).length(); }
+
+  get eyesOffset() { return this.midEyes.sub(this.headPivot); }
+  get headOffset() { return this.midHead.sub(this.midEyes); }
+  get cameraOffset() { return this.midEyes.sub(this.head); }
+  get hipsOffset() { return this.midEyes.sub(this.hips); }
+
+  //get height() { return this.headTop.y; }
+  get lowestBone() { return this._mmbone(this.bones.Hips, -1).bone; }
+  get highestBone() { return this._mmbone(this.bones.Hips, 1).bone; }
+  _mmbone(root, dir) {
+    var out = {
+      root: root,
+      dir: dir,
+      bone: null,
+      pos: dir < 0 ? new THREE.Vector3(Infinity, Infinity, Infinity) : new THREE.Vector3(-Infinity, -Infinity, -Infinity),
+    };
+    root.traverse((b)=> {
+      var pt = this.pos(b);
+      var better = dir < 0 ? (pt.y < out.pos.y) : (pt.y > out.pos.y);
+      if (better) {
+        out.bone = b;
+        out.pos.copy(pt);
+      }
+    });
+    return out;
+  }
+
+  get height() { return this.headTop.distanceTo(this.feet); }
+  get eyeHeight() { return this.midEyes.distanceTo(this.feet); }
+
+  get altitude() { return this.hips.y; }
+
+  relativeTo(bone, names) {
+    names = names || this.boneNames;
+    var bones = names.map((x) => this.get(x));
+    var inv = new THREE.Matrix4().getInverse(bone.matrixWorld);
+    return bones.reduce((out, bone) => {
+      out[bone.name] = this.pos(bone).applyMatrix4(inv);
+      return out;
+    }, {});
+  }
+};
+
+export { SkeletonMetrics };
+
+try { Object.assign(self, { SkeletonMetrics }); } catch(e) {}
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------