three-stdlib 2.35.7 → 2.35.8

package/shaders/UnpackDepthRGBAShader.d.cts

@@ -0,0 +1,16 @@
+/**
+ * Unpack RGBA depth shader
+ * - show RGBA encoded depth as monochrome color
+ */
+export declare const UnpackDepthRGBAShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        opacity: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/VerticalBlurShader.d.cts

@@ -0,0 +1,18 @@
+/**
+ * Two pass Gaussian blur filter (horizontal and vertical blur shaders)
+ * - described in http://www.gamerendering.com/2008/10/11/gaussian-blur-filter-shader/
+ *   and used in http://www.cake23.de/traveling-wavefronts-lit-up.html
+ *
+ * - 9 samples per pass
+ * - standard deviation 2.7
+ * - "h" and "v" parameters should be set to "1 / width" and "1 / height"
+ */
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types.d.cts';
+export type VerticalBlurShaderUniforms = {
+    tDiffuse: IUniform<Texture | null>;
+    v: IUniform<number>;
+};
+export interface IVerticalBlurShader extends IShader<VerticalBlurShaderUniforms> {
+}
+export declare const VerticalBlurShader: IVerticalBlurShader;

package/shaders/VerticalBlurShader.d.ts

@@ -8,7 +8,7 @@
  * - "h" and "v" parameters should be set to "1 / width" and "1 / height"
  */
 import type { IUniform, Texture } from 'three';
