@types/three 0.143.0 → 0.144.0

three/examples/jsm/nodes/functions/BSDF/F_Schlick.d.ts

@@ -0,0 +1,6 @@
+import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements';
+import Node from '../../core/Node';
+
+declare const F_Schlick: ShaderNode<{ f0: Node; f90: Node; dotVH: Node }>;
+
+export default F_Schlick;

three/examples/jsm/nodes/functions/BSDF/V_GGX_SmithCorrelated.d.ts

@@ -0,0 +1,6 @@
+import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements';
+import Node from '../../core/Node';
+
+declare const V_GGX_SmithCorrelated: ShaderNode<{ alpha: Node; dotNL: Node; dotNV: Node }>;
+
+export default V_GGX_SmithCorrelated;

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

@@ -0,0 +1,11 @@
+import { ShaderNode } from '../shadernode/ShaderNodeElements';
+import Node from '../core/Node';
+
+declare const PhysicalLightingModel: {
+    direct: ShaderNode<{ lightDirection: Node; lightColor: Node; reflectedLight: Node }>;
+    indirectDiffuse: ShaderNode<{ irradiance: Node; reflectedLight: Node }>;
+    indirectSpecular: ShaderNode<{ radiance: Node; iblIrradiance: Node; reflectedLight: Node }>;
+    ambientOcclusion: ShaderNode<{ ambientOcclusion: Node; reflectedLight: Node }>;
+};
+
+export default PhysicalLightingModel;

three/examples/jsm/nodes/functions/light/getDistanceAttenuation.d.ts

@@ -0,0 +1,5 @@
+import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements';
+import Node from '../../core/Node';
+declare const getDistanceAttenuation: ShaderNode<{ lightDistance: Node; cutoffDistance: Node; decayExponent: Node }>;
+
+export default getDistanceAttenuation;

three/examples/jsm/nodes/functions/material/getGeometryRoughness.d.ts

@@ -0,0 +1,5 @@
+import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements';
+
+declare const getGeometryRoughness: ShaderNode;
+
+export default getGeometryRoughness;

three/examples/jsm/nodes/functions/material/getRoughness.d.ts

@@ -0,0 +1,6 @@
+import { ShaderNode } from '../../shadernode/ShaderNodeElements';
+import Node from '../../core/Node';
+
+declare const getRoughness: ShaderNode<{ roughness: Node }>;
+
+export default getRoughness;

three/examples/jsm/nodes/geometry/RangeNode.d.ts

@@ -0,0 +1,12 @@
+import { Color, Vector2, Vector3, Vector4 } from '../../../../src/Three';
+import Node from '../core/Node';
+
+export type RangeModeBound = number | Color | Vector2 | Vector3 | Vector4;
+
+export default class RangeNode extends Node {
+    min: RangeModeBound;
+    max: RangeModeBound;
+
+    constructor(min: RangeModeBound, max: RangeModeBound);
+    getVectorLength(): number;
+}

three/examples/jsm/nodes/gpgpu/ComputeNode.d.ts

@@ -0,0 +1,11 @@
+import Node from '../core/Node';
+
+export default class ComputeNode extends Node {
+    isComputeNode: true;
+
+    count: number;
+    workgroupSize: number[];
+    dispatchCount: number;
+
+    constructor(computeNode: Node, count: number, workgroupSize?: number[]);
+}

three/examples/jsm/nodes/lighting/AONode.d.ts

@@ -0,0 +1,8 @@
+import LightingNode from './LightingNode';
+import Node from '../core/Node';
+
+export default class AONode extends LightingNode {
+    aoNode: Node | null;
+
+    constructor(aoNode?: Node | null);
+}

three/examples/jsm/nodes/lighting/AnalyticLightNode.d.ts

@@ -0,0 +1,10 @@
+import LightingNode from './LightingNode';
+import { Light } from '../../../../src/Three';
+import Node from '../core/Node';
+
+export default class AnalyticLightNode<T extends Light> extends LightingNode {
+    light: T | null;
+    colorNode: Node;
+
+    constructor(light?: T | null);
+}

three/examples/jsm/nodes/lighting/EnvironmentNode.d.ts

@@ -0,0 +1,8 @@
+import LightingNode from './LightingNode';
+import Node from '../core/Node';
+
+export default class EnvironmentNode extends LightingNode {
+    envNode: Node | null;
+
+    constructor(envNode?: Node | null);
+}

