three-stdlib 2.8.4 → 2.8.5

package/index.d.ts

@@ -233,12 +233,16 @@ export * from './postprocessing/ShaderPass';
 export * from './postprocessing/SSAARenderPass';
 export * from './postprocessing/RenderPass';
 export * from './postprocessing/BloomPass';
-export * from './webxr/XRHandModelFactory';
-export * from './webxr/XREstimatedLight';
-export * from './webxr/XRHandOculusMeshModel';
+export * from './webxr/ARButton';
+export * from './webxr/OculusHandModel';
+export * from './webxr/OculusHandPointerModel';
+export * from './webxr/Text2D';
 export * from './webxr/VRButton';
+export * from './webxr/XRControllerModelFactory';
+export * from './webxr/XREstimatedLight';
+export * from './webxr/XRHandMeshModel';
+export * from './webxr/XRHandModelFactory';
 export * from './webxr/XRHandPrimitiveModel';
-export * from './webxr/ARButton';
 export * from './geometries/ParametricGeometries';
 export * from './geometries/ConvexGeometry';
 export * from './geometries/LightningStrike';
@@ -384,3 +388,4 @@ export * from './curves/NURBSSurface';
 export * from './curves/CurveExtras';
 export * from './deprecated/Geometry';
 export * from './libs/MeshoptDecoder';
+export * from './libs/MotionControllers';

package/index.js

@@ -178,12 +178,16 @@ export { ShaderPass } from './postprocessing/ShaderPass.js';
 export { SSAARenderPass } from './postprocessing/SSAARenderPass.js';
 export { RenderPass } from './postprocessing/RenderPass.js';
 export { BloomPass } from './postprocessing/BloomPass.js';
-export { XRHandModelFactory } from './webxr/XRHandModelFactory.js';
-export { XREstimatedLight } from './webxr/XREstimatedLight.js';
-export { XRHandOculusMeshModel } from './webxr/XRHandOculusMeshModel.js';
+export { ARButton } from './webxr/ARButton.js';
+export { OculusHandModel } from './webxr/OculusHandModel.js';
+export { OculusHandPointerModel } from './webxr/OculusHandPointerModel.js';
+export { createText } from './webxr/Text2D.js';
 export { VRButton } from './webxr/VRButton.js';
+export { XRControllerModelFactory } from './webxr/XRControllerModelFactory.js';
+export { XREstimatedLight } from './webxr/XREstimatedLight.js';
+export { XRHandMeshModel } from './webxr/XRHandMeshModel.js';
+export { XRHandModelFactory } from './webxr/XRHandModelFactory.js';
 export { XRHandPrimitiveModel } from './webxr/XRHandPrimitiveModel.js';
-export { ARButton } from './webxr/ARButton.js';
 export { ParametricGeometries } from './geometries/ParametricGeometries.js';
 export { ConvexGeometry } from './geometries/ConvexGeometry.js';
 export { LightningStrike } from './geometries/LightningStrike.js';
@@ -327,3 +331,4 @@ export { NURBSSurface } from './curves/NURBSSurface.js';
 export { CinquefoilKnot, DecoratedTorusKnot4a, DecoratedTorusKnot4b, DecoratedTorusKnot5a, DecoratedTorusKnot5c, FigureEightPolynomialKnot, GrannyKnot, HeartCurve, HelixCurve, KnotCurve, TorusKnot, TrefoilKnot, TrefoilPolynomialKnot, VivianiCurve, scaleTo } from './curves/CurveExtras.js';
 export { Face3, Geometry } from './deprecated/Geometry.js';
 export { MeshoptDecoder } from './libs/MeshoptDecoder.js';
+export { MotionController, MotionControllerConstants, fetchProfile, fetchProfilesList } from './libs/MotionControllers.js';

