three-stdlib 2.8.2 → 2.8.6

package/renderers/webgpu/WebGPUTextures.js

@@ -365,47 +365,68 @@ class WebGPUTextures {
 
   _getBlockData(format) {
     // this method is only relevant for compressed texture formats
-    if (format === GPUTextureFormat.BC1RGBAUnorm || format === GPUTextureFormat.BC1RGBAUnormSRGB) return {
-      byteLength: 8,
-      width: 4,
-      height: 4
-    }; // DXT1
-
-    if (format === GPUTextureFormat.BC2RGBAUnorm || format === GPUTextureFormat.BC2RGBAUnormSRGB) return {
-      byteLength: 16,
-      width: 4,
-      height: 4
-    }; // DXT3
-
-    if (format === GPUTextureFormat.BC3RGBAUnorm || format === GPUTextureFormat.BC3RGBAUnormSRGB) return {
-      byteLength: 16,
-      width: 4,
-      height: 4
-    }; // DXT5
-
-    if (format === GPUTextureFormat.BC4RUnorm || format === GPUTextureFormat.BC4RSNorm) return {
-      byteLength: 8,
-      width: 4,
-      height: 4
-    }; // RGTC1
-
-    if (format === GPUTextureFormat.BC5RGUnorm || format === GPUTextureFormat.BC5RGSnorm) return {
-      byteLength: 16,
-      width: 4,
-      height: 4
-    }; // RGTC2
-
-    if (format === GPUTextureFormat.BC6HRGBUFloat || format === GPUTextureFormat.BC6HRGBFloat) return {
-      byteLength: 16,
-      width: 4,
-      height: 4
-    }; // BPTC (float)
-
-    if (format === GPUTextureFormat.BC7RGBAUnorm || format === GPUTextureFormat.BC7RGBAUnormSRGB) return {
-      byteLength: 16,
-      width: 4,
-      height: 4
-    }; // BPTC (unorm)
+    if (format === GPUTextureFormat.BC1RGBAUnorm || format === GPUTextureFormat.BC1RGBAUnormSRGB) {
+      return {
+        byteLength: 8,
+        width: 4,
+        height: 4
+      };
+    } // DXT1
+
+
+    if (format === GPUTextureFormat.BC2RGBAUnorm || format === GPUTextureFormat.BC2RGBAUnormSRGB) {
+      return {
+        byteLength: 16,
+        width: 4,
+        height: 4
+      };
+    } // DXT3
+
+
+    if (format === GPUTextureFormat.BC3RGBAUnorm || format === GPUTextureFormat.BC3RGBAUnormSRGB) {
+      return {
+        byteLength: 16,
+        width: 4,
+        height: 4
+      };
+    } // DXT5
+
+
+    if (format === GPUTextureFormat.BC4RUnorm || format === GPUTextureFormat.BC4RSNorm) {
+      return {
+        byteLength: 8,
+        width: 4,
+        height: 4
+      };
+    } // RGTC1
+
+
+    if (format === GPUTextureFormat.BC5RGUnorm || format === GPUTextureFormat.BC5RGSnorm) {
+      return {
+        byteLength: 16,
+        width: 4,
+        height: 4
+      };
+    } // RGTC2
+
+
+    if (format === GPUTextureFormat.BC6HRGBUFloat || format === GPUTextureFormat.BC6HRGBFloat) {
+      return {
+        byteLength: 16,
+        width: 4,
+        height: 4
+      };
+    } // BPTC (float)
+
+
+    if (format === GPUTextureFormat.BC7RGBAUnorm || format === GPUTextureFormat.BC7RGBAUnormSRGB) {
+      return {
+        byteLength: 16,
+        width: 4,
+        height: 4
+      };
+    } // BPTC (unorm)
+
   }
 
   _getBytesPerTexel(format) {

package/shaders/SSRShader.d.ts

@@ -27,8 +27,7 @@ export interface SSRShader {
         opacity: IUniform<number>;
         maxDistance: IUniform<number>;
         cameraRange: IUniform<number>;
-        surfDist: IUniform<number>;
-        thickTolerance: IUniform<number>;
+        thickness: IUniform<number>;
     };
     vertexShader: string;
     fragmentShader: string;

package/utils/BufferGeometryUtils.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),require("three"),require("../types/helpers.cjs.js");var e=require("../BufferGeometryUtils-9eb5c2e7.js");exports.computeMorphedAttributes=e.computeMorphedAttributes,exports.estimateBytesUsed=e.estimateBytesUsed,exports.interleaveAttributes=e.interleaveAttributes,exports.mergeBufferAttributes=e.mergeBufferAttributes,exports.mergeBufferGeometries=e.mergeBufferGeometries,exports.mergeVertices=e.mergeVertices,exports.toTrianglesDrawMode=e.toTrianglesDrawMode;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),require("three"),require("../types/helpers.cjs.js");var e=require("../BufferGeometryUtils-971dfde3.js");exports.computeMorphedAttributes=e.computeMorphedAttributes,exports.estimateBytesUsed=e.estimateBytesUsed,exports.interleaveAttributes=e.interleaveAttributes,exports.mergeBufferAttributes=e.mergeBufferAttributes,exports.mergeBufferGeometries=e.mergeBufferGeometries,exports.mergeVertices=e.mergeVertices,exports.toTrianglesDrawMode=e.toTrianglesDrawMode;

