@types/three 0.174.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: Thu, 27 Feb 2025 18:02:49 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/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/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/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.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": "42b773a4ca2b467bb5f631194fbba7e91c3510c11d419d1c442487b3e4c90b2e",
+    "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;
@@ -407,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;
@@ -432,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;