three/examples/jsm/nodes/lighting/HemisphereLightNode.d.ts

@@ -0,0 +1,13 @@
+import AnalyticLightNode from './AnalyticLightNode';
+import Object3DNode from '../accessors/Object3DNode';
+import { HemisphereLight } from '../../../../src/Three';
+import Node from '../core/Node';
+
+export default class HemisphereLightNode extends AnalyticLightNode<HemisphereLight> {
+    lightPositionNode: Object3DNode;
+    lightDirectionNode: Node;
+
+    groundColorNode: Node;
+
+    constructor(light?: HemisphereLight | null);
+}

three/examples/jsm/nodes/lighting/LightingContextNode.d.ts

@@ -0,0 +1,15 @@
+import ContextNode from '../core/ContextNode';
+import Node from '../core/Node';
+import { ShaderNode } from '../Nodes';
+
+export interface LightingModelNode {
+    indirectDiffuse?: ShaderNode;
+    indirectSpecular?: ShaderNode;
+    ambientOcclusion?: ShaderNode;
+}
+
+export default class LightingContextNode extends ContextNode {
+    lightingModelNode: LightingModelNode | null;
+
+    constructor(node: Node, lightingModelNode?: LightingModelNode | null);
+}

three/examples/jsm/nodes/lighting/LightingNode.d.ts

@@ -0,0 +1,5 @@
+import Node from '../core/Node';
+
+export default abstract class LightingNode extends Node {
+    constructor();
+}

three/examples/jsm/nodes/lighting/LightsNode.d.ts

@@ -0,0 +1,19 @@
+import { Light } from '../../../../src/Three';
+import Node from '../core/Node';
+import LightingNode from './LightingNode';
+
+export default class LightsNode extends Node {
+    lightNodes: LightingNode[];
+
+    constructor(lightNodes?: LightingNode[]);
+
+    get hasLight(): boolean;
+    getLightNodeByHash(hash: string): LightingNode | null;
+
+    fromLights(lights: Light[]): this;
+
+    static setReference<T extends Light>(
+        lightClass: { new (): T },
+        lightNodeClass: { new (light: T): LightingNode },
+    ): void;
+}

three/examples/jsm/nodes/lighting/PunctualLightNode.d.ts

@@ -0,0 +1,12 @@
+import AnalyticLightNode from './AnalyticLightNode';
+import Node from '../core/Node';
+import { PointLight, SpotLight } from '../../../../src/Three';
+
+export type PunctualLight = PointLight | SpotLight;
+
+export default class PunctualLightNode extends AnalyticLightNode<PunctualLight> {
+    cutoffDistanceNode: Node;
+    decayExponentNode: Node;
+
+    constructor(light?: PunctualLight | null);
+}

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

@@ -0,0 +1,21 @@
+import { Loader, LoadingManager, Texture } from '../../../../src/Three';
+import { Node, AnyJson } from '../Nodes';
+
+export interface NodeLoaderResult {
+    [hash: string]: Node;
+}
+
+export default class NodeLoader extends Loader {
+    constructor(manager?: LoadingManager);
+
+    load(
+        url: string,
+        onLoad: (gltf: NodeLoaderResult) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (event: ErrorEvent) => void,
+    ): void;
+
+    parseNodes(json: AnyJson): NodeLoaderResult;
+    parse(json: AnyJson): Node;
+    setTextures(textures: { [key: string]: Texture }): this;
+}

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

@@ -0,0 +1,8 @@
+import { MaterialLoader } from '../../../../src/Three';
+import { NodeLoaderResult } from './NodeLoader';
+
+export default class NodeMaterialLoader extends MaterialLoader {
+    nodes: NodeLoaderResult;
+
+    setNodes(value: NodeLoaderResult): this;
+}

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

@@ -0,0 +1,11 @@
+import { NodeLoaderResult } from './NodeLoader';
+import { Material, ObjectLoader, Texture } from '../../../../src/Three';
+import { AnyJson } from '../core/constants';
+
+export default class NodeObjectLoader extends ObjectLoader {
+    parseNodes(json: AnyJson, textures: { [key: string]: Texture }): NodeLoaderResult;
+
+    // tslint:disable-next-line:comment-format
+    //@ts-expect-error
+    parseMaterials(json: AnyJson, textures: { [key: string]: Texture }): { [key: string]: Material };
+}

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