package/libs/MotionControllers.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const e={Handedness:Object.freeze({NONE:"none",LEFT:"left",RIGHT:"right"}),ComponentState:Object.freeze({DEFAULT:"default",TOUCHED:"touched",PRESSED:"pressed"}),ComponentProperty:Object.freeze({BUTTON:"button",X_AXIS:"xAxis",Y_AXIS:"yAxis",STATE:"state"}),ComponentType:Object.freeze({TRIGGER:"trigger",SQUEEZE:"squeeze",TOUCHPAD:"touchpad",THUMBSTICK:"thumbstick",BUTTON:"button"}),ButtonTouchThreshold:.05,AxisTouchThreshold:.1,VisualResponseProperty:Object.freeze({TRANSFORM:"transform",VISIBILITY:"visibility"})};async function t(e){const t=await fetch(e);if(t.ok)return t.json();throw new Error(t.statusText)}async function s(e){if(!e)throw new Error("No basePath supplied");return await t(`${e}/profilesList.json`)}const o={xAxis:0,yAxis:0,button:0,state:e.ComponentState.DEFAULT};class a{constructor(t){this.componentProperty=t.componentProperty,this.states=t.states,this.valueNodeName=t.valueNodeName,this.valueNodeProperty=t.valueNodeProperty,this.valueNodeProperty===e.VisualResponseProperty.TRANSFORM&&(this.minNodeName=t.minNodeName,this.maxNodeName=t.maxNodeName),this.value=0,this.updateFromComponent(o)}updateFromComponent({xAxis:t,yAxis:s,button:o,state:a}){const{normalizedXAxis:i,normalizedYAxis:n}=function(e=0,t=0){let s=e,o=t;if(Math.sqrt(e*e+t*t)>1){const a=Math.atan2(t,e);s=Math.cos(a),o=Math.sin(a)}return{normalizedXAxis:.5*s+.5,normalizedYAxis:.5*o+.5}}(t,s);switch(this.componentProperty){case e.ComponentProperty.X_AXIS:this.value=this.states.includes(a)?i:.5;break;case e.ComponentProperty.Y_AXIS:this.value=this.states.includes(a)?n:.5;break;case e.ComponentProperty.BUTTON:this.value=this.states.includes(a)?o:0;break;case e.ComponentProperty.STATE:this.valueNodeProperty===e.VisualResponseProperty.VISIBILITY?this.value=this.states.includes(a):this.value=this.states.includes(a)?1:0;break;default:throw new Error(`Unexpected visualResponse componentProperty ${this.componentProperty}`)}}}class i{constructor(t,s){if(!(t&&s&&s.visualResponses&&s.gamepadIndices&&0!==Object.keys(s.gamepadIndices).length))throw new Error("Invalid arguments supplied");this.id=t,this.type=s.type,this.rootNodeName=s.rootNodeName,this.touchPointNodeName=s.touchPointNodeName,this.visualResponses={},Object.keys(s.visualResponses).forEach((e=>{const t=new a(s.visualResponses[e]);this.visualResponses[e]=t})),this.gamepadIndices=Object.assign({},s.gamepadIndices),this.values={state:e.ComponentState.DEFAULT,button:void 0!==this.gamepadIndices.button?0:void 0,xAxis:void 0!==this.gamepadIndices.xAxis?0:void 0,yAxis:void 0!==this.gamepadIndices.yAxis?0:void 0}}get data(){return{id:this.id,...this.values}}updateFromGamepad(t){if(this.values.state=e.ComponentState.DEFAULT,void 0!==this.gamepadIndices.button&&t.buttons.length>this.gamepadIndices.button){const s=t.buttons[this.gamepadIndices.button];this.values.button=s.value,this.values.button=this.values.button<0?0:this.values.button,this.values.button=this.values.button>1?1:this.values.button,s.pressed||1===this.values.button?this.values.state=e.ComponentState.PRESSED:(s.touched||this.values.button>e.ButtonTouchThreshold)&&(this.values.state=e.ComponentState.TOUCHED)}void 0!==this.gamepadIndices.xAxis&&t.axes.length>this.gamepadIndices.xAxis&&(this.values.xAxis=t.axes[this.gamepadIndices.xAxis],this.values.xAxis=this.values.xAxis<-1?-1:this.values.xAxis,this.values.xAxis=this.values.xAxis>1?1:this.values.xAxis,this.values.state===e.ComponentState.DEFAULT&&Math.abs(this.values.xAxis)>e.AxisTouchThreshold&&(this.values.state=e.ComponentState.TOUCHED)),void 0!==this.gamepadIndices.yAxis&&t.axes.length>this.gamepadIndices.yAxis&&(this.values.yAxis=t.axes[this.gamepadIndices.yAxis],this.values.yAxis=this.values.yAxis<-1?-1:this.values.yAxis,this.values.yAxis=this.values.yAxis>1?1:this.values.yAxis,this.values.state===e.ComponentState.DEFAULT&&Math.abs(this.values.yAxis)>e.AxisTouchThreshold&&(this.values.state=e.ComponentState.TOUCHED)),Object.values(this.visualResponses).forEach((e=>{e.updateFromComponent(this.values)}))}}exports.MotionController=class{constructor(e,t,s){if(!e)throw new Error("No xrInputSource supplied");if(!t)throw new Error("No profile supplied");this.xrInputSource=e,this.assetUrl=s,this.id=t.profileId,this.layoutDescription=t.layouts[e.handedness],this.components={},Object.keys(this.layoutDescription.components).forEach((e=>{const t=this.layoutDescription.components[e];this.components[e]=new i(e,t)})),this.updateFromGamepad()}get gripSpace(){return this.xrInputSource.gripSpace}get targetRaySpace(){return this.xrInputSource.targetRaySpace}get data(){const e=[];return Object.values(this.components).forEach((t=>{e.push(t.data)})),e}updateFromGamepad(){Object.values(this.components).forEach((e=>{e.updateFromGamepad(this.xrInputSource.gamepad)}))}},exports.MotionControllerConstants=e,exports.fetchProfile=async function(e,o,a=null,i=!0){if(!e)throw new Error("No xrInputSource supplied");if(!o)throw new Error("No basePath supplied");const n=await s(o);let r;if(e.profiles.some((e=>{const t=n[e];return t&&(r={profileId:e,profilePath:`${o}/${t.path}`,deprecated:!!t.deprecated}),!!r})),!r){if(!a)throw new Error("No matching profile name found");const e=n[a];if(!e)throw new Error(`No matching profile name found and default profile "${a}" missing.`);r={profileId:a,profilePath:`${o}/${e.path}`,deprecated:!!e.deprecated}}const h=await t(r.profilePath);let u;if(i){let t;if(t="any"===e.handedness?h.layouts[Object.keys(h.layouts)[0]]:h.layouts[e.handedness],!t)throw new Error(`No matching handedness, ${e.handedness}, in profile ${r.profileId}`);t.assetPath&&(u=r.profilePath.replace("profile.json",t.assetPath))}return{profile:h,assetPath:u}},exports.fetchProfilesList=s;

