three-stdlib 2.16.0 → 2.16.1

package/webxr/XRControllerModelFactory.js

@@ -1,22 +1,24 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
-const GLTFLoader = require("../loaders/GLTFLoader.js");
-const MotionControllers = require("../libs/MotionControllers.js");
-const DEFAULT_PROFILES_PATH = "https://cdn.jsdelivr.net/npm/@webxr-input-profiles/assets@1.0/dist/profiles";
-const DEFAULT_PROFILE = "generic-trigger";
-class XRControllerModel extends THREE.Object3D {
+import { Object3D, SphereGeometry, MeshBasicMaterial, Mesh } from 'three';
+import { GLTFLoader } from '../loaders/GLTFLoader.js';
+import { fetchProfile, MotionController, MotionControllerConstants } from '../libs/MotionControllers.js';
+
+const DEFAULT_PROFILES_PATH = 'https://cdn.jsdelivr.net/npm/@webxr-input-profiles/assets@1.0/dist/profiles';
+const DEFAULT_PROFILE = 'generic-trigger';
+
+class XRControllerModel extends Object3D {
   constructor() {
     super();
     this.motionController = null;
     this.envMap = null;
   }
+
   setEnvironmentMap(envMap) {
     if (this.envMap == envMap) {
       return this;
     }
+
     this.envMap = envMap;
-    this.traverse((child) => {
+    this.traverse(child => {
       if (child.isMesh) {
         child.material.envMap = this.envMap;
         child.material.needsUpdate = true;
@@ -24,123 +26,179 @@ class XRControllerModel extends THREE.Object3D {
     });
     return this;
   }
+  /**
+   * Polls data from the XRInputSource and updates the model's components to match
+   * the real world data
+   */
+
+
   updateMatrixWorld(force) {
     super.updateMatrixWorld(force);
-    if (!this.motionController)
-      return;
-    this.motionController.updateFromGamepad();
-    Object.values(this.motionController.components).forEach((component) => {
-      Object.values(component.visualResponses).forEach((visualResponse) => {
-        const { valueNode, minNode, maxNode, value, valueNodeProperty } = visualResponse;
-        if (!valueNode)
-          return;
-        if (valueNodeProperty === MotionControllers.MotionControllerConstants.VisualResponseProperty.VISIBILITY) {
+    if (!this.motionController) return; // Cause the MotionController to poll the Gamepad for data
+
+    this.motionController.updateFromGamepad(); // Update the 3D model to reflect the button, thumbstick, and touchpad state
+
+    Object.values(this.motionController.components).forEach(component => {
+      // Update node data based on the visual responses' current states
+      Object.values(component.visualResponses).forEach(visualResponse => {
+        const {
+          valueNode,
+          minNode,
+          maxNode,
+          value,
+          valueNodeProperty
+        } = visualResponse; // Skip if the visual response node is not found. No error is needed,
+        // because it will have been reported at load time.
+
+        if (!valueNode) return; // Calculate the new properties based on the weight supplied
+
+        if (valueNodeProperty === MotionControllerConstants.VisualResponseProperty.VISIBILITY) {
           valueNode.visible = value;
-        } else if (valueNodeProperty === MotionControllers.MotionControllerConstants.VisualResponseProperty.TRANSFORM) {
+        } else if (valueNodeProperty === MotionControllerConstants.VisualResponseProperty.TRANSFORM) {
           valueNode.quaternion.slerpQuaternions(minNode.quaternion, maxNode.quaternion, value);
           valueNode.position.lerpVectors(minNode.position, maxNode.position, value);
         }
       });
     });
   }
+
 }
+/**
+ * Walks the model's tree to find the nodes needed to animate the components and
+ * saves them to the motionContoller components for use in the frame loop. When
+ * touchpads are found, attaches a touch dot to them.
+ */
+
+
 function findNodes(motionController, scene) {
-  Object.values(motionController.components).forEach((component) => {
-    const { type, touchPointNodeName, visualResponses } = component;
-    if (type === MotionControllers.MotionControllerConstants.ComponentType.TOUCHPAD) {
+  // Loop through the components and find the nodes needed for each components' visual responses
+  Object.values(motionController.components).forEach(component => {
+    const {
+      type,
+      touchPointNodeName,
+      visualResponses
+    } = component;
+
+    if (type === MotionControllerConstants.ComponentType.TOUCHPAD) {
       component.touchPointNode = scene.getObjectByName(touchPointNodeName);
+
       if (component.touchPointNode) {
-        const sphereGeometry = new THREE.SphereGeometry(1e-3);
-        const material = new THREE.MeshBasicMaterial({ color: 255 });
-        const sphere = new THREE.Mesh(sphereGeometry, material);
+        // Attach a touch dot to the touchpad.
+        const sphereGeometry = new SphereGeometry(0.001);
+        const material = new MeshBasicMaterial({
+          color: 0x0000ff
+        });
+        const sphere = new Mesh(sphereGeometry, material);
         component.touchPointNode.add(sphere);
       } else {
         console.warn(`Could not find touch dot, ${component.touchPointNodeName}, in touchpad component ${component.id}`);
       }
-    }
-    Object.values(visualResponses).forEach((visualResponse) => {
-      const { valueNodeName, minNodeName, maxNodeName, valueNodeProperty } = visualResponse;
-      if (valueNodeProperty === MotionControllers.MotionControllerConstants.VisualResponseProperty.TRANSFORM) {
+    } // Loop through all the visual responses to be applied to this component
+
+
+    Object.values(visualResponses).forEach(visualResponse => {
+      const {
+        valueNodeName,
+        minNodeName,
+        maxNodeName,
+        valueNodeProperty
+      } = visualResponse; // If animating a transform, find the two nodes to be interpolated between.
+
+      if (valueNodeProperty === MotionControllerConstants.VisualResponseProperty.TRANSFORM) {
         visualResponse.minNode = scene.getObjectByName(minNodeName);
-        visualResponse.maxNode = scene.getObjectByName(maxNodeName);
+        visualResponse.maxNode = scene.getObjectByName(maxNodeName); // If the extents cannot be found, skip this animation
+
         if (!visualResponse.minNode) {
           console.warn(`Could not find ${minNodeName} in the model`);
           return;
         }
+
         if (!visualResponse.maxNode) {
           console.warn(`Could not find ${maxNodeName} in the model`);
           return;
         }
-      }
+      } // If the target node cannot be found, skip this animation
+
+
       visualResponse.valueNode = scene.getObjectByName(valueNodeName);
+
       if (!visualResponse.valueNode) {
         console.warn(`Could not find ${valueNodeName} in the model`);
       }
     });
   });
 }
+
 function addAssetSceneToControllerModel(controllerModel, scene) {
-  findNodes(controllerModel.motionController, scene);
+  // Find the nodes needed for animation and cache them on the motionController.
+  findNodes(controllerModel.motionController, scene); // Apply any environment map that the mesh already has set.
+
   if (controllerModel.envMap) {
-    scene.traverse((child) => {
+    scene.traverse(child => {
       if (child.isMesh) {
         child.material.envMap = controllerModel.envMap;
         child.material.needsUpdate = true;
       }
     });
-  }
+  } // Add the glTF scene to the controllerModel.
+
+
   controllerModel.add(scene);
 }
+
 class XRControllerModelFactory {
   constructor(gltfLoader = null) {
     this.gltfLoader = gltfLoader;
     this.path = DEFAULT_PROFILES_PATH;
-    this._assetCache = {};
+    this._assetCache = {}; // If a GLTFLoader wasn't supplied to the constructor create a new one.
+
     if (!this.gltfLoader) {
-      this.gltfLoader = new GLTFLoader.GLTFLoader();
+      this.gltfLoader = new GLTFLoader();
     }
   }
+
   createControllerModel(controller) {
     const controllerModel = new XRControllerModel();
     let scene = null;
-    controller.addEventListener("connected", (event) => {
+    controller.addEventListener('connected', event => {
       const xrInputSource = event.data;
-      if (xrInputSource.targetRayMode !== "tracked-pointer" || !xrInputSource.gamepad)
-        return;
-      MotionControllers.fetchProfile(xrInputSource, this.path, DEFAULT_PROFILE).then(({ profile, assetPath }) => {
-        controllerModel.motionController = new MotionControllers.MotionController(xrInputSource, profile, assetPath);
+      if (xrInputSource.targetRayMode !== 'tracked-pointer' || !xrInputSource.gamepad) return;
+      fetchProfile(xrInputSource, this.path, DEFAULT_PROFILE).then(({
+        profile,
+        assetPath
+      }) => {
+        controllerModel.motionController = new MotionController(xrInputSource, profile, assetPath);
         const cachedAsset = this._assetCache[controllerModel.motionController.assetUrl];
+
         if (cachedAsset) {
           scene = cachedAsset.scene.clone();
           addAssetSceneToControllerModel(controllerModel, scene);
         } else {
           if (!this.gltfLoader) {
-            throw new Error("GLTFLoader not set.");
+            throw new Error('GLTFLoader not set.');
           }
-          this.gltfLoader.setPath("");
-          this.gltfLoader.load(
-            controllerModel.motionController.assetUrl,
-            (asset) => {
-              this._assetCache[controllerModel.motionController.assetUrl] = asset;
-              scene = asset.scene.clone();
-              addAssetSceneToControllerModel(controllerModel, scene);
-            },
-            null,
-            () => {
-              throw new Error(`Asset ${controllerModel.motionController.assetUrl} missing or malformed.`);
-            }
-          );
+
+          this.gltfLoader.setPath('');
+          this.gltfLoader.load(controllerModel.motionController.assetUrl, asset => {
+            this._assetCache[controllerModel.motionController.assetUrl] = asset;
+            scene = asset.scene.clone();
+            addAssetSceneToControllerModel(controllerModel, scene);
+          }, null, () => {
+            throw new Error(`Asset ${controllerModel.motionController.assetUrl} missing or malformed.`);
+          });
         }
-      }).catch((err) => {
+      }).catch(err => {
         console.warn(err);
       });
     });
-    controller.addEventListener("disconnected", () => {
+    controller.addEventListener('disconnected', () => {
       controllerModel.motionController = null;
       controllerModel.remove(scene);
       scene = null;
     });
     return controllerModel;
   }
+
 }
-exports.XRControllerModelFactory = XRControllerModelFactory;
+
+export { XRControllerModelFactory };

package/webxr/XREstimatedLight.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t=require("three");class i{constructor(i,e,n,s,r){this.xrLight=i,this.renderer=e,this.lightProbe=n,this.xrWebGLBinding=null,this.estimationStartCallback=r,this.frameCallback=this.onXRFrame.bind(this);const h=e.xr.getSession();if(s&&"XRWebGLBinding"in window){const n=new t.WebGLCubeRenderTarget(16);i.environment=n.texture;const s=e.getContext();switch(h.preferredReflectionFormat){case"srgba8":s.getExtension("EXT_sRGB");break;case"rgba16f":s.getExtension("OES_texture_half_float")}this.xrWebGLBinding=new XRWebGLBinding(h,s),this.lightProbe.addEventListener("reflectionchange",(()=>{this.updateReflection()}))}h.requestAnimationFrame(this.frameCallback)}updateReflection(){const t=this.renderer.properties.get(this.xrLight.environment);if(t){const i=this.xrWebGLBinding.getReflectionCubeMap(this.lightProbe);i&&(t.__webglTexture=i,this.xrLight.environment.needsPMREMUpdate=!0)}}onXRFrame(t,i){if(!this.xrLight)return;i.session.requestAnimationFrame(this.frameCallback);const e=i.getLightEstimate(this.lightProbe);if(e){this.xrLight.lightProbe.sh.fromArray(e.sphericalHarmonicsCoefficients),this.xrLight.lightProbe.intensity=1;const t=Math.max(1,Math.max(e.primaryLightIntensity.x,Math.max(e.primaryLightIntensity.y,e.primaryLightIntensity.z)));this.xrLight.directionalLight.color.setRGB(e.primaryLightIntensity.x/t,e.primaryLightIntensity.y/t,e.primaryLightIntensity.z/t),this.xrLight.directionalLight.intensity=t,this.xrLight.directionalLight.position.copy(e.primaryLightDirection),this.estimationStartCallback&&(this.estimationStartCallback(),this.estimationStartCallback=null)}}dispose(){this.xrLight=null,this.renderer=null,this.lightProbe=null,this.xrWebGLBinding=null}}class e extends t.Group{constructor(e,n=!0){super(),this.lightProbe=new t.LightProbe,this.lightProbe.intensity=0,this.add(this.lightProbe),this.directionalLight=new t.DirectionalLight,this.directionalLight.intensity=0,this.add(this.directionalLight),this.environment=null;let s=null,r=!1;e.xr.addEventListener("sessionstart",(()=>{const t=e.xr.getSession();"requestLightProbe"in t&&t.requestLightProbe({reflectionFormat:t.preferredReflectionFormat}).then((t=>{s=new i(this,e,t,n,(()=>{r=!0,this.dispatchEvent({type:"estimationstart"})}))}))})),e.xr.addEventListener("sessionend",(()=>{s&&(s.dispose(),s=null),r&&this.dispatchEvent({type:"estimationend"})})),this.dispose=()=>{s&&(s.dispose(),s=null),this.remove(this.lightProbe),this.lightProbe=null,this.remove(this.directionalLight),this.directionalLight=null,this.environment=null}}}exports.XREstimatedLight=e;

package/webxr/XREstimatedLight.js

@@ -1,6 +1,5 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
+import { Group, LightProbe, DirectionalLight, WebGLCubeRenderTarget } from 'three';
+
 class SessionLightProbe {
   constructor(xrLight, renderer, lightProbe, environmentEstimation, estimationStartCallback) {
     this.xrLight = xrLight;
@@ -9,112 +8,138 @@ class SessionLightProbe {
     this.xrWebGLBinding = null;
     this.estimationStartCallback = estimationStartCallback;
     this.frameCallback = this.onXRFrame.bind(this);
-    const session = renderer.xr.getSession();
-    if (environmentEstimation && "XRWebGLBinding" in window) {
-      const cubeRenderTarget = new THREE.WebGLCubeRenderTarget(16);
+    const session = renderer.xr.getSession(); // If the XRWebGLBinding class is available then we can also query an
+    // estimated reflection cube map.
+
+    if (environmentEstimation && 'XRWebGLBinding' in window) {
+      // This is the simplest way I know of to initialize a WebGL cubemap in Three.
+      const cubeRenderTarget = new WebGLCubeRenderTarget(16);
       xrLight.environment = cubeRenderTarget.texture;
-      const gl = renderer.getContext();
+      const gl = renderer.getContext(); // Ensure that we have any extensions needed to use the preferred cube map format.
+
       switch (session.preferredReflectionFormat) {
-        case "srgba8":
-          gl.getExtension("EXT_sRGB");
+        case 'srgba8':
+          gl.getExtension('EXT_sRGB');
           break;
-        case "rgba16f":
-          gl.getExtension("OES_texture_half_float");
+
+        case 'rgba16f':
+          gl.getExtension('OES_texture_half_float');
           break;
       }
+
       this.xrWebGLBinding = new XRWebGLBinding(session, gl);
-      this.lightProbe.addEventListener("reflectionchange", () => {
+      this.lightProbe.addEventListener('reflectionchange', () => {
         this.updateReflection();
       });
-    }
+    } // Start monitoring the XR animation frame loop to look for lighting
+    // estimation changes.
+
+
     session.requestAnimationFrame(this.frameCallback);
   }
+
   updateReflection() {
     const textureProperties = this.renderer.properties.get(this.xrLight.environment);
+
     if (textureProperties) {
       const cubeMap = this.xrWebGLBinding.getReflectionCubeMap(this.lightProbe);
+
       if (cubeMap) {
         textureProperties.__webglTexture = cubeMap;
         this.xrLight.environment.needsPMREMUpdate = true;
       }
     }
   }
+
   onXRFrame(time, xrFrame) {
+    // If either this obejct or the XREstimatedLight has been destroyed, stop
+    // running the frame loop.
     if (!this.xrLight) {
       return;
     }
+
     const session = xrFrame.session;
     session.requestAnimationFrame(this.frameCallback);
     const lightEstimate = xrFrame.getLightEstimate(this.lightProbe);
+
     if (lightEstimate) {
+      // We can copy the estimate's spherical harmonics array directly into the light probe.
       this.xrLight.lightProbe.sh.fromArray(lightEstimate.sphericalHarmonicsCoefficients);
-      this.xrLight.lightProbe.intensity = 1;
-      const intensityScalar = Math.max(
-        1,
-        Math.max(
-          lightEstimate.primaryLightIntensity.x,
-          Math.max(lightEstimate.primaryLightIntensity.y, lightEstimate.primaryLightIntensity.z)
-        )
-      );
-      this.xrLight.directionalLight.color.setRGB(
-        lightEstimate.primaryLightIntensity.x / intensityScalar,
-        lightEstimate.primaryLightIntensity.y / intensityScalar,
-        lightEstimate.primaryLightIntensity.z / intensityScalar
-      );
+      this.xrLight.lightProbe.intensity = 1.0; // For the directional light we have to normalize the color and set the scalar as the
+      // intensity, since WebXR can return color values that exceed 1.0.
+
+      const intensityScalar = Math.max(1.0, Math.max(lightEstimate.primaryLightIntensity.x, Math.max(lightEstimate.primaryLightIntensity.y, lightEstimate.primaryLightIntensity.z)));
+      this.xrLight.directionalLight.color.setRGB(lightEstimate.primaryLightIntensity.x / intensityScalar, lightEstimate.primaryLightIntensity.y / intensityScalar, lightEstimate.primaryLightIntensity.z / intensityScalar);
       this.xrLight.directionalLight.intensity = intensityScalar;
       this.xrLight.directionalLight.position.copy(lightEstimate.primaryLightDirection);
+
       if (this.estimationStartCallback) {
         this.estimationStartCallback();
         this.estimationStartCallback = null;
       }
     }
   }
+
   dispose() {
     this.xrLight = null;
     this.renderer = null;
     this.lightProbe = null;
     this.xrWebGLBinding = null;
   }
+
 }
-class XREstimatedLight extends THREE.Group {
+
+class XREstimatedLight extends Group {
   constructor(renderer, environmentEstimation = true) {
     super();
-    this.lightProbe = new THREE.LightProbe();
+    this.lightProbe = new LightProbe();
     this.lightProbe.intensity = 0;
     this.add(this.lightProbe);
-    this.directionalLight = new THREE.DirectionalLight();
+    this.directionalLight = new DirectionalLight();
     this.directionalLight.intensity = 0;
-    this.add(this.directionalLight);
+    this.add(this.directionalLight); // Will be set to a cube map in the SessionLightProbe is environment estimation is
+    // available and requested.
+
     this.environment = null;
     let sessionLightProbe = null;
     let estimationStarted = false;
-    renderer.xr.addEventListener("sessionstart", () => {
+    renderer.xr.addEventListener('sessionstart', () => {
       const session = renderer.xr.getSession();
-      if ("requestLightProbe" in session) {
+
+      if ('requestLightProbe' in session) {
         session.requestLightProbe({
           reflectionFormat: session.preferredReflectionFormat
-        }).then((probe) => {
+        }).then(probe => {
           sessionLightProbe = new SessionLightProbe(this, renderer, probe, environmentEstimation, () => {
-            estimationStarted = true;
-            this.dispatchEvent({ type: "estimationstart" });
+            estimationStarted = true; // Fired to indicate that the estimated lighting values are now being updated.
+
+            this.dispatchEvent({
+              type: 'estimationstart'
+            });
           });
         });
       }
     });
-    renderer.xr.addEventListener("sessionend", () => {
+    renderer.xr.addEventListener('sessionend', () => {
       if (sessionLightProbe) {
         sessionLightProbe.dispose();
         sessionLightProbe = null;
       }
+
       if (estimationStarted) {
-        this.dispatchEvent({ type: "estimationend" });
+        // Fired to indicate that the estimated lighting values are no longer being updated.
+        this.dispatchEvent({
+          type: 'estimationend'
+        });
       }
-    });
+    }); // Done inline to provide access to sessionLightProbe.
+
     this.dispose = () => {
       if (sessionLightProbe) {
         sessionLightProbe.dispose();
         sessionLightProbe = null;
       }
+
       this.remove(this.lightProbe);
       this.lightProbe = null;
       this.remove(this.directionalLight);
@@ -122,5 +147,7 @@ class XREstimatedLight extends THREE.Group {
       this.environment = null;
     };
   }
+
 }
-exports.XREstimatedLight = XREstimatedLight;
+
+export { XREstimatedLight };

package/webxr/XRHandMeshModel.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/defineProperty"),i=require("../loaders/GLTFLoader.cjs.js");function n(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}require("three");var t=n(e);exports.XRHandMeshModel=class{constructor(e,n,a="https://cdn.jsdelivr.net/npm/@webxr-input-profiles/assets@1.0/dist/profiles/generic-hand/",r,l){t.default(this,"controller",void 0),t.default(this,"handModel",void 0),t.default(this,"bones",void 0),this.controller=n,this.handModel=e,this.bones=[];const o=new i.GLTFLoader;l||o.setPath(a),o.load(null!=l?l:`${r}.glb`,(e=>{const i=e.scene.children[0];this.handModel.add(i);const n=i.getObjectByProperty("type","SkinnedMesh");n.frustumCulled=!1,n.castShadow=!0,n.receiveShadow=!0;["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"].forEach((e=>{const n=i.getObjectByName(e);void 0!==n?n.jointName=e:console.warn(`Couldn't find ${e} in ${r} hand mesh`),this.bones.push(n)}))}))}updateMesh(){const e=this.controller.joints;for(let i=0;i<this.bones.length;i++){const n=this.bones[i];if(n){const i=e[n.jointName];if(i.visible){const e=i.position;n.position.copy(e),n.quaternion.copy(i.quaternion)}}}}};

package/webxr/XRHandMeshModel.js

@@ -1,73 +1,62 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const GLTFLoader = require("../loaders/GLTFLoader.js");
-const DEFAULT_HAND_PROFILE_PATH = "https://cdn.jsdelivr.net/npm/@webxr-input-profiles/assets@1.0/dist/profiles/generic-hand/";
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import { GLTFLoader } from '../loaders/GLTFLoader.js';
+
+const DEFAULT_HAND_PROFILE_PATH = 'https://cdn.jsdelivr.net/npm/@webxr-input-profiles/assets@1.0/dist/profiles/generic-hand/';
+
 class XRHandMeshModel {
   constructor(handModel, controller, path = DEFAULT_HAND_PROFILE_PATH, handedness, customModelPath) {
+    _defineProperty(this, "controller", void 0);
+
+    _defineProperty(this, "handModel", void 0);
+
+    _defineProperty(this, "bones", void 0);
+
     this.controller = controller;
     this.handModel = handModel;
     this.bones = [];
-    const loader = new GLTFLoader.GLTFLoader();
-    if (!customModelPath)
-      loader.setPath(path);
-    loader.load(customModelPath != null ? customModelPath : `${handedness}.glb`, (gltf) => {
+    const loader = new GLTFLoader();
+    if (!customModelPath) loader.setPath(path);
+    loader.load(customModelPath != null ? customModelPath : `${handedness}.glb`, gltf => {
       const object = gltf.scene.children[0];
       this.handModel.add(object);
-      const mesh = object.getObjectByProperty("type", "SkinnedMesh");
+      const mesh = object.getObjectByProperty('type', 'SkinnedMesh');
       mesh.frustumCulled = false;
       mesh.castShadow = true;
       mesh.receiveShadow = true;
-      const 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"
-      ];
-      joints.forEach((jointName) => {
+      const 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'];
+      joints.forEach(jointName => {
         const bone = object.getObjectByName(jointName);
-        if (bone !== void 0) {
+
+        if (bone !== undefined) {
           bone.jointName = jointName;
         } else {
           console.warn(`Couldn't find ${jointName} in ${handedness} hand mesh`);
         }
+
         this.bones.push(bone);
       });
     });
   }
+
   updateMesh() {
+    // XR Joints
     const XRJoints = this.controller.joints;
+
     for (let i = 0; i < this.bones.length; i++) {
       const bone = this.bones[i];
+
       if (bone) {
         const XRJoint = XRJoints[bone.jointName];
+
         if (XRJoint.visible) {
           const position = XRJoint.position;
           bone.position.copy(position);
-          bone.quaternion.copy(XRJoint.quaternion);
+          bone.quaternion.copy(XRJoint.quaternion); // bone.scale.setScalar( XRJoint.jointRadius || defaultRadius );
         }
       }
     }
   }
+
 }
-exports.XRHandMeshModel = XRHandMeshModel;
+
+export { XRHandMeshModel };

package/webxr/XRHandModelFactory.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three"),t=require("./XRHandPrimitiveModel.cjs.js"),r=require("./XRHandMeshModel.cjs.js");require("@babel/runtime/helpers/defineProperty"),require("../loaders/GLTFLoader.cjs.js");class o extends e.Object3D{constructor(e){super(),this.controller=e,this.motionController=null,this.envMap=null,this.mesh=null}updateMatrixWorld(e){super.updateMatrixWorld(e),this.motionController&&this.motionController.updateMesh()}}exports.XRHandModelFactory=class{constructor(){this.path=null}setPath(e){return this.path=e,this}createHandModel(e,n){const s=new o(e);return e.addEventListener("connected",(o=>{const i=o.data;i.hand&&!s.motionController&&(s.xrInputSource=i,void 0===n||"spheres"===n?s.motionController=new t.XRHandPrimitiveModel(s,e,this.path,i.handedness,{primitive:"sphere"}):"boxes"===n?s.motionController=new t.XRHandPrimitiveModel(s,e,this.path,i.handedness,{primitive:"box"}):"mesh"===n&&(s.motionController=new r.XRHandMeshModel(s,e,this.path,i.handedness)))})),e.addEventListener("disconnected",(()=>{})),s}};