package/utils/BufferGeometryUtils.js

@@ -485,7 +485,8 @@ function computeMorphedAttributes(object) {
 
     const morphInfluences = object.morphTargetInfluences;
 
-    if (material.morphTargets && morphAttribute && morphInfluences) {
+    if ( // @ts-expect-error
+    material.morphTargets && morphAttribute && morphInfluences) {
       _morphA.set(0, 0, 0);
 
       _morphB.set(0, 0, 0);

package/utils/LDrawUtils.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t=require("three"),r=require("../BufferGeometryUtils-9eb5c2e7.js");require("../types/helpers.cjs.js");exports.LDrawUtils=class{static mergeObject(e){function i(r,e,i,n){const a=new t.BufferGeometry,o=r.getAttribute("position").array,s=3===i?r.getAttribute("normal").array:null,u=Math.min(e.count,Math.floor(o.length/3)-e.start),l=3*e.start,c=3*(e.start+u),f=o.subarray(l,c),m=null!==s?s.subarray(l,c):null;if(a.setAttribute("position",new t.BufferAttribute(f,3)),null!==m&&a.setAttribute("normal",new t.BufferAttribute(m,3)),n){const e=r.getAttribute("control0").array.subarray(l,c),i=r.getAttribute("control1").array.subarray(l,c),n=r.getAttribute("direction").array.subarray(l,c);a.setAttribute("control0",new t.BufferAttribute(e,3,!1)),a.setAttribute("control1",new t.BufferAttribute(i,3,!1)),a.setAttribute("direction",new t.BufferAttribute(n,3,!1))}return a}function n(t,r,e){const i=e[t.uuid];i?i.arr.push(r):e[t.uuid]={mat:t,arr:[r]}}function a(t,r){if(!t)return;const e=t.array,i=Math.floor(e.length/3);let n=0;for(let t=0;t<i;t++){const t=e[n],i=e[n+1],a=e[n+2];e[n]=e[n+3],e[n+1]=e[n+4],e[n+2]=e[n+5],e[n+3]=t,e[n+4]=i,e[n+5]=a,n+=3*r}}const o={},s={},u={};e.updateMatrixWorld(!0);const l=new t.Matrix3;e.traverse((t=>{if(t.isMesh|t.isLineSegments){const r=t.isMesh?3:2,e=t.geometry.clone();t.matrixWorld.determinant()<0&&(a(e.attributes.position,r),a(e.attributes.normal,r)),e.applyMatrix4(t.matrixWorld),t.isConditionalLine&&(e.attributes.control0.applyMatrix4(t.matrixWorld),e.attributes.control1.applyMatrix4(t.matrixWorld),l.getNormalMatrix(t.matrixWorld),e.attributes.direction.applyNormalMatrix(l));const c=t.isMesh?o:t.isConditionalLine?u:s;if(Array.isArray(t.material))for(const a in e.groups){const o=e.groups[a];n(t.material[o.materialIndex],i(e,o,r,t.isConditionalLine),c)}else n(t.material,e,c)}}));const c=new t.Group,f=Object.keys(o);for(const e in f){const i=o[f[e]],n=r.mergeBufferGeometries(i.arr);c.add(new t.Mesh(n,i.mat))}const m=Object.keys(s);for(const e in m){const i=s[m[e]],n=r.mergeBufferGeometries(i.arr);c.add(new t.LineSegments(n,i.mat))}const b=Object.keys(u);for(const e in b){const i=u[b[e]],n=r.mergeBufferGeometries(i.arr),a=new t.LineSegments(n,i.mat);a.isConditionalLine=!0,c.add(a)}return c.userData.constructionStep=0,c.userData.numConstructionSteps=1,c}};
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t=require("three"),r=require("../BufferGeometryUtils-971dfde3.js");require("../types/helpers.cjs.js");exports.LDrawUtils=class{static mergeObject(e){function i(r,e,i,n){const a=new t.BufferGeometry,o=r.getAttribute("position").array,s=3===i?r.getAttribute("normal").array:null,u=Math.min(e.count,Math.floor(o.length/3)-e.start),l=3*e.start,c=3*(e.start+u),f=o.subarray(l,c),m=null!==s?s.subarray(l,c):null;if(a.setAttribute("position",new t.BufferAttribute(f,3)),null!==m&&a.setAttribute("normal",new t.BufferAttribute(m,3)),n){const e=r.getAttribute("control0").array.subarray(l,c),i=r.getAttribute("control1").array.subarray(l,c),n=r.getAttribute("direction").array.subarray(l,c);a.setAttribute("control0",new t.BufferAttribute(e,3,!1)),a.setAttribute("control1",new t.BufferAttribute(i,3,!1)),a.setAttribute("direction",new t.BufferAttribute(n,3,!1))}return a}function n(t,r,e){const i=e[t.uuid];i?i.arr.push(r):e[t.uuid]={mat:t,arr:[r]}}function a(t,r){if(!t)return;const e=t.array,i=Math.floor(e.length/3);let n=0;for(let t=0;t<i;t++){const t=e[n],i=e[n+1],a=e[n+2];e[n]=e[n+3],e[n+1]=e[n+4],e[n+2]=e[n+5],e[n+3]=t,e[n+4]=i,e[n+5]=a,n+=3*r}}const o={},s={},u={};e.updateMatrixWorld(!0);const l=new t.Matrix3;e.traverse((t=>{if(t.isMesh|t.isLineSegments){const r=t.isMesh?3:2,e=t.geometry.clone();t.matrixWorld.determinant()<0&&(a(e.attributes.position,r),a(e.attributes.normal,r)),e.applyMatrix4(t.matrixWorld),t.isConditionalLine&&(e.attributes.control0.applyMatrix4(t.matrixWorld),e.attributes.control1.applyMatrix4(t.matrixWorld),l.getNormalMatrix(t.matrixWorld),e.attributes.direction.applyNormalMatrix(l));const c=t.isMesh?o:t.isConditionalLine?u:s;if(Array.isArray(t.material))for(const a in e.groups){const o=e.groups[a];n(t.material[o.materialIndex],i(e,o,r,t.isConditionalLine),c)}else n(t.material,e,c)}}));const c=new t.Group,f=Object.keys(o);for(const e in f){const i=o[f[e]],n=r.mergeBufferGeometries(i.arr);c.add(new t.Mesh(n,i.mat))}const m=Object.keys(s);for(const e in m){const i=s[m[e]],n=r.mergeBufferGeometries(i.arr);c.add(new t.LineSegments(n,i.mat))}const b=Object.keys(u);for(const e in b){const i=u[b[e]],n=r.mergeBufferGeometries(i.arr),a=new t.LineSegments(n,i.mat);a.isConditionalLine=!0,c.add(a)}return c.userData.constructionStep=0,c.userData.numConstructionSteps=1,c}};

package/utils/LDrawUtils.d.ts

@@ -0,0 +1,5 @@
+import { Group, Object3D } from 'three';
+
+export namespace LDrawUtils {
+    function mergeObject(object: Object3D): Group;
+}

package/utils/LDrawUtils.js

@@ -1,5 +1,5 @@
 import { Matrix3, Group, Mesh, LineSegments, BufferGeometry, BufferAttribute } from 'three';
-import { m as mergeBufferGeometries } from '../BufferGeometryUtils-582025b8.js';
+import { m as mergeBufferGeometries } from '../BufferGeometryUtils-1a7a235c.js';
 import '../types/helpers.js';
 
 class LDrawUtils {

package/utils/RoughnessMipmapper.js

@@ -31,7 +31,11 @@ RoughnessMipmapper.prototype = {
       roughnessMap,
       normalMap
     } = material;
-    if (roughnessMap === null || normalMap === null || !roughnessMap.generateMipmaps || material.userData.roughnessUpdated) return;
+
+    if (roughnessMap === null || normalMap === null || !roughnessMap.generateMipmaps || material.userData.roughnessUpdated) {
+      return;
+    }
+
     material.userData.roughnessUpdated = true;
     var width = Math.max(roughnessMap.image.width, normalMap.image.width);
     var height = Math.max(roughnessMap.image.height, normalMap.image.height);

package/utils/SceneUtils.d.ts

@@ -1,14 +1,12 @@
 import { BufferGeometry, Group, InstancedMesh, Material, Object3D, Scene } from 'three';
 
-export namespace SceneUtils {
-    function createMeshesFromInstancedMesh(instancedMesh: InstancedMesh): Group;
-    function createMultiMaterialObject(geometry: BufferGeometry, materials: Material[]): Group;
-    /**
-     * @deprecated Use scene.attach( child ) instead.
-     */
-    function detach(child: Object3D, parent: Object3D, scene: Scene): void;
-    /**
-     * @deprecated Use parent.attach( child ) instead.
-     */
-    function attach(child: Object3D, scene: Scene, parent: Object3D): void;
-}
+export function createMeshesFromInstancedMesh(instancedMesh: InstancedMesh): Group;
+export function createMultiMaterialObject(geometry: BufferGeometry, materials: Material[]): Group;
+/**
+ * @deprecated Use scene.attach( child ) instead.
+ */
+export function detach(child: Object3D, parent: Object3D, scene: Scene): void;
+/**
+ * @deprecated Use parent.attach( child ) instead.
+ */
+export function attach(child: Object3D, scene: Scene, parent: Object3D): void;

package/utils/ShadowMapViewer.js

@@ -111,7 +111,10 @@ var ShadowMapViewer = function (light) {
       var width = scope.size.width;
       var height = scope.size.height;
       mesh.position.set(-window.innerWidth / 2 + width / 2 + this.x, window.innerHeight / 2 - height / 2 - this.y, 0);
-      if (doRenderLabel) labelMesh.position.set(mesh.position.x, mesh.position.y - scope.size.height / 2 + labelCanvas.height / 2, 0);
+
+      if (doRenderLabel) {
+        labelMesh.position.set(mesh.position.x, mesh.position.y - scope.size.height / 2 + labelCanvas.height / 2, 0);
+      }
     }
   };
 

package/webxr/OculusHandModel.cjs.js

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

package/webxr/OculusHandModel.d.ts

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

package/webxr/OculusHandModel.js

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

package/webxr/OculusHandPointerModel.cjs.js

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

package/webxr/OculusHandPointerModel.d.ts

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

package/webxr/OculusHandPointerModel.js

@@ -0,0 +1,248 @@
+import * as THREE from 'three';
+
+const PINCH_MAX = 0.05;
+const PINCH_THRESHOLD = 0.02;
+const PINCH_MIN = 0.01;
+const POINTER_ADVANCE_MAX = 0.02;
+const POINTER_OPACITY_MAX = 1;
+const POINTER_OPACITY_MIN = 0.4;
+const POINTER_FRONT_RADIUS = 0.002;
+const POINTER_REAR_RADIUS = 0.01;
+const POINTER_REAR_RADIUS_MIN = 0.003;
+const POINTER_LENGTH = 0.035;
+const POINTER_SEGMENTS = 16;
+const POINTER_RINGS = 12;
+const POINTER_HEMISPHERE_ANGLE = 110;
+const YAXIS = new THREE.Vector3(0, 1, 0);
+const ZAXIS = new THREE.Vector3(0, 0, 1);
+const CURSOR_RADIUS = 0.02;
+const CURSOR_MAX_DISTANCE = 1.5;
+
+class OculusHandPointerModel extends THREE.Object3D {
+  constructor(hand, controller) {
+    super();
+    this.hand = hand;
+    this.controller = controller;
+    this.motionController = null;
+    this.envMap = null;
+    this.mesh = null;
+    this.pointerGeometry = null;
+    this.pointerMesh = null;
+    this.pointerObject = null;
+    this.pinched = false;
+    this.attached = false;
+    this.cursorObject = null;
+    this.raycaster = null;
+    hand.addEventListener('connected', event => {
+      const xrInputSource = event.data;
+
+      if (xrInputSource.hand) {
+        this.visible = true;
+        this.xrInputSource = xrInputSource;
+        this.createPointer();
+      }
+    });
+  }
+
+  _drawVerticesRing(vertices, baseVector, ringIndex) {
+    const segmentVector = baseVector.clone();
+
+    for (var i = 0; i < POINTER_SEGMENTS; i++) {
+      segmentVector.applyAxisAngle(ZAXIS, Math.PI * 2 / POINTER_SEGMENTS);
+      const vid = ringIndex * POINTER_SEGMENTS + i;
+      vertices[3 * vid] = segmentVector.x;
+      vertices[3 * vid + 1] = segmentVector.y;
+      vertices[3 * vid + 2] = segmentVector.z;
+    }
+  }
+
+  _updatePointerVertices(rearRadius) {
+    const vertices = this.pointerGeometry.attributes.position.array; // first ring for front face
+
+    const frontFaceBase = new THREE.Vector3(POINTER_FRONT_RADIUS, 0, -1 * (POINTER_LENGTH - rearRadius));
+
+    this._drawVerticesRing(vertices, frontFaceBase, 0); // rings for rear hemisphere
+
+
+    const rearBase = new THREE.Vector3(Math.sin(Math.PI * POINTER_HEMISPHERE_ANGLE / 180) * rearRadius, Math.cos(Math.PI * POINTER_HEMISPHERE_ANGLE / 180) * rearRadius, 0);
+
+    for (var i = 0; i < POINTER_RINGS; i++) {
+      this._drawVerticesRing(vertices, rearBase, i + 1);
+
+      rearBase.applyAxisAngle(YAXIS, Math.PI * POINTER_HEMISPHERE_ANGLE / 180 / (POINTER_RINGS * -2));
+    } // front and rear face center vertices
+
+
+    const frontCenterIndex = POINTER_SEGMENTS * (1 + POINTER_RINGS);
+    const rearCenterIndex = POINTER_SEGMENTS * (1 + POINTER_RINGS) + 1;
+    const frontCenter = new THREE.Vector3(0, 0, -1 * (POINTER_LENGTH - rearRadius));
+    vertices[frontCenterIndex * 3] = frontCenter.x;
+    vertices[frontCenterIndex * 3 + 1] = frontCenter.y;
+    vertices[frontCenterIndex * 3 + 2] = frontCenter.z;
+    const rearCenter = new THREE.Vector3(0, 0, rearRadius);
+    vertices[rearCenterIndex * 3] = rearCenter.x;
+    vertices[rearCenterIndex * 3 + 1] = rearCenter.y;
+    vertices[rearCenterIndex * 3 + 2] = rearCenter.z;
+    this.pointerGeometry.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3)); // verticesNeedUpdate = true;
+  }
+
+  createPointer() {
+    var i, j;
+    const vertices = new Array(((POINTER_RINGS + 1) * POINTER_SEGMENTS + 2) * 3).fill(0); // const vertices = [];
+
+    const indices = [];
+    this.pointerGeometry = new THREE.BufferGeometry();
+    this.pointerGeometry.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3));
+
+    this._updatePointerVertices(POINTER_REAR_RADIUS); // construct faces to connect rings
+
+
+    for (i = 0; i < POINTER_RINGS; i++) {
+      for (j = 0; j < POINTER_SEGMENTS - 1; j++) {
+        indices.push(i * POINTER_SEGMENTS + j, i * POINTER_SEGMENTS + j + 1, (i + 1) * POINTER_SEGMENTS + j);
+        indices.push(i * POINTER_SEGMENTS + j + 1, (i + 1) * POINTER_SEGMENTS + j + 1, (i + 1) * POINTER_SEGMENTS + j);
+      }
+
+      indices.push((i + 1) * POINTER_SEGMENTS - 1, i * POINTER_SEGMENTS, (i + 2) * POINTER_SEGMENTS - 1);
+      indices.push(i * POINTER_SEGMENTS, (i + 1) * POINTER_SEGMENTS, (i + 2) * POINTER_SEGMENTS - 1);
+    } // construct front and rear face
+
+
+    const frontCenterIndex = POINTER_SEGMENTS * (1 + POINTER_RINGS);
+    const rearCenterIndex = POINTER_SEGMENTS * (1 + POINTER_RINGS) + 1;
+
+    for (i = 0; i < POINTER_SEGMENTS - 1; i++) {
+      indices.push(frontCenterIndex, i + 1, i);
+      indices.push(rearCenterIndex, i + POINTER_SEGMENTS * POINTER_RINGS, i + POINTER_SEGMENTS * POINTER_RINGS + 1);
+    }
+
+    indices.push(frontCenterIndex, 0, POINTER_SEGMENTS - 1);
+    indices.push(rearCenterIndex, POINTER_SEGMENTS * (POINTER_RINGS + 1) - 1, POINTER_SEGMENTS * POINTER_RINGS);
+    const material = new THREE.MeshBasicMaterial();
+    material.transparent = true;
+    material.opacity = POINTER_OPACITY_MIN;
+    this.pointerGeometry.setIndex(indices);
+    this.pointerMesh = new THREE.Mesh(this.pointerGeometry, material);
+    this.pointerMesh.position.set(0, 0, -1 * POINTER_REAR_RADIUS);
+    this.pointerObject = new THREE.Object3D();
+    this.pointerObject.add(this.pointerMesh);
+    this.raycaster = new THREE.Raycaster(); // create cursor
+
+    const cursorGeometry = new THREE.SphereGeometry(CURSOR_RADIUS, 10, 10);
+    const cursorMaterial = new THREE.MeshBasicMaterial();
+    cursorMaterial.transparent = true;
+    cursorMaterial.opacity = POINTER_OPACITY_MIN;
+    this.cursorObject = new THREE.Mesh(cursorGeometry, cursorMaterial);
+    this.pointerObject.add(this.cursorObject);
+    this.add(this.pointerObject);
+  }
+
+  _updateRaycaster() {
+    if (this.raycaster) {
+      const pointerMatrix = this.pointerObject.matrixWorld;
+      const tempMatrix = new THREE.Matrix4();
+      tempMatrix.identity().extractRotation(pointerMatrix);
+      this.raycaster.ray.origin.setFromMatrixPosition(pointerMatrix);
+      this.raycaster.ray.direction.set(0, 0, -1).applyMatrix4(tempMatrix);
+    }
+  }
+
+  _updatePointer() {
+    this.pointerObject.visible = this.controller.visible;
+    const indexTip = this.hand.joints['index-finger-tip'];
+    const thumbTip = this.hand.joints['thumb-tip'];
+    const distance = indexTip.position.distanceTo(thumbTip.position);
+    const position = indexTip.position.clone().add(thumbTip.position).multiplyScalar(0.5);
+    this.pointerObject.position.copy(position);
+    this.pointerObject.quaternion.copy(this.controller.quaternion);
+    this.pinched = distance <= PINCH_THRESHOLD;
+    const pinchScale = (distance - PINCH_MIN) / (PINCH_MAX - PINCH_MIN);
+    const focusScale = (distance - PINCH_MIN) / (PINCH_THRESHOLD - PINCH_MIN);
+
+    if (pinchScale > 1) {
+      this._updatePointerVertices(POINTER_REAR_RADIUS);
+
+      this.pointerMesh.position.set(0, 0, -1 * POINTER_REAR_RADIUS);
+      this.pointerMesh.material.opacity = POINTER_OPACITY_MIN;
+    } else if (pinchScale > 0) {
+      const rearRadius = (POINTER_REAR_RADIUS - POINTER_REAR_RADIUS_MIN) * pinchScale + POINTER_REAR_RADIUS_MIN;
+
+      this._updatePointerVertices(rearRadius);
+
+      if (focusScale < 1) {
+        this.pointerMesh.position.set(0, 0, -1 * rearRadius - (1 - focusScale) * POINTER_ADVANCE_MAX);
+        this.pointerMesh.material.opacity = POINTER_OPACITY_MIN + (1 - focusScale) * (POINTER_OPACITY_MAX - POINTER_OPACITY_MIN);
+      } else {
+        this.pointerMesh.position.set(0, 0, -1 * rearRadius);
+        this.pointerMesh.material.opacity = POINTER_OPACITY_MIN;
+      }
+    } else {
+      this._updatePointerVertices(POINTER_REAR_RADIUS_MIN);
+
+      this.pointerMesh.position.set(0, 0, -1 * POINTER_REAR_RADIUS_MIN - POINTER_ADVANCE_MAX);
+      this.pointerMesh.material.opacity = POINTER_OPACITY_MAX;
+    }
+
+    this.cursorObject.material.opacity = this.pointerMesh.material.opacity;
+  }
+
+  updateMatrixWorld(force) {
+    super.updateMatrixWorld(force);
+
+    if (this.pointerGeometry) {
+      this._updatePointer();
+
+      this._updateRaycaster();
+    }
+  }
+
+  isPinched() {
+    return this.pinched;
+  }
+
+  setAttached(attached) {
+    this.attached = attached;
+  }
+
+  isAttached() {
+    return this.attached;
+  }
+
+  intersectObject(object, recursive = true) {
+    if (this.raycaster) {
+      return this.raycaster.intersectObject(object, recursive);
+    }
+  }
+
+  intersectObjects(objects, recursive = true) {
+    if (this.raycaster) {
+      return this.raycaster.intersectObjects(objects, recursive);
+    }
+  }
+
+  checkIntersections(objects, recursive = false) {
+    if (this.raycaster && !this.attached) {
+      const intersections = this.raycaster.intersectObjects(objects, recursive);
+      const direction = new THREE.Vector3(0, 0, -1);
+
+      if (intersections.length > 0) {
+        const intersection = intersections[0];
+        const distance = intersection.distance;
+        this.cursorObject.position.copy(direction.multiplyScalar(distance));
+      } else {
+        this.cursorObject.position.copy(direction.multiplyScalar(CURSOR_MAX_DISTANCE));
+      }
+    }
+  }
+
+  setCursor(distance) {
+    const direction = new THREE.Vector3(0, 0, -1);
+
+    if (this.raycaster && !this.attached) {
+      this.cursorObject.position.copy(direction.multiplyScalar(distance));
+    }
+  }
+
+}
+
+export { OculusHandPointerModel };

package/webxr/Text2D.cjs.js

@@ -0,0 +1 @@
+"use strict";function e(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(r){if("default"!==r){var n=Object.getOwnPropertyDescriptor(e,r);Object.defineProperty(t,r,n.get?n:{enumerable:!0,get:function(){return e[r]}})}})),t.default=e,Object.freeze(t)}Object.defineProperty(exports,"__esModule",{value:!0});var t=e(require("three"));exports.createText=function(e,r){const n=document.createElement("canvas"),l=n.getContext("2d");let o=null;const a=100;l.font="normal 100px Arial",o=l.measureText(e);const c=o.width;n.width=c,n.height=a,l.font="normal 100px Arial",l.textAlign="center",l.textBaseline="middle",l.fillStyle="#ffffff",l.fillText(e,c/2,50);const i=new t.Texture(n);i.needsUpdate=!0;const f=new t.MeshBasicMaterial({color:16777215,side:t.DoubleSide,map:i,transparent:!0}),s=new t.PlaneGeometry(r*c/a,r);return new t.Mesh(s,f)};

package/webxr/Text2D.d.ts

@@ -0,0 +1,3 @@
+import { Mesh } from 'three';
+
+export function createText(message: string, height: number): Mesh;