three-stdlib 2.22.7 → 2.22.9

package/dist/webxr/XREstimatedLight.mjs

@@ -0,0 +1,126 @@
+import { WebGLCubeRenderTarget, Group, LightProbe, DirectionalLight } from "three";
+class SessionLightProbe {
+  constructor(xrLight, renderer, lightProbe, environmentEstimation, estimationStartCallback) {
+    this.xrLight = xrLight;
+    this.renderer = renderer;
+    this.lightProbe = lightProbe;
+    this.xrWebGLBinding = null;
+    this.estimationStartCallback = estimationStartCallback;
+    this.frameCallback = this.onXRFrame.bind(this);
+    const session = renderer.xr.getSession();
+    if (environmentEstimation && "XRWebGLBinding" in window) {
+      const cubeRenderTarget = new WebGLCubeRenderTarget(16);
+      xrLight.environment = cubeRenderTarget.texture;
+      const gl = renderer.getContext();
+      switch (session.preferredReflectionFormat) {
+        case "srgba8":
+          gl.getExtension("EXT_sRGB");
+          break;
+        case "rgba16f":
+          gl.getExtension("OES_texture_half_float");
+          break;
+      }
+      this.xrWebGLBinding = new XRWebGLBinding(session, gl);
+      this.lightProbe.addEventListener("reflectionchange", () => {
+        this.updateReflection();
+      });
+    }
+    session.requestAnimationFrame(this.frameCallback);
+  }
+  updateReflection() {
+    const textureProperties = this.renderer.properties.get(this.xrLight.environment);
+    if (textureProperties) {
+      const cubeMap = this.xrWebGLBinding.getReflectionCubeMap(this.lightProbe);
+      if (cubeMap) {
+        textureProperties.__webglTexture = cubeMap;
+        this.xrLight.environment.needsPMREMUpdate = true;
+      }
+    }
+  }
+  onXRFrame(time, xrFrame) {
+    if (!this.xrLight) {
+      return;
+    }
+    const session = xrFrame.session;
+    session.requestAnimationFrame(this.frameCallback);
+    const lightEstimate = xrFrame.getLightEstimate(this.lightProbe);
+    if (lightEstimate) {
+      this.xrLight.lightProbe.sh.fromArray(lightEstimate.sphericalHarmonicsCoefficients);
+      this.xrLight.lightProbe.intensity = 1;
+      const intensityScalar = Math.max(
+        1,
+        Math.max(
+          lightEstimate.primaryLightIntensity.x,
+          Math.max(lightEstimate.primaryLightIntensity.y, lightEstimate.primaryLightIntensity.z)
+        )
+      );
+      this.xrLight.directionalLight.color.setRGB(
+        lightEstimate.primaryLightIntensity.x / intensityScalar,
+        lightEstimate.primaryLightIntensity.y / intensityScalar,
+        lightEstimate.primaryLightIntensity.z / intensityScalar
+      );
+      this.xrLight.directionalLight.intensity = intensityScalar;
+      this.xrLight.directionalLight.position.copy(lightEstimate.primaryLightDirection);
+      if (this.estimationStartCallback) {
+        this.estimationStartCallback();
+        this.estimationStartCallback = null;
+      }
+    }
+  }
+  dispose() {
+    this.xrLight = null;
+    this.renderer = null;
+    this.lightProbe = null;
+    this.xrWebGLBinding = null;
+  }
+}
+class XREstimatedLight extends Group {
+  constructor(renderer, environmentEstimation = true) {
+    super();
+    this.lightProbe = new LightProbe();
+    this.lightProbe.intensity = 0;
+    this.add(this.lightProbe);
+    this.directionalLight = new DirectionalLight();
+    this.directionalLight.intensity = 0;
+    this.add(this.directionalLight);
+    this.environment = null;
+    let sessionLightProbe = null;
+    let estimationStarted = false;
+    renderer.xr.addEventListener("sessionstart", () => {
+      const session = renderer.xr.getSession();
+      if ("requestLightProbe" in session) {
+        session.requestLightProbe({
+          reflectionFormat: session.preferredReflectionFormat
+        }).then((probe) => {
+          sessionLightProbe = new SessionLightProbe(this, renderer, probe, environmentEstimation, () => {
+            estimationStarted = true;
+            this.dispatchEvent({ type: "estimationstart" });
+          });
+        });
+      }
+    });
+    renderer.xr.addEventListener("sessionend", () => {
+      if (sessionLightProbe) {
+        sessionLightProbe.dispose();
+        sessionLightProbe = null;
+      }
+      if (estimationStarted) {
+        this.dispatchEvent({ type: "estimationend" });
+      }
+    });
+    this.dispose = () => {
+      if (sessionLightProbe) {
+        sessionLightProbe.dispose();
+        sessionLightProbe = null;
+      }
+      this.remove(this.lightProbe);
+      this.lightProbe = null;
+      this.remove(this.directionalLight);
+      this.directionalLight = null;
+      this.environment = null;
+    };
+  }
+}
+export {
+  XREstimatedLight
+};

