🤖 Merge PR DefinitelyTyped#73995 [three] r181 by @Methuselah96

Author: Methuselah96

types/three/examples/jsm/geometries/TextGeometry.d.ts

@@ -59,6 +59,8 @@ export interface TextGeometryParameters extends ExtrudeGeometryOptions {
      * @defaultValue `3`
      */
     bevelSegments?: number | undefined;
+
+    direction?: "ltr" | "rtl" | "tb" | undefined;
 }
 
 /**

types/three/examples/jsm/gpgpu/BitonicSort.d.ts

@@ -0,0 +1,21 @@
+import { Node, Renderer, StorageBufferNode } from "three/webgpu";
+
+export const getBitonicFlipIndices: (index: Node, blockHeight: Node) => Node;
+
+export const getBitonicDisperseIndices: (index: Node, swapSpan: Node) => Node;
+
+export interface BitonicSortOptions {
+    workgroupSize?: number | undefined;
+}
+
+export class BitonicSort {
+    infoStorage: StorageBufferNode;
+
+    swapOpCount: number;
+    stepCount: number;
+
+    constructor(renderer: Renderer, dataBuffer: StorageBufferNode, options?: BitonicSortOptions);
+
+    computeStep(renderer: Renderer): Promise<void>;
+    compute(renderer: Renderer): Promise<void>;
+}

types/three/examples/jsm/inspector/Inspector.d.ts

@@ -0,0 +1,10 @@
+import { RendererInspector } from "./RendererInspector.js";
+import { ParametersGroup } from "./tabs/Parameters.js";
+
+declare class Inspector extends RendererInspector {
+    createParameters(name: string): ParametersGroup;
+
+    get domElement(): HTMLDivElement;
+}
+
+export { Inspector };

types/three/examples/jsm/inspector/RendererInspector.d.ts

@@ -0,0 +1,4 @@
+import { InspectorBase } from "three/webgpu";
+
+export class RendererInspector extends InspectorBase {
+}

types/three/examples/jsm/inspector/tabs/Parameters.d.ts

@@ -0,0 +1,95 @@
+import { Tab } from "../ui/Tab.js";
+import { ValueButton, ValueCheckbox, ValueColor, ValueNumber, ValueSelect, ValueSlider } from "../ui/Values.js";
+
+type KeyToValueOfType<T, V> = { [K in keyof T]: T[K] extends V ? K : never }[keyof T];
+
+interface ValueSelectWithParameters<T = Record<string, unknown>, K extends keyof T = keyof T>
+    extends ValueSelect<T, K>
+{
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+interface ValueNumberWithParameters<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, number> = KeyToValueOfType<T, number>,
+> extends ValueNumber<T, K> {
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+interface ValueSliderWithParameters<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, number> = KeyToValueOfType<T, number>,
+> extends ValueSlider<T, K> {
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+interface ValueCheckboxWithParameters<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, boolean> = KeyToValueOfType<T, boolean>,
+> extends ValueCheckbox<T, K> {
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+interface ValueButtonWithParameters<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, (this: T) => void> = KeyToValueOfType<T, (this: T) => void>,
+> extends ValueButton<T, K> {
+    name: (name: string) => this;
+}
+
+interface ValueColorWithParameters<
+    T = Record<string, unknown>,
+    K extends keyof T = keyof T,
+> extends ValueColor<T, K> {
+    name: (name: string) => this;
+    listen: () => this;
+}
+
+declare class ParametersGroup {
+    name: string;
+
+    constructor(parameters: never, name: string);
+
+    add<T, K extends keyof T>(
+        object: T,
+        property: K,
+        options: ReadonlyArray<T[K]> | Record<string, T[K]>,
+    ): ValueSelectWithParameters<T, K>;
+    add<T, K extends KeyToValueOfType<T, number>>(
+        object: T,
+        property: K,
+        min: number,
+        max: number,
+        step?: number,
+    ): ValueSliderWithParameters<T, K>;
+    add<T, K extends KeyToValueOfType<T, number>>(
+        object: T,
+        property: K,
+        min?: number,
+    ): ValueNumberWithParameters<T, K>;
+    add<T, K extends KeyToValueOfType<T, boolean>>(
+        object: T,
+        property: K,
+        options?: never,
+    ): ValueCheckboxWithParameters<T, K>;
+    add<T, K extends KeyToValueOfType<T, (this: T) => void>>(
+        object: T,
+        property: K,
+        options?: never,
+    ): ValueButtonWithParameters<T, K>;
+
+    addFolder(name: string): ParametersGroup;
+
+    addColor<T, K extends keyof T>(object: T, property: K, rgbScale?: number): ValueColorWithParameters<T, K>;
+}
+
+declare class Parameters extends Tab {
+    createGroup(name: string): ParametersGroup;
+}
+
+export { Parameters };
+export type { ParametersGroup };

types/three/examples/jsm/inspector/ui/Tab.d.ts

@@ -0,0 +1,3 @@
+export class Tab {
+    constructor(title: string);
+}

types/three/examples/jsm/inspector/ui/Values.d.ts

@@ -0,0 +1,80 @@
+import { ColorRepresentation, EventDispatcher } from "three";
+
+type KeyToValueOfType<T, V> = { [K in keyof T]: T[K] extends V ? K : never }[keyof T];
+
+declare class Value<T = Record<string, unknown>, K extends keyof T = keyof T> extends EventDispatcher {
+    onChange(callback: (value: T[K]) => void): this;
+}
+
+export interface ValueNumberParams {
+    value?: number;
+    step?: number;
+    min?: number;
+    max?: number;
+}
+
+declare class ValueNumber<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, number> = KeyToValueOfType<T, number>,
+> extends Value<T, K> {
+    constructor(params: ValueNumberParams);
+}
+
+export interface ValueCheckboxParams {
+    value?: boolean;
+}
+
+declare class ValueCheckbox<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, boolean> = KeyToValueOfType<T, boolean>,
+> extends Value<T, K> {
+    constructor(params: ValueCheckboxParams);
+}
+
+export interface ValueSliderParams {
+    value?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+
+declare class ValueSlider<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, number> = KeyToValueOfType<T, number>,
+> extends Value<T, K> {
+    constructor(params: ValueSliderParams);
+
+    setValue(val: number): this;
+    step(value: number): this;
+}
+
+export interface ValueSelectParams<T, K extends keyof T> {
+    options?: ReadonlyArray<T[K]> | Record<string, T[K]>;
+    value?: number;
+}
+
+declare class ValueSelect<T = Record<string, unknown>, K extends keyof T = keyof T> extends Value<T, K> {
+    constructor(params: ValueSelectParams<T, K>);
+}
+
+export interface ValueColorParams {
+    value?: ColorRepresentation;
+}
+
+declare class ValueColor<T = Record<string, unknown>, K extends keyof T = keyof T> extends Value<T, K> {
+    constructor(params: ValueColorParams);
+}
+
+export interface ValueButtonParams {
+    text?: string;
+    value?: () => void;
+}
+
+declare class ValueButton<
+    T = Record<string, unknown>,
+    K extends KeyToValueOfType<T, (this: T) => void> = KeyToValueOfType<T, (this: T) => void>,
+> extends Value<T, K> {
+    constructor(params: ValueColorParams);
+}
+
+export { Value, ValueButton, ValueCheckbox, ValueColor, ValueNumber, ValueSelect, ValueSlider };

types/three/examples/jsm/interactive/SelectionBox.d.ts

@@ -1,16 +1,16 @@
-import { Camera, Frustum, Mesh, Object3D, Scene, Vector3 } from "three";
+import { Camera, Object3D, Scene, Vector3 } from "three";
 
-export class SelectionBox {
-    constructor(camera: Camera, scene: Scene, deep?: number);
+declare class SelectionBox {
     camera: Camera;
-    collection: Mesh[];
-    deep: number;
-    endPoint: Vector3;
     scene: Scene;
     startPoint: Vector3;
+    endPoint: Vector3;
+    collection: Object3D[];
     instances: Record<string, number[]>;
+    batches: Record<string, number[]>;
+    deep: number;
+
+    constructor(camera: Camera, scene: Scene, deep?: number);
 
-    select(startPoint?: Vector3, endPoint?: Vector3): Mesh[];
-    updateFrustum(startPoint: Vector3, endPoint: Vector3): void;
-    searchChildInFrustum(frustum: Frustum, object: Object3D): void;
+    select(startPoint?: Vector3, endPoint?: Vector3): Object3D[];
 }

types/three/examples/jsm/lighting/TiledLighting.d.ts

@@ -1,10 +1,9 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Lighting } from "three/webgpu";
 import { Light } from "../../../src/lights/Light.js";
 import TiledLightsNode from "../tsl/lighting/TiledLightsNode.js";
 
 export class TiledLighting extends Lighting {
     constructor();
 
-    createNode(lights?: Light[]): ShaderNodeObject<TiledLightsNode>;
+    createNode(lights?: Light[]): TiledLightsNode;
 }

types/three/examples/jsm/loaders/FontLoader.d.ts

@@ -37,5 +37,5 @@ export class Font {
 
     constructor(data: FontData);
 
-    generateShapes(text: string, size?: number): Shape[];
+    generateShapes(text: string, size?: number, direction?: "ltr" | "rtl" | "tb"): Shape[];
 }