three-stdlib 2.16.0 → 2.16.2

package/libs/MotionControllers.js

@@ -1,63 +1,78 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+/**
+ * @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"
+    NONE: 'none',
+    LEFT: 'left',
+    RIGHT: 'right'
   }),
   ComponentState: Object.freeze({
-    DEFAULT: "default",
-    TOUCHED: "touched",
-    PRESSED: "pressed"
+    DEFAULT: 'default',
+    TOUCHED: 'touched',
+    PRESSED: 'pressed'
   }),
   ComponentProperty: Object.freeze({
-    BUTTON: "button",
-    X_AXIS: "xAxis",
-    Y_AXIS: "yAxis",
-    STATE: "state"
+    BUTTON: 'button',
+    X_AXIS: 'xAxis',
+    Y_AXIS: 'yAxis',
+    STATE: 'state'
   }),
   ComponentType: Object.freeze({
-    TRIGGER: "trigger",
-    SQUEEZE: "squeeze",
-    TOUCHPAD: "touchpad",
-    THUMBSTICK: "thumbstick",
-    BUTTON: "button"
+    TRIGGER: 'trigger',
+    SQUEEZE: 'squeeze',
+    TOUCHPAD: 'touchpad',
+    THUMBSTICK: 'thumbstick',
+    BUTTON: 'button'
   }),
   ButtonTouchThreshold: 0.05,
   AxisTouchThreshold: 0.1,
   VisualResponseProperty: Object.freeze({
-    TRANSFORM: "transform",
-    VISIBILITY: "visibility"
+    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");
+    throw new Error('No basePath supplied');
   }
-  const profileListFileName = "profilesList.json";
+
+  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");
+    throw new Error('No xrInputSource supplied');
   }
+
   if (!basePath) {
-    throw new Error("No basePath supplied");
-  }
-  const supportedProfilesList = await fetchProfilesList(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) => {
+  xrInputSource.profiles.some(profileId => {
     const supportedProfile = supportedProfilesList[profileId];
+
     if (supportedProfile) {
       match = {
         profileId,
@@ -65,197 +80,324 @@ async function fetchProfile(xrInputSource, basePath, defaultProfile = null, getA
         deprecated: !!supportedProfile.deprecated
       };
     }
+
     return !!match;
   });
+
   if (!match) {
     if (!defaultProfile) {
-      throw new Error("No matching profile name found");
+      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") {
+
+    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);
+      assetPath = match.profilePath.replace('profile.json', layout.assetPath);
     }
   }
-  return { profile, 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;
+  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);
   }
-  updateFromComponent({ xAxis, yAxis, button, state }) {
-    const { normalizedXAxis, normalizedYAxis } = normalizeAxes(xAxis, yAxis);
+  /**
+   * 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;
+          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");
+      throw new Error('Invalid arguments supplied');
     }
+
     this.id = componentId;
     this.type = componentDescription.type;
     this.rootNodeName = componentDescription.rootNodeName;
-    this.touchPointNodeName = componentDescription.touchPointNodeName;
+    this.touchPointNodeName = componentDescription.touchPointNodeName; // Build all the visual responses for this component
+
     this.visualResponses = {};
-    Object.keys(componentDescription.visualResponses).forEach((responseName) => {
+    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 !== void 0 ? 0 : void 0,
-      xAxis: this.gamepadIndices.xAxis !== void 0 ? 0 : void 0,
-      yAxis: this.gamepadIndices.yAxis !== void 0 ? 0 : void 0
+      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 };
+    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) {
-    this.values.state = MotionControllerConstants.ComponentState.DEFAULT;
-    if (this.gamepadIndices.button !== void 0 && gamepad.buttons.length > this.gamepadIndices.button) {
+    // 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;
+      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;
       }
-    }
-    if (this.gamepadIndices.xAxis !== void 0 && gamepad.axes.length > this.gamepadIndices.xAxis) {
+    } // 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;
+      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;
       }
-    }
-    if (this.gamepadIndices.yAxis !== void 0 && gamepad.axes.length > this.gamepadIndices.yAxis) {
+    } // 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;
+      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;
       }
-    }
-    Object.values(this.visualResponses).forEach((visualResponse) => {
+    } // 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");
+      throw new Error('No xrInputSource supplied');
     }
+
     if (!profile) {
-      throw new Error("No profile supplied");
+      throw new Error('No profile supplied');
     }
+
     this.xrInputSource = xrInputSource;
     this.assetUrl = assetUrl;
-    this.id = profile.profileId;
+    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) => {
+    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) => {
+    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) => {
+    Object.values(this.components).forEach(component => {
       component.updateFromGamepad(this.xrInputSource.gamepad);
     });
   }
+
 }
-exports.MotionController = MotionController;
-exports.MotionControllerConstants = MotionControllerConstants;
-exports.fetchProfile = fetchProfile;
-exports.fetchProfilesList = fetchProfilesList;
+
+export { MotionController, MotionControllerConstants, fetchProfile, fetchProfilesList };

package/lights/LightProbeGenerator.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three"),r={fromCubeTexture:function(r){var a,n,o,s=0,c=new e.Vector3,i=new e.Vector3,h=new e.Color,l=[0,0,0,0,0,0,0,0,0],g=new e.SphericalHarmonics3,b=g.coefficients;for(let a=0;a<6;a++){var d=r.image[a],f=d.width,w=d.height,u=document.createElement("canvas");u.width=f,u.height=w;var v=u.getContext("2d");v.drawImage(d,0,0,f,w);var m=v.getImageData(0,0,f,w),k=m.data,p=m.width,x=2/p;for(let g=0,d=k.length;g<d;g+=4){h.setRGB(k[g]/255,k[g+1]/255,k[g+2]/255),t(h,r.encoding);var y=g/4,P=(y%p+.5)*x-1,G=1-(Math.floor(y/p)+.5)*x;switch(a){case 0:c.set(-1,G,-P);break;case 1:c.set(1,G,P);break;case 2:c.set(-P,1,-G);break;case 3:c.set(-P,-1,G);break;case 4:c.set(-P,G,1);break;case 5:c.set(P,G,-1)}n=c.lengthSq(),s+=o=4/(Math.sqrt(n)*n),i.copy(c).normalize(),e.SphericalHarmonics3.getBasisAt(i,l);for(let e=0;e<9;e++)b[e].x+=l[e]*h.r*o,b[e].y+=l[e]*h.g*o,b[e].z+=l[e]*h.b*o}}a=4*Math.PI/s;for(let e=0;e<9;e++)b[e].x*=a,b[e].y*=a,b[e].z*=a;return new e.LightProbe(g)},fromCubeRenderTarget:function(r,a){var n,o,s,c=0,i=new e.Vector3,h=new e.Vector3,l=new e.Color,g=[0,0,0,0,0,0,0,0,0],b=new e.SphericalHarmonics3,d=b.coefficients;for(let n=0;n<6;n++){var f=a.width,w=new Uint8Array(f*f*4);r.readRenderTargetPixels(a,0,0,f,f,w,n);var u=2/f;for(let r=0,b=w.length;r<b;r+=4){l.setRGB(w[r]/255,w[r+1]/255,w[r+2]/255),t(l,a.texture.encoding);var v=r/4,m=(v%f+.5)*u-1,k=1-(Math.floor(v/f)+.5)*u;switch(n){case 0:i.set(1,k,-m);break;case 1:i.set(-1,k,m);break;case 2:i.set(m,1,-k);break;case 3:i.set(m,-1,k);break;case 4:i.set(m,k,1);break;case 5:i.set(-m,k,-1)}o=i.lengthSq(),c+=s=4/(Math.sqrt(o)*o),h.copy(i).normalize(),e.SphericalHarmonics3.getBasisAt(h,g);for(let e=0;e<9;e++)d[e].x+=g[e]*l.r*s,d[e].y+=g[e]*l.g*s,d[e].z+=g[e]*l.b*s}}n=4*Math.PI/c;for(let e=0;e<9;e++)d[e].x*=n,d[e].y*=n,d[e].z*=n;return new e.LightProbe(b)}},t=function(r,t){switch(t){case e.sRGBEncoding:r.convertSRGBToLinear();break;case e.LinearEncoding:break;default:console.warn("WARNING: LightProbeGenerator convertColorToLinear() encountered an unsupported encoding.")}return r};exports.LightProbeGenerator=r;