package/libs/MotionControllers.js

@@ -0,0 +1,403 @@
+/**
+ * @webxr-input-profiles/motion-controllers 1.0.0 https://github.com/immersive-web/webxr-input-profiles
+ */
+const MotionControllerConstants = {
+  Handedness: Object.freeze({
+    NONE: 'none',
+    LEFT: 'left',
+    RIGHT: 'right'
+  }),
+  ComponentState: Object.freeze({
+    DEFAULT: 'default',
+    TOUCHED: 'touched',
+    PRESSED: 'pressed'
+  }),
+  ComponentProperty: Object.freeze({
+    BUTTON: 'button',
+    X_AXIS: 'xAxis',
+    Y_AXIS: 'yAxis',
+    STATE: 'state'
+  }),
+  ComponentType: Object.freeze({
+    TRIGGER: 'trigger',
+    SQUEEZE: 'squeeze',
+    TOUCHPAD: 'touchpad',
+    THUMBSTICK: 'thumbstick',
+    BUTTON: 'button'
+  }),
+  ButtonTouchThreshold: 0.05,
+  AxisTouchThreshold: 0.1,
+  VisualResponseProperty: Object.freeze({
+    TRANSFORM: 'transform',
+    VISIBILITY: 'visibility'
+  })
+};
+/**
+ * @description Static helper function to fetch a JSON file and turn it into a JS object
+ * @param {string} path - Path to JSON file to be fetched
+ */
+
+async function fetchJsonFile(path) {
+  const response = await fetch(path);
+
+  if (!response.ok) {
+    throw new Error(response.statusText);
+  } else {
+    return response.json();
+  }
+}
+
+async function fetchProfilesList(basePath) {
+  if (!basePath) {
+    throw new Error('No basePath supplied');
+  }
+
+  const profileListFileName = 'profilesList.json';
+  const profilesList = await fetchJsonFile(`${basePath}/${profileListFileName}`);
+  return profilesList;
+}
+
+async function fetchProfile(xrInputSource, basePath, defaultProfile = null, getAssetPath = true) {
+  if (!xrInputSource) {
+    throw new Error('No xrInputSource supplied');
+  }
+
+  if (!basePath) {
+    throw new Error('No basePath supplied');
+  } // Get the list of profiles
+
+
+  const supportedProfilesList = await fetchProfilesList(basePath); // Find the relative path to the first requested profile that is recognized
+
+  let match;
+  xrInputSource.profiles.some(profileId => {
+    const supportedProfile = supportedProfilesList[profileId];
+
+    if (supportedProfile) {
+      match = {
+        profileId,
+        profilePath: `${basePath}/${supportedProfile.path}`,
+        deprecated: !!supportedProfile.deprecated
+      };
+    }
+
+    return !!match;
+  });
+
+  if (!match) {
+    if (!defaultProfile) {
+      throw new Error('No matching profile name found');
+    }
+
+    const supportedProfile = supportedProfilesList[defaultProfile];
+
+    if (!supportedProfile) {
+      throw new Error(`No matching profile name found and default profile "${defaultProfile}" missing.`);
+    }
+
+    match = {
+      profileId: defaultProfile,
+      profilePath: `${basePath}/${supportedProfile.path}`,
+      deprecated: !!supportedProfile.deprecated
+    };
+  }
+
+  const profile = await fetchJsonFile(match.profilePath);
+  let assetPath;
+
+  if (getAssetPath) {
+    let layout;
+
+    if (xrInputSource.handedness === 'any') {
+      layout = profile.layouts[Object.keys(profile.layouts)[0]];
+    } else {
+      layout = profile.layouts[xrInputSource.handedness];
+    }
+
+    if (!layout) {
+      throw new Error(`No matching handedness, ${xrInputSource.handedness}, in profile ${match.profileId}`);
+    }
+
+    if (layout.assetPath) {
+      assetPath = match.profilePath.replace('profile.json', layout.assetPath);
+    }
+  }
+
+  return {
+    profile,
+    assetPath
+  };
+}
+/** @constant {Object} */
+
+
+const defaultComponentValues = {
+  xAxis: 0,
+  yAxis: 0,
+  button: 0,
+  state: MotionControllerConstants.ComponentState.DEFAULT
+};
+/**
+ * @description Converts an X, Y coordinate from the range -1 to 1 (as reported by the Gamepad
+ * API) to the range 0 to 1 (for interpolation). Also caps the X, Y values to be bounded within
+ * a circle. This ensures that thumbsticks are not animated outside the bounds of their physical
+ * range of motion and touchpads do not report touch locations off their physical bounds.
+ * @param {number} x The original x coordinate in the range -1 to 1
+ * @param {number} y The original y coordinate in the range -1 to 1
+ */
+
+function normalizeAxes(x = 0, y = 0) {
+  let xAxis = x;
+  let yAxis = y; // Determine if the point is outside the bounds of the circle
+  // and, if so, place it on the edge of the circle
+
+  const hypotenuse = Math.sqrt(x * x + y * y);
+
+  if (hypotenuse > 1) {
+    const theta = Math.atan2(y, x);
+    xAxis = Math.cos(theta);
+    yAxis = Math.sin(theta);
+  } // Scale and move the circle so values are in the interpolation range.  The circle's origin moves
+  // from (0, 0) to (0.5, 0.5). The circle's radius scales from 1 to be 0.5.
+
+
+  const result = {
+    normalizedXAxis: xAxis * 0.5 + 0.5,
+    normalizedYAxis: yAxis * 0.5 + 0.5
+  };
+  return result;
+}
+/**
+ * Contains the description of how the 3D model should visually respond to a specific user input.
+ * This is accomplished by initializing the object with the name of a node in the 3D model and
+ * property that need to be modified in response to user input, the name of the nodes representing
+ * the allowable range of motion, and the name of the input which triggers the change. In response
+ * to the named input changing, this object computes the appropriate weighting to use for
+ * interpolating between the range of motion nodes.
+ */
+
+
+class VisualResponse {
+  constructor(visualResponseDescription) {
+    this.componentProperty = visualResponseDescription.componentProperty;
+    this.states = visualResponseDescription.states;
+    this.valueNodeName = visualResponseDescription.valueNodeName;
+    this.valueNodeProperty = visualResponseDescription.valueNodeProperty;
+
+    if (this.valueNodeProperty === MotionControllerConstants.VisualResponseProperty.TRANSFORM) {
+      this.minNodeName = visualResponseDescription.minNodeName;
+      this.maxNodeName = visualResponseDescription.maxNodeName;
+    } // Initializes the response's current value based on default data
+
+
+    this.value = 0;
+    this.updateFromComponent(defaultComponentValues);
+  }
+  /**
+   * Computes the visual response's interpolation weight based on component state
+   * @param {Object} componentValues - The component from which to update
+   * @param {number} xAxis - The reported X axis value of the component
+   * @param {number} yAxis - The reported Y axis value of the component
+   * @param {number} button - The reported value of the component's button
+   * @param {string} state - The component's active state
+   */
+
+
+  updateFromComponent({
+    xAxis,
+    yAxis,
+    button,
+    state
+  }) {
+    const {
+      normalizedXAxis,
+      normalizedYAxis
+    } = normalizeAxes(xAxis, yAxis);
+
+    switch (this.componentProperty) {
+      case MotionControllerConstants.ComponentProperty.X_AXIS:
+        this.value = this.states.includes(state) ? normalizedXAxis : 0.5;
+        break;
+
+      case MotionControllerConstants.ComponentProperty.Y_AXIS:
+        this.value = this.states.includes(state) ? normalizedYAxis : 0.5;
+        break;
+
+      case MotionControllerConstants.ComponentProperty.BUTTON:
+        this.value = this.states.includes(state) ? button : 0;
+        break;
+
+      case MotionControllerConstants.ComponentProperty.STATE:
+        if (this.valueNodeProperty === MotionControllerConstants.VisualResponseProperty.VISIBILITY) {
+          this.value = this.states.includes(state);
+        } else {
+          this.value = this.states.includes(state) ? 1.0 : 0.0;
+        }
+
+        break;
+
+      default:
+        throw new Error(`Unexpected visualResponse componentProperty ${this.componentProperty}`);
+    }
+  }
+
+}
+
+class Component {
+  /**
+   * @param {Object} componentId - Id of the component
+   * @param {Object} componentDescription - Description of the component to be created
+   */
+  constructor(componentId, componentDescription) {
+    if (!componentId || !componentDescription || !componentDescription.visualResponses || !componentDescription.gamepadIndices || Object.keys(componentDescription.gamepadIndices).length === 0) {
+      throw new Error('Invalid arguments supplied');
+    }
+
+    this.id = componentId;
+    this.type = componentDescription.type;
+    this.rootNodeName = componentDescription.rootNodeName;
+    this.touchPointNodeName = componentDescription.touchPointNodeName; // Build all the visual responses for this component
+
+    this.visualResponses = {};
+    Object.keys(componentDescription.visualResponses).forEach(responseName => {
+      const visualResponse = new VisualResponse(componentDescription.visualResponses[responseName]);
+      this.visualResponses[responseName] = visualResponse;
+    }); // Set default values
+
+    this.gamepadIndices = Object.assign({}, componentDescription.gamepadIndices);
+    this.values = {
+      state: MotionControllerConstants.ComponentState.DEFAULT,
+      button: this.gamepadIndices.button !== undefined ? 0 : undefined,
+      xAxis: this.gamepadIndices.xAxis !== undefined ? 0 : undefined,
+      yAxis: this.gamepadIndices.yAxis !== undefined ? 0 : undefined
+    };
+  }
+
+  get data() {
+    const data = {
+      id: this.id,
+      ...this.values
+    };
+    return data;
+  }
+  /**
+   * @description Poll for updated data based on current gamepad state
+   * @param {Object} gamepad - The gamepad object from which the component data should be polled
+   */
+
+
+  updateFromGamepad(gamepad) {
+    // Set the state to default before processing other data sources
+    this.values.state = MotionControllerConstants.ComponentState.DEFAULT; // Get and normalize button
+
+    if (this.gamepadIndices.button !== undefined && gamepad.buttons.length > this.gamepadIndices.button) {
+      const gamepadButton = gamepad.buttons[this.gamepadIndices.button];
+      this.values.button = gamepadButton.value;
+      this.values.button = this.values.button < 0 ? 0 : this.values.button;
+      this.values.button = this.values.button > 1 ? 1 : this.values.button; // Set the state based on the button
+
+      if (gamepadButton.pressed || this.values.button === 1) {
+        this.values.state = MotionControllerConstants.ComponentState.PRESSED;
+      } else if (gamepadButton.touched || this.values.button > MotionControllerConstants.ButtonTouchThreshold) {
+        this.values.state = MotionControllerConstants.ComponentState.TOUCHED;
+      }
+    } // Get and normalize x axis value
+
+
+    if (this.gamepadIndices.xAxis !== undefined && gamepad.axes.length > this.gamepadIndices.xAxis) {
+      this.values.xAxis = gamepad.axes[this.gamepadIndices.xAxis];
+      this.values.xAxis = this.values.xAxis < -1 ? -1 : this.values.xAxis;
+      this.values.xAxis = this.values.xAxis > 1 ? 1 : this.values.xAxis; // If the state is still default, check if the xAxis makes it touched
+
+      if (this.values.state === MotionControllerConstants.ComponentState.DEFAULT && Math.abs(this.values.xAxis) > MotionControllerConstants.AxisTouchThreshold) {
+        this.values.state = MotionControllerConstants.ComponentState.TOUCHED;
+      }
+    } // Get and normalize Y axis value
+
+
+    if (this.gamepadIndices.yAxis !== undefined && gamepad.axes.length > this.gamepadIndices.yAxis) {
+      this.values.yAxis = gamepad.axes[this.gamepadIndices.yAxis];
+      this.values.yAxis = this.values.yAxis < -1 ? -1 : this.values.yAxis;
+      this.values.yAxis = this.values.yAxis > 1 ? 1 : this.values.yAxis; // If the state is still default, check if the yAxis makes it touched
+
+      if (this.values.state === MotionControllerConstants.ComponentState.DEFAULT && Math.abs(this.values.yAxis) > MotionControllerConstants.AxisTouchThreshold) {
+        this.values.state = MotionControllerConstants.ComponentState.TOUCHED;
+      }
+    } // Update the visual response weights based on the current component data
+
+
+    Object.values(this.visualResponses).forEach(visualResponse => {
+      visualResponse.updateFromComponent(this.values);
+    });
+  }
+
+}
+/**
+ * @description Builds a motion controller with components and visual responses based on the
+ * supplied profile description. Data is polled from the xrInputSource's gamepad.
+ * @author Nell Waliczek / https://github.com/NellWaliczek
+ */
+
+
+class MotionController {
+  /**
+   * @param {Object} xrInputSource - The XRInputSource to build the MotionController around
+   * @param {Object} profile - The best matched profile description for the supplied xrInputSource
+   * @param {Object} assetUrl
+   */
+  constructor(xrInputSource, profile, assetUrl) {
+    if (!xrInputSource) {
+      throw new Error('No xrInputSource supplied');
+    }
+
+    if (!profile) {
+      throw new Error('No profile supplied');
+    }
+
+    this.xrInputSource = xrInputSource;
+    this.assetUrl = assetUrl;
+    this.id = profile.profileId; // Build child components as described in the profile description
+
+    this.layoutDescription = profile.layouts[xrInputSource.handedness];
+    this.components = {};
+    Object.keys(this.layoutDescription.components).forEach(componentId => {
+      const componentDescription = this.layoutDescription.components[componentId];
+      this.components[componentId] = new Component(componentId, componentDescription);
+    }); // Initialize components based on current gamepad state
+
+    this.updateFromGamepad();
+  }
+
+  get gripSpace() {
+    return this.xrInputSource.gripSpace;
+  }
+
+  get targetRaySpace() {
+    return this.xrInputSource.targetRaySpace;
+  }
+  /**
+   * @description Returns a subset of component data for simplified debugging
+   */
+
+
+  get data() {
+    const data = [];
+    Object.values(this.components).forEach(component => {
+      data.push(component.data);
+    });
+    return data;
+  }
+  /**
+   * @description Poll for updated data based on current gamepad state
+   */
+
+
+  updateFromGamepad() {
+    Object.values(this.components).forEach(component => {
+      component.updateFromGamepad(this.xrInputSource.gamepad);
+    });
+  }
+
+}
+
+export { MotionController, MotionControllerConstants, fetchProfile, fetchProfilesList };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-stdlib",
-  "version": "2.8.4",
+  "version": "2.8.5",
   "private": false,
   "description": "stand-alone library of threejs examples",
   "main": "index.cjs.js",
