three-stdlib 2.15.1 → 2.15.2

package/webxr/XRControllerModelFactory.mjs

@@ -0,0 +1,146 @@
+import { Object3D, SphereGeometry, MeshBasicMaterial, Mesh } from "three";
+import { GLTFLoader } from "../loaders/GLTFLoader.mjs";
+import { MotionControllerConstants, fetchProfile, MotionController } from "../libs/MotionControllers.mjs";
+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) => {
+      if (child.isMesh) {
+        child.material.envMap = this.envMap;
+        child.material.needsUpdate = true;
+      }
+    });
+    return this;
+  }
+  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 === MotionControllerConstants.VisualResponseProperty.VISIBILITY) {
+          valueNode.visible = value;
+        } else if (valueNodeProperty === MotionControllerConstants.VisualResponseProperty.TRANSFORM) {
+          valueNode.quaternion.slerpQuaternions(minNode.quaternion, maxNode.quaternion, value);
+          valueNode.position.lerpVectors(minNode.position, maxNode.position, value);
+        }
+      });
+    });
+  }
+}
+function findNodes(motionController, scene) {
+  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 SphereGeometry(1e-3);
+        const material = new MeshBasicMaterial({ color: 255 });
+        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 === MotionControllerConstants.VisualResponseProperty.TRANSFORM) {
+        visualResponse.minNode = scene.getObjectByName(minNodeName);
+        visualResponse.maxNode = scene.getObjectByName(maxNodeName);
+        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;
+        }
+      }
+      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);
+  if (controllerModel.envMap) {
+    scene.traverse((child) => {
+      if (child.isMesh) {
+        child.material.envMap = controllerModel.envMap;
+        child.material.needsUpdate = true;
+      }
+    });
+  }
+  controllerModel.add(scene);
+}
+class XRControllerModelFactory {
+  constructor(gltfLoader = null) {
+    this.gltfLoader = gltfLoader;
+    this.path = DEFAULT_PROFILES_PATH;
+    this._assetCache = {};
+    if (!this.gltfLoader) {
+      this.gltfLoader = new GLTFLoader();
+    }
+  }
+  createControllerModel(controller) {
+    const controllerModel = new XRControllerModel();
+    let scene = null;
+    controller.addEventListener("connected", (event) => {
+      const xrInputSource = event.data;
+      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.");
+          }
+          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) => {
+        console.warn(err);
+      });
+    });
+    controller.addEventListener("disconnected", () => {
+      controllerModel.motionController = null;
+      controllerModel.remove(scene);
+      scene = null;
+    });
+    return controllerModel;
+  }
+}
+export {
+  XRControllerModelFactory
+};

package/webxr/XREstimatedLight.js

@@ -1,5 +1,6 @@
-import { Group, LightProbe, DirectionalLight, WebGLCubeRenderTarget } from 'three';
-
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
 class SessionLightProbe {
   constructor(xrLight, renderer, lightProbe, environmentEstimation, estimationStartCallback) {
     this.xrLight = xrLight;
@@ -8,138 +9,112 @@ class SessionLightProbe {
     this.xrWebGLBinding = null;
     this.estimationStartCallback = estimationStartCallback;
     this.frameCallback = this.onXRFrame.bind(this);
-    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);
+    const session = renderer.xr.getSession();
+    if (environmentEstimation && "XRWebGLBinding" in window) {
+      const cubeRenderTarget = new THREE.WebGLCubeRenderTarget(16);
       xrLight.environment = cubeRenderTarget.texture;
-      const gl = renderer.getContext(); // Ensure that we have any extensions needed to use the preferred cube map format.
-
+      const gl = renderer.getContext();
       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.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.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.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 Group {
+class XREstimatedLight extends THREE.Group {
   constructor(renderer, environmentEstimation = true) {
     super();
-    this.lightProbe = new LightProbe();
+    this.lightProbe = new THREE.LightProbe();
     this.lightProbe.intensity = 0;
     this.add(this.lightProbe);
-    this.directionalLight = new DirectionalLight();
+    this.directionalLight = new THREE.DirectionalLight();
     this.directionalLight.intensity = 0;
-    this.add(this.directionalLight); // Will be set to a cube map in the SessionLightProbe is environment estimation is
-    // available and requested.
-
+    this.add(this.directionalLight);
     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; // Fired to indicate that the estimated lighting values are now being updated.
-
-            this.dispatchEvent({
-              type: 'estimationstart'
-            });
+            estimationStarted = true;
+            this.dispatchEvent({ type: "estimationstart" });
           });
         });
       }
     });
