🤖 Merge PR DefinitelyTyped#72309 [three] r175 by @Methuselah96

Author: Methuselah96

types/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";

types/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.

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

types/three/examples/jsm/geometries/ParametricGeometries.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;
 }

types/three/examples/jsm/interactive/HTMLMesh.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;
 

types/three/examples/jsm/loaders/LUTImageLoader.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>;

types/three/examples/jsm/postprocessing/HalftonePass.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);
 }

types/three/examples/jsm/postprocessing/LUTPass.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;

types/three/examples/jsm/postprocessing/SMAAPass.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;
 }