@@ -22,7 +22,6 @@
   "dependencies": {
     "@babel/runtime": "^7.16.7",
     "@webgpu/glslang": "^0.0.15",
-    "@webxr-input-profiles/motion-controllers": "^1.0.0",
     "chevrotain": "^9.0.2",
     "draco3d": "^1.4.1",
     "fflate": "^0.6.9",
@@ -33,6 +32,6 @@
     "zstddec": "^0.0.2"
   },
   "peerDependencies": {
-    "three": ">=0.128.0"
+    "three": ">=0.137.0"
   }
 }

package/webxr/OculusHandModel.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three"),t=require("./XRHandMeshModel.cjs.js");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,e.addEventListener("connected",(o=>{const n=o.data;n.hand&&!this.motionController&&(this.xrInputSource=n,this.motionController=new t.XRHandMeshModel(this,e,this.path,n.handedness))})),e.addEventListener("disconnected",(()=>{this.clear(),this.motionController=null}))}updateMatrixWorld(e){super.updateMatrixWorld(e),this.motionController&&this.motionController.updateMesh()}getPointerPosition(){const e=this.controller.joints["index-finger-tip"];return e?e.position:null}intersectBoxObject(t){const o=this.getPointerPosition();if(o){const n=new e.Sphere(o,.01),r=(new e.Box3).setFromObject(t);return n.intersectsBox(r)}return!1}checkButton(e){this.intersectBoxObject(e)?e.onPress():e.onClear(),e.isPressed()&&e.whilePressed()}}exports.OculusHandModel=o;