package/dist/webxr/XRHandMeshModel.d.ts

@@ -0,0 +1,9 @@
+import { Object3D } from 'three';
+declare class XRHandMeshModel {
+    controller: Object3D;
+    handModel: Object3D;
+    bones: Object3D[];
+    constructor(handModel: Object3D, controller: Object3D, path: string | undefined, handedness: string, customModelPath?: string);
+    updateMesh(): void;
+}
+export { XRHandMeshModel };

package/dist/webxr/XRHandMeshModel.js

@@ -0,0 +1,82 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const GLTFLoader = require("../loaders/GLTFLoader.js");
+const DEFAULT_HAND_PROFILE_PATH = "https://cdn.jsdelivr.net/npm/@webxr-input-profiles/assets@1.0/dist/profiles/generic-hand/";
+class XRHandMeshModel {
+  constructor(handModel, controller, path = DEFAULT_HAND_PROFILE_PATH, handedness, customModelPath) {
+    __publicField(this, "controller");
+    __publicField(this, "handModel");
+    __publicField(this, "bones");
+    this.controller = controller;
+    this.handModel = handModel;
+    this.bones = [];
+    const loader = new GLTFLoader.GLTFLoader();
+    if (!customModelPath)
+      loader.setPath(path);
+    loader.load(customModelPath != null ? customModelPath : `${handedness}.glb`, (gltf) => {
+      const object = gltf.scene.children[0];
+      this.handModel.add(object);
+      const mesh = object.getObjectByProperty("type", "SkinnedMesh");
+      mesh.frustumCulled = false;
+      mesh.castShadow = true;
+      mesh.receiveShadow = true;
+      const joints = [
+        "wrist",
+        "thumb-metacarpal",
+        "thumb-phalanx-proximal",
+        "thumb-phalanx-distal",
+        "thumb-tip",
+        "index-finger-metacarpal",
+        "index-finger-phalanx-proximal",
+        "index-finger-phalanx-intermediate",
+        "index-finger-phalanx-distal",
+        "index-finger-tip",
+        "middle-finger-metacarpal",
+        "middle-finger-phalanx-proximal",
+        "middle-finger-phalanx-intermediate",
+        "middle-finger-phalanx-distal",
+        "middle-finger-tip",
+        "ring-finger-metacarpal",
+        "ring-finger-phalanx-proximal",
+        "ring-finger-phalanx-intermediate",
+        "ring-finger-phalanx-distal",
+        "ring-finger-tip",
+        "pinky-finger-metacarpal",
+        "pinky-finger-phalanx-proximal",
+        "pinky-finger-phalanx-intermediate",
+        "pinky-finger-phalanx-distal",
+        "pinky-finger-tip"
+      ];
+      joints.forEach((jointName) => {
+        const bone = object.getObjectByName(jointName);
+        if (bone !== void 0) {
+          bone.jointName = jointName;
+        } else {
+          console.warn(`Couldn't find ${jointName} in ${handedness} hand mesh`);
+        }
+        this.bones.push(bone);
+      });
+    });
+  }
+  updateMesh() {
+    const XRJoints = this.controller.joints;
+    for (let i = 0; i < this.bones.length; i++) {
+      const bone = this.bones[i];
+      if (bone) {
+        const XRJoint = XRJoints[bone.jointName];
+        if (XRJoint.visible) {
+          const position = XRJoint.position;
+          bone.position.copy(position);
+          bone.quaternion.copy(XRJoint.quaternion);
+        }
+      }
+    }
+  }
+}
+exports.XRHandMeshModel = XRHandMeshModel;

package/dist/webxr/XRHandMeshModel.mjs

