three-stdlib 2.35.6 → 2.35.8

package/utils/RoughnessMipmapper.d.ts

@@ -1,4 +1,4 @@
-import { Material, WebGLRenderer } from 'three'
+import type { Material, WebGLRenderer } from 'three'
 
 export class RoughnessMipmapper {
   constructor(renderer: WebGLRenderer)

package/utils/SceneUtils.d.cts

@@ -0,0 +1,9 @@
+import type { Group } from 'three';
+import type { BufferGeometry, InstancedMesh, Material, Object3D, Scene } from 'three';
+declare const SceneUtils: {
+    createMeshesFromInstancedMesh: (instancedMesh: InstancedMesh) => Group;
+    createMultiMaterialObject: (geometry: BufferGeometry, materials: Material[]) => Group;
+    detach: (child: Object3D, parent: Object3D, scene: Scene) => void;
+    attach: (child: Object3D, scene: Scene, parent: Object3D) => void;
+};
+export { type SceneUtils };

package/utils/SceneUtils.d.ts

@@ -1,4 +1,4 @@
-import { Group } from 'three';
+import type { Group } from 'three';
 import type { BufferGeometry, InstancedMesh, Material, Object3D, Scene } from 'three';
 declare const SceneUtils: {
     createMeshesFromInstancedMesh: (instancedMesh: InstancedMesh) => Group;
@@ -6,4 +6,4 @@ declare const SceneUtils: {
     detach: (child: Object3D, parent: Object3D, scene: Scene) => void;
     attach: (child: Object3D, scene: Scene, parent: Object3D) => void;
 };
-export { SceneUtils };
+export { type SceneUtils };

package/utils/ShadowMapViewer.d.cts

@@ -0,0 +1,24 @@
+import type { Light, WebGLRenderer } from 'three'
+
+export interface Size {
+  width: number
+  height: number
+  set: (width: number, height: number) => void
+}
+
+export interface Position {
+  x: number
+  y: number
+  set: (x: number, y: number) => void
+}
+
+export class ShadowMapViewer {
+  constructor(light: Light)
+
+  enabled: boolean
+  size: Size
+  position: Position
+  render(renderer: WebGLRenderer): void
+  updateForWindowResize(): void
+  update(): void
+}

package/utils/ShadowMapViewer.d.ts

@@ -1,4 +1,4 @@
-import { Light, WebGLRenderer } from 'three'
+import type { Light, WebGLRenderer } from 'three'
 
 export interface Size {
   width: number

package/utils/SkeletonUtils.d.cts

@@ -0,0 +1,14 @@
+import type { AnimationClip, Object3D, Skeleton } from 'three'
+
+export namespace SkeletonUtils {
+  export function clone(source: Object3D): Object3D
+
+  export function retarget(target: Object3D | Skeleton, source: Object3D | Skeleton, options: {}): void
+
+  export function retargetClip(
+    target: Skeleton | Object3D,
+    source: Skeleton | Object3D,
+    clip: AnimationClip,
+    options: {},
+  ): AnimationClip
+}

package/utils/SkeletonUtils.d.ts

@@ -1,4 +1,4 @@
-import { AnimationClip, Object3D, Skeleton } from 'three'
+import type { AnimationClip, Object3D, Skeleton } from 'three'
 
 export namespace SkeletonUtils {
   export function clone(source: Object3D): Object3D

package/utils/UVsDebug.d.cts

@@ -0,0 +1,3 @@
+import type { BufferGeometry } from 'three'
+
+export function UVsDebug(geometry: BufferGeometry, size: number): HTMLCanvasElement

package/utils/UVsDebug.d.ts

@@ -1,3 +1,3 @@
-import { BufferGeometry } from 'three'
+import type { BufferGeometry } from 'three'
 
 export function UVsDebug(geometry: BufferGeometry, size: number): HTMLCanvasElement

package/webxr/ARButton.d.cts

@@ -0,0 +1,6 @@
+/// <reference types="webxr" />
+import type { WebGLRenderer } from 'three';
+declare const ARButton: {
+    createButton(renderer: WebGLRenderer, sessionInit?: XRSessionInit): HTMLButtonElement | HTMLAnchorElement;
+};
+export { type ARButton };

package/webxr/ARButton.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="webxr" />
-import { WebGLRenderer } from 'three';
+import type { WebGLRenderer } from 'three';
 declare const ARButton: {
     createButton(renderer: WebGLRenderer, sessionInit?: XRSessionInit): HTMLButtonElement | HTMLAnchorElement;
 };
-export { ARButton };
+export { type ARButton };

package/webxr/OculusHandModel.d.cts

@@ -0,0 +1,23 @@
+/// <reference types="webxr" />
+import type { Object3D, Mesh, Texture, Vector3 } from 'three';
+import type { XRHandMeshModel } from './XRHandMeshModel.d.cts';
+export interface XRButton extends Object3D {
+    onPress(): void;
+    onClear(): void;
+    isPressed(): boolean;
+    whilePressed(): void;
+}
+declare class OculusHandModel extends Object3D {
+    controller: Object3D;
+    motionController: XRHandMeshModel | null;
+    envMap: Texture | null;
+    mesh: Mesh | null;
+    xrInputSource: XRInputSource | null;
+    constructor(controller: Object3D, leftModelPath?: string, rightModelPath?: string);
+    updateMatrixWorld(force?: boolean): void;
+    getPointerPosition(): Vector3 | null;
+    intersectBoxObject(boxObject: Object3D): boolean;
+    checkButton(button: XRButton): void;
+    dispose(): void;
+}
+export { type OculusHandModel };

package/webxr/OculusHandModel.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="webxr" />
-import { Object3D, Mesh, Texture, Vector3 } from 'three';
-import { XRHandMeshModel } from './XRHandMeshModel';
+import type { Object3D, Mesh, Texture, Vector3 } from 'three';
+import type { XRHandMeshModel } from './XRHandMeshModel.d.ts';
 export interface XRButton extends Object3D {
     onPress(): void;
     onClear(): void;
@@ -20,4 +20,4 @@ declare class OculusHandModel extends Object3D {
     checkButton(button: XRButton): void;
     dispose(): void;
 }
-export { OculusHandModel };
+export { type OculusHandModel };

package/webxr/OculusHandPointerModel.d.cts

@@ -0,0 +1,65 @@
+import type {
+  BufferGeometry,
+  Intersection,
+  Mesh,
+  MeshBasicMaterial,
+  Object3D,
+  Raycaster,
+  SphereGeometry,
+  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<SphereGeometry, 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
+
+  public dispose(): void
+}

package/webxr/OculusHandPointerModel.d.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   BufferGeometry,
   Intersection,
   Mesh,

package/webxr/Text2D.d.cts

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

package/webxr/Text2D.d.ts

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

package/webxr/VRButton.d.cts

@@ -0,0 +1,11 @@
+import type { WebGLRenderer } from 'three'
+
+declare class VRButton {
+  static createButton(renderer: WebGLRenderer, sessionInit?: XRSessionInit): HTMLButtonElement | HTMLAnchorElement
+
+  static xrSessionIsGranted: boolean
+
+  static registerSessionGrantedListener(): void
+}
+
+export { type VRButton }

package/webxr/VRButton.d.ts

@@ -1,4 +1,4 @@
-import { WebGLRenderer } from 'three'
+import type { WebGLRenderer } from 'three'
 
 declare class VRButton {
   static createButton(renderer: WebGLRenderer, sessionInit?: XRSessionInit): HTMLButtonElement | HTMLAnchorElement
@@ -8,4 +8,4 @@ declare class VRButton {
   static registerSessionGrantedListener(): void
 }
 
-export { VRButton }
+export { type VRButton }

package/webxr/XRControllerModelFactory.d.cts

@@ -0,0 +1,23 @@
+import type { Object3D } from 'three';
+import type { Texture, Group } from 'three';
+import type { GLTFLoader } from '../loaders/GLTFLoader.d.cts';
+import type { MotionController } from '../libs/MotionControllers.d.cts';
+declare class XRControllerModel extends Object3D {
+    envMap: Texture | null;
+    motionController: MotionController | null;
+    constructor();
+    setEnvironmentMap(envMap: Texture): XRControllerModel;
+    /**
+     * Polls data from the XRInputSource and updates the model's components to match
+     * the real world data
+     */
+    updateMatrixWorld(force: boolean): void;
+}
+declare class XRControllerModelFactory {
+    gltfLoader: GLTFLoader;
+    path: string;
+    private _assetCache;
+    constructor(gltfLoader?: GLTFLoader);
+    createControllerModel(controller: Group): XRControllerModel;
+}
+export { type XRControllerModelFactory };

package/webxr/XRControllerModelFactory.d.ts

@@ -1,7 +1,7 @@
-import { Object3D } from 'three';
+import type { Object3D } from 'three';
 import type { Texture, Group } from 'three';
-import { GLTFLoader } from '../loaders/GLTFLoader';
-import { MotionController } from '../libs/MotionControllers';
+import type { GLTFLoader } from '../loaders/GLTFLoader.d.ts';
+import type { MotionController } from '../libs/MotionControllers.d.ts';
 declare class XRControllerModel extends Object3D {
     envMap: Texture | null;
     motionController: MotionController | null;
@@ -20,4 +20,4 @@ declare class XRControllerModelFactory {
     constructor(gltfLoader?: GLTFLoader);
     createControllerModel(controller: Group): XRControllerModel;
 }
-export { XRControllerModelFactory };
+export { type XRControllerModelFactory };

package/webxr/XREstimatedLight.d.cts

@@ -0,0 +1,33 @@
+/// <reference types="webxr" />
+import type { DirectionalLight, Group, LightProbe, WebGLRenderer, Texture } from 'three'
+
+export class SessionLightProbe {
+  xrLight: XREstimatedLight
+  renderer: WebGLRenderer
+  lightProbe: unknown
+  xrWebGLBinding: unknown | null
+  estimationStartCallback: () => void
+  frameCallback: (this: SessionLightProbe, time: number, xrFrame: XRFrame) => void
+
+  constructor(
+    xrLight: XREstimatedLight,
+    renderer: WebGLRenderer,
+    lightProbe: unknown,
+    environmentEstimation: boolean,
+    estimationStartCallback: () => void,
+  )
+
+  updateReflection: () => void
+
+  onXRFrame: (time: number, xrFrame: XRFrame) => void
+
+  dispose: () => void
+}
+
+export class XREstimatedLight extends Group {
+  lightProbe: LightProbe
+  directionalLight: DirectionalLight
+  environment: Texture
+
+  constructor(renderer: WebGLRenderer, environmentEstimation?: boolean)
+}

package/webxr/XREstimatedLight.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="webxr" />
-import { DirectionalLight, Group, LightProbe, WebGLRenderer, Texture } from 'three'
+import type { DirectionalLight, Group, LightProbe, WebGLRenderer, Texture } from 'three'
 
 export class SessionLightProbe {
   xrLight: XREstimatedLight

package/webxr/XRHandMeshModel.d.cts

@@ -0,0 +1,9 @@
+import type { 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 { type XRHandMeshModel };

package/webxr/XRHandMeshModel.d.ts

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

package/webxr/XRHandModelFactory.d.cts

@@ -0,0 +1,25 @@
+import type { Group, Object3D } from 'three'
+
+import type { XRHandPrimitiveModel, XRHandPrimitiveModelOptions } from './XRHandPrimitiveModel.d.cts'
+import type { XRHandMeshModel } from './XRHandMeshModel.d.cts'
+
+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/webxr/XRHandModelFactory.d.ts

@@ -1,7 +1,7 @@
-import { Group, Object3D } from 'three'
+import type { Group, Object3D } from 'three'
 
-import { XRHandPrimitiveModel, XRHandPrimitiveModelOptions } from './XRHandPrimitiveModel'
-import { XRHandMeshModel } from './XRHandMeshModel'
+import type { XRHandPrimitiveModel, XRHandPrimitiveModelOptions } from './XRHandPrimitiveModel.d.ts'
+import type { XRHandMeshModel } from './XRHandMeshModel.d.ts'
 
 export type XRHandModelHandedness = 'left' | 'right'
 

package/webxr/XRHandPrimitiveModel.d.cts

@@ -0,0 +1,24 @@
+import type { Group, Texture } from 'three'
+
+import type { XRHandModel, XRHandModelHandedness } from './XRHandModelFactory.d.cts'
+
+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/webxr/XRHandPrimitiveModel.d.ts

@@ -1,6 +1,6 @@
-import { Group, Texture } from 'three'
+import type { Group, Texture } from 'three'
 
-import { XRHandModel, XRHandModelHandedness } from './XRHandModelFactory'
+import type { XRHandModel, XRHandModelHandedness } from './XRHandModelFactory.d.ts'
 
 export interface XRHandPrimitiveModelOptions {
   primitive?: 'sphere' | 'box' | undefined