package/webxr/OculusHandModel.d.ts

@@ -0,0 +1,19 @@
+import { Object3D, Sphere, Box3, Mesh, Texture, Vector3 } from 'three';
+
+export class OculusHandModel extends Object3D {
+    controller: Object3D;
+    motionController: Object3D | null;
+    envMap: Texture | null;
+
+    mesh: Mesh | null;
+
+    constructor(controller: Object3D);
+
+    updateMatrixWorld(force?: boolean): void;
+
+    getPointerPosition(): Vector3 | null;
+
+    intersectBoxObject(boxObject: Object3D): boolean;
+
+    checkButton(button: Object3D): void;
+}

package/webxr/OculusHandModel.js

@@ -0,0 +1,72 @@
+import { Object3D, Sphere, Box3 } from 'three';
+import { XRHandMeshModel } from './XRHandMeshModel.js';
+
+const TOUCH_RADIUS = 0.01;
+const POINTING_JOINT = 'index-finger-tip';
+
+class OculusHandModel extends Object3D {
+  constructor(controller) {
+    super();
+    this.controller = controller;
+    this.motionController = null;
+    this.envMap = null;
+    this.mesh = null;
+    controller.addEventListener('connected', event => {
+      const xrInputSource = event.data;
+
+      if (xrInputSource.hand && !this.motionController) {
+        this.xrInputSource = xrInputSource;
+        this.motionController = new XRHandMeshModel(this, controller, this.path, xrInputSource.handedness);
+      }
+    });
+    controller.addEventListener('disconnected', () => {
+      this.clear();
+      this.motionController = null;
+    });
+  }
+
+  updateMatrixWorld(force) {
+    super.updateMatrixWorld(force);
+
+    if (this.motionController) {
+      this.motionController.updateMesh();
+    }
+  }
+
+  getPointerPosition() {
+    const indexFingerTip = this.controller.joints[POINTING_JOINT];
+
+    if (indexFingerTip) {
+      return indexFingerTip.position;
+    } else {
+      return null;
+    }
+  }
+
+  intersectBoxObject(boxObject) {
+    const pointerPosition = this.getPointerPosition();
+
+    if (pointerPosition) {
+      const indexSphere = new Sphere(pointerPosition, TOUCH_RADIUS);
+      const box = new Box3().setFromObject(boxObject);
+      return indexSphere.intersectsBox(box);
+    } else {
+      return false;
+    }
+  }
+
+  checkButton(button) {
+    if (this.intersectBoxObject(button)) {
+      button.onPress();
+    } else {
+      button.onClear();
+    }
+
+    if (button.isPressed()) {
+      button.whilePressed();
+    }
+  }
+
+}
+
+export { OculusHandModel };