@@ -0,0 +1,16 @@
+import NodeMaterial from './NodeMaterial';
+import { ShaderMaterialParameters } from '../../../../src/Three';
+import { Node } from '../Nodes';
+
+export default class LineBasicNodeMaterial extends NodeMaterial {
+    isLineBasicNodeMaterial: true;
+
+    colorNode: Node | null;
+    opacityNode: Node | null;
+    alphaTestNode: Node | null;
+    lightNode: Node | null;
+    positionNode: Node | null;
+
+    constructor(parameters?: ShaderMaterialParameters);
+    copy(source: LineBasicNodeMaterial): this;
+}

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

@@ -0,0 +1,17 @@
+import NodeMaterial from './NodeMaterial';
+import LineBasicNodeMaterial from './LineBasicNodeMaterial';
+import MeshBasicNodeMaterial from './MeshBasicNodeMaterial';
+import MeshStandardNodeMaterial from './MeshStandardNodeMaterial';
+import PointsNodeMaterial from './PointsNodeMaterial';
+import SpriteNodeMaterial from './SpriteNodeMaterial';
+import MeshPhysicalNodeMaterial from './MeshPhysicalNodeMaterial';
+
+export {
+    NodeMaterial,
+    LineBasicNodeMaterial,
+    MeshBasicNodeMaterial,
+    MeshPhysicalNodeMaterial,
+    MeshStandardNodeMaterial,
+    PointsNodeMaterial,
+    SpriteNodeMaterial,
+};

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

@@ -0,0 +1,19 @@
+import NodeMaterial from './NodeMaterial';
+import Node from '../core/Node';
+import { ShaderMaterialParameters } from '../../../../src/Three';
+
+export default class MeshBasicNodeMaterial extends NodeMaterial {
+    isMeshBasicNodeMaterial: true;
+    lights: true;
+
+    colorNode: Node | null;
+    opacityNode: Node | null;
+
+    alphaTestNode: Node | null;
+    lightNode: Node | null;
+
+    positionNode: Node | null;
+
+    constructor(paramters?: ShaderMaterialParameters);
+    copy(source: MeshBasicNodeMaterial): this;
+}

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

@@ -0,0 +1,22 @@
+import { ShaderMaterialParameters } from '../../../../src/Three';
+import { Swizzable, CheckerNode, Node } from '../Nodes';
+
+import MeshStandardNodeMaterial from './MeshStandardNodeMaterial';
+
+export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
+    iridescenceNode: null | Swizzable<CheckerNode>;
+    iridescenceIORNode: null | Swizzable;
+    iridescenceThicknessNode: null | Swizzable;
+
+    specularIntensityNode: Node | null;
+    specularColorNode: Node | null;
+
+    transmissionNode: Node | null;
+    thicknessNode: Node | null;
+    attenuationDistanceNode: Node | null;
+    attenuationColorNode: Node | null;
+
+    constructor(parameters: ShaderMaterialParameters);
+
+    copy(source: MeshPhysicalNodeMaterial): this;
+}

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

@@ -0,0 +1,27 @@
+import { ShaderMaterialParameters } from '../../../../src/Three';
+import Node from '../core/Node';
+import NodeMaterial from './NodeMaterial';
+
+export default class MeshStandardNodeMaterial extends NodeMaterial {
+    isMeshStandardNodeMaterial: true;
+
+    colorNode: Node | null;
+    opacityNode: Node | null;
+    alphaTestNode: Node | null;
+    normalNode: Node | null;
+    emissiveNode: Node | null;
+
+    metalnessNode: Node | null;
+    roughnessNode: Node | null;
+
+    clearcoatNode: Node | null;
+    clearcoatRoughnessNode: Node | null;
+
+    envNode: Node | null;
+
+    lightsNode: Node | null;
+    positionNode: Node | null;
+
+    constructor(paramters?: ShaderMaterialParameters);
+    copy(source: MeshStandardNodeMaterial): this;
+}

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

