@types/three 0.159.0 → 0.160.0

three/examples/jsm/nodes/shadernode/ShaderNode.d.ts

@@ -1,20 +1,37 @@
-import { ConstNode, Node, NodeBuilder, NodeTypeOption, SwizzleOption } from '../Nodes.js';
-// lot of private typescript magic here
-export {};
+import Node from '../core/Node.js';
+import { NodeTypeOption, SwizzleOption } from '../core/constants.js';
+import ConstNode from '../core/ConstNode.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+import SplitNode from '../utils/SplitNode.js';
+
+export interface NodeElements {}
+
+export function addNodeElement(name: string, nodeElement: unknown): void;
+
 export type Swizzable<T extends Node = Node> = T & {
-    [key in SwizzleOption | number]: Swizzable;
+    [key in SwizzleOption | number]: ShaderNodeObject<SplitNode>;
 };
 
+export type ShaderNodeObject<T extends Node> = T & {
+    [Key in keyof NodeElements]: NodeElements[Key] extends (node: T, ...args: infer Args) => infer R
+        ? (...args: Args) => R
+        : never;
+} & Swizzable<T>;
+
 /** anything that can be passed to {@link nodeObject} and returns a proxy */
-export type NodeRepresentation<T extends Node = Node> = number | boolean | Node | Swizzable<T>;
+export type NodeRepresentation<T extends Node = Node> = number | boolean | Node | ShaderNodeObject<T>;
 
 /** anything that can be passed to {@link nodeObject} */
 export type NodeObjectOption = NodeRepresentation | string;
 
-// same logic as in ShaderNodeObject: number,boolean,node->swizzable, otherwise do nothing
-export type NodeObject<T> = T extends Node ? Swizzable<T> : T extends number | boolean ? Swizzable<ConstNode> : T;
+// same logic as in ShaderNodeObject: number,boolean,node->ShaderNodeObject, otherwise do nothing
+export type NodeObject<T> = T extends Node
+    ? ShaderNodeObject<T>
+    : T extends number | boolean
+    ? ShaderNodeObject<ConstNode<number | boolean>>
+    : T;
 
-// opposite of NodeObject: node -> node|swizzable|boolean|number, otherwise do nothing
+// opposite of NodeObject: node -> node|ShaderNodeObject|boolean|number, otherwise do nothing
 type Proxied<T> = T extends Node ? NodeRepresentation<T> : T;
 // https://github.com/microsoft/TypeScript/issues/42435#issuecomment-765557874
 export type ProxiedTuple<T extends readonly [...unknown[]]> = [...{ [index in keyof T]: Proxied<T[index]> }];
@@ -102,11 +119,7 @@ type GetConstructorsByScope<T, S> = ConstructorUnion<FilterConstructorsByScope<O
 type GetConstructors<T> = ConstructorUnion<OverloadedConstructorsOf<T>>;
 type GetPossibleScopes<T> = ExtractScopes<OverloadedConstructorsOf<T>>;
 
-export type ConvertType = (...params: unknown[]) => Swizzable;
-
-export const ConvertType: {
-    new (type: NodeTypeOption, cacheMap?: Map<unknown, ConstNode>): ConvertType;
-};
+export type ConvertType = (...params: unknown[]) => ShaderNodeObject<Node>;
 
 type NodeArray<T extends NodeObjectOption[]> = { [index in keyof T]: NodeObject<T[index]> };
 type NodeObjects<T> = { [key in keyof T]: T[key] extends NodeObjectOption ? NodeObject<T[key]> : T[key] };