-import type { IShader } from './types';
+import type { IShader } from './types.d.ts';
 export type VerticalBlurShaderUniforms = {
     tDiffuse: IUniform<Texture | null>;
     v: IUniform<number>;

package/shaders/VerticalTiltShiftShader.d.cts

@@ -0,0 +1,23 @@
+/**
+ * Simple fake tilt-shift effect, modulating two pass Gaussian blur (see above) by vertical position
+ *
+ * - 9 samples per pass
+ * - standard deviation 2.7
+ * - "h" and "v" parameters should be set to "1 / width" and "1 / height"
+ * - "r" parameter control where "focused" horizontal line lies
+ */
+export declare const VerticalTiltShiftShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        v: {
+            value: number;
+        };
+        r: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/VignetteShader.d.cts

@@ -0,0 +1,20 @@
+/**
+ * Vignette shader
+ * based on PaintEffect postprocess from ro.me
+ * http://code.google.com/p/3-dreams-of-black/source/browse/deploy/js/effects/PaintEffect.js
+ */
+export declare const VignetteShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        offset: {
+            value: number;
+        };
+        darkness: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/VolumeShader.d.cts

@@ -0,0 +1,30 @@
+import type { Vector2, Vector3 } from 'three';
+/**
+ * Shaders to render 3D volumes using raycasting.
+ * The applied techniques are based on similar implementations in the Visvis and Vispy projects.
+ * This is not the only approach, therefore it's marked 1.
+ */
+export declare const VolumeRenderShader1: {
+    uniforms: {
+        u_size: {
+            value: Vector3;
+        };
+        u_renderstyle: {
+            value: number;
+        };
+        u_renderthreshold: {
+            value: number;
+        };
+        u_clim: {
+            value: Vector2;
+        };
+        u_data: {
+            value: null;
+        };
+        u_cmdata: {
+            value: null;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/VolumeShader.d.ts

@@ -1,4 +1,4 @@
-import { Vector2, Vector3 } from 'three';
+import type { Vector2, Vector3 } from 'three';
 /**
  * Shaders to render 3D volumes using raycasting.
  * The applied techniques are based on similar implementations in the Visvis and Vispy projects.

package/shaders/WaterRefractionShader.d.cts

@@ -0,0 +1,21 @@
+export declare const WaterRefractionShader: {
+    uniforms: {
+        color: {
+            value: null;
+        };
+        time: {
+            value: number;
+        };
+        tDiffuse: {
+            value: null;
+        };
+        tDudv: {
+            value: null;
+        };
+        textureMatrix: {
+            value: null;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/types.d.cts

@@ -0,0 +1,13 @@
+import type { IUniform } from 'three';
+export type Defines = {
+    [key: string]: boolean | number | string;
+};
+export type Uniforms = {
+    [key: string]: IUniform;
+};
+export interface IShader<U extends Uniforms, D extends Defines | undefined = undefined> {
+    defines?: D;
+    fragmentShader: string;
+    uniforms: U;
+    vertexShader: string;
+}

package/textures/FlakesTexture.d.cts

@@ -0,0 +1,4 @@
+declare class FlakesTexture {
+    constructor(width?: number, height?: number);
+}
+export { type FlakesTexture };

package/textures/FlakesTexture.d.ts

@@ -1,4 +1,4 @@
 declare class FlakesTexture {
     constructor(width?: number, height?: number);
 }
-export { FlakesTexture };
+export { type FlakesTexture };

package/types/helpers.d.cts

@@ -0,0 +1 @@
+export declare const getWithKey: <T, K extends keyof T>(obj: T, key: K) => T[K];

package/types/shared.d.cts

@@ -0,0 +1,9 @@
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
+export type TypedArrayConstructors = Int8Array['constructor'] | Uint8Array['constructor'] | Uint8ClampedArray['constructor'] | Int16Array['constructor'] | Uint16Array['constructor'] | Int32Array['constructor'] | Uint32Array['constructor'] | Float32Array['constructor'] | Float64Array['constructor'];
+type LinearEncoding = 3000;
+type sRGBEncoding = 3001;
+/**
+ * Stub for `TextureEncoding` type since it was removed in r162.
+ */
+export type TextureEncoding = LinearEncoding | sRGBEncoding;
+export {};

package/types/utils.d.cts

@@ -0,0 +1,3 @@
+export type Nullable<T> = {
+    [K in keyof T]: T[K] | null;
+};

package/utils/BufferGeometryUtils.d.cts

@@ -0,0 +1,63 @@
+import type { BufferAttribute, BufferGeometry, Float32BufferAttribute, InterleavedBufferAttribute, Mesh, Line, Points } from 'three';
+/**
+ * @param  {Array<BufferGeometry>} geometries
+ * @param  {Boolean} useGroups
+ * @return {BufferGeometry}
+ */
+export declare const mergeBufferGeometries: (geometries: BufferGeometry[], useGroups?: boolean) => BufferGeometry | null;
+/**
+ * @param {Array<BufferAttribute>} attributes
+ * @return {BufferAttribute}
+ */
+export declare const mergeBufferAttributes: (attributes: BufferAttribute[]) => BufferAttribute | null | undefined;
+/**
+ * @param {Array<BufferAttribute>} attributes
+ * @return {Array<InterleavedBufferAttribute>}
+ */
+export declare const interleaveAttributes: (attributes: BufferAttribute[]) => InterleavedBufferAttribute[] | null;
+/**
+ * @param {Array<BufferGeometry>} geometry
+ * @return {number}
+ */
+export declare function estimateBytesUsed(geometry: BufferGeometry): number;
+/**
+ * @param {BufferGeometry} geometry
+ * @param {number} tolerance
+ * @return {BufferGeometry>}
+ */
+export declare function mergeVertices(geometry: BufferGeometry, tolerance?: number): BufferGeometry;
+/**
+ * @param {BufferGeometry} geometry
+ * @param {number} drawMode
+ * @return {BufferGeometry}
+ */
+export declare function toTrianglesDrawMode(geometry: BufferGeometry, drawMode: number): BufferGeometry;
+/**
+ * Calculates the morphed attributes of a morphed/skinned BufferGeometry.
+ * Helpful for Raytracing or Decals.
+ * @param {Mesh | Line | Points} object An instance of Mesh, Line or Points.
+ * @return {Object} An Object with original position/normal attributes and morphed ones.
+ */
+export type ComputedMorphedAttribute = {
+    positionAttribute: BufferAttribute | InterleavedBufferAttribute;
+    normalAttribute: BufferAttribute | InterleavedBufferAttribute;
+    morphedPositionAttribute: Float32BufferAttribute;
+    morphedNormalAttribute: Float32BufferAttribute;
+};
+export declare function computeMorphedAttributes(object: Mesh | Line | Points): ComputedMorphedAttribute | null;
+/**
+ * Modifies the supplied geometry if it is non-indexed, otherwise creates a new,
+ * non-indexed geometry. Returns the geometry with smooth normals everywhere except
+ * faces that meet at an angle greater than the crease angle.
+ *
+ * Backwards compatible with code such as @react-three/drei's `<RoundedBox>`
+ * which uses this method to operate on the original geometry.
+ *
+ * As of this writing, BufferGeometry.toNonIndexed() warns if the geometry is
+ * non-indexed and returns `this`, i.e. the same geometry on which it was called:
+ * `BufferGeometry is already non-indexed.`
+ *
+ * @param geometry
+ * @param creaseAngle
+ */
+export declare function toCreasedNormals(geometry: BufferGeometry, creaseAngle?: number): BufferGeometry;

package/utils/BufferGeometryUtils.d.ts

@@ -1,4 +1,4 @@
-import { BufferAttribute, BufferGeometry, Float32BufferAttribute, InterleavedBufferAttribute, Mesh, Line, Points } from 'three';
+import type { BufferAttribute, BufferGeometry, Float32BufferAttribute, InterleavedBufferAttribute, Mesh, Line, Points } from 'three';
 /**
  * @param  {Array<BufferGeometry>} geometries
  * @param  {Boolean} useGroups

package/utils/GeometryCompressionUtils.d.cts

@@ -0,0 +1,7 @@
+import type { Mesh } from 'three'
+
+export namespace GeometryCompressionUtils {
+  function compressNormals(mesh: Mesh, encodeMethod: string): void
+  function compressPositions(mesh: Mesh): void
+  function compressUvs(mesh: Mesh): void
+}

package/utils/GeometryCompressionUtils.d.ts

@@ -1,4 +1,4 @@
-import { Mesh } from 'three'
+import type { Mesh } from 'three'
 
 export namespace GeometryCompressionUtils {
   function compressNormals(mesh: Mesh, encodeMethod: string): void

package/utils/GeometryUtils.d.cts

@@ -0,0 +1,6 @@
+import type { Vector3 } from 'three';
+export declare const GeometryUtils: {
+    hilbert3D: (center?: Vector3, size?: number, iterations?: number, v0?: number, v1?: number, v2?: number, v3?: number, v4?: number, v5?: number, v6?: number, v7?: number) => Vector3[];
+    gosper: (size?: number) => number[];
+    hilbert2D: (center?: Vector3, size?: number, iterations?: number, v0?: number, v1?: number, v2?: number, v3?: number) => Vector3[];
+};

package/utils/GeometryUtils.d.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from 'three';
+import type { Vector3 } from 'three';
 export declare const GeometryUtils: {
     hilbert3D: (center?: Vector3, size?: number, iterations?: number, v0?: number, v1?: number, v2?: number, v3?: number, v4?: number, v5?: number, v6?: number, v7?: number) => Vector3[];
     gosper: (size?: number) => number[];

package/utils/LDrawUtils.d.cts

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

package/utils/LDrawUtils.d.ts

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

package/utils/RoughnessMipmapper.d.cts

@@ -0,0 +1,8 @@
+import type { Material, WebGLRenderer } from 'three'
+
+export class RoughnessMipmapper {
+  constructor(renderer: WebGLRenderer)
+
+  generateMipmaps(material: Material): void
+  dispose(): void
+}

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 };