@@ -0,0 +1,22 @@
+import { Material, ShaderMaterial } from '../../../../src/Three';
+import NodeBuilder from '../core/NodeBuilder';
+import Node from '../core/Node';
+import { LightingModelNode } from '../lighting/LightingContextNode';
+
+export default class NodeMaterial extends ShaderMaterial {
+    isNodeMaterial: true;
+    lights: true;
+    type: string;
+    constructor();
+
+    build(builder: NodeBuilder): void;
+    customProgramCacheKey(): string;
+    generatePosition(builder: NodeBuilder): void;
+    generateDiffuseColor(builder: NodeBuilder): void;
+    generateLight(
+        builder: NodeBuilder,
+        lights: { diffuseColorNode: Node; lightingModelNode: LightingModelNode; lightsNode?: Node },
+    ): void;
+    generateOutput(builder: NodeBuilder, lights: { diffuseColorNode: Node; outgoingLightNode: Node }): void;
+    static fromMaterial(m: Material): NodeMaterial;
+}

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

@@ -0,0 +1,15 @@
+import NodeMaterial from './NodeMaterial';
+import { ShaderMaterialParameters } from '../../../../src/Three';
+import { Node } from '../Nodes';
+
+export default class PointsNodeMaterial extends NodeMaterial {
+    isPointsNodeMateria: true;
+    colorNode: Node | null;
+    opacityNode: Node | null;
+    alphaTestNode: Node | null;
+    lightNode: Node | null;
+    sizeNode: Node | null;
+    positionNode: Node | null;
+    constructor(parameters?: ShaderMaterialParameters);
+    copy(source: PointsNodeMaterial): this;
+}

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

@@ -0,0 +1,23 @@
+import NodeMaterial from './NodeMaterial';
+import { ShaderMaterialParameters } from '../../../../src/Three';
+import { NodeBuilder } from '../Nodes';
+import Node from '../core/Node';
+
+export default class SpriteNodeMaterial extends NodeMaterial {
+    isSpriteNodeMaterial: true;
+
+    colorNode: Node | null;
+    opacityNode: Node | null;
+
+    alphaTestNode: Node | null;
+
+    lightNode: Node | null;
+
+    positionNode: Node | null;
+    rotationNode: Node | null;
+    scaleNode: Node | null;
+
+    constructor(parameters?: ShaderMaterialParameters);
+    generatePosition(builder: NodeBuilder): void;
+    copy(source: SpriteNodeMaterial): this;
+}

three/examples/jsm/nodes/materialx/functions/lib/mx_hsv.d.ts

@@ -0,0 +1,4 @@
+import { Fn, Node, Swizzable } from '../../../Nodes';
+
+export function mx_hsvtorgb(...params: Fn<[Node]>): Swizzable;
+export function mx_rgbtohsv(...params: Fn<[Node]>): Swizzable;

three/examples/jsm/nodes/materialx/functions/lib/mx_noise.d.ts

@@ -0,0 +1,6 @@
+import { Fn, Node, Swizzable } from '../../../Nodes';
+
+export function mx_perlin_noise_float(...params: Fn<[Node]>): Swizzable;
+export function mx_cell_noise_float(...params: Fn<[Node]>): Swizzable;
+export function mx_worley_noise_float(...params: Fn<[Node]>): Swizzable;
+export function mx_fractal_noise_float(...params: Fn<[Node, Node, Node, Node]>): Swizzable;

three/examples/jsm/nodes/math/CondNode.d.ts

@@ -0,0 +1,9 @@
+import Node from '../core/Node';
+
+export default class CondNode extends Node {
+    condNode: Node;
+    ifNode: Node;
+    elseNode: Node;
+
+    constructor(condNode: Node, ifNode: Node, elseNode: Node);
+}

three/examples/jsm/nodes/math/MathNode.d.ts

