@types/three 0.173.0 → 0.175.0

three/README.md

@@ -8,7 +8,7 @@ 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: Fri, 31 Jan 2025 19:32:17 GMT
+ * Last updated: Fri, 28 Mar 2025 18:39:32 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)
 
 # Credits

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/animation/CCDIKSolver.d.ts

@@ -14,6 +14,7 @@ export interface IK {
     minAngle?: number | undefined;
     maxAngle?: number | undefined;
     target: number;
+    blendFactor?: number | undefined;
 }
 
 export class CCDIKSolver {
@@ -22,8 +23,8 @@ export class CCDIKSolver {
 
     constructor(mesh: SkinnedMesh, iks?: IK[]);
 
-    update(): this;
-    updateOne(ik: IK): this;
+    update(globalBlendFactor?: number): this;
+    updateOne(ik: IK, overrideBlend?: number): this;
     createHelper(sphereSize?: number): CCDIKHelper;
 }
 

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/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/MTLLoader.d.ts

@@ -38,8 +38,8 @@ export class MTLLoader extends Loader<MTLLoader.MaterialCreator> {
 }
 
 export interface MaterialInfo {
-    ks?: number[] | undefined;
     kd?: number[] | undefined;
+    ks?: number[] | undefined;
     ke?: number[] | undefined;
     map_kd?: string | undefined;
     map_ks?: string | undefined;
@@ -47,6 +47,7 @@ export interface MaterialInfo {
     norm?: string | undefined;
     map_bump?: string | undefined;
     bump?: string | undefined;
+    disp?: string | undefined;
     map_d?: string | undefined;
     ns?: number | undefined;
     d?: number | undefined;

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

@@ -4,8 +4,8 @@
  *
  * - {@link Timer} has an {@link .update()} method that updates its internal state. That makes it possible to call
  *   {@link .getDelta()} and {@link .getElapsed()} multiple times per simulation step without getting different values.
- * - The class uses the Page Visibility API to avoid large time delta values when the app is inactive (e.g. tab switched
- *   or browser hidden).
+ * - The class can make use of the Page Visibility API to avoid large time delta values when the app is inactive (e.g.
+ *   tab switched or browser hidden).
  *
  * @example
  * const timer = new Timer();
@@ -24,6 +24,17 @@
 export class Timer {
     constructor();
 
+    /**
+     * Connects the timer to the given document. Calling this method is not mandatory to use the timer but enables the
+     * usage of the Page Visibility API to avoid large time delta values.
+     */
+    connect(document: Document): void;
+
+    /**
+     * Disconnects the timer from the DOM and also disables the usage of the Page Visibility API.
+     */
+    disconnect(): void;
+
     /**
      * Returns the time delta in seconds.
      */

three/examples/jsm/objects/Reflector.d.ts

@@ -11,6 +11,7 @@ export interface ReflectorOptions {
 
 export class Reflector extends Mesh {
     type: "Reflector";
+    forceUpdate: boolean;
     camera: PerspectiveCamera;
 
     constructor(geometry?: BufferGeometry, options?: ReflectorOptions);

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/math/Bayer.d.ts

@@ -0,0 +1,4 @@
+import { ShaderNodeObject } from "three/tsl";
+import { Node } from "three/webgpu";
+
+export const bayer16: (uv: Node) => ShaderNodeObject<Node>;

three/examples/jsm/tsl/utils/Raymarching.d.ts

@@ -0,0 +1,9 @@
+import { ShaderNodeObject } from "three/tsl";
+import { FunctionNode, Node } from "three/webgpu";
+
+export const RaymarchingBox: (
+    steps: number | Node,
+    callback:
+        | ((params: { positionRay: ShaderNodeObject<Node> }) => void)
+        | FunctionNode<{ positionRay: ShaderNodeObject<Node> }>,
+) => void;

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.173.0",
+    "version": "0.175.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -48,6 +48,6 @@
         "meshoptimizer": "~0.18.1"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "87d1eae9912dd0ad6de0abf1b48f1f1492997e994d634cca6cfd07481576ed8f",
+    "typesPublisherContentHash": "4f8410c1c95a3d20772bbb010426c784f9e9d9f20a8e4ab737d05ff2918553d6",
     "typeScriptVersion": "5.0"
 }

three/src/Three.TSL.d.ts

@@ -116,6 +116,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 +129,7 @@ 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 defaultBuildStages: typeof TSL.defaultBuildStages;
 export const defaultShaderStages: typeof TSL.defaultShaderStages;
 export const defined: typeof TSL.defined;
@@ -285,6 +287,7 @@ export const modInt: typeof TSL.modInt;
 export const modelDirection: typeof TSL.modelDirection;
 export const modelNormalMatrix: typeof TSL.modelNormalMatrix;
 export const modelPosition: typeof TSL.modelPosition;
+export const modelRadius: typeof TSL.modelRadius;
 export const modelScale: typeof TSL.modelScale;
 export const modelViewMatrix: typeof TSL.modelViewMatrix;
 export const modelViewPosition: typeof TSL.modelViewPosition;
@@ -336,6 +339,7 @@ export const numWorkgroups: typeof TSL.numWorkgroups;
 export const objectDirection: typeof TSL.objectDirection;
 export const objectGroup: typeof TSL.objectGroup;
 export const objectPosition: typeof TSL.objectPosition;
+export const objectRadius: typeof TSL.objectRadius;
 export const objectScale: typeof TSL.objectScale;
 export const objectViewPosition: typeof TSL.objectViewPosition;
 export const objectWorldMatrix: typeof TSL.objectWorldMatrix;
@@ -380,6 +384,7 @@ export const range: typeof TSL.range;
 export const rangeFog: typeof TSL.rangeFog;
 export const rangeFogFactor: typeof TSL.rangeFogFactor;
 export const reciprocal: typeof TSL.reciprocal;
+export const lightProjectionUV: typeof TSL.lightProjectionUV;
 export const reference: typeof TSL.reference;
 export const referenceBuffer: typeof TSL.referenceBuffer;
 export const reflect: typeof TSL.reflect;
@@ -404,6 +409,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;
@@ -416,6 +422,7 @@ export const select: typeof TSL.select;
 export const setCurrentStack: typeof TSL.setCurrentStack;
 export const shaderStages: typeof TSL.shaderStages;
 export const shadow: typeof TSL.shadow;
+export const pointShadow: typeof TSL.pointShadow;
 export const shadowPositionWorld: typeof TSL.shadowPositionWorld;
 export const sharedUniformGroup: typeof TSL.sharedUniformGroup;
 export const shapeCircle: typeof TSL.shapeCircle;
@@ -428,7 +435,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;

three/src/Three.d.ts

@@ -28,7 +28,12 @@ export type { WebGLProperties } from "./renderers/webgl/WebGLProperties.js";
 export type { RenderItem, WebGLRenderList, WebGLRenderLists } from "./renderers/webgl/WebGLRenderLists.js";
 export type { WebGLShader } from "./renderers/webgl/WebGLShader.js";
 export type { WebGLShadowMap } from "./renderers/webgl/WebGLShadowMap.js";
-export type { WebGLState } from "./renderers/webgl/WebGLState.js";
+export type {
+    WebGLColorBuffer,
+    WebGLDepthBuffer,
+    WebGLState,
+    WebGLStencilBuffer,
+} from "./renderers/webgl/WebGLState.js";
 export type { WebGLTextures } from "./renderers/webgl/WebGLTextures.js";
 export type { WebGLUniforms } from "./renderers/webgl/WebGLUniforms.js";
 export * from "./renderers/webgl/WebGLUtils.js";