three-stdlib 2.16.0 → 2.16.2

package/webxr/XRHandModelFactory.js

@@ -1,9 +1,8 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
-const XRHandPrimitiveModel = require("./XRHandPrimitiveModel.js");
-const XRHandMeshModel = require("./XRHandMeshModel.js");
-class XRHandModel extends THREE.Object3D {
+import { Object3D } from 'three';
+import { XRHandPrimitiveModel } from './XRHandPrimitiveModel.js';
+import { XRHandMeshModel } from './XRHandMeshModel.js';
+
+class XRHandModel extends Object3D {
   constructor(controller) {
     super();
     this.controller = controller;
@@ -11,51 +10,55 @@ class XRHandModel extends THREE.Object3D {
     this.envMap = null;
     this.mesh = null;
   }
+
   updateMatrixWorld(force) {
     super.updateMatrixWorld(force);
+
     if (this.motionController) {
       this.motionController.updateMesh();
     }
   }
+
 }
+
 class XRHandModelFactory {
   constructor() {
     this.path = null;
   }
+
   setPath(path) {
     this.path = path;
     return this;
   }
+
   createHandModel(controller, profile) {
     const handModel = new XRHandModel(controller);
-    controller.addEventListener("connected", (event) => {
+    controller.addEventListener('connected', event => {
       const xrInputSource = event.data;
+
       if (xrInputSource.hand && !handModel.motionController) {
-        handModel.xrInputSource = xrInputSource;
-        if (profile === void 0 || profile === "spheres") {
-          handModel.motionController = new XRHandPrimitiveModel.XRHandPrimitiveModel(
-            handModel,
-            controller,
-            this.path,
-            xrInputSource.handedness,
-            { primitive: "sphere" }
-          );
-        } else if (profile === "boxes") {
-          handModel.motionController = new XRHandPrimitiveModel.XRHandPrimitiveModel(
-            handModel,
-            controller,
-            this.path,
-            xrInputSource.handedness,
-            { primitive: "box" }
-          );
-        } else if (profile === "mesh") {
-          handModel.motionController = new XRHandMeshModel.XRHandMeshModel(handModel, controller, this.path, xrInputSource.handedness);
+        handModel.xrInputSource = xrInputSource; // @todo Detect profile if not provided
+
+        if (profile === undefined || profile === 'spheres') {
+          handModel.motionController = new XRHandPrimitiveModel(handModel, controller, this.path, xrInputSource.handedness, {
+            primitive: 'sphere'
+          });
+        } else if (profile === 'boxes') {
+          handModel.motionController = new XRHandPrimitiveModel(handModel, controller, this.path, xrInputSource.handedness, {
+            primitive: 'box'
+          });
+        } else if (profile === 'mesh') {
+          handModel.motionController = new XRHandMeshModel(handModel, controller, this.path, xrInputSource.handedness);
         }
       }
     });
-    controller.addEventListener("disconnected", () => {
+    controller.addEventListener('disconnected', () => {// handModel.motionController = null;
+      // handModel.remove( scene );
+      // scene = null;
     });
     return handModel;
   }
+
 }
-exports.XRHandModelFactory = XRHandModelFactory;
+
+export { XRHandModelFactory };

package/webxr/XRHandPrimitiveModel.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three");const i=new e.Matrix4,n=new e.Vector3;exports.XRHandPrimitiveModel=class{constructor(i,n,a,t,r){let s;this.controller=n,this.handModel=i,this.envMap=null,r&&r.primitive&&"sphere"!==r.primitive?"box"===r.primitive&&(s=new e.BoxGeometry(1,1,1)):s=new e.SphereGeometry(1,10,10);const h=new e.MeshStandardMaterial;this.handMesh=new e.InstancedMesh(s,h,30),this.handMesh.instanceMatrix.setUsage(e.DynamicDrawUsage),this.handMesh.castShadow=!0,this.handMesh.receiveShadow=!0,this.handModel.add(this.handMesh),this.joints=["wrist","thumb-metacarpal","thumb-phalanx-proximal","thumb-phalanx-distal","thumb-tip","index-finger-metacarpal","index-finger-phalanx-proximal","index-finger-phalanx-intermediate","index-finger-phalanx-distal","index-finger-tip","middle-finger-metacarpal","middle-finger-phalanx-proximal","middle-finger-phalanx-intermediate","middle-finger-phalanx-distal","middle-finger-tip","ring-finger-metacarpal","ring-finger-phalanx-proximal","ring-finger-phalanx-intermediate","ring-finger-phalanx-distal","ring-finger-tip","pinky-finger-metacarpal","pinky-finger-phalanx-proximal","pinky-finger-phalanx-intermediate","pinky-finger-phalanx-distal","pinky-finger-tip"]}updateMesh(){const e=this.controller.joints;let a=0;for(let t=0;t<this.joints.length;t++){const r=e[this.joints[t]];r.visible&&(n.setScalar(r.jointRadius||.008),i.compose(r.position,r.quaternion,n),this.handMesh.setMatrixAt(t,i),a++)}this.handMesh.count=a,this.handMesh.instanceMatrix.needsUpdate=!0}};

package/webxr/XRHandPrimitiveModel.js

@@ -1,68 +1,54 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
-const _matrix = new THREE.Matrix4();
-const _vector = new THREE.Vector3();
+import { Matrix4, Vector3, SphereGeometry, BoxGeometry, MeshStandardMaterial, InstancedMesh, DynamicDrawUsage } from 'three';
+
+const _matrix = new Matrix4();
+
+const _vector = new Vector3();
+
 class XRHandPrimitiveModel {
   constructor(handModel, controller, path, handedness, options) {
     this.controller = controller;
     this.handModel = handModel;
     this.envMap = null;
     let geometry;
-    if (!options || !options.primitive || options.primitive === "sphere") {
-      geometry = new THREE.SphereGeometry(1, 10, 10);
-    } else if (options.primitive === "box") {
-      geometry = new THREE.BoxGeometry(1, 1, 1);
+
+    if (!options || !options.primitive || options.primitive === 'sphere') {
+      geometry = new SphereGeometry(1, 10, 10);
+    } else if (options.primitive === 'box') {
+      geometry = new BoxGeometry(1, 1, 1);
     }
-    const material = new THREE.MeshStandardMaterial();
-    this.handMesh = new THREE.InstancedMesh(geometry, material, 30);
-    this.handMesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+
+    const material = new MeshStandardMaterial();
+    this.handMesh = new InstancedMesh(geometry, material, 30);
+    this.handMesh.instanceMatrix.setUsage(DynamicDrawUsage); // will be updated every frame
+
     this.handMesh.castShadow = true;
     this.handMesh.receiveShadow = true;
     this.handModel.add(this.handMesh);
-    this.joints = [
-      "wrist",
-      "thumb-metacarpal",
-      "thumb-phalanx-proximal",
-      "thumb-phalanx-distal",
-      "thumb-tip",
-      "index-finger-metacarpal",
-      "index-finger-phalanx-proximal",
-      "index-finger-phalanx-intermediate",
-      "index-finger-phalanx-distal",
-      "index-finger-tip",
-      "middle-finger-metacarpal",
-      "middle-finger-phalanx-proximal",
-      "middle-finger-phalanx-intermediate",
-      "middle-finger-phalanx-distal",
-      "middle-finger-tip",
-      "ring-finger-metacarpal",
-      "ring-finger-phalanx-proximal",
-      "ring-finger-phalanx-intermediate",
-      "ring-finger-phalanx-distal",
-      "ring-finger-tip",
-      "pinky-finger-metacarpal",
-      "pinky-finger-phalanx-proximal",
-      "pinky-finger-phalanx-intermediate",
-      "pinky-finger-phalanx-distal",
-      "pinky-finger-tip"
-    ];
+    this.joints = ['wrist', 'thumb-metacarpal', 'thumb-phalanx-proximal', 'thumb-phalanx-distal', 'thumb-tip', 'index-finger-metacarpal', 'index-finger-phalanx-proximal', 'index-finger-phalanx-intermediate', 'index-finger-phalanx-distal', 'index-finger-tip', 'middle-finger-metacarpal', 'middle-finger-phalanx-proximal', 'middle-finger-phalanx-intermediate', 'middle-finger-phalanx-distal', 'middle-finger-tip', 'ring-finger-metacarpal', 'ring-finger-phalanx-proximal', 'ring-finger-phalanx-intermediate', 'ring-finger-phalanx-distal', 'ring-finger-tip', 'pinky-finger-metacarpal', 'pinky-finger-phalanx-proximal', 'pinky-finger-phalanx-intermediate', 'pinky-finger-phalanx-distal', 'pinky-finger-tip'];
   }
+
   updateMesh() {
-    const defaultRadius = 8e-3;
+    const defaultRadius = 0.008;
     const joints = this.controller.joints;
     let count = 0;
+
     for (let i = 0; i < this.joints.length; i++) {
       const joint = joints[this.joints[i]];
+
       if (joint.visible) {
         _vector.setScalar(joint.jointRadius || defaultRadius);
+
         _matrix.compose(joint.position, joint.quaternion, _vector);
+
         this.handMesh.setMatrixAt(i, _matrix);
         count++;
       }
     }
+
     this.handMesh.count = count;
     this.handMesh.instanceMatrix.needsUpdate = true;
   }
+
 }
-exports.XRHandPrimitiveModel = XRHandPrimitiveModel;
+
+export { XRHandPrimitiveModel };

package/animation/AnimationClipCreator.mjs

@@ -1,57 +0,0 @@
-import { NumberKeyframeTrack, AnimationClip, Vector3, VectorKeyframeTrack, BooleanKeyframeTrack, ColorKeyframeTrack } from "three";
-const AnimationClipCreator = () => {
-};
-AnimationClipCreator.CreateRotationAnimation = (period, axis) => {
-  const times = [0, period], values = [0, 360];
-  axis = axis || "x";
-  const trackName = `.rotation[${axis}]`;
-  const track = new NumberKeyframeTrack(trackName, times, values);
-  return new AnimationClip(null, period, [track]);
-};
-AnimationClipCreator.CreateScaleAxisAnimation = (period, axis) => {
-  const times = [0, period], values = [0, 1];
-  axis = axis || "x";
-  const trackName = `.scale[${axis}]`;
-  const track = new NumberKeyframeTrack(trackName, times, values);
-  return new AnimationClip(null, period, [track]);
-};
-AnimationClipCreator.CreateShakeAnimation = (duration, shakeScale) => {
-  const times = [], values = [], tmp = new Vector3();
-  for (let i = 0; i < duration * 10; i++) {
-    times.push(i / 10);
-    tmp.set(Math.random() * 2 - 1, Math.random() * 2 - 1, Math.random() * 2 - 1).multiply(shakeScale).toArray(values, values.length);
-  }
-  const trackName = ".position";
-  const track = new VectorKeyframeTrack(trackName, times, values);
-  return new AnimationClip(null, duration, [track]);
-};
-AnimationClipCreator.CreatePulsationAnimation = (duration, pulseScale) => {
-  const times = [], values = [], tmp = new Vector3();
-  for (let i = 0; i < duration * 10; i++) {
-    times.push(i / 10);
-    const scaleFactor = Math.random() * pulseScale;
-    tmp.set(scaleFactor, scaleFactor, scaleFactor).toArray(values, values.length);
-  }
-  const trackName = ".scale";
-  const track = new VectorKeyframeTrack(trackName, times, values);
-  return new AnimationClip(null, duration, [track]);
-};
-AnimationClipCreator.CreateVisibilityAnimation = (duration) => {
-  const times = [0, duration / 2, duration], values = [true, false, true];
-  const trackName = ".visible";
-  const track = new BooleanKeyframeTrack(trackName, times, values);
-  return new AnimationClip(null, duration, [track]);
-};
-AnimationClipCreator.CreateMaterialColorAnimation = (duration, colors) => {
-  const times = [], values = [], timeStep = duration / colors.length;
-  for (let i = 0; i <= colors.length; i++) {
-    times.push(i * timeStep);
-    values.push(colors[i % colors.length]);
-  }
-  const trackName = ".material[0].color";
-  const track = new ColorKeyframeTrack(trackName, times, values);
-  return new AnimationClip(null, duration, [track]);
-};
-export {
-  AnimationClipCreator
-};

package/animation/CCDIKSolver.mjs

@@ -1,223 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-import { Object3D, Matrix4, Vector3, SphereGeometry, MeshBasicMaterial, Color, LineBasicMaterial, BufferGeometry, BufferAttribute, Mesh, Line, Quaternion } from "three";
-class CCDIKHelper extends Object3D {
-  constructor(mesh, iks = []) {
-    super();
-    __publicField(this, "_m", new Matrix4());
-    __publicField(this, "_v", new Vector3());
-    this.root = mesh;
-    this.iks = iks;
-    this.matrix.copy(mesh.matrixWorld);
-    this.matrixAutoUpdate = false;
-    this.sphereGeometry = new SphereGeometry(0.25, 16, 8);
-    this.targetSphereMaterial = new MeshBasicMaterial({
-      color: new Color(16746632),
-      depthTest: false,
-      depthWrite: false,
-      transparent: true
-    });
-    this.effectorSphereMaterial = new MeshBasicMaterial({
-      color: new Color(8978312),
-      depthTest: false,
-      depthWrite: false,
-      transparent: true
-    });
-    this.linkSphereMaterial = new MeshBasicMaterial({
-      color: new Color(8947967),
-      depthTest: false,
-      depthWrite: false,
-      transparent: true
-    });
-    this.lineMaterial = new LineBasicMaterial({
-      color: new Color(16711680),
-      depthTest: false,
-      depthWrite: false,
-      transparent: true
-    });
-    function createLineGeometry(ik) {
-      const geometry = new BufferGeometry();
-      const vertices = new Float32Array((2 + ik.links.length) * 3);
-      geometry.setAttribute("position", new BufferAttribute(vertices, 3));
-      return geometry;
-    }
-    function createTargetMesh() {
-      return new Mesh(scope.sphereGeometry, scope.targetSphereMaterial);
-    }
-    function createEffectorMesh() {
-      return new Mesh(scope.sphereGeometry, scope.effectorSphereMaterial);
-    }
-    function createLinkMesh() {
-      return new Mesh(scope.sphereGeometry, scope.linkSphereMaterial);
-    }
-    function createLine(ik) {
-      return new Line(createLineGeometry(ik), scope.lineMaterial);
-    }
-    for (let i = 0, il = iks.length; i < il; i++) {
-      const ik = iks[i];
-      this.add(createTargetMesh());
-      this.add(createEffectorMesh());
-      for (let j = 0, jl = ik.links.length; j < jl; j++) {
-        this.add(createLinkMesh());
-      }
-      this.add(createLine(ik));
-    }
-  }
-  _getPosition(bone, matrixWorldInv) {
-    return this._v.setFromMatrixPosition(bone.matrixWorld).applyMatrix4(matrixWorldInv);
-  }
-  _setPositionOfBoneToAttributeArray(array, index, bone, matrixWorldInv) {
-    const v = this._getPosition(bone, matrixWorldInv);
-    array[index * 3 + 0] = v.x;
-    array[index * 3 + 1] = v.y;
-    array[index * 3 + 2] = v.z;
-  }
-  updateMatrixWorld(force) {
-    const mesh = this.root;
-    if (this.visible) {
-      let offset = 0;
-      const iks = this.iks;
-      const bones = mesh.skeleton.bones;
-      this._m.copy(mesh.matrixWorld).invert();
-      for (let i = 0, il = iks.length; i < il; i++) {
-        const ik = iks[i];
-        const targetBone = bones[ik.target];
-        const effectorBone = bones[ik.effector];
-        const targetMesh = this.children[offset++];
-        const effectorMesh = this.children[offset++];
-        targetMesh.position.copy(this._getPosition(targetBone, this._m));
-        effectorMesh.position.copy(this._getPosition(effectorBone, this._m));
-        for (let j = 0, jl = ik.links.length; j < jl; j++) {
-          const link = ik.links[j];
-          const linkBone = bones[link.index];
-          const linkMesh = this.children[offset++];
-          linkMesh.position.copy(this._getPosition(linkBone, this._m));
-        }
-        const line = this.children[offset++];
-        const array = line.geometry.attributes.position.array;
-        this._setPositionOfBoneToAttributeArray(array, 0, targetBone, this._m);
-        this._setPositionOfBoneToAttributeArray(array, 1, effectorBone, this._m);
-        for (let j = 0, jl = ik.links.length; j < jl; j++) {
-          const link = ik.links[j];
-          const linkBone = bones[link.index];
-          this._setPositionOfBoneToAttributeArray(array, j + 2, linkBone, this._m);
-        }
-        line.geometry.attributes.position.needsUpdate = true;
-      }
-    }
-    this.matrix.copy(mesh.matrixWorld);
-    super.updateMatrixWorld(force);
-  }
-}
-class CCDIKSolver {
-  constructor(mesh, iks) {
-    __publicField(this, "q", new Quaternion());
-    __publicField(this, "targetPos", new Vector3());
-    __publicField(this, "targetVec", new Vector3());
-    __publicField(this, "effectorPos", new Vector3());
-    __publicField(this, "effectorVec", new Vector3());
-    __publicField(this, "linkPos", new Vector3());
-    __publicField(this, "invLinkQ", new Quaternion());
-    __publicField(this, "linkScale", new Vector3());
-    __publicField(this, "axis", new Vector3());
-    __publicField(this, "vector", new Vector3());
-    this.mesh = mesh;
-    this.iks = iks;
-    const bones = this.mesh.skeleton.bones;
-    for (let i = 0, il = this.iks.length; i < il; i++) {
-      const ik = this.iks[i];
-      const effector = bones[ik.effector];
-      const links = ik.links;
-      let link0, link1;
-      link0 = effector;
-      for (let 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;
-      }
-    }
-  }
-  update() {
-    const bones = this.mesh.skeleton.bones;
-    const iks = this.iks;
-    const math = Math;
-    for (let i = 0, il = iks.length; i < il; i++) {
-      const ik = iks[i];
-      const effector = bones[ik.effector];
-      const target = bones[ik.target];
-      this.targetPos.setFromMatrixPosition(target.matrixWorld);
-      const links = ik.links;
-      const iteration = ik.iteration !== void 0 ? ik.iteration : 1;
-      for (let j = 0; j < iteration; j++) {
-        let rotated = false;
-        for (let k = 0, kl = links.length; k < kl; k++) {
-          const link = bones[links[k].index];
-          if (links[k].enabled === false)
-            break;
-          const limitation = links[k].limitation;
-          const rotationMin = links[k].rotationMin;
-          const rotationMax = links[k].rotationMax;
-          link.matrixWorld.decompose(this.linkPos, this.invLinkQ, this.linkScale);
-          this.invLinkQ.invert();
-          this.effectorPos.setFromMatrixPosition(effector.matrixWorld);
-          this.effectorVec.subVectors(this.effectorPos, this.linkPos);
-          this.effectorVec.applyQuaternion(this.invLinkQ);
-          this.effectorVec.normalize();
-          this.targetVec.subVectors(this.targetPos, this.linkPos);
-          this.targetVec.applyQuaternion(this.invLinkQ);
-          this.targetVec.normalize();
-          let angle = this.targetVec.dot(this.effectorVec);
-          if (angle > 1) {
-            angle = 1;
-          } else if (angle < -1) {
-            angle = -1;
-          }
-          angle = math.acos(angle);
-          if (angle < 1e-5)
-            continue;
-          if (ik.minAngle !== void 0 && angle < ik.minAngle) {
-            angle = ik.minAngle;
-          }
-          if (ik.maxAngle !== void 0 && angle > ik.maxAngle) {
-            angle = ik.maxAngle;
-          }
-          this.axis.crossVectors(this.effectorVec, this.targetVec);
-          this.axis.normalize();
-          this.q.setFromAxisAngle(this.axis, angle);
-          link.quaternion.multiply(this.q);
-          if (limitation !== void 0) {
-            let c = link.quaternion.w;
-            if (c > 1)
-              c = 1;
-            const c2 = math.sqrt(1 - c * c);
-            link.quaternion.set(limitation.x * c2, limitation.y * c2, limitation.z * c2, c);
-          }
-          if (rotationMin !== void 0) {
-            link.rotation.setFromVector3(link.rotation.toVector3(this.vector).max(rotationMin));
-          }
-          if (rotationMax !== void 0) {
-            link.rotation.setFromVector3(link.rotation.toVector3(this.vector).min(rotationMax));
-          }
-          link.updateMatrixWorld(true);
-          rotated = true;
-        }
-        if (!rotated)
-          break;
-      }
-    }
-    return this;
-  }
-  createHelper() {
-    return new CCDIKHelper(this.mesh, this.mesh.geometry.userData.MMD.iks);
-  }
-}
-export {
-  CCDIKHelper,
-  CCDIKSolver
-};