package/webxr/OculusHandPointerModel.cjs.js

@@ -0,0 +1 @@
+"use strict";function t(t){if(t&&t.__esModule)return t;var e=Object.create(null);return t&&Object.keys(t).forEach((function(i){if("default"!==i){var s=Object.getOwnPropertyDescriptor(t,i);Object.defineProperty(e,i,s.get?s:{enumerable:!0,get:function(){return t[i]}})}})),e.default=t,Object.freeze(e)}Object.defineProperty(exports,"__esModule",{value:!0});var e=t(require("three"));const i=new e.Vector3(0,1,0),s=new e.Vector3(0,0,1);class r extends e.Object3D{constructor(t,e){super(),this.hand=t,this.controller=e,this.motionController=null,this.envMap=null,this.mesh=null,this.pointerGeometry=null,this.pointerMesh=null,this.pointerObject=null,this.pinched=!1,this.attached=!1,this.cursorObject=null,this.raycaster=null,t.addEventListener("connected",(t=>{const e=t.data;e.hand&&(this.visible=!0,this.xrInputSource=e,this.createPointer())}))}_drawVerticesRing(t,e,i){const r=e.clone();for(var o=0;o<16;o++){r.applyAxisAngle(s,2*Math.PI/16);const e=16*i+o;t[3*e]=r.x,t[3*e+1]=r.y,t[3*e+2]=r.z}}_updatePointerVertices(t){const s=this.pointerGeometry.attributes.position.array,r=new e.Vector3(.002,0,-1*(.035-t));this._drawVerticesRing(s,r,0);const o=new e.Vector3(Math.sin(110*Math.PI/180)*t,Math.cos(110*Math.PI/180)*t,0);for(var n=0;n<12;n++)this._drawVerticesRing(s,o,n+1),o.applyAxisAngle(i,110*Math.PI/180/-24);const a=new e.Vector3(0,0,-1*(.035-t));s[624]=a.x,s[625]=a.y,s[626]=a.z;const c=new e.Vector3(0,0,t);s[627]=c.x,s[628]=c.y,s[629]=c.z,this.pointerGeometry.setAttribute("position",new e.Float32BufferAttribute(s,3))}createPointer(){var t,i;const s=new Array(630).fill(0),r=[];for(this.pointerGeometry=new e.BufferGeometry,this.pointerGeometry.setAttribute("position",new e.Float32BufferAttribute(s,3)),this._updatePointerVertices(.01),t=0;t<12;t++){for(i=0;i<15;i++)r.push(16*t+i,16*t+i+1,16*(t+1)+i),r.push(16*t+i+1,16*(t+1)+i+1,16*(t+1)+i);r.push(16*(t+1)-1,16*t,16*(t+2)-1),r.push(16*t,16*(t+1),16*(t+2)-1)}for(t=0;t<15;t++)r.push(208,t+1,t),r.push(209,t+192,t+192+1);r.push(208,0,15),r.push(209,207,192);const o=new e.MeshBasicMaterial;o.transparent=!0,o.opacity=.4,this.pointerGeometry.setIndex(r),this.pointerMesh=new e.Mesh(this.pointerGeometry,o),this.pointerMesh.position.set(0,0,-.01),this.pointerObject=new e.Object3D,this.pointerObject.add(this.pointerMesh),this.raycaster=new e.Raycaster;const n=new e.SphereGeometry(.02,10,10),a=new e.MeshBasicMaterial;a.transparent=!0,a.opacity=.4,this.cursorObject=new e.Mesh(n,a),this.pointerObject.add(this.cursorObject),this.add(this.pointerObject)}_updateRaycaster(){if(this.raycaster){const t=this.pointerObject.matrixWorld,i=new e.Matrix4;i.identity().extractRotation(t),this.raycaster.ray.origin.setFromMatrixPosition(t),this.raycaster.ray.direction.set(0,0,-1).applyMatrix4(i)}}_updatePointer(){this.pointerObject.visible=this.controller.visible;const t=this.hand.joints["index-finger-tip"],e=this.hand.joints["thumb-tip"],i=t.position.distanceTo(e.position),s=t.position.clone().add(e.position).multiplyScalar(.5);this.pointerObject.position.copy(s),this.pointerObject.quaternion.copy(this.controller.quaternion),this.pinched=i<=.02;const r=(i-.01)/.04,o=(i-.01)/.01;if(r>1)this._updatePointerVertices(.01),this.pointerMesh.position.set(0,0,-.01),this.pointerMesh.material.opacity=.4;else if(r>0){const t=.007*r+.003;this._updatePointerVertices(t),o<1?(this.pointerMesh.position.set(0,0,-1*t-.02*(1-o)),this.pointerMesh.material.opacity=.4+.6*(1-o)):(this.pointerMesh.position.set(0,0,-1*t),this.pointerMesh.material.opacity=.4)}else this._updatePointerVertices(.003),this.pointerMesh.position.set(0,0,-.023),this.pointerMesh.material.opacity=1;this.cursorObject.material.opacity=this.pointerMesh.material.opacity}updateMatrixWorld(t){super.updateMatrixWorld(t),this.pointerGeometry&&(this._updatePointer(),this._updateRaycaster())}isPinched(){return this.pinched}setAttached(t){this.attached=t}isAttached(){return this.attached}intersectObject(t,e=!0){if(this.raycaster)return this.raycaster.intersectObject(t,e)}intersectObjects(t,e=!0){if(this.raycaster)return this.raycaster.intersectObjects(t,e)}checkIntersections(t,i=!1){if(this.raycaster&&!this.attached){const s=this.raycaster.intersectObjects(t,i),r=new e.Vector3(0,0,-1);if(s.length>0){const t=s[0].distance;this.cursorObject.position.copy(r.multiplyScalar(t))}else this.cursorObject.position.copy(r.multiplyScalar(1.5))}}setCursor(t){const i=new e.Vector3(0,0,-1);this.raycaster&&!this.attached&&this.cursorObject.position.copy(i.multiplyScalar(t))}}exports.OculusHandPointerModel=r;

