@types/three 0.164.1 → 0.165.0

three/examples/jsm/nodes/core/UniformGroupNode.d.ts

@@ -0,0 +1,21 @@
+import Node from "./Node.js";
+
+export default class UniformGroupNode extends Node {
+    name: string;
+    version: number;
+
+    shared: boolean;
+
+    readonly isUniformGroup: true;
+
+    constructor(name: string, shared?: boolean);
+
+    set needsUpdate(value: boolean);
+}
+
+export const uniformGroup: (name: string) => UniformGroupNode;
+export const sharedUniformGroup: (name: string) => UniformGroupNode;
+
+export const frameGroup: UniformGroupNode;
+export const renderGroup: UniformGroupNode;
+export const objectGroup: UniformGroupNode;

three/examples/jsm/nodes/core/UniformNode.d.ts

@@ -1,18 +1,21 @@
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import { NodeTypeOption } from "./constants.js";
+import { NodeUpdateType } from "./constants.js";
 import InputNode from "./InputNode.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
-
-export default class UniformNode<Value> extends InputNode<Value> {
+import NodeFrame from "./NodeFrame.js";
+import UniformGroupNode from "./UniformGroupNode.js";
+declare class UniformNode<TValue> extends InputNode<TValue> {
     readonly isUniformNode: true;
-
-    constructor(value: Value, nodeType?: NodeTypeOption | null);
-
+    groupNode: UniformGroupNode;
+    constructor(value: TValue, nodeType?: string | null);
+    setGroup(group: UniformGroupNode): this;
+    getGroup(): UniformGroupNode;
     getUniformHash(builder: NodeBuilder): string;
+    onUpdate(callback: (frame: NodeFrame, self: this) => TValue | undefined, updateType: NodeUpdateType): this;
+    generate(builder: NodeBuilder, output: string | null): string;
 }
-
-export const uniform: <Value>(
-    arg1: InputNode<Value> | Value,
+export default UniformNode;
+export declare const uniform: <TValue>(
+    arg1: InputNode<TValue> | TValue,
     arg2?: Node | string,
-) => ShaderNodeObject<UniformNode<Value>>;
+) => import("../shadernode/ShaderNode.js").ShaderNodeObject<UniformNode<TValue>>;

three/examples/jsm/nodes/core/VaryingNode.d.ts

@@ -1,11 +1,15 @@
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import Node from "./Node.js";
+import NodeBuilder from "./NodeBuilder.js";
+import NodeVarying from "./NodeVarying.js";
 
 export default class VaryingNode extends Node {
     node: Node;
     name: string | null;
 
     constructor(node: Node, name?: string | null);
+
+    setupVarying(builder: NodeBuilder): NodeVarying;
 }
 
 export const varying: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VaryingNode>;

three/examples/jsm/nodes/core/constants.d.ts

@@ -1,79 +1,27 @@
-export enum NodeShaderStage {
-    VERTEX = "vertex",
-    FRAGMENT = "fragment",
-}
-
-export enum NodeUpdateType {
-    NONE = "none",
-    FRAME = "frame",
-    RENDER = "render",
-    OBJECT = "object",
-}
-
-export enum NodeType {
-    BOOLEAN = "bool",
-    INTEGER = "int",
-    FLOAT = "float",
-    VECTOR2 = "vec2",
-    VECTOR3 = "vec3",
-    VECTOR4 = "vec4",
-    MATRIX2 = "mat2",
-    MATRIX3 = "mat3",
-    MATRIX4 = "mat4",
-}
-
-export type NodeTypeOption =
-    | "bool"
-    | "int"
-    | "float"
-    | "vec2"
-    | "vec3"
-    | "vec4"
-    | "mat2"
-    | "mat3"
-    | "mat4"
-    | "code" /* CodeNode */
-    | "color" /* NodeUtis.getValueType */
-    | "uint"
-    | "int" /* NodeBuilder.getComponentType */
-    | "void"
-    | "property"
-    | "sampler"
-    | "texture"
-    | "cubeTexture" /* NodeBuilder.isReference */
-    | "ivec2"
-    | "uvec2"
-    | "bvec2" /* ShaderNodeBaseElements */
-    | "ivec3"
-    | "uvec3"
-    | "bvec3"
-    | "ivec4"
-    | "uvec4"
-    | "bvec4"
-    | "imat3"
-    | "umat3"
-    | "bmat3"
-    | "imat4"
-    | "umat4"
-    | "bmat4";
-
-export type SwizzleCharacter = "x" | "y" | "z" | "w" | "r" | "g" | "b" | "a" | "s" | "t" | "p" | "q";
-
-export type SwizzleOption = Exclude<
-    | `${SwizzleCharacter}`
-    | `${SwizzleCharacter}${SwizzleCharacter}`
-    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`
-    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`,
-    "abs" | "sqrt"
->;
-
-/** Should be the same type as Object3D.userData */
-export type NodeUserData = Record<string, any>;
-
-/** generic key value type,curretly used by nodes  */
-export interface AnyObject {
-    [key: string]: any;
-}
-
-/** a generic JSON type, used by nodes only */
-export type AnyJson = any;
+export declare const NodeShaderStage: {
+    readonly VERTEX: "vertex";
+    readonly FRAGMENT: "fragment";
+};
+export declare const NodeUpdateType: {
+    readonly NONE: "none";
+    readonly FRAME: "frame";
+    readonly RENDER: "render";
+    readonly OBJECT: "object";
+};
+export declare const NodeType: {
+    readonly BOOLEAN: "bool";
+    readonly INTEGER: "int";
+    readonly FLOAT: "float";
+    readonly VECTOR2: "vec2";
+    readonly VECTOR3: "vec3";
+    readonly VECTOR4: "vec4";
+    readonly MATRIX2: "mat2";
+    readonly MATRIX3: "mat3";
+    readonly MATRIX4: "mat4";
+};
+export type NodeShaderStage = "vertex" | "fragment" | "compute";
+export type NodeUpdateType = "none" | "frame" | "render" | "object";
+export declare const defaultShaderStages: NodeShaderStage[];
+export declare const defaultBuildStages: string[];
+export declare const shaderStages: NodeShaderStage[];
+export declare const vectorComponents: string[];

three/examples/jsm/nodes/functions/PhysicalLightingModel.d.ts

@@ -7,6 +7,7 @@ export default class PhysicalLightingModel extends LightingModel {
     iridescence: boolean;
     anisotropy: boolean;
     transmission: boolean;
+    dispersion: boolean;
 
     clearcoatRadiance: Node | null;
     clearcoatSpecularDirect: Node | null;
@@ -22,6 +23,7 @@ export default class PhysicalLightingModel extends LightingModel {
         iridescence?: boolean,
         anisotropy?: boolean,
         transmission?: boolean,
+        dispersion?: boolean,
     );
 
     computeMultiscattering(singleScatter: Node, multiScatter: Node, specularF90: Node): void;

three/examples/jsm/nodes/functions/ToonLightingModel.d.ts

@@ -0,0 +1,4 @@
+import LightingModel from "../core/LightingModel.js";
+
+export default class ToonLightingModel extends LightingModel {
+}

three/examples/jsm/nodes/loaders/NodeLoader.d.ts

@@ -1,5 +1,5 @@
 import { Loader, LoadingManager, Texture } from "three";
-import { AnyJson, Node } from "../Nodes.js";
+import { Node } from "../Nodes.js";
 
 export interface NodeLoaderResult {
     [hash: string]: Node;
@@ -8,7 +8,7 @@ export interface NodeLoaderResult {
 export default class NodeLoader extends Loader<NodeLoaderResult> {
     constructor(manager?: LoadingManager);
 
-    parseNodes(json: AnyJson): NodeLoaderResult;
-    parse(json: AnyJson): Node;
+    parseNodes(json: unknown): NodeLoaderResult;
+    parse(json: unknown): Node;
     setTextures(textures: { [key: string]: Texture }): this;
 }

three/examples/jsm/nodes/loaders/NodeObjectLoader.d.ts

@@ -1,9 +1,8 @@
 import { Material, ObjectLoader, Texture } from "three";
-import { AnyJson } from "../core/constants.js";
 import { NodeLoaderResult } from "./NodeLoader.js";
 
 export default class NodeObjectLoader extends ObjectLoader {
-    parseNodes(json: AnyJson, textures: { [key: string]: Texture }): NodeLoaderResult;
+    parseNodes(json: unknown, textures: { [key: string]: Texture }): NodeLoaderResult;
 
-    parseMaterials(json: AnyJson, textures: { [key: string]: Texture }): { [key: string]: Material };
+    parseMaterials(json: unknown, textures: { [key: string]: Texture }): { [key: string]: Material };
 }

three/examples/jsm/nodes/materials/LineBasicNodeMaterial.d.ts

@@ -10,6 +10,8 @@ export default class LineBasicNodeMaterial extends NodeMaterial {
     // Properties from LineBasicMaterial
     readonly isLineBasicMaterial: true;
     color: Color;
+    fog: boolean;
+    linewidth: number;
     linecap: string;
     linejoin: string;
     map: Texture | null;

three/examples/jsm/nodes/materials/Materials.d.ts

@@ -1,11 +1,14 @@
 export { default as LineBasicNodeMaterial } from "./LineBasicNodeMaterial.js";
 export { default as MeshBasicNodeMaterial } from "./MeshBasicNodeMaterial.js";
+export { default as MeshMatcapNodeMaterial } from "./MeshMatcapNodeMaterial.js";
 export { default as MeshNormalNodeMaterial } from "./MeshNormalNodeMaterial.js";
 export { default as MeshPhongNodeMaterial } from "./MeshPhongNodeMaterial.js";
 export { default as MeshPhysicalNodeMaterial } from "./MeshPhysicalNodeMaterial.js";
 export { default as MeshSSSPhysicalNodeMaterial } from "./MeshSSSNodeMaterial.js";
 export { default as MeshStandardNodeMaterial } from "./MeshStandardNodeMaterial.js";
+export { default as MeshToonNodeMaterial } from "./MeshToonNodeMaterial.js";
 export { default as NodeMaterial } from "./NodeMaterial.js";
 export { default as PointsNodeMaterial } from "./PointsNodeMaterial.js";
 export { default as ShadowNodeMaterial } from "./ShadowNodeMaterial.js";
 export { default as SpriteNodeMaterial } from "./SpriteNodeMaterial.js";
+export { default as VolumeNodeMaterial } from "./VolumeNodeMaterial.js";

three/examples/jsm/nodes/materials/MeshBasicNodeMaterial.d.ts

@@ -1,4 +1,4 @@
-import { Color, Combine, MeshBasicMaterialParameters, Texture } from "three";
+import { Color, Combine, Euler, MeshBasicMaterialParameters, Texture } from "three";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshBasicMaterialParameters {
@@ -18,11 +18,15 @@ export default class MeshBasicNodeMaterial extends NodeMaterial {
     specularMap: Texture | null;
     alphaMap: Texture | null;
     envMap: Texture | null;
+    envMapRotation: Euler;
     combine: Combine;
     reflectivity: number;
     refractionRatio: number;
+    wireframe: boolean;
+    wireframeLinewidth: number;
     wireframeLinecap: string;
     wireframeLinejoin: string;
+    fog: boolean;
 
     constructor(parameters?: MeshBasicNodeMaterialParameters);
 }

three/examples/jsm/nodes/materials/MeshMatcapNodeMaterial.d.ts

@@ -0,0 +1,28 @@
+import { Color, MeshMatcapMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshMatcapNodeMaterialParameters extends NodeMaterialParameters, MeshMatcapMaterialParameters {
+}
+
+export default class MeshMatcapNodeMaterial extends NodeMaterial {
+    readonly isMeshMatcapNodeMaterial: true;
+
+    // Properties from MeshMatcapMaterial
+    readonly isMeshMatcapMaterial: true;
+    color: Color;
+    matcap: Texture | null;
+    map: Texture | null;
+    bumpMap: Texture | null;
+    bumpScale: number;
+    normalMap: Texture | null;
+    normalMapType: NormalMapTypes;
+    normalScale: Vector2;
+    displacementMap: Texture | null;
+    displacementScale: number;
+    displacementBias: number;
+    alphaMap: Texture | null;
+    flatShading: boolean;
+    fog: boolean;
+
+    constructor(paramters: MeshMatcapNodeMaterialParameters);
+}

three/examples/jsm/nodes/materials/MeshNormalNodeMaterial.d.ts

@@ -17,6 +17,8 @@ export default class MeshNormalNodeMaterial extends NodeMaterial {
     displacementMap: Texture | null;
     displacementScale: number;
     displacementBias: number;
+    wireframe: boolean;
+    wireframeLinewidth: number;
     flatShading: boolean;
 
     constructor(parameters?: MeshBasicNodeMaterialParameters);

three/examples/jsm/nodes/materials/MeshPhongNodeMaterial.d.ts

@@ -1,4 +1,4 @@
-import { Color, Combine, MeshPhongMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
+import { Color, Combine, Euler, MeshPhongMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
 import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
@@ -36,13 +36,17 @@ export default class MeshPhongNodeMaterial extends NodeMaterial {
     specularMap: Texture | null;
     alphaMap: Texture | null;
     envMap: Texture | null;
+    envMapRotation: Euler;
     combine: Combine;
     reflectivity: number;
     refractionRatio: number;
+    wireframe: boolean;
+    wireframeLinewidth: number;
     wireframeLinecap: string;
     wireframeLinejoin: string;
     flatShading: boolean;
     metal: boolean;
+    fog: boolean;
 
     constructor(parameters?: MeshPhongNodeMaterialParameters);
 }

three/examples/jsm/nodes/materials/MeshPhysicalNodeMaterial.d.ts

@@ -32,6 +32,7 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     thicknessNode: ShaderNodeObject<Node> | null;
     attenuationDistanceNode: ShaderNodeObject<Node> | null;
     attenuationColorNode: ShaderNodeObject<Node> | null;
+    dispersionNode: ShaderNodeObject<Node> | null;
 
     anisotropyNode: ShaderNodeObject<Node> | null;
 
@@ -78,4 +79,11 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     set transmission(value: number);
 
     constructor(parameters?: MeshPhysicalNodeMaterialParameters);
+
+    get useClearcoat(): boolean;
+    get useIridescence(): boolean;
+    get useSheen(): boolean;
+    get useAnisotropy(): boolean;
+    get useTransmission(): boolean;
+    get useDispersion(): boolean;
 }

three/examples/jsm/nodes/materials/MeshStandardNodeMaterial.d.ts

@@ -1,4 +1,4 @@
-import { Color, MeshStandardMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
+import { Color, Euler, MeshStandardMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
 import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
@@ -39,10 +39,14 @@ export default class MeshStandardNodeMaterial extends NodeMaterial {
     metalnessMap: Texture | null;
     alphaMap: Texture | null;
     envMap: Texture | null;
+    envMapRotation: Euler;
     envMapIntensity: number;
+    wireframe: boolean;
+    wireframeLinewidth: number;
     wireframeLinecap: string;
     wireframeLinejoin: string;
     flatShading: boolean;
+    fog: boolean;
 
     constructor(paramters?: MeshStandardNodeMaterialParameters);
 }

three/examples/jsm/nodes/materials/MeshToonNodeMaterial.d.ts

@@ -0,0 +1,38 @@
+import { Color, MeshToonMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshToonNodeMaterialParameters extends NodeMaterialParameters, MeshToonMaterialParameters {
+}
+
+export default class MeshToonNodeMaterial extends NodeMaterial {
+    readonly isMeshToonNodeMaterial: true;
+
+    // Properties from MeshToonMaterial
+    readonly isMeshToonMaterial: true;
+    color: Color;
+    gradientMap: Texture | null;
+    map: Texture | null;
+    lightMap: Texture | null;
+    lightMapIntensity: number;
+    aoMap: Texture | null;
+    aoMapIntensity: number;
+    emissive: Color;
+    emissiveIntensity: number;
+    emissiveMap: Texture | null;
+    bumpMap: Texture | null;
+    bumpScale: number;
+    normalMap: Texture | null;
+    normalMapType: NormalMapTypes;
+    normalScale: Vector2;
+    displacementMap: Texture | null;
+    displacementScale: number;
+    displacementBias: number;
+    alphaMap: Texture | null;
+    wireframe: boolean;
+    wireframeLinewidth: number;
+    wireframeLinecap: string;
+    wireframeLinejoin: string;
+    fog: boolean;
+
+    constructor(paramters: MeshToonNodeMaterialParameters);
+}

three/examples/jsm/nodes/materials/NodeMaterial.d.ts

@@ -1,14 +1,15 @@
 import {
     LineBasicMaterial,
     Material,
+    MaterialParameters,
     MeshBasicMaterial,
+    MeshMatcapMaterial,
     MeshNormalMaterial,
     MeshPhongMaterial,
     MeshPhysicalMaterial,
     MeshStandardMaterial,
+    MeshToonMaterial,
     PointsMaterial,
-    ShaderMaterial,
-    ShaderMaterialParameters,
     ShadowMaterial,
     SpriteMaterial,
 } from "three";
@@ -20,15 +21,17 @@ import LightsNode from "../lighting/LightsNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import LineBasicNodeMaterial from "./LineBasicNodeMaterial.js";
 import MeshBasicNodeMaterial from "./MeshBasicNodeMaterial.js";
+import MeshMatcapNodeMaterial from "./MeshMatcapNodeMaterial.js";
 import MeshNormalNodeMaterial from "./MeshNormalNodeMaterial.js";
 import MeshPhongNodeMaterial from "./MeshPhongNodeMaterial.js";
 import MeshPhysicalNodeMaterial from "./MeshPhysicalNodeMaterial.js";
 import MeshStandardNodeMaterial from "./MeshStandardNodeMaterial.js";
+import MeshToonNodeMaterial from "./MeshToonNodeMaterial.js";
 import PointsNodeMaterial from "./PointsNodeMaterial.js";
 import ShadowNodeMaterial from "./ShadowNodeMaterial.js";
 import SpriteNodeMaterial from "./SpriteNodeMaterial.js";
 
-export interface NodeMaterialParameters extends ShaderMaterialParameters {
+export interface NodeMaterialParameters extends MaterialParameters {
     normals?: boolean | undefined;
 
     colorSpaced?: boolean | undefined;
@@ -55,7 +58,7 @@ export interface NodeMaterialParameters extends ShaderMaterialParameters {
     vertexNode?: ShaderNodeObject<Node> | null | undefined;
 }
 
-export default class NodeMaterial extends ShaderMaterial {
+export default class NodeMaterial extends Material {
     readonly isNodeMaterial: true;
 
     normals: boolean;
@@ -102,10 +105,12 @@ export default class NodeMaterial extends ShaderMaterial {
 
     static fromMaterial(material: LineBasicMaterial): LineBasicNodeMaterial;
     static fromMaterial(material: MeshBasicMaterial): MeshBasicNodeMaterial;
+    static fromMaterial(material: MeshMatcapMaterial): MeshMatcapNodeMaterial;
     static fromMaterial(material: MeshNormalMaterial): MeshNormalNodeMaterial;
     static fromMaterial(material: MeshPhongMaterial): MeshPhongNodeMaterial;
     static fromMaterial(material: MeshPhysicalMaterial): MeshPhysicalNodeMaterial;
     static fromMaterial(material: MeshStandardMaterial): MeshStandardNodeMaterial;
+    static fromMaterial(material: MeshToonMaterial): MeshToonNodeMaterial;
     static fromMaterial(material: PointsMaterial): PointsNodeMaterial;
     static fromMaterial(material: ShadowMaterial): ShadowNodeMaterial;
     static fromMaterial(material: SpriteMaterial): SpriteNodeMaterial;

three/examples/jsm/nodes/materials/PointsNodeMaterial.d.ts

@@ -14,6 +14,7 @@ export default class PointsNodeMaterial extends NodeMaterial {
     alphaMap: Texture | null;
     size: number;
     sizeAttenuation: boolean;
+    fog: boolean;
 
     constructor(parameters?: PointsNodeMaterialParameters);
 }

three/examples/jsm/nodes/materials/ShadowNodeMaterial.d.ts

@@ -10,6 +10,7 @@ export default class ShadowNodeMaterial extends NodeMaterial {
     // Properties from ShadowMaterial
     readonly isShadowMaterial: true;
     color: Color;
+    fog: boolean;
 
     constructor(parameters?: ShadowNodeMaterialParameters);
 }

three/examples/jsm/nodes/materials/SpriteNodeMaterial.d.ts

@@ -19,6 +19,7 @@ export default class SpriteNodeMaterial extends NodeMaterial {
     alphaMap: Texture | null;
     rotation: number;
     sizeAttenuation: boolean;
+    fog: boolean;
 
     constructor(parameters?: SpriteNodeMaterialParameters);
 }

three/examples/jsm/nodes/materials/VolumeNodeMaterial.d.ts

@@ -0,0 +1,10 @@
+import Node from "../core/Node.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export default class VolumeNodeMaterial extends NodeMaterial {
+    lights: boolean;
+    readonly isVolumeNodeMaterial: true;
+    testNode: Node | null;
+
+    constructor(parameters?: NodeMaterialParameters);
+}