@@ -0,0 +1,116 @@
+import Node from '../core/Node';
+import TempNode from '../core/TempNode';
+
+export type MathNodeMethod1 =
+    | typeof MathNode.RADIANS
+    | typeof MathNode.DEGREES
+    | typeof MathNode.EXP
+    | typeof MathNode.EXP2
+    | typeof MathNode.LOG
+    | typeof MathNode.LOG2
+    | typeof MathNode.SQRT
+    | typeof MathNode.INVERSE_SQRT
+    | typeof MathNode.FLOOR
+    | typeof MathNode.CEIL
+    | typeof MathNode.NORMALIZE
+    | typeof MathNode.FRACT
+    | typeof MathNode.SIN
+    | typeof MathNode.COS
+    | typeof MathNode.TAN
+    | typeof MathNode.ASIN
+    | typeof MathNode.ACOS
+    | typeof MathNode.ATAN
+    | typeof MathNode.ABS
+    | typeof MathNode.SIGN
+    | typeof MathNode.LENGTH
+    | typeof MathNode.NEGATE
+    | typeof MathNode.INVERT
+    | typeof MathNode.DFDX
+    | typeof MathNode.DFDY
+    | typeof MathNode.SATURATE
+    | typeof MathNode.ROUND;
+
+export type MathNodeMethod2 =
+    | typeof MathNode.ATAN2
+    | typeof MathNode.MIN
+    | typeof MathNode.MAX
+    | typeof MathNode.MOD
+    | typeof MathNode.STEP
+    | typeof MathNode.REFLECT
+    | typeof MathNode.DISTANCE
+    | typeof MathNode.DOT
+    | typeof MathNode.CROSS
+    | typeof MathNode.POW
+    | typeof MathNode.TRANSFORM_DIRECTION;
+
+export type MathNodeMethod3 =
+    | typeof MathNode.MIX
+    | typeof MathNode.CLAMP
+    | typeof MathNode.REFRACT
+    | typeof MathNode.SMOOTHSTEP
+    | typeof MathNode.FACEFORWARD;
+
+export type MathNodeMethod = MathNodeMethod1 | MathNodeMethod2 | MathNodeMethod3;
+
+export default class MathNode extends TempNode {
+    // 1 input
+
+    static RADIANS: 'radians';
+    static DEGREES: 'degrees';
+    static EXP: 'exp';
+    static EXP2: 'exp2';
+    static LOG: 'log';
+    static LOG2: 'log2';
+    static SQRT: 'sqrt';
+    static INVERSE_SQRT: 'inversesqrt';
+    static FLOOR: 'floor';
+    static CEIL: 'ceil';
+    static NORMALIZE: 'normalize';
+    static FRACT: 'fract';
+    static SIN: 'sin';
+    static COS: 'cos';
+    static TAN: 'tan';
+    static ASIN: 'asin';
+    static ACOS: 'acos';
+    static ATAN: 'atan';
+    static ABS: 'abs';
+    static SIGN: 'sign';
+    static LENGTH: 'length';
+    static NEGATE: 'negate';
+    static INVERT: 'invert';
+    static DFDX: 'dFdx';
+    static DFDY: 'dFdy';
+    static SATURATE: 'saturate';
+    static ROUND: 'round';
+
+    // 2 inputs
+
+    static ATAN2: 'atan2';
+    static MIN: 'min';
+    static MAX: 'max';
+    static MOD: 'mod';
+    static STEP: 'step';
+    static REFLECT: 'reflect';
+    static DISTANCE: 'distance';
+    static DOT: 'dot';
+    static CROSS: 'cross';
+    static POW: 'pow';
+    static TRANSFORM_DIRECTION: 'transformDirection';
+
+    // 3 inputs
+
+    static MIX: 'mix';
+    static CLAMP: 'clamp';
+    static REFRACT: 'refract';
+    static SMOOTHSTEP: 'smoothstep';
+    static FACEFORWARD: 'faceforward';
+
+    method: MathNodeMethod;
+    aNode: Node;
+    bNode: Node | null;
+    cNode: Node | null;
+
+    constructor(method: MathNodeMethod1, aNode: Node);
+    constructor(method: MathNodeMethod2, aNode: Node, bNode: Node);
+    constructor(method: MathNodeMethod3, aNode: Node, bNode: Node, cNode: Node);
+}

three/examples/jsm/nodes/math/OperatorNode.d.ts

@@ -0,0 +1,31 @@
+import TempNode from '../core/TempNode';
+import Node from '../core/Node';
+
+export type OperatorNodeOp =
+    | '='
+    | '%'
+    | '&'
+    | '|'
+    | '^'
+    | '>>'
+    | '<<'
+    | '=='
+    | '&&'
+    | '||'
+    | '^^'
+    | '<'
+    | '>'
+    | '<='
+    | '>='
+    | '+'
+    | '-'
+    | '*'
+    | '/';
+
+export default class OperatorNode extends TempNode {
+    aNode: Node;
+    bNode: Node;
+    op: OperatorNodeOp;
+
+    constructor(op: OperatorNodeOp, ...params: [Node, Node, ...Node[]]);
+}

three/examples/jsm/nodes/procedural/CheckerNode.d.ts

@@ -0,0 +1,6 @@
+import TempNode from '../core/TempNode';
+
+export default class CheckerNode extends TempNode {
+    uvNode: Node;
+    constructor(uvNode?: Node);
+}