@@ -0,0 +1,82 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { GLTFLoader } from "../loaders/GLTFLoader.mjs";
+const DEFAULT_HAND_PROFILE_PATH = "https://cdn.jsdelivr.net/npm/@webxr-input-profiles/assets@1.0/dist/profiles/generic-hand/";
+class XRHandMeshModel {
+  constructor(handModel, controller, path = DEFAULT_HAND_PROFILE_PATH, handedness, customModelPath) {
+    __publicField(this, "controller");
+    __publicField(this, "handModel");
+    __publicField(this, "bones");
+    this.controller = controller;
+    this.handModel = handModel;
+    this.bones = [];
+    const loader = new GLTFLoader();
+    if (!customModelPath)
+      loader.setPath(path);
+    loader.load(customModelPath != null ? customModelPath : `${handedness}.glb`, (gltf) => {
+      const object = gltf.scene.children[0];
+      this.handModel.add(object);
+      const mesh = object.getObjectByProperty("type", "SkinnedMesh");
+      mesh.frustumCulled = false;
+      mesh.castShadow = true;
+      mesh.receiveShadow = true;
+      const joints = [
+        "wrist",
+        "thumb-metacarpal",
+        "thumb-phalanx-proximal",
+        "thumb-phalanx-distal",
+        "thumb-tip",
+        "index-finger-metacarpal",
+        "index-finger-phalanx-proximal",
+        "index-finger-phalanx-intermediate",
+        "index-finger-phalanx-distal",
+        "index-finger-tip",
+        "middle-finger-metacarpal",
+        "middle-finger-phalanx-proximal",
+        "middle-finger-phalanx-intermediate",
+        "middle-finger-phalanx-distal",
+        "middle-finger-tip",
+        "ring-finger-metacarpal",
+        "ring-finger-phalanx-proximal",
+        "ring-finger-phalanx-intermediate",
+        "ring-finger-phalanx-distal",
+        "ring-finger-tip",
+        "pinky-finger-metacarpal",
+        "pinky-finger-phalanx-proximal",
+        "pinky-finger-phalanx-intermediate",
+        "pinky-finger-phalanx-distal",
+        "pinky-finger-tip"
+      ];
+      joints.forEach((jointName) => {
+        const bone = object.getObjectByName(jointName);
+        if (bone !== void 0) {
+          bone.jointName = jointName;
+        } else {
+          console.warn(`Couldn't find ${jointName} in ${handedness} hand mesh`);
+        }
+        this.bones.push(bone);
+      });
+    });
+  }
+  updateMesh() {
+    const XRJoints = this.controller.joints;
+    for (let i = 0; i < this.bones.length; i++) {
+      const bone = this.bones[i];
+      if (bone) {
+        const XRJoint = XRJoints[bone.jointName];
+        if (XRJoint.visible) {
+          const position = XRJoint.position;
+          bone.position.copy(position);
+          bone.quaternion.copy(XRJoint.quaternion);
+        }
+      }
+    }
+  }
+}
+export {
+  XRHandMeshModel
+};

package/dist/webxr/XRHandModelFactory.d.ts

@@ -0,0 +1,25 @@
+import { Group, Object3D } from 'three'
+
+import { XRHandPrimitiveModel, XRHandPrimitiveModelOptions } from './XRHandPrimitiveModel'
+import { XRHandMeshModel } from './XRHandMeshModel'
+
+export type XRHandModelHandedness = 'left' | 'right'
+
+export class XRHandModel extends Object3D {
+  constructor()
+
+  motionController: XRHandPrimitiveModel | XRHandMeshModel
+}
+
+export class XRHandModelFactory {
+  constructor()
+  path: string
+
+  setPath(path: string): XRHandModelFactory
+
+  createHandModel(
+    controller: Group,
+    profile?: 'spheres' | 'boxes' | 'oculus',
+    options?: XRHandPrimitiveModelOptions,
+  ): XRHandModel
+}

package/dist/webxr/XRHandModelFactory.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const XRHandPrimitiveModel = require("./XRHandPrimitiveModel.js");
+const XRHandMeshModel = require("./XRHandMeshModel.js");
+class XRHandModel extends THREE.Object3D {
+  constructor(controller) {
+    super();
+    this.controller = controller;
+    this.motionController = null;
+    this.envMap = null;
+    this.mesh = null;
+  }
+  updateMatrixWorld(force) {
+    super.updateMatrixWorld(force);
+    if (this.motionController) {
+      this.motionController.updateMesh();
+    }
+  }
+}
+class XRHandModelFactory {
+  constructor() {
+    this.path = null;
+  }
+  setPath(path) {
+    this.path = path;
+    return this;
+  }
+  createHandModel(controller, profile) {
+    const handModel = new XRHandModel(controller);
+    controller.addEventListener("connected", (event) => {
+      const xrInputSource = event.data;
+      if (xrInputSource.hand && !handModel.motionController) {
+        handModel.xrInputSource = xrInputSource;
+        if (profile === void 0 || profile === "spheres") {
+          handModel.motionController = new XRHandPrimitiveModel.XRHandPrimitiveModel(
+            handModel,
+            controller,
+            this.path,
+            xrInputSource.handedness,
+            { primitive: "sphere" }
+          );
+        } else if (profile === "boxes") {
+          handModel.motionController = new XRHandPrimitiveModel.XRHandPrimitiveModel(
+            handModel,
+            controller,
+            this.path,
+            xrInputSource.handedness,
+            { primitive: "box" }
+          );
+        } else if (profile === "mesh") {
+          handModel.motionController = new XRHandMeshModel.XRHandMeshModel(handModel, controller, this.path, xrInputSource.handedness);
+        }
+      }
+    });
+    controller.addEventListener("disconnected", () => {
+    });
+    return handModel;
+  }
+}
+exports.XRHandModelFactory = XRHandModelFactory;

