three-stdlib 2.15.2 → 2.16.1

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,234 +0,0 @@
-import { Quaternion, Vector3, Object3D, SphereGeometry, MeshBasicMaterial, Color, LineBasicMaterial, Matrix4, BufferGeometry, BufferAttribute, Mesh, Line } from "three";
-const CCDIKSolver = (() => {
-  function CCDIKSolver2(mesh, iks) {
-    this.mesh = mesh;
-    this.iks = iks || [];
-    this._valid();
-  }
-  CCDIKSolver2.prototype = {
-    constructor: CCDIKSolver2,
-    update: (() => {
-      const q = new Quaternion();
-      const targetPos = new Vector3();
-      const targetVec = new Vector3();
-      const effectorPos = new Vector3();
-      const effectorVec = new Vector3();
-      const linkPos = new Vector3();
-      const invLinkQ = new Quaternion();
-      const linkScale = new Vector3();
-      const axis = new Vector3();
-      const vector = new Vector3();
-      return function 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];
-          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(linkPos, invLinkQ, linkScale);
-              invLinkQ.invert();
-              effectorPos.setFromMatrixPosition(effector.matrixWorld);
-              effectorVec.subVectors(effectorPos, linkPos);
-              effectorVec.applyQuaternion(invLinkQ);
-              effectorVec.normalize();
-              targetVec.subVectors(targetPos, linkPos);
-              targetVec.applyQuaternion(invLinkQ);
-              targetVec.normalize();
-              let angle = targetVec.dot(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;
-              }
-              axis.crossVectors(effectorVec, targetVec);
-              axis.normalize();
-              q.setFromAxisAngle(axis, angle);
-              link.quaternion.multiply(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(vector).max(rotationMin));
-              }
-              if (rotationMax !== void 0) {
-                link.rotation.setFromVector3(link.rotation.toVector3(vector).min(rotationMax));
-              }
-              link.updateMatrixWorld(true);
-              rotated = true;
-            }
-            if (!rotated)
-              break;
-          }
-        }
-        return this;
-      };
-    })(),
-    createHelper: function() {
-      return new CCDIKHelper(this.mesh, this.mesh.geometry.userData.MMD.iks);
-    },
-    _valid: function() {
-      const iks = this.iks;
-      const bones = this.mesh.skeleton.bones;
-      for (let i = 0, il = iks.length; i < il; i++) {
-        const ik = 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;
-        }
-      }
-    }
-  };
-  function CCDIKHelper(mesh, iks) {
-    Object3D.call(this);
-    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
-    });
-    this._init();
-  }
-  CCDIKHelper.prototype = Object.assign(Object.create(Object3D.prototype), {
-    constructor: CCDIKHelper,
-    updateMatrixWorld: (() => {
-      const matrix = new Matrix4();
-      const vector = new Vector3();
-      function getPosition(bone, matrixWorldInv) {
-        return vector.setFromMatrixPosition(bone.matrixWorld).applyMatrix4(matrixWorldInv);
-      }
-      function setPositionOfBoneToAttributeArray(array, index, bone, matrixWorldInv) {
-        const v = getPosition(bone, matrixWorldInv);
-        array[index * 3 + 0] = v.x;
-        array[index * 3 + 1] = v.y;
-        array[index * 3 + 2] = v.z;
-      }
-      return function updateMatrixWorld(force) {
-        const mesh = this.root;
-        if (this.visible) {
-          let offset = 0;
-          const iks = this.iks;
-          const bones = mesh.skeleton.bones;
-          matrix.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(getPosition(targetBone, matrix));
-            effectorMesh.position.copy(getPosition(effectorBone, matrix));
-            for (let j = 0, jl = ik.links.length; j < jl; j++) {
-              var link = ik.links[j];
-              var linkBone = bones[link.index];
-              const linkMesh = this.children[offset++];
-              linkMesh.position.copy(getPosition(linkBone, matrix));
-            }
-            const line = this.children[offset++];
-            const array = line.geometry.attributes.position.array;
-            setPositionOfBoneToAttributeArray(array, 0, targetBone, matrix);
-            setPositionOfBoneToAttributeArray(array, 1, effectorBone, matrix);
-            for (let 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);
-        Object3D.prototype.updateMatrixWorld.call(this, force);
-      };
-    })(),
-    _init: function() {
-      const scope = this;
-      const iks = this.iks;
-      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));
-      }
-    }
-  });
-  return CCDIKSolver2;
-})();
-export {
-  CCDIKSolver
-};