package/webxr/OculusHandPointerModel.d.ts

@@ -0,0 +1,63 @@
+import {
+    BufferGeometry,
+    Intersection,
+    Mesh,
+    MeshBasicMaterial,
+    Object3D,
+    Raycaster,
+    SphereBufferGeometry,
+    Texture,
+    Vector3,
+} from 'three';
+
+export class OculusHandPointerModel extends Object3D {
+    hand: Object3D;
+    controller: Object3D;
+    motionController: Object3D | null;
+
+    envMap: Texture | null;
+
+    mesh: Mesh | null;
+
+    pointerGeometry: BufferGeometry | null;
+    pointerMesh: Mesh<BufferGeometry, MeshBasicMaterial> | null;
+    pointerObject: Object3D | null;
+
+    pinched: boolean;
+    attached: boolean;
+
+    cursorObject: Mesh<SphereBufferGeometry, MeshBasicMaterial> | null;
+
+    raycaster: Raycaster;
+
+    visible: boolean;
+    xrInputSource: unknown;
+
+    constructor(hand: Object3D, controller: Object3D);
+
+    private _drawVerticesRing(vertices: number[], baseVector: Vector3, ringIndex: number): void;
+
+    private _updatePointerVertices(rearRadius: number): void;
+
+    public createPointer(): void;
+
+    private _updateRaycaster(): void;
+
+    private _updatePointer(): void;
+
+    public updateMatrixWorld(force?: boolean): void;
+
+    public isPinched(): boolean;
+
+    public setAttached(attached: boolean): void;
+
+    public isAttached(): boolean;
+
+    public intersectObject(object: Object3D, recursive?: boolean): Intersection[] | void;
+
+    public intersectObjects(objects: Object3D[], recursive?: boolean): Intersection[] | void;
+
+    public checkIntersections(objects: Object3D[], recursive?: boolean): void;
+
+    public setCursor(distance: number): void;
+}