package/dist/webxr/XRHandModelFactory.mjs

@@ -0,0 +1,61 @@
+import { Object3D } from "three";
+import { XRHandPrimitiveModel } from "./XRHandPrimitiveModel.mjs";
+import { XRHandMeshModel } from "./XRHandMeshModel.mjs";
+class XRHandModel extends Object3D {
+  constructor(controller) {
+    super();
+    this.controller = controller;
+    this.motionController = null;
+    this.envMap = null;
+    this.mesh = null;
+  }
+  updateMatrixWorld(force) {
+    super.updateMatrixWorld(force);
+    if (this.motionController) {
+      this.motionController.updateMesh();
+    }
+  }
+}
+class XRHandModelFactory {
+  constructor() {
+    this.path = null;
+  }
+  setPath(path) {
+    this.path = path;
+    return this;
+  }
+  createHandModel(controller, profile) {
+    const handModel = new XRHandModel(controller);
+    controller.addEventListener("connected", (event) => {
+      const xrInputSource = event.data;
+      if (xrInputSource.hand && !handModel.motionController) {
+        handModel.xrInputSource = xrInputSource;
+        if (profile === void 0 || profile === "spheres") {
+          handModel.motionController = new XRHandPrimitiveModel(
+            handModel,
+            controller,
+            this.path,
+            xrInputSource.handedness,
+            { primitive: "sphere" }
+          );
+        } else if (profile === "boxes") {
+          handModel.motionController = new XRHandPrimitiveModel(
+            handModel,
+            controller,
+            this.path,
+            xrInputSource.handedness,
+            { primitive: "box" }
+          );
+        } else if (profile === "mesh") {
+          handModel.motionController = new XRHandMeshModel(handModel, controller, this.path, xrInputSource.handedness);
+        }
+      }
+    });
+    controller.addEventListener("disconnected", () => {
+    });
+    return handModel;
+  }
+}
+export {
+  XRHandModelFactory
+};

package/dist/webxr/XRHandPrimitiveModel.d.ts

@@ -0,0 +1,24 @@
+import { Group, Texture } from 'three'
+
+import { XRHandModel, XRHandModelHandedness } from './XRHandModelFactory'
+
+export interface XRHandPrimitiveModelOptions {
+  primitive?: 'sphere' | 'box' | undefined
+}
+
+export class XRHandPrimitiveModel {
+  controller: Group
+  handModel: XRHandModel
+  envMap: Texture | null
+  handMesh: Group
+
+  constructor(
+    handModel: XRHandModel,
+    controller: Group,
+    path: string,
+    handedness: XRHandModelHandedness,
+    options: XRHandPrimitiveModelOptions,
+  )
+
+  updateMesh: () => void
+}