@@ -114,7 +127,16 @@ type ConstructedNode<T> = T extends new (...args: any[]) => infer R ? (R extends
 
 export type NodeOrType = Node | NodeTypeOption;
 
-export function getConstNodeType(value: NodeOrType): NodeTypeOption | null;
+export const getConstNodeType: (value: NodeOrType) => NodeTypeOption | null;
+
+export class ShaderNode<T = {}, R extends Node = Node> {
+    constructor(jsFunc: (inputs: NodeObjects<T>, builder: NodeBuilder) => NodeRepresentation);
+    call: (
+        inputs: { [key in keyof T]: T[key] extends NodeRepresentation ? ShaderNodeObject<Node> | Node : T[key] },
+        builder?: NodeBuilder,
+    ) => ShaderNodeObject<R>;
+}
+
 export function nodeObject<T extends NodeObjectOption>(obj: T): NodeObject<T>;
 export function nodeObjects<T>(obj: T): NodeObjects<T>;
 
@@ -122,35 +144,55 @@ export function nodeArray<T extends NodeObjectOption[]>(obj: readonly [...T]): N
 
 export function nodeProxy<T>(
     nodeClass: T,
-): (...params: ProxiedTuple<GetConstructors<T>>) => Swizzable<ConstructedNode<T>>;
+): (...params: ProxiedTuple<GetConstructors<T>>) => ShaderNodeObject<ConstructedNode<T>>;
 
 export function nodeProxy<T, S extends GetPossibleScopes<T>>(
     nodeClass: T,
     scope: S,
-): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
+): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
 
 export function nodeProxy<T, S extends GetPossibleScopes<T>>(
     nodeClass: T,
     scope: S,
     factor: NodeObjectOption,
-): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
+): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
 
 export function nodeImmutable<T>(
     nodeClass: T,
     ...params: ProxiedTuple<GetConstructors<T>>
-): Swizzable<ConstructedNode<T>>;
-
-export class ShaderNode<T = {}, R extends Node = Node> {
-    constructor(jsFunc: (inputs: NodeObjects<T>, builder: NodeBuilder) => NodeRepresentation);
-    call: (
-        inputs: { [key in keyof T]: T[key] extends NodeRepresentation ? Swizzable | Node : T[key] },
-        builder?: NodeBuilder,
-    ) => Swizzable<R>;
-}
-
-export const cacheMaps: {
-    bool: Map<boolean, ConstNode>;
-    uint: Map<number, ConstNode>;
-    int: Map<number, ConstNode>;
-    float: Map<number, ConstNode>;
-};
+): ShaderNodeObject<ConstructedNode<T>>;
+
+export const color: ConvertType;
+
+export const float: ConvertType;
+export const int: ConvertType;
+export const uint: ConvertType;
+export const bool: ConvertType;
+
+export const vec2: ConvertType;
+export const ivec2: ConvertType;
+export const uvec2: ConvertType;
+export const bvec2: ConvertType;
+
+export const vec3: ConvertType;
+export const ivec3: ConvertType;
+export const uvec3: ConvertType;
+export const bvec3: ConvertType;
+
+export const vec4: ConvertType;
+export const ivec4: ConvertType;
+export const uvec4: ConvertType;
+export const bvec4: ConvertType;
+
+export const mat3: ConvertType;
+export const imat3: ConvertType;
+export const umat3: ConvertType;
+export const bmat3: ConvertType;
+
+export const mat4: ConvertType;
+export const imat4: ConvertType;
+export const umat4: ConvertType;
+export const bmat4: ConvertType;
+
+export const element: (node: NodeRepresentation, indexNode: NodeRepresentation) => ShaderNodeObject<Node>;
+export const convert: (node: NodeRepresentation, types: NodeTypeOption) => ShaderNodeObject<Node>;

three/examples/jsm/nodes/utils/EquirectUVNode.d.ts

@@ -1,6 +1,8 @@
 import { PositionNode, TempNode } from '../Nodes.js';
-import { Swizzable } from '../shadernode/ShaderNodeElements.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class EquirectUVNode extends TempNode {
-    constructor(dirNode?: Swizzable<PositionNode>);
+    constructor(dirNode?: ShaderNodeObject<PositionNode>);
 }
+
+export const equirectUV: ShaderNodeObject<EquirectUVNode>;

three/examples/jsm/nodes/utils/MatcapUVNode.d.ts

@@ -1,5 +1,8 @@
 import TempNode from '../core/TempNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class MatcapUVNode extends TempNode {
     constructor();
 }
+
+export const matcapUV: ShaderNodeObject<MatcapUVNode>;

three/examples/jsm/nodes/utils/MaxMipLevelNode.d.ts

