three-stdlib 2.8.2 → 2.8.6

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/loaders/AssimpLoader.js

@@ -568,12 +568,30 @@ AssimpLoader.prototype = Object.assign(Object.create(Loader.prototype), {
         if (scene.mMaterials[this.mMaterialIndex]) mat = scene.mMaterials[this.mMaterialIndex].toTHREE(scene);else mat = new MeshLambertMaterial();
         geometry.setIndex(new BufferAttribute(new Uint32Array(this.mIndexArray), 1));
         geometry.setAttribute('position', new BufferAttribute(this.mVertexBuffer, 3));
-        if (this.mNormalBuffer && this.mNormalBuffer.length > 0) geometry.setAttribute('normal', new BufferAttribute(this.mNormalBuffer, 3));
-        if (this.mColorBuffer && this.mColorBuffer.length > 0) geometry.setAttribute('color', new BufferAttribute(this.mColorBuffer, 4));
-        if (this.mTexCoordsBuffers[0] && this.mTexCoordsBuffers[0].length > 0) geometry.setAttribute('uv', new BufferAttribute(new Float32Array(this.mTexCoordsBuffers[0]), 2));
-        if (this.mTexCoordsBuffers[1] && this.mTexCoordsBuffers[1].length > 0) geometry.setAttribute('uv1', new BufferAttribute(new Float32Array(this.mTexCoordsBuffers[1]), 2));
-        if (this.mTangentBuffer && this.mTangentBuffer.length > 0) geometry.setAttribute('tangents', new BufferAttribute(this.mTangentBuffer, 3));
-        if (this.mBitangentBuffer && this.mBitangentBuffer.length > 0) geometry.setAttribute('bitangents', new BufferAttribute(this.mBitangentBuffer, 3));
+
+        if (this.mNormalBuffer && this.mNormalBuffer.length > 0) {
+          geometry.setAttribute('normal', new BufferAttribute(this.mNormalBuffer, 3));
+        }
+
+        if (this.mColorBuffer && this.mColorBuffer.length > 0) {
+          geometry.setAttribute('color', new BufferAttribute(this.mColorBuffer, 4));
+        }
+
+        if (this.mTexCoordsBuffers[0] && this.mTexCoordsBuffers[0].length > 0) {
+          geometry.setAttribute('uv', new BufferAttribute(new Float32Array(this.mTexCoordsBuffers[0]), 2));
+        }
+
+        if (this.mTexCoordsBuffers[1] && this.mTexCoordsBuffers[1].length > 0) {
+          geometry.setAttribute('uv1', new BufferAttribute(new Float32Array(this.mTexCoordsBuffers[1]), 2));
+        }
+
+        if (this.mTangentBuffer && this.mTangentBuffer.length > 0) {
+          geometry.setAttribute('tangents', new BufferAttribute(this.mTangentBuffer, 3));
+        }
+
+        if (this.mBitangentBuffer && this.mBitangentBuffer.length > 0) {
+          geometry.setAttribute('bitangents', new BufferAttribute(this.mBitangentBuffer, 3));
+        }
 
         if (this.mBones.length > 0) {
           var weights = [];
@@ -824,10 +842,21 @@ AssimpLoader.prototype = Object.assign(Object.create(Loader.prototype), {
         var mat = new MeshPhongMaterial();
 
         for (let i = 0; i < this.mProperties.length; i++) {
-          if (nameTypeMapping[this.mProperties[i].mKey] == 'float') mat[namePropMapping[this.mProperties[i].mKey]] = this.mProperties[i].dataAsFloat();
-          if (nameTypeMapping[this.mProperties[i].mKey] == 'color') mat[namePropMapping[this.mProperties[i].mKey]] = this.mProperties[i].dataAsColor();
-          if (nameTypeMapping[this.mProperties[i].mKey] == 'bool') mat[namePropMapping[this.mProperties[i].mKey]] = this.mProperties[i].dataAsBool();
-          if (nameTypeMapping[this.mProperties[i].mKey] == 'string') mat[namePropMapping[this.mProperties[i].mKey]] = this.mProperties[i].dataAsString();
+          if (nameTypeMapping[this.mProperties[i].mKey] == 'float') {
+            mat[namePropMapping[this.mProperties[i].mKey]] = this.mProperties[i].dataAsFloat();
+          }
+
+          if (nameTypeMapping[this.mProperties[i].mKey] == 'color') {
+            mat[namePropMapping[this.mProperties[i].mKey]] = this.mProperties[i].dataAsColor();
+          }
+
+          if (nameTypeMapping[this.mProperties[i].mKey] == 'bool') {
+            mat[namePropMapping[this.mProperties[i].mKey]] = this.mProperties[i].dataAsBool();
+          }
+
+          if (nameTypeMapping[this.mProperties[i].mKey] == 'string') {
+            mat[namePropMapping[this.mProperties[i].mKey]] = this.mProperties[i].dataAsString();
+          }
 
           if (nameTypeMapping[this.mProperties[i].mKey] == 'map') {
             var prop = this.mProperties[i];

package/loaders/ColladaLoader.js

@@ -370,7 +370,11 @@ class ColladaLoader extends Loader {
       }
 
       if (positionData.length > 0) tracks.push(new VectorKeyframeTrack(name + '.position', times, positionData));
-      if (quaternionData.length > 0) tracks.push(new QuaternionKeyframeTrack(name + '.quaternion', times, quaternionData));
+
+      if (quaternionData.length > 0) {
+        tracks.push(new QuaternionKeyframeTrack(name + '.quaternion', times, quaternionData));
+      }
+
       if (scaleData.length > 0) tracks.push(new VectorKeyframeTrack(name + '.scale', times, scaleData));
       return tracks;
     }
@@ -1835,13 +1839,26 @@ class ColladaLoader extends Loader {
       } // build geometry
 
 
-      if (position.array.length > 0) geometry.setAttribute('position', new Float32BufferAttribute(position.array, position.stride));
-      if (normal.array.length > 0) geometry.setAttribute('normal', new Float32BufferAttribute(normal.array, normal.stride));
+      if (position.array.length > 0) {
+        geometry.setAttribute('position', new Float32BufferAttribute(position.array, position.stride));
+      }
+
+      if (normal.array.length > 0) {
+        geometry.setAttribute('normal', new Float32BufferAttribute(normal.array, normal.stride));
+      }
+
       if (color.array.length > 0) geometry.setAttribute('color', new Float32BufferAttribute(color.array, color.stride));
       if (uv.array.length > 0) geometry.setAttribute('uv', new Float32BufferAttribute(uv.array, uv.stride));
       if (uv2.array.length > 0) geometry.setAttribute('uv2', new Float32BufferAttribute(uv2.array, uv2.stride));
-      if (skinIndex.array.length > 0) geometry.setAttribute('skinIndex', new Float32BufferAttribute(skinIndex.array, skinIndex.stride));
-      if (skinWeight.array.length > 0) geometry.setAttribute('skinWeight', new Float32BufferAttribute(skinWeight.array, skinWeight.stride));
+
+      if (skinIndex.array.length > 0) {
+        geometry.setAttribute('skinIndex', new Float32BufferAttribute(skinIndex.array, skinIndex.stride));
+      }
+
+      if (skinWeight.array.length > 0) {
+        geometry.setAttribute('skinWeight', new Float32BufferAttribute(skinWeight.array, skinWeight.stride));
+      }
+
       build.data = geometry;
       build.type = primitives[0].type;
       build.materialKeys = materialKeys;

package/loaders/EXRLoader.js

@@ -1067,7 +1067,11 @@ class EXRLoader extends DataTextureLoader {
         totalDcUncompressedCount: parseInt64(inDataView, inOffset),
         acCompression: parseInt64(inDataView, inOffset)
       };
-      if (dwaHeader.version < 2) throw 'EXRLoader.parse: ' + EXRHeader.compression + ' version ' + dwaHeader.version + ' is unsupported'; // Read channel ruleset information
+
+      if (dwaHeader.version < 2) {
+        throw 'EXRLoader.parse: ' + EXRHeader.compression + ' version ' + dwaHeader.version + ' is unsupported';
+      } // Read channel ruleset information
+
 
       var channelRules = new Array();
       var ruleSize = parseUint16(inDataView, inOffset) - INT16_SIZE;

package/loaders/FBXLoader.js

@@ -514,7 +514,11 @@ class FBXTreeParser {
         if (deformerNode.attrType === 'Skin') {
           const skeleton = this.parseSkeleton(relationships, DeformerNodes);
           skeleton.ID = nodeID;
-          if (relationships.parents.length > 1) console.warn('THREE.FBXLoader: skeleton attached to more than one geometry is not supported.');
+
+          if (relationships.parents.length > 1) {
+            console.warn('THREE.FBXLoader: skeleton attached to more than one geometry is not supported.');
+          }
+
           skeleton.geometryID = relationships.parents[0].ID;
           skeletons[nodeID] = skeleton;
         } else if (deformerNode.attrType === 'BlendShape') {
@@ -523,7 +527,11 @@ class FBXTreeParser {
           };
           morphTarget.rawTargets = this.parseMorphTargets(relationships, DeformerNodes);
           morphTarget.id = nodeID;
-          if (relationships.parents.length > 1) console.warn('THREE.FBXLoader: morph target attached to more than one geometry is not supported.');
+
+          if (relationships.parents.length > 1) {
+            console.warn('THREE.FBXLoader: morph target attached to more than one geometry is not supported.');
+          }
+
           morphTargets[nodeID] = morphTarget;
         }
       }