package/dist/webxr/XRHandPrimitiveModel.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const _matrix = new THREE.Matrix4();
+const _vector = new THREE.Vector3();
+class XRHandPrimitiveModel {
+  constructor(handModel, controller, path, handedness, options) {
+    this.controller = controller;
+    this.handModel = handModel;
+    this.envMap = null;
+    let geometry;
+    if (!options || !options.primitive || options.primitive === "sphere") {
+      geometry = new THREE.SphereGeometry(1, 10, 10);
+    } else if (options.primitive === "box") {
+      geometry = new THREE.BoxGeometry(1, 1, 1);
+    }
+    const material = new THREE.MeshStandardMaterial();
+    this.handMesh = new THREE.InstancedMesh(geometry, material, 30);
+    this.handMesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+    this.handMesh.castShadow = true;
+    this.handMesh.receiveShadow = true;
+    this.handModel.add(this.handMesh);
+    this.joints = [
+      "wrist",
+      "thumb-metacarpal",
+      "thumb-phalanx-proximal",
+      "thumb-phalanx-distal",
+      "thumb-tip",
+      "index-finger-metacarpal",
+      "index-finger-phalanx-proximal",
+      "index-finger-phalanx-intermediate",
+      "index-finger-phalanx-distal",
+      "index-finger-tip",
+      "middle-finger-metacarpal",
+      "middle-finger-phalanx-proximal",
+      "middle-finger-phalanx-intermediate",
+      "middle-finger-phalanx-distal",
+      "middle-finger-tip",
+      "ring-finger-metacarpal",
+      "ring-finger-phalanx-proximal",
+      "ring-finger-phalanx-intermediate",
+      "ring-finger-phalanx-distal",
+      "ring-finger-tip",
+      "pinky-finger-metacarpal",
+      "pinky-finger-phalanx-proximal",
+      "pinky-finger-phalanx-intermediate",
+      "pinky-finger-phalanx-distal",
+      "pinky-finger-tip"
+    ];
+  }
+  updateMesh() {
+    const defaultRadius = 8e-3;
+    const joints = this.controller.joints;
+    let count = 0;
+    for (let i = 0; i < this.joints.length; i++) {
+      const joint = joints[this.joints[i]];
+      if (joint.visible) {
+        _vector.setScalar(joint.jointRadius || defaultRadius);
+        _matrix.compose(joint.position, joint.quaternion, _vector);
+        this.handMesh.setMatrixAt(i, _matrix);
+        count++;
+      }
+    }
+    this.handMesh.count = count;
+    this.handMesh.instanceMatrix.needsUpdate = true;
+  }
+}
+exports.XRHandPrimitiveModel = XRHandPrimitiveModel;

package/dist/webxr/XRHandPrimitiveModel.mjs

@@ -0,0 +1,68 @@
+import { Matrix4, Vector3, SphereGeometry, BoxGeometry, MeshStandardMaterial, InstancedMesh, DynamicDrawUsage } from "three";
+const _matrix = new Matrix4();
+const _vector = new Vector3();
+class XRHandPrimitiveModel {
+  constructor(handModel, controller, path, handedness, options) {
+    this.controller = controller;
+    this.handModel = handModel;
+    this.envMap = null;
+    let geometry;
+    if (!options || !options.primitive || options.primitive === "sphere") {
+      geometry = new SphereGeometry(1, 10, 10);
+    } else if (options.primitive === "box") {
+      geometry = new BoxGeometry(1, 1, 1);
+    }
+    const material = new MeshStandardMaterial();
+    this.handMesh = new InstancedMesh(geometry, material, 30);
+    this.handMesh.instanceMatrix.setUsage(DynamicDrawUsage);
+    this.handMesh.castShadow = true;
+    this.handMesh.receiveShadow = true;
+    this.handModel.add(this.handMesh);
+    this.joints = [
+      "wrist",
+      "thumb-metacarpal",
+      "thumb-phalanx-proximal",
+      "thumb-phalanx-distal",
+      "thumb-tip",
+      "index-finger-metacarpal",
+      "index-finger-phalanx-proximal",
+      "index-finger-phalanx-intermediate",
+      "index-finger-phalanx-distal",
+      "index-finger-tip",
+      "middle-finger-metacarpal",
+      "middle-finger-phalanx-proximal",
+      "middle-finger-phalanx-intermediate",
+      "middle-finger-phalanx-distal",
+      "middle-finger-tip",
+      "ring-finger-metacarpal",
+      "ring-finger-phalanx-proximal",
+      "ring-finger-phalanx-intermediate",
+      "ring-finger-phalanx-distal",
+      "ring-finger-tip",
+      "pinky-finger-metacarpal",
+      "pinky-finger-phalanx-proximal",
+      "pinky-finger-phalanx-intermediate",
+      "pinky-finger-phalanx-distal",
+      "pinky-finger-tip"
+    ];
+  }
+  updateMesh() {
+    const defaultRadius = 8e-3;
+    const joints = this.controller.joints;
+    let count = 0;
+    for (let i = 0; i < this.joints.length; i++) {
+      const joint = joints[this.joints[i]];
+      if (joint.visible) {
+        _vector.setScalar(joint.jointRadius || defaultRadius);
+        _matrix.compose(joint.position, joint.quaternion, _vector);
+        this.handMesh.setMatrixAt(i, _matrix);
+        count++;
+      }
+    }
+    this.handMesh.count = count;
+    this.handMesh.instanceMatrix.needsUpdate = true;
+  }
+}
+export {
+  XRHandPrimitiveModel
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-stdlib",
-  "version": "2.22.7",
+  "version": "2.22.9",
   "description": "stand-alone library of threejs examples",
   "keywords": [
     "three",