@@ -1,11 +1,14 @@
-import UniformNode from '../core/UniformNode.js';
 import { Texture } from '../../../../src/Three.js';
-import { TextureNode } from '../Nodes.js';
+import UniformNode from '../core/UniformNode.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
-export default class MaxMipLevelNode extends UniformNode {
+export default class MaxMipLevelNode extends UniformNode<0> {
     textureNode: TextureNode;
 
     constructor(textureNode: TextureNode);
 
     get texture(): Texture;
 }
+
+export const maxMipLevel: (texture: Texture) => ShaderNodeObject<MaxMipLevelNode>;

three/examples/jsm/nodes/utils/OscNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type OscNodeMethod =
     | typeof OscNode.SINE
@@ -17,3 +18,8 @@ export default class OscNode extends Node {
 
     constructor(method: OscNodeMethod, timeNode?: Node);
 }
+
+export const oscSine: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;
+export const oscSquare: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;
+export const oscTriangle: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;
+export const oscSawtooth: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;

three/examples/jsm/nodes/utils/RemapNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class RemapNode extends Node {
     node: Node;
@@ -11,3 +12,6 @@ export default class RemapNode extends Node {
 
     constructor(node: Node, inLowNode: Node, inHighNode: Node, outLowNode: Node, outHighNode: Node);
 }
+
+export const remap: (node: Node, inLowNode: Node) => ShaderNodeObject<RemapNode>;
+export const remapClamp: (node: Node, inLowNode: Node) => ShaderNodeObject<RemapNode>;

three/examples/jsm/nodes/utils/RotateUVNode.d.ts

@@ -1,5 +1,6 @@
 import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class RotateUVNode extends TempNode {
     uvNode: Node;
@@ -8,3 +9,5 @@ export default class RotateUVNode extends TempNode {
 
     constructor(uvNode: Node, rotationNode: Node, centerNode?: Node);
 }
+
+export const rotateUV: (uvNode: Node, rotationNode: Node, centerNode?: Node) => ShaderNodeObject<RotateUVNode>;

three/examples/jsm/nodes/utils/SpecularMIPLevelNode.d.ts

@@ -1,4 +1,6 @@
-import { Node, TextureNode } from '../Nodes.js';
+import Node from '../core/Node.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class SpecularMIPLevelNode extends Node {
     textureNode: TextureNode;
@@ -6,3 +8,5 @@ export default class SpecularMIPLevelNode extends Node {
 
     constructor(textureNode: TextureNode, roughnessNode?: Node | null);
 }
+
+export const specularMIPLevel: () => ShaderNodeObject<SpecularMIPLevelNode>;

three/examples/jsm/nodes/utils/SpriteSheetUVNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class SpriteSheetUVNode extends Node {
     countNode: Node;
@@ -7,3 +8,9 @@ export default class SpriteSheetUVNode extends Node {
 
     constructor(countNode: Node, uvNode?: Node, frameNode?: Node);
 }
+
+export const spritesheetUV: (
+    countNode: NodeRepresentation,
+    uvNode?: NodeRepresentation,
+    frameNode?: NodeRepresentation,
+) => ShaderNodeObject<SpriteSheetUVNode>;

three/examples/jsm/nodes/utils/TimerNode.d.ts

@@ -1,4 +1,5 @@
 import UniformNode from '../core/UniformNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type TimerNodeScope =
     | typeof TimerNode.LOCAL
@@ -6,7 +7,7 @@ export type TimerNodeScope =
     | typeof TimerNode.DELTA
     | typeof TimerNode.FRAME;
 
-export default class TimerNode extends UniformNode {
+export default class TimerNode extends UniformNode<number> {
     static LOCAL: 'local';
     static GLOBAL: 'global';
     static DELTA: 'delta';
@@ -17,3 +18,8 @@ export default class TimerNode extends UniformNode {
 
     constructor(scope?: TimerNodeScope, scale?: number, value?: number);
 }
+
+export const timerLocal: (timeScale?: number, value?: number) => ShaderNodeObject<TimerNode>;
+export const timerGlobal: (timeScale?: number, value?: number) => ShaderNodeObject<TimerNode>;
+export const timerDelta: (timeScale?: number, value?: number) => ShaderNodeObject<TimerNode>;
+export const frameId: ShaderNodeObject<TimerNode>;

three/examples/jsm/nodes/utils/TriplanarTexturesNode.d.ts

@@ -1,22 +1,37 @@
 import Node from '../core/Node.js';
-import { PositionNode, Swizzable, TextureNode } from '../Nodes.js';
+import PositionNode from '../accessors/PositionNode.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class TriplanarTexturesNode extends Node {
     textureXNode: TextureNode;
     textureYNode: TextureNode | null;
     textureZNode: TextureNode | null;
 
-    scaleNode: Swizzable;
+    scaleNode: ShaderNodeObject<Node>;
 
-    positionNode: Swizzable<PositionNode>;
-    normalNode: Swizzable<PositionNode>;
+    positionNode: ShaderNodeObject<PositionNode>;
+    normalNode: ShaderNodeObject<PositionNode>;
 
     constructor(
         textureXNode: Node,
         textureYNode?: TextureNode | null,
         textureZNode?: TextureNode | null,
-        scaleNode?: Swizzable,
-        positionNode?: Swizzable<PositionNode>,
-        normalNode?: Swizzable<PositionNode>,
+        scaleNode?: ShaderNodeObject<Node>,
+        positionNode?: ShaderNodeObject<PositionNode>,
+        normalNode?: ShaderNodeObject<PositionNode>,
     );
 }
+
+export const triplanarTextures: (
+    textureXNode: NodeRepresentation,
+    textureYNode?: NodeRepresentation,
+    textureZNode?: NodeRepresentation,
+    scaleNode?: NodeRepresentation,
+    positionNode?: NodeRepresentation,
+    normalNode?: NodeRepresentation,
+) => ShaderNodeObject<TriplanarTexturesNode>;
+export const triplanarTexture: (
+    texture: NodeRepresentation,
+    ...params: NodeRepresentation[]
+) => ShaderNodeObject<TriplanarTexturesNode>;

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

@@ -0,0 +1,13 @@
+import { Material } from '../../../src/Three.js';
+import Renderer from '../renderers/common/Renderer.js';
+
+export default class QuadMesh {
+    constructor(material?: Material | null);
+
+    dispose(): void;
+
+    render(renderer: Renderer): void;
+
+    get material(): Material;
+    set material(value: Material);
+}

three/examples/jsm/postprocessing/{HBAOPass.d.ts → GTAOPass.d.ts}

@@ -1,4 +1,5 @@
 import {
+    Box3,
     Camera,
     Color,
     ColorRepresentation,
@@ -14,23 +15,26 @@ import {
 
 import { FullScreenQuad, Pass } from './Pass.js';
 
-export class HBAOPass extends Pass {
+export class GTAOPass extends Pass {
     width: number;
     height: number;
     clear: boolean;
     camera: Camera;
     scene: Scene;
     output: number;
+    blendIntensity: number;
 
-    rings: number;
-    samples: number;
+    pdRings: number;
+    pdRadiusExponent: number;
+    pdSamples: number;
 
-    noiseTexture: DataTexture;
+    gtaoNoiseTexture: DataTexture;
+    pdNoiseTexture: DataTexture;
 
-    hbaoRenderTarget: WebGLRenderTarget;
+    gtaoRenderTarget: WebGLRenderTarget;
     pdRenderTarget: WebGLRenderTarget;
 
-    hbaoMaterial: ShaderMaterial;
+    gtaoMaterial: ShaderMaterial;
 
     normalMaterial: MeshNormalMaterial;
 
@@ -40,6 +44,8 @@ export class HBAOPass extends Pass {
 
     copyMaterial: ShaderMaterial;
 
+    blendMaterial: ShaderMaterial;
+
     fsQuad: FullScreenQuad;
 
     originalClearColor: Color;
@@ -55,13 +61,18 @@ export class HBAOPass extends Pass {
         parameters?: { depthTexture?: DepthTexture | undefined; normalTexture?: Texture | undefined } | undefined,
     );
 
-    setTextures(depthTexture?: DepthTexture | undefined, normalTexture?: Texture | undefined): void;
+    setGBuffer(depthTexture?: DepthTexture | undefined, normalTexture?: Texture | undefined): void;
+
+    setSceneClipBox(box: Box3): void;
 
-    updateHbaoMaterial(parameters: {
+    updateGtaoMaterial(parameters: {
         radius?: number | undefined;
         distanceExponent?: number | undefined;
-        bias?: number | undefined;
+        thickness?: number | undefined;
+        distanceFallOff?: number | undefined;
+        scale?: number | undefined;
         samples?: number | undefined;
+        screenSpaceRadius?: boolean | undefined;
     }): void;
 
     updatePdMaterial(parameters: {
@@ -69,6 +80,7 @@ export class HBAOPass extends Pass {
         depthPhi?: number | undefined;
         normalPhi?: number | undefined;
         radius?: number | undefined;
+        radiusExponent?: number | undefined;
         rings?: number | undefined;
         samples?: number | undefined;
     }): void;
@@ -100,7 +112,7 @@ export class HBAOPass extends Pass {
         Diffuse: 1;
         Depth: 2;
         Normal: 3;
-        HBAO: 4;
+        AO: 4;
         Denoise: 5;
     };
 }

three/examples/jsm/renderers/webgl-legacy/nodes/WebGLNodes.d.ts

@@ -0,0 +1,3 @@
+import { NodeFrame } from '../../../nodes/Nodes.js';
+
+export const nodeFrame: NodeFrame;

three/examples/jsm/shaders/{HBAOShader.d.ts → GTAOShader.d.ts}

@@ -1,14 +1,15 @@
-import { IUniform, Matrix4, Vector2 } from '../../../src/Three.js';
+import { DataTexture, IUniform, Matrix4, Vector2, Vector3 } from '../../../src/Three.js';
 
-export const HBAOShader: {
+export const GTAOShader: {
     name: string;
     defines: {
         PERSPECTIVE_CAMERA: number;
         SAMPLES: number;
-        SAMPLE_VECTORS: string;
         NORMAL_VECTOR_TYPE: number;
-        DEPTH_VALUE_SOURCE: number;
-        SAMPLING_FROM_NOISE: number;
+        DEPTH_SWIZZLING: string;
+        SCREEN_SPACE_RADIUS: number;
+        SCREEN_SPACE_RADIUS_SCALE: number;
+        SCENE_CLIP_BOX: number;
     };
     uniforms: {
         tNormal: IUniform;
@@ -21,13 +22,17 @@ export const HBAOShader: {
         cameraProjectionMatrixInverse: IUniform<Matrix4>;
         radius: IUniform<number>;
         distanceExponent: IUniform<number>;
-        bias: IUniform<number>;
+        thickness: IUniform<number>;
+        distanceFallOff: IUniform<number>;
+        scale: IUniform<number>;
+        sceneBoxMin: IUniform<Vector3>;
+        sceneBoxMax: IUniform<Vector3>;
     };
     vertexShader: string;
     fragmentShader: string;
 };
 
-export const HBAODepthShader: {
+export const GTAODepthShader: {
     name: string;
     defines: {
         PERSPECTIVE_CAMERA: number;
@@ -41,4 +46,14 @@ export const HBAODepthShader: {
     fragmentShader: string;
 };
 
-export function generateHaboSampleKernelInitializer(samples: number): string;
+export const GTAOBlendShader: {
+    name: string;
+    uniforms: {
+        tDiffuse: IUniform;
+        intensity: IUniform<number>;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+
+export function generateMagicSquareNoise(samples?: number): DataTexture;

three/examples/jsm/shaders/PoissonDenoiseShader.d.ts

@@ -25,4 +25,4 @@ export const PoissonDenoiseShader: {
     fragmentShader: string;
 };
 
-export function generatePdSamplePointInitializer(samples: number, rings: number): string;
+export function generatePdSamplePointInitializer(samples: number, rings: number, radiusExponent: number): string;

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.159.0",
+    "version": "0.160.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -44,6 +44,6 @@
         "fflate": "~0.6.10",
         "meshoptimizer": "~0.18.1"
     },
-    "typesPublisherContentHash": "00146f19c0acfa1923520aa89574fd3c011b0b97251b16d57b2bc5999534c2c9",
+    "typesPublisherContentHash": "7de688c4d074af1d79f7696d827bdd1236ff9e159d0b343b35e0b152202c544e",
     "typeScriptVersion": "4.6"
 }

three/src/Three.d.ts

@@ -223,6 +223,7 @@ export * from './scenes/Scene.js';
  */
 export * from './textures/VideoTexture.js';
 export * from './textures/CompressedArrayTexture.js';
+export * from './textures/CompressedCubeTexture.js';
 export * from './textures/DataTexture.js';
 export * from './textures/CompressedTexture.js';
 export * from './textures/CubeTexture.js';

three/src/constants.d.ts

@@ -140,13 +140,15 @@ export const ReinhardToneMapping: 2;
 export const CineonToneMapping: 3;
 export const ACESFilmicToneMapping: 4;
 export const CustomToneMapping: 5;
+export const AgXToneMapping: 6;
 export type ToneMapping =
     | typeof NoToneMapping
     | typeof LinearToneMapping
     | typeof ReinhardToneMapping
     | typeof CineonToneMapping
     | typeof ACESFilmicToneMapping
-    | typeof CustomToneMapping;
+    | typeof CustomToneMapping
+    | typeof AgXToneMapping;
 
 // Bind modes
 export const AttachedBindMode: 'attached';

three/src/core/UniformsGroup.d.ts

@@ -15,11 +15,11 @@ export class UniformsGroup extends EventDispatcher<{ dispose: {} }> {
 
     usage: Usage;
 
-    uniforms: Uniform[];
+    uniforms: Array<Uniform | Uniform[]>;
 
-    add(uniform: Uniform): this;
+    add(uniform: Uniform | Uniform[]): this;
 
-    remove(uniform: Uniform): this;
+    remove(uniform: Uniform | Uniform[]): this;
 
     setName(name: string): this;
 

three/src/lights/PointLight.d.ts

@@ -29,6 +29,13 @@ export class PointLight extends Light<PointLightShadow> {
      */
     constructor(color?: ColorRepresentation, intensity?: number, distance?: number, decay?: number);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link PointLight}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isPointLight: true;
+
     /**
      * @default 'PointLight'
      */

three/src/loaders/MaterialLoader.d.ts

@@ -4,13 +4,16 @@ import { Texture } from '../textures/Texture.js';
 import { Material } from '../materials/Material.js';
 
 export class MaterialLoader extends Loader<Material> {
-    constructor(manager?: LoadingManager);
-
     /**
      * @default {}
      */
     textures: { [key: string]: Texture };
 
-    setTextures(textures: { [key: string]: Texture }): this;
+    constructor(manager?: LoadingManager);
+
     parse(json: unknown): Material;
+
+    setTextures(textures: { [key: string]: Texture }): this;
+
+    static createMaterialFromType(type: string): Material;
 }

three/src/materials/LineBasicMaterial.d.ts

@@ -13,6 +13,13 @@ export interface LineBasicMaterialParameters extends MaterialParameters {
 export class LineBasicMaterial extends Material {
     constructor(parameters?: LineBasicMaterialParameters);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link LineBasicMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isLineBasicMaterial: true;
+
     /**
      * @default 'LineBasicMaterial'
      */

three/src/materials/LineDashedMaterial.d.ts

@@ -9,6 +9,13 @@ export interface LineDashedMaterialParameters extends LineBasicMaterialParameter
 export class LineDashedMaterial extends LineBasicMaterial {
     constructor(parameters?: LineDashedMaterialParameters);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link LineDashedMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isLineDashedMaterial: true;
+
     /**
      * @default 'LineDashedMaterial'
      */
@@ -28,7 +35,6 @@ export class LineDashedMaterial extends LineBasicMaterial {
      * @default 1
      */
     gapSize: number;
-    readonly isLineDashedMaterial: true;
 
     setValues(parameters: LineDashedMaterialParameters): void;
 }