-    renderer.xr.addEventListener('sessionend', () => {
+    renderer.xr.addEventListener("sessionend", () => {
       if (sessionLightProbe) {
         sessionLightProbe.dispose();
         sessionLightProbe = null;
       }
-
       if (estimationStarted) {
-        // Fired to indicate that the estimated lighting values are no longer being updated.
-        this.dispatchEvent({
-          type: 'estimationend'
-        });
+        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);
@@ -147,7 +122,5 @@ class XREstimatedLight extends Group {
       this.environment = null;
     };
   }
-
 }
-
-export { XREstimatedLight };
+exports.XREstimatedLight = XREstimatedLight;

package/webxr/XREstimatedLight.mjs

@@ -0,0 +1,126 @@
+import { WebGLCubeRenderTarget, Group, LightProbe, DirectionalLight } from "three";
+class SessionLightProbe {
+  constructor(xrLight, renderer, lightProbe, environmentEstimation, estimationStartCallback) {
+    this.xrLight = xrLight;
+    this.renderer = renderer;
+    this.lightProbe = lightProbe;
+    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 WebGLCubeRenderTarget(16);
+      xrLight.environment = cubeRenderTarget.texture;
+      const gl = renderer.getContext();
+      switch (session.preferredReflectionFormat) {
+        case "srgba8":
+          gl.getExtension("EXT_sRGB");
+          break;
+        case "rgba16f":
+          gl.getExtension("OES_texture_half_float");
+          break;
+      }
+      this.xrWebGLBinding = new XRWebGLBinding(session, gl);
+      this.lightProbe.addEventListener("reflectionchange", () => {
+        this.updateReflection();
+      });
+    }
+    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 (!this.xrLight) {
+      return;
+    }
+    const session = xrFrame.session;
+    session.requestAnimationFrame(this.frameCallback);
+    const lightEstimate = xrFrame.getLightEstimate(this.lightProbe);
+    if (lightEstimate) {
+      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.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 Group {
+  constructor(renderer, environmentEstimation = true) {
+    super();
+    this.lightProbe = new LightProbe();
+    this.lightProbe.intensity = 0;
+    this.add(this.lightProbe);
+    this.directionalLight = new DirectionalLight();
+    this.directionalLight.intensity = 0;
+    this.add(this.directionalLight);
+    this.environment = null;
+    let sessionLightProbe = null;
+    let estimationStarted = false;
+    renderer.xr.addEventListener("sessionstart", () => {
+      const session = renderer.xr.getSession();
+      if ("requestLightProbe" in session) {
+        session.requestLightProbe({
+          reflectionFormat: session.preferredReflectionFormat
+        }).then((probe) => {
+          sessionLightProbe = new SessionLightProbe(this, renderer, probe, environmentEstimation, () => {
+            estimationStarted = true;
+            this.dispatchEvent({ type: "estimationstart" });
+          });
+        });
+      }
+    });
+    renderer.xr.addEventListener("sessionend", () => {
+      if (sessionLightProbe) {
+        sessionLightProbe.dispose();
+        sessionLightProbe = null;
+      }
+      if (estimationStarted) {
+        this.dispatchEvent({ type: "estimationend" });
+      }
+    });
+    this.dispose = () => {
+      if (sessionLightProbe) {
+        sessionLightProbe.dispose();
+        sessionLightProbe = null;
+      }
+      this.remove(this.lightProbe);
+      this.lightProbe = null;
+      this.remove(this.directionalLight);
+      this.directionalLight = null;
+      this.environment = null;
+    };
+  }
+}
+export {
+  XREstimatedLight
+};

package/webxr/XRHandMeshModel.js

@@ -1,62 +1,73 @@
-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/';
-
+"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/";
 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();
-    if (!customModelPath) loader.setPath(path);
-    loader.load(customModelPath != null ? customModelPath : `${handedness}.glb`, gltf => {
+    const loader = new GLTFLoader.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 !== undefined) {
+        if (bone !== void 0) {
           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.scale.setScalar( XRJoint.jointRadius || defaultRadius );
+          bone.quaternion.copy(XRJoint.quaternion);
         }
       }
     }
   }
-
 }
-
-export { XRHandMeshModel };
+exports.XRHandMeshModel = XRHandMeshModel;

package/webxr/XRHandMeshModel.mjs

@@ -0,0 +1,73 @@
+import { GLTFLoader } from "../loaders/GLTFLoader.mjs";
+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) {
+    this.controller = controller;
+    this.handModel = handModel;
+    this.bones = [];
+    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");
+      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 bone = object.getObjectByName(jointName);
+        if (bone !== void 0) {
+          bone.jointName = jointName;
+        } else {
+          console.warn(`Couldn't find ${jointName} in ${handedness} hand mesh`);
+        }
+        this.bones.push(bone);
+      });
+    });
+  }
+  updateMesh() {
+    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);
+        }
+      }
+    }
+  }
+}
+export {
+  XRHandMeshModel
+};