@types/three 0.174.0 → 0.176.0

three/README.md

@@ -8,8 +8,8 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Thu, 27 Feb 2025 18:02:49 GMT
- * Dependencies: [@tweenjs/tween.js](https://npmjs.com/package/@tweenjs/tween.js), [@types/stats.js](https://npmjs.com/package/@types/stats.js), [@types/webxr](https://npmjs.com/package/@types/webxr), [@webgpu/types](https://npmjs.com/package/@webgpu/types), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
+ * Last updated: Thu, 24 Apr 2025 08:02:30 GMT
+ * Dependencies: [@dimforge/rapier3d-compat](https://npmjs.com/package/@dimforge/rapier3d-compat), [@tweenjs/tween.js](https://npmjs.com/package/@tweenjs/tween.js), [@types/stats.js](https://npmjs.com/package/@types/stats.js), [@types/webxr](https://npmjs.com/package/@types/webxr), [@webgpu/types](https://npmjs.com/package/@webgpu/types), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
 
 # Credits
 These definitions were written by [Josh Ellis](https://github.com/joshuaellis), and [Nathan Bierema](https://github.com/Methuselah96).

three/examples/jsm/Addons.d.ts

@@ -46,7 +46,7 @@ export * from "./exporters/USDZExporter.js";
 export * from "./geometries/BoxLineGeometry.js";
 export * from "./geometries/ConvexGeometry.js";
 export * from "./geometries/DecalGeometry.js";
-export * from "./geometries/ParametricGeometries.js";
+export * from "./geometries/ParametricFunctions.js";
 export * from "./geometries/ParametricGeometry.js";
 export * from "./geometries/RoundedBoxGeometry.js";
 export * from "./geometries/TeapotGeometry.js";

three/examples/jsm/controls/PointerLockControls.d.ts

@@ -74,8 +74,11 @@ declare class PointerLockControls extends Controls<PointerLockControlsEventMap>
 
     /**
      * Activates the pointer lock.
+     *
+     * @param {boolean} [unadjustedMovement=false] - Disables OS-level adjustment for mouse acceleration, and accesses raw mouse input instead.
+     * Setting it to true will disable mouse acceleration.
      */
-    lock(): void;
+    lock(unadjustedMovement?: boolean): void;
 
     /**
      * Exits the pointer lock.

three/examples/jsm/geometries/ParametricFunctions.d.ts

@@ -0,0 +1,8 @@
+import { Vector3 } from "three";
+
+declare function klein(v: number, u: number, target: Vector3): void;
+declare function plane(u: number, v: number, target: Vector3): void;
+declare function mobius(u: number, t: number, target: Vector3): void;
+declare function mobius3d(u: number, t: number, target: Vector3): void;
+
+export { klein, mobius, mobius3d, plane };

three/examples/jsm/helpers/RapierHelper.d.ts

@@ -0,0 +1,13 @@
+import * as RAPIER from "@dimforge/rapier3d-compat";
+import { LineSegments } from "three";
+
+declare class RapierHelper extends LineSegments {
+    world: RAPIER.World;
+
+    constructor(world: RAPIER.World);
+
+    update(): void;
+    dispose(): void;
+}
+
+export { RapierHelper };

three/examples/jsm/interactive/HTMLMesh.d.ts

@@ -1,6 +1,13 @@
-import { Mesh, MeshBasicMaterial, PlaneGeometry } from "three";
+import { Mesh, MeshBasicMaterial, Object3DEventMap, PlaneGeometry } from "three";
 
-export class HTMLMesh extends Mesh<PlaneGeometry, MeshBasicMaterial> {
+export interface HTMLMeshEventMap extends Object3DEventMap {
+    mousedown: { data: { x: number; y: number } };
+    mousemove: { data: { x: number; y: number } };
+    mouseup: { data: { x: number; y: number } };
+    click: { data: { x: number; y: number } };
+}
+
+export class HTMLMesh extends Mesh<PlaneGeometry, MeshBasicMaterial, HTMLMeshEventMap> {
     constructor(dom: HTMLElement);
     dispose(): void;
 }

three/examples/jsm/loaders/LUTImageLoader.d.ts

@@ -1,4 +1,4 @@
-import { Data3DTexture, Loader, Texture } from "three";
+import { Data3DTexture, Loader, LoadingManager, Texture } from "three";
 
 export interface LUTImageResult {
     size: number;
@@ -8,7 +8,7 @@ export interface LUTImageResult {
 export class LUTImageLoader extends Loader<LUTImageResult> {
     flip: boolean;
 
-    constructor(flipVertical?: boolean);
+    constructor(manager?: LoadingManager);
 
     getImageData(texture: Texture): ImageData;
 

three/examples/jsm/loaders/LottieLoader.d.ts

@@ -1,6 +1,10 @@
 import { CanvasTexture, Loader, LoadingManager } from "three";
 
 export class LottieLoader extends Loader<CanvasTexture> {
+    /**
+     * @deprecated The loader has been deprecated and will be removed with r186. Use lottie-web instead and create your
+     * animated texture manually.
+     */
     constructor(manager?: LoadingManager);
 
     load(

three/examples/jsm/misc/MD2CharacterComplex.d.ts

@@ -9,7 +9,7 @@ export class MD2CharacterComplex {
     maxReverseSpeed: number;
     frontAcceleration: number;
     backAcceleration: number;
-    frontDecceleration: number;
+    frontDeceleration: number;
     angularSpeed: number;
     root: Object3D;
     meshBody: Mesh | null;

three/examples/jsm/physics/RapierPhysics.d.ts

@@ -1,12 +1,24 @@
+import * as RAPIER from "@dimforge/rapier3d-compat";
 import { Mesh, Object3D } from "three";
 
 type Vector = { x: number; y: number; z: number };
 
 export interface RapierPhysicsObject {
+    RAPIER: typeof RAPIER;
+    world: RAPIER.World;
     addScene: (scene: Object3D) => void;
     addMesh: (mesh: Mesh, mass?: number, restitution?: number) => void;
     setMeshPosition: (mesh: Mesh, position: Vector, index?: number) => void;
     setMeshVelocity: (mesh: Mesh, velocity: Vector, index?: number) => void;
+    addHeightfield: (
+        mesh: Mesh,
+        width: number,
+        depth: number,
+        heights: Float32Array,
+        scale: Vector,
+    ) => RAPIER.RigidBody;
 }
 
 export function RapierPhysics(): Promise<RapierPhysicsObject>;
+
+export type RAPIER = typeof RAPIER;

three/examples/jsm/postprocessing/BokehPass.d.ts

@@ -2,7 +2,7 @@ import { Camera, Color, MeshDepthMaterial, Scene, ShaderMaterial, WebGLRenderTar
 
 import { FullScreenQuad, Pass } from "./Pass.js";
 
-export interface BokehPassParamters {
+export interface BokehPassParameters {
     focus?: number;
     aspect?: number;
     aperture?: number;
@@ -10,7 +10,7 @@ export interface BokehPassParamters {
 }
 
 export class BokehPass extends Pass {
-    constructor(scene: Scene, camera: Camera, params: BokehPassParamters);
+    constructor(scene: Scene, camera: Camera, params: BokehPassParameters);
     scene: Scene;
     camera: Camera;
     renderTargetColor: WebGLRenderTarget;

three/examples/jsm/postprocessing/HalftonePass.d.ts

@@ -16,7 +16,7 @@ export interface HalftonePassParameters {
 }
 
 export class HalftonePass extends Pass {
-    constructor(width: number, height: number, params: HalftonePassParameters);
+    constructor(params: HalftonePassParameters);
     uniforms: {
         tDiffuse: IUniform;
         shape: IUniform<number>;

three/examples/jsm/postprocessing/LUTPass.d.ts

@@ -9,5 +9,5 @@ export interface LUTPassParameters {
 export class LUTPass extends ShaderPass {
     lut?: DataTexture | Data3DTexture;
     intensity?: number;
-    constructor(params: LUTPassParameters);
+    constructor(params?: LUTPassParameters);
 }

three/examples/jsm/postprocessing/SMAAPass.d.ts

@@ -3,7 +3,7 @@ import { ShaderMaterial, Texture, WebGLRenderTarget } from "three";
 import { FullScreenQuad, Pass } from "./Pass.js";
 
 export class SMAAPass extends Pass {
-    constructor(width: number, height: number);
+    constructor();
     edgesRT: WebGLRenderTarget;
     weightsRT: WebGLRenderTarget;
     areaTexture: Texture;

three/examples/jsm/transpiler/AST.d.ts

@@ -1,7 +1,224 @@
 export class Program {
-    body: unknown[];
+    constructor();
+
+    body: Statement[];
 
     isProgram: true;
+}
+
+// Boolean seems to be handled as a Unary
+export type Statement =
+    | VariableDeclaration
+    | Uniform
+    | Varying
+    | FunctionParameter
+    | FunctionDeclaration
+    | Expression
+    | Ternary
+    | Operator
+    | Unary
+    | Number
+    | String
+    | Conditional
+    | FunctionCall
+    | Return
+    | Discard
+    | Accessor
+    | StaticElement
+    | DynamicElement
+    | AccessorElements
+    | For
+    | null;
+
+export class VariableDeclaration {
+    constructor(
+        type: string,
+        name: string,
+        value?: Accessor | null,
+        next?: VariableDeclaration | null,
+        immutable?: boolean,
+    );
+
+    type: string;
+    name: string;
+    value: Accessor | null;
+    next: VariableDeclaration | null;
+
+    immutable: boolean;
+
+    isVariableDeclaration: true;
+}
+
+export class Uniform {
+    constructor(type: string, name: string);
+
+    type: string;
+    name: string;
+
+    isUniform: true;
+}
+
+export class Varying {
+    constructor(type: string, name: string);
+
+    type: string;
+    name: string;
+
+    isVarying: true;
+}
+
+export class FunctionParameter {
+    constructor(type: string, name: string, qualifier?: string | null, immutable?: boolean);
+
+    type: string;
+    name: string;
+    qualifier: string | null;
+    immutable: boolean;
+
+    isFunctionParameter: true;
+}
+
+export class FunctionDeclaration {
+    constructor(type: string, name: string, params?: FunctionParameter[]);
+
+    type: string;
+    name: string;
+    params: FunctionParameter[];
+    body: Statement[];
+
+    isFunctionDeclaration: true;
+}
+
+export class Expression {
+    constructor(expression: string);
+
+    expression: string;
+
+    isExpression: true;
+}
+
+export class Ternary {
+    constructor(cond: Statement, left: Statement, right: Statement);
+
+    cond: Statement;
+    left: Statement;
+    right: Statement;
+
+    isTernary: true;
+}
+
+export class Operator {
+    constructor(type: string, left: Statement, right: Statement);
+
+    type: string;
+    left: Statement;
+    right: Statement;
+
+    isOperator: true;
+}
+
+export class Unary {
+    constructor(type: string, expression: Statement, after?: boolean);
+
+    type: string;
+    expression: Statement;
+    after: boolean;
+
+    isUnary: true;
+}
+
+export class Number {
+    constructor(value: string, type?: string);
 
+    type: string;
+    value: string;
+
+    isNumber: true;
+}
+
+export class String {
+    constructor(value: string);
+
+    value: string;
+
+    isString: true;
+}
+
+export class Conditional {
+    constructor(cond?: Conditional | null);
+
+    cond: Conditional | null;
+
+    body: Statement[];
+    elseConditional: Conditional | null;
+
+    isConditional: true;
+}
+
+export class FunctionCall {
+    constructor(name: string, params?: Statement[]);
+
+    name: string;
+    params: Statement[];
+
+    isFunctionCall: true;
+}
+
+export class Return {
+    constructor(value: Statement);
+
+    value: Statement;
+
+    isReturn: true;
+}
+
+export class Discard {
     constructor();
+
+    isDiscard: true;
+}
+
+export class Accessor {
+    constructor(property: string);
+
+    property: string;
+
+    isAccessor: true;
+}
+
+export class StaticElement {
+    constructor(value: Statement);
+
+    value: Statement;
+
+    isStaticElement: true;
+}
+
+export class DynamicElement {
+    constructor(value: Statement);
+
+    value: Statement;
+
+    isDynamicElement: true;
+}
+
+export class AccessorElements {
+    constructor(object: FunctionCall | Accessor, elements?: (StaticElement | DynamicElement)[]);
+
+    object: FunctionCall | Accessor;
+    elements: (StaticElement | DynamicElement)[];
+
+    isAccessorElements: true;
+}
+
+export class For {
+    constructor(initialization: Statement, condition: Statement, afterthought: Statement);
+
+    initialization: Statement;
+    condition: Statement;
+    afterthought: Statement;
+
+    body: Statement[];
+
+    isFor: true;
 }

three/examples/jsm/transpiler/TSLEncoder.d.ts

@@ -1,7 +1,41 @@
-import { Program } from "./AST.js";
+import {
+    Conditional,
+    Expression,
+    For,
+    FunctionDeclaration,
+    Program,
+    Statement,
+    Ternary,
+    Uniform,
+    VariableDeclaration,
+    Varying,
+} from "./AST.js";
 
 export default class TSLEncoder {
     constructor();
 
+    tab: string;
+    imports: Set<string>;
+    global: Set<string>;
+    overloadings: Map<string, string>;
+    iife: boolean;
+    uniqueNames: boolean;
+    reference: boolean;
+
+    addImport(name: string): void;
+    emitUniform(node: Uniform): string;
+    emitExpression(node: Expression): string;
+    emitBody(body: Statement[]): string;
+    emitTernary(node: Ternary): string;
+    emitConditional(node: Conditional): string;
+    emitLoop(node: For): string;
+    emitFor(node: For): string;
+    emitForWhile(node: For): string;
+    emitVariables(node: VariableDeclaration, isRoot?: boolean): string;
+    emitVarying(node: Varying): string;
+    emitOverloadingFunction(nodes: FunctionDeclaration[]): string;
+    emitFunction(node: FunctionDeclaration): string;
+    setLastStatement(statement: Statement | null): void;
+    emitExtraLine(statement: Statement): string;
     emit(ast: Program): string;
 }

three/examples/jsm/tsl/shadows/TileShadowNode.d.ts

@@ -0,0 +1,14 @@
+import { Light, ShadowBaseNode } from "three/webgpu";
+
+export interface TileShadeNodeConfig {
+    tilesX?: number | undefined;
+    tilesY?: number | undefined;
+    resolution?: { width: number; height: number };
+    debug?: boolean | undefined;
+}
+
+declare class TileShadowNode extends ShadowBaseNode {
+    constructor(light: Light, options?: TileShadeNodeConfig);
+}
+
+export { TileShadowNode };

three/examples/jsm/tsl/shadows/TileShadowNodeHelper.d.ts

@@ -0,0 +1,14 @@
+import { Group } from "three/webgpu";
+import { TileShadowNode } from "./TileShadowNode.js";
+
+declare class TileShadowNodeHelper extends Group {
+    constructor(tileShadowNode: TileShadowNode);
+
+    init(): void;
+
+    update(): void;
+
+    dispose(): void;
+}
+
+export { TileShadowNodeHelper };

three/examples/jsm/webxr/VRButton.d.ts

@@ -1,5 +1,7 @@
-import { WebGLRenderer } from "three";
+export interface VRButtonRenderer {
+    xr: { setSession: (value: XRSession) => Promise<void> };
+}
 
 export class VRButton {
-    static createButton(renderer: WebGLRenderer, sessionInit?: XRSessionInit): HTMLElement;
+    static createButton(renderer: VRButtonRenderer, sessionInit?: XRSessionInit): HTMLElement;
 }

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.174.0",
+    "version": "0.176.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -40,6 +40,7 @@
     },
     "scripts": {},
     "dependencies": {
+        "@dimforge/rapier3d-compat": "^0.12.0",
         "@tweenjs/tween.js": "~23.1.3",
         "@types/stats.js": "*",
         "@types/webxr": "*",
@@ -48,6 +49,6 @@
         "meshoptimizer": "~0.18.1"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "42b773a4ca2b467bb5f631194fbba7e91c3510c11d419d1c442487b3e4c90b2e",
-    "typeScriptVersion": "5.0"
+    "typesPublisherContentHash": "2633ecc9f78b2c3a7ff53ae098668242bacbcea8b1a3e8ca27d1bf0a943233a6",
+    "typeScriptVersion": "5.1"
 }

three/src/Three.Core.d.ts

@@ -103,6 +103,7 @@ export { ColorManagement, ColorSpaceDefinition } from "./math/ColorManagement.js
 export * from "./math/Cylindrical.js";
 export * from "./math/Euler.js";
 export * from "./math/Frustum.js";
+export * from "./math/FrustumArray.js";
 export * from "./math/Interpolant.js";
 export * from "./math/interpolants/CubicInterpolant.js";
 export * from "./math/interpolants/DiscreteInterpolant.js";
@@ -152,6 +153,7 @@ export * from "./textures/CubeTexture.js";
 export * from "./textures/Data3DTexture.js";
 export * from "./textures/DataArrayTexture.js";
 export * from "./textures/DataTexture.js";
+export * from "./textures/DepthArrayTexture.js";
 export * from "./textures/DepthTexture.js";
 export * from "./textures/FramebufferTexture.js";
 export * from "./textures/Source.js";

three/src/Three.TSL.d.ts

@@ -13,6 +13,7 @@ export const F_Schlick: typeof TSL.F_Schlick;
 export const Fn: typeof TSL.Fn;
 export const INFINITY: typeof TSL.INFINITY;
 export const If: typeof TSL.If;
+export const Switch: typeof TSL.Switch;
 export const Loop: typeof TSL.Loop;
 export const NodeShaderStage: typeof TSL.NodeShaderStage;
 export const NodeType: typeof TSL.NodeType;
@@ -116,6 +117,7 @@ export const color: typeof TSL.color;
 export const colorSpaceToWorking: typeof TSL.colorSpaceToWorking;
 export const colorToDirection: typeof TSL.colorToDirection;
 export const compute: typeof TSL.compute;
+export const computeSkinning: typeof TSL.computeSkinning;
 export const cond: typeof TSL.cond;
 export const Const: typeof TSL.Const;
 export const context: typeof TSL.context;
@@ -128,6 +130,9 @@ export const cubeTexture: typeof TSL.cubeTexture;
 export const dFdx: typeof TSL.dFdx;
 export const dFdy: typeof TSL.dFdy;
 export const dashSize: typeof TSL.dashSize;
+export const debug: typeof TSL.debug;
+export const decrement: typeof TSL.decrement;
+export const decrementBefore: typeof TSL.decrementBefore;
 export const defaultBuildStages: typeof TSL.defaultBuildStages;
 export const defaultShaderStages: typeof TSL.defaultShaderStages;
 export const defined: typeof TSL.defined;
@@ -181,6 +186,8 @@ export const getScreenPosition: typeof TSL.getScreenPosition;
 export const getShIrradianceAt: typeof TSL.getShIrradianceAt;
 export const getTextureIndex: typeof TSL.getTextureIndex;
 export const getViewPosition: typeof TSL.getViewPosition;
+export const getShadowMaterial: typeof TSL.getShadowMaterial;
+export const getShadowRenderObjectFunction: typeof TSL.getShadowRenderObjectFunction;
 export const glsl: typeof TSL.glsl;
 export const glslFn: typeof TSL.glslFn;
 export const grayscale: typeof TSL.grayscale;
@@ -190,6 +197,8 @@ export const hash: typeof TSL.hash;
 export const highpModelNormalViewMatrix: typeof TSL.highpModelNormalViewMatrix;
 export const highPrecisionModelViewMatrix: typeof TSL.highpModelViewMatrix;
 export const hue: typeof TSL.hue;
+export const increment: typeof TSL.increment;
+export const incrementBefore: typeof TSL.incrementBefore;
 export const instance: typeof TSL.instance;
 export const instanceIndex: typeof TSL.instanceIndex;
 export const instancedArray: typeof TSL.instancedArray;
@@ -215,6 +224,7 @@ export const lengthSq: typeof TSL.lengthSq;
 export const lessThan: typeof TSL.lessThan;
 export const lessThanEqual: typeof TSL.lessThanEqual;
 export const lightPosition: typeof TSL.lightPosition;
+export const lightShadowMatrix: typeof TSL.lightShadowMatrix;
 export const lightTargetDirection: typeof TSL.lightTargetDirection;
 export const lightTargetPosition: typeof TSL.lightTargetPosition;
 export const lightViewPosition: typeof TSL.lightViewPosition;
@@ -407,6 +417,7 @@ export const rtt: typeof TSL.rtt;
 export const sRGBTransferEOTF: typeof TSL.sRGBTransferEOTF;
 export const sRGBTransferOETF: typeof TSL.sRGBTransferOETF;
 export const sampler: typeof TSL.sampler;
+export const samplerComparison: typeof TSL.samplerComparison;
 export const saturate: typeof TSL.saturate;
 export const saturation: typeof TSL.saturation;
 export const screen: typeof TSL.screen;
@@ -432,7 +443,6 @@ export const sign: typeof TSL.sign;
 export const sin: typeof TSL.sin;
 export const sinc: typeof TSL.sinc;
 export const skinning: typeof TSL.skinning;
-export const skinningReference: typeof TSL.skinningReference;
 export const smoothstep: typeof TSL.smoothstep;
 export const smoothstepElement: typeof TSL.smoothstepElement;
 export const specularColor: typeof TSL.specularColor;