itowns 2.45.1 → 2.45.2-next.0

package/lib/ThreeExtended/libs/motion-controllers.module.js

@@ -0,0 +1,375 @@
+/**
+ * @webxr-input-profiles/motion-controllers 1.0.0 https://github.com/immersive-web/webxr-input-profiles
+ */
+
+const Constants = {
+  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 profilesList = await fetchJsonFile(`${basePath}/${'profilesList.json'}`);
+  return profilesList;
+}
+async function fetchProfile(xrInputSource, basePath) {
+  let defaultProfile = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+  let getAssetPath = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 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: Constants.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() {
+  let x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  let y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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 === Constants.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(_ref) {
+    let {
+      xAxis,
+      yAxis,
+      button,
+      state
+    } = _ref;
+    const {
+      normalizedXAxis,
+      normalizedYAxis
+    } = normalizeAxes(xAxis, yAxis);
+    switch (this.componentProperty) {
+      case Constants.ComponentProperty.X_AXIS:
+        this.value = this.states.includes(state) ? normalizedXAxis : 0.5;
+        break;
+      case Constants.ComponentProperty.Y_AXIS:
+        this.value = this.states.includes(state) ? normalizedYAxis : 0.5;
+        break;
+      case Constants.ComponentProperty.BUTTON:
+        this.value = this.states.includes(state) ? button : 0;
+        break;
+      case Constants.ComponentProperty.STATE:
+        if (this.valueNodeProperty === Constants.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: Constants.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 = Constants.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 = Constants.ComponentState.PRESSED;
+      } else if (gamepadButton.touched || this.values.button > Constants.ButtonTouchThreshold) {
+        this.values.state = Constants.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 === Constants.ComponentState.DEFAULT && Math.abs(this.values.xAxis) > Constants.AxisTouchThreshold) {
+        this.values.state = Constants.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 === Constants.ComponentState.DEFAULT && Math.abs(this.values.yAxis) > Constants.AxisTouchThreshold) {
+        this.values.state = Constants.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 { Constants, MotionController, fetchProfile, fetchProfilesList };

package/lib/ThreeExtended/libs/zstddec.module.d.ts

@@ -0,0 +1,6 @@
+export { Q as ZSTDDecoder };
+declare class Q {
+    init(): any;
+    _init(A: any): void;
+    decode(A: any, g?: number): any;
+}

package/lib/ThreeExtended/loaders/DDSLoader.js

@@ -74,6 +74,32 @@ class DDSLoader extends CompressedTextureLoader {
       }
       return byteArray;
     }
+    function loadRGBMip(buffer, dataOffset, width, height) {
+      const dataLength = width * height * 3;
+      const srcBuffer = new Uint8Array(buffer, dataOffset, dataLength);
+      const byteArray = new Uint8Array(width * height * 4);
+      let dst = 0;
+      let src = 0;
+      for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+          const b = srcBuffer[src];
+          src++;
+          const g = srcBuffer[src];
+          src++;
+          const r = srcBuffer[src];
+          src++;
+          byteArray[dst] = r;
+          dst++; //r
+          byteArray[dst] = g;
+          dst++; //g
+          byteArray[dst] = b;
+          dst++; //b
+          byteArray[dst] = 255;
+          dst++; //a
+        }
+      }
+      return byteArray;
+    }
     const FOURCC_DXT1 = fourCCToInt32('DXT1');
     const FOURCC_DXT3 = fourCCToInt32('DXT3');
     const FOURCC_DXT5 = fourCCToInt32('DXT5');
@@ -86,6 +112,11 @@ class DDSLoader extends CompressedTextureLoader {
 
     // const off_pfFlags = 20;
 
+    const off_RGBBitCount = 22;
+    const off_RBitMask = 23;
+    const off_GBitMask = 24;
+    const off_BBitMask = 25;
+
     // const off_caps = 27;
 
     // const off_caps3 = 29;
@@ -103,6 +134,7 @@ class DDSLoader extends CompressedTextureLoader {
     let blockBytes;
     const fourCC = header[21];
     let isRGBAUncompressed = false;
+    let isRGBUncompressed = false;
     let dataOffset = header[1] + 4;
     switch (fourCC) {
       case FOURCC_DXT1:
@@ -146,10 +178,14 @@ class DDSLoader extends CompressedTextureLoader {
         }
         break;
       default:
-        if (header[22] === 32 && header[23] & 0xff0000 && header[24] & 0xff00 && header[25] & 0xff && header[26] & 0xff000000) {
+        if (header[off_RGBBitCount] === 32 && header[off_RBitMask] & 0xff0000 && header[off_GBitMask] & 0xff00 && header[off_BBitMask] & 0xff && header[26] & 0xff000000) {
           isRGBAUncompressed = true;
           blockBytes = 64;
           dds.format = RGBAFormat;
+        } else if (header[off_RGBBitCount] === 24 && header[off_RBitMask] & 0xff0000 && header[off_GBitMask] & 0xff00 && header[off_BBitMask] & 0xff) {
+          isRGBUncompressed = true;
+          blockBytes = 64;
+          dds.format = RGBAFormat;
         } else {
           console.error('THREE.DDSLoader.parse: Unsupported FourCC code ', int32ToFourCC(fourCC));
           return dds;
@@ -179,6 +215,9 @@ class DDSLoader extends CompressedTextureLoader {
         if (isRGBAUncompressed) {
           byteArray = loadARGBMip(buffer, dataOffset, width, height);
           dataLength = byteArray.length;
+        } else if (isRGBUncompressed) {
+          byteArray = loadRGBMip(buffer, dataOffset, width, height);
+          dataLength = width * height * 3;
         } else {
           dataLength = Math.max(4, width) / 4 * Math.max(4, height) / 4 * blockBytes;
           byteArray = new Uint8Array(buffer, dataOffset, dataLength);

package/lib/ThreeExtended/loaders/DRACOLoader.d.ts

@@ -0,0 +1,41 @@
+export class DRACOLoader extends Loader<any, string> {
+    constructor(manager: any);
+    decoderPath: string;
+    decoderConfig: {};
+    decoderBinary: any;
+    decoderPending: Promise<void> | null;
+    workerLimit: number;
+    workerPool: any[];
+    workerNextTaskID: number;
+    workerSourceURL: string;
+    defaultAttributeIDs: {
+        position: string;
+        normal: string;
+        color: string;
+        uv: string;
+    };
+    defaultAttributeTypes: {
+        position: string;
+        normal: string;
+        color: string;
+        uv: string;
+    };
+    setDecoderPath(path: any): this;
+    setDecoderConfig(config: any): this;
+    setWorkerLimit(workerLimit: any): this;
+    load(url: any, onLoad: any, onProgress: any, onError: any): void;
+    parse(buffer: any, onLoad: any, onError?: () => void): void;
+    decodeDracoFile(buffer: any, callback: any, attributeIDs: any, attributeTypes: any, vertexColorSpace?: "srgb-linear", onError?: () => void): any;
+    decodeGeometry(buffer: any, taskConfig: any): any;
+    _createGeometry(geometryData: any): BufferGeometry<import("three").NormalBufferAttributes>;
+    _assignVertexColorSpace(attribute: any, inputColorSpace: any): void;
+    _loadLibrary(url: any, responseType: any): Promise<any>;
+    preload(): this;
+    _initDecoder(): Promise<void>;
+    _getWorker(taskID: any, taskCost: any): Promise<any>;
+    _releaseTask(worker: any, taskID: any): void;
+    debug(): void;
+    dispose(): this;
+}
+import { Loader } from 'three';
+import { BufferGeometry } from 'three';

package/lib/ThreeExtended/loaders/GLTFLoader.d.ts

@@ -0,0 +1,16 @@
+export class GLTFLoader extends Loader<any, string> {
+    constructor(manager: any);
+    dracoLoader: any;
+    ktx2Loader: any;
+    meshoptDecoder: any;
+    pluginCallbacks: any[];
+    load(url: any, onLoad: any, onProgress: any, onError: any): void;
+    setDRACOLoader(dracoLoader: any): this;
+    setKTX2Loader(ktx2Loader: any): this;
+    setMeshoptDecoder(meshoptDecoder: any): this;
+    register(callback: any): this;
+    unregister(callback: any): this;
+    parse(data: any, path: any, onLoad: any, onError: any): void;
+    parseAsync(data: any, path: any): Promise<any>;
+}
+import { Loader } from 'three';

package/lib/ThreeExtended/loaders/GLTFLoader.js

@@ -329,7 +329,6 @@ class GLTFLightsExtension {
     // Some lights (e.g. spot) default to a position other than the origin. Reset the position
     // here, because node-level parsing will only override position if explicitly specified.
     lightNode.position.set(0, 0, 0);
-    lightNode.decay = 2;
     assignExtrasToUserData(lightNode, lightDef);
     if (lightDef.intensity !== undefined) lightNode.intensity = lightDef.intensity;
     lightNode.name = parser.createUniqueName(lightDef.name || 'light_' + lightIndex);
@@ -1353,6 +1352,9 @@ const ALPHA_MODES = {
 
 /**
  * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#default-material
+ *
+ * @param {Object<string, Material>} cache
+ * @return {Material}
  */
 function createDefaultMaterial(cache) {
   if (cache['DefaultMaterial'] === undefined) {
@@ -1677,6 +1679,9 @@ class GLTFParser {
    * Textures) can be reused directly and are not marked here.
    *
    * Example: CesiumMilkTruck sample model reuses "Wheel" meshes.
+   *
+   * @param {Object} cache
+   * @param {Object3D} index
    */
   _addNodeRef(cache, index) {
     if (index === undefined) return;
@@ -1686,7 +1691,14 @@ class GLTFParser {
     cache.refs[index]++;
   }
 
-  /** Returns a reference to a shared resource, cloning it if necessary. */
+  /**
+   * Returns a reference to a shared resource, cloning it if necessary.
+   *
+   * @param {Object} cache
+   * @param {number} index
+   * @param {Object} object
+   * @return {Object}
+   */
   _getNodeRef(cache, index, object) {
     if (cache.refs[index] <= 1) return object;
     const ref = object.clone();
@@ -2050,9 +2062,11 @@ class GLTFParser {
 
   /**
    * Asynchronously assigns a texture to the given material parameters.
+   *
    * @param {Object} materialParams
    * @param {string} mapName
    * @param {Object} mapDef
+   * @param {string} colorSpace
    * @return {Promise<Texture>}
    */
   assignTexture(materialParams, mapName, mapDef, colorSpace) {
@@ -2241,7 +2255,12 @@ class GLTFParser {
     });
   }
 
-  /** When Object3D instances are targeted by animation, they need unique names. */
+  /**
+   * When Object3D instances are targeted by animation, they need unique names.
+   *
+   * @param {string} originalName
+   * @return {string}
+   */
   createUniqueName(originalName) {
     const sanitizedName = PropertyBinding.sanitizeNodeName(originalName || '');
     if (sanitizedName in this.nodeNamesUsed) {