@types/three 0.143.0 → 0.144.0

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

@@ -0,0 +1,157 @@
+import { ConstNode, Node, NodeBuilder, NodeTypeOption, SwizzleOption } from '../Nodes';
+// lot of private typescript magic here
+export {};
+export type Swizzable<T extends Node = Node> = T &
+    {
+        [key in SwizzleOption | number]: Swizzable;
+    };
+
+/** anything that can be passed to {@link nodeObject} and returns a proxy */
+export type NodeRepresentation<T extends Node = Node> = number | boolean | Node | Swizzable<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;
+
+// opposite of NodeObject: node -> node|swizzable|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]> }];
+export type ProxiedObject<T> = { [index in keyof T]: Proxied<T[index]> };
+type RemoveTail<T extends readonly [...unknown[]]> = T extends [unknown, ...infer X] ? X : [];
+type RemoveHeadAndTail<T extends readonly [...unknown[]]> = T extends [unknown, ...infer X, unknown] ? X : [];
+
+/**
+ * Temporary type to save signatures of 4 constructors. Each element may be tuple or undefined.
+ *
+ * We use an object instead of tuple or union as it makes stuff easier, especially in Typescript 4.0.
+ */
+interface Construtors<
+    A extends undefined | [...unknown[]],
+    B extends undefined | [...unknown[]],
+    C extends undefined | [...unknown[]],
+    D extends undefined | [...unknown[]],
+> {
+    a: A;
+    b: B;
+    c: C;
+    d: D;
+}
+
+/**
+ * Returns all constructors
+ *
+ * <https://github.com/microsoft/TypeScript/issues/37079>
+ * <https://stackoverflow.com/a/52761156/1623826>
+ */
+type OverloadedConstructorsOf<T> = T extends {
+    new (...args: infer A1): unknown;
+    new (...args: infer A2): unknown;
+    new (...args: infer A3): unknown;
+    new (...args: infer A4): unknown;
+}
+    ? Construtors<A1, A2, A3, A4>
+    : T extends {
+          new (...args: infer A1): unknown;
+          new (...args: infer A2): unknown;
+          new (...args: infer A3): unknown;
+      }
+    ? Construtors<A1, A2, A3, undefined>
+    : T extends {
+          new (...args: infer A1): unknown;
+          new (...args: infer A2): unknown;
+      }
+    ? Construtors<A1, A2, undefined, undefined>
+    : T extends new (...args: infer A) => unknown
+    ? Construtors<A, undefined, undefined, undefined>
+    : Construtors<undefined, undefined, undefined, undefined>;
+
+type AnyConstructors = Construtors<any, any, any, any>;
+
+/**
+ * Returns all constructors where the first paramter is assignable to given "scope"
+ */
+// tslint:disable-next-line:interface-over-type-literal
+type FilterConstructorsByScope<T extends AnyConstructors, S> = {
+    a: S extends T['a'][0] ? T['a'] : undefined;
+    b: S extends T['b'][0] ? T['b'] : undefined;
+    c: S extends T['c'][0] ? T['c'] : undefined;
+    d: S extends T['d'][0] ? T['d'] : undefined;
+};
+/**
+ * "flattens" the tuple into an union type
+ */
+type ConstructorUnion<T extends AnyConstructors> =
+    | Exclude<T['a'], undefined>
+    | Exclude<T['b'], undefined>
+    | Exclude<T['c'], undefined>
+    | Exclude<T['d'], undefined>;
+
+/**
+ * Extract list of possible scopes - union of the first paramter
+ * of all constructors, should it be string
+ */
+type ExtractScopes<T extends AnyConstructors> =
+    | (T['a'][0] extends string ? T['a'][0] : never)
+    | (T['b'][0] extends string ? T['b'][0] : never)
+    | (T['c'][0] extends string ? T['c'][0] : never)
+    | (T['d'][0] extends string ? T['d'][0] : never);
+
+type GetConstructorsByScope<T, S> = ConstructorUnion<FilterConstructorsByScope<OverloadedConstructorsOf<T>, S>>;
+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;
+};
+
+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] };
+type ConstructedNode<T> = T extends new (...args: any[]) => infer R ? (R extends Node ? R : never) : never;
+
+export type NodeOrType = Node | NodeTypeOption;
+
+export function getConstNodeType(value: NodeOrType): NodeTypeOption | null;
+export function nodeObject<T extends NodeObjectOption>(obj: T): NodeObject<T>;
+export function nodeObjects<T>(obj: T): NodeObjects<T>;
+
+export function nodeArray<T extends NodeObjectOption[]>(obj: readonly [...T]): NodeArray<T>;
+
+export function nodeProxy<T>(
+    nodeClass: T,
+): (...params: ProxiedTuple<GetConstructors<T>>) => Swizzable<ConstructedNode<T>>;
+
+export function nodeProxy<T, S extends GetPossibleScopes<T>>(
+    nodeClass: T,
+    scope: S,
+): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => Swizzable<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>>;
+
+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>;
+};

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

@@ -0,0 +1,285 @@
+import TextureNode from '../accessors/TextureNode';
+import Node from '../core/Node';
+
+// shader node utils
+import {
+    ShaderNode,
+    nodeObject,
+    nodeObjects,
+    nodeArray,
+    nodeProxy,
+    nodeImmutable,
+    ConvertType,
+    Swizzable,
+    NodeRepresentation,
+    NodeOrType,
+    ProxiedObject,
+    ProxiedTuple,
+} from './ShaderNode';
+import { Material, Texture } from '../../../../src/Three';
+import { NodeTypeOption, NodeUserData, NodeValueOption } from '../core/constants';
+import { NodeBuilderContext } from '../core/NodeBuilder';
+import {
+    BufferNode,
+    BypassNode,
+    CameraNode,
+    CodeNode,
+    CodeNodeInclude,
+    ComputeNode,
+    ContextNode,
+    ExpressionNode,
+    FrontFacingNode,
+    FunctionCallNode,
+    FunctionNode,
+    FunctionNodeArguments,
+    InstanceIndexNode,
+    MaterialNode,
+    MaterialReferenceNode,
+    MathNode,
+    ModelNode,
+    ModelViewProjectionNode,
+    NormalNode,
+    PointUVNode,
+    PositionNode,
+    PropertyNode,
+    ReferenceNode,
+    UserDataNode,
+    UVNode,
+    VarNode,
+    VaryNode,
+} from '../Nodes';
+import StorageBufferNode from '../accessors/StorageBufferNode';
+
+// shader node base
+
+export { ShaderNode, nodeObject, nodeObjects, nodeArray, nodeProxy, nodeImmutable, Swizzable };
+
+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 function uniform(nodeOrType: Node | Swizzable | NodeValueOption): Swizzable;
+
+export function attribute(attributeName: string, nodeType: NodeTypeOption): Swizzable;
+export function property(name: string, nodeOrType: Node | NodeTypeOption): Swizzable;
+
+export function bypass(returnNode: NodeRepresentation, callNode: NodeRepresentation): Swizzable<BypassNode>;
+export function code(code: string, nodeType?: NodeTypeOption): Swizzable<CodeNode>;
+export function context(node: NodeRepresentation, context: NodeBuilderContext): Swizzable<ContextNode>;
+export function expression(snipped?: string, nodeType?: NodeTypeOption): Swizzable<ExpressionNode>;
+
+// definition: const call = nodeProxy(FunctionCallNode);
+export function call<P extends FunctionNodeArguments>(
+    functionNode?: FunctionNode<P>,
+    parameters?: ProxiedObject<P>,
+): Swizzable<FunctionCallNode<P>>;
+
+export type Fn<P extends FunctionNodeArguments> = P extends readonly [...unknown[]]
+    ? ProxiedTuple<P>
+    : readonly [ProxiedObject<P>];
+
+// tslint:disable:no-unnecessary-generics
+export function func<P extends FunctionNodeArguments>(
+    code: string,
+    includes?: CodeNodeInclude[],
+): { call: (...params: Fn<P>) => Swizzable };
+
+export function fn<P extends FunctionNodeArguments>(
+    code: string,
+    includes?: CodeNodeInclude[],
+): (...params: Fn<P>) => Swizzable;
+// tslint:enable:no-unnecessary-generics
+
+export const instanceIndex: Swizzable<InstanceIndexNode>;
+export function label(node: NodeRepresentation, name?: string): Swizzable<VarNode>;
+export function temp(node: NodeRepresentation, name?: string): Swizzable<VarNode>;
+export function vary(node: NodeRepresentation, name?: string): Swizzable<VaryNode>;
+
+// accesors
+
+export function buffer(value: ArrayLike<number>, nodeOrType: NodeOrType, count: number): Swizzable<BufferNode>;
+export function storage(value: ArrayLike<number>, nodeOrType: NodeOrType, count: number): Swizzable<StorageBufferNode>;
+
+export const cameraProjectionMatrix: Swizzable<CameraNode>;
+export const cameraViewMatrix: Swizzable<CameraNode>;
+export const cameraNormalMatrix: Swizzable<CameraNode>;
+export const cameraWorldMatrix: Swizzable<CameraNode>;
+export const cameraPosition: Swizzable<CameraNode>;
+
+export const materialAlphaTest: Swizzable<MaterialNode>;
+export const materialColor: Swizzable<MaterialNode>;
+export const materialEmissive: Swizzable<MaterialNode>;
+export const materialOpacity: Swizzable<MaterialNode>;
+export const materialRoughness: Swizzable<MaterialNode>;
+export const materialMetalness: Swizzable<MaterialNode>;
+export const materialRotation: Swizzable<MaterialNode>;
+
+export const diffuseColor: Swizzable<PropertyNode>;
+export const roughness: Swizzable<PropertyNode>;
+export const metalness: Swizzable<PropertyNode>;
+export const alphaTest: Swizzable<PropertyNode>;
+export const specularColor: Swizzable<PropertyNode>;
+
+export function reference<T>(name: string, nodeOrType: NodeOrType, object: T): Swizzable<ReferenceNode<T>>;
+export function materialReference(
+    name: string,
+    nodeOrType: NodeOrType,
+    material: Material,
+): Swizzable<MaterialReferenceNode>;
+export function userData(name: string, inputType: NodeTypeOption, userData?: NodeUserData): Swizzable<UserDataNode>;
+
+export function modelViewProjection(position?: NodeRepresentation): Swizzable<ModelViewProjectionNode>;
+
+export const normalGeometry: Swizzable<NormalNode>;
+export const normalLocal: Swizzable<NormalNode>;
+export const normalWorld: Swizzable<NormalNode>;
+export const normalView: Swizzable<NormalNode>;
+export const transformedNormalView: Swizzable<VarNode>;
+
+export const modelViewMatrix: Swizzable<ModelNode>;
+export const modelNormalMatrix: Swizzable<ModelNode>;
+export const modelWorldMatrix: Swizzable<ModelNode>;
+export const modelPosition: Swizzable<ModelNode>;
+export const modelViewPosition: Swizzable<ModelNode>;
+
+export const positionGeometry: Swizzable<PositionNode>;
+export const positionLocal: Swizzable<PositionNode>;
+export const positionWorld: Swizzable<PositionNode>;
+export const positionView: Swizzable<PositionNode>;
+export const positionViewDirection: Swizzable<PositionNode>;
+
+export function texture(
+    value: Texture,
+    uvNode?: NodeRepresentation,
+    levelNode?: NodeRepresentation,
+): Swizzable<TextureNode>;
+export function sampler(texture: Texture | TextureNode): Swizzable;
+export function uv(index?: number): Swizzable<UVNode>;
+export const pointUV: Swizzable<PointUVNode>;
+
+// gpgpu
+
+export function compute(node: NodeRepresentation, count: number, workgroupSize: number[]): Swizzable<ComputeNode>;
+
+// math
+
+export const EPSILON: Swizzable;
+export const INFINITY: Swizzable;
+
+export function cond(condNode: NodeRepresentation, ifNode: NodeRepresentation, elseNode: NodeRepresentation): Swizzable;
+
+type Operator = (a: NodeRepresentation, b: NodeRepresentation, ...others: NodeRepresentation[]) => Swizzable;
+type Unary = (a: NodeRepresentation) => Swizzable<MathNode>;
+type Binary = (a: NodeRepresentation, b: NodeRepresentation) => Swizzable<MathNode>;
+type Ternary = (a: NodeRepresentation, b: NodeRepresentation, c: NodeRepresentation) => Swizzable<MathNode>;
+
+export const add: Operator;
+export const sub: Operator;
+export const mul: Operator;
+export const div: Operator;
+export const remainder: Operator;
+export const equal: Operator;
+export const assign: Operator;
+export const lessThan: Operator;
+export const greaterThan: Operator;
+export const lessThanEqual: Operator;
+export const greaterThanEqual: Operator;
+export const and: Operator;
+export const or: Operator;
+export const xor: Operator;
+export const bitAnd: Operator;
+export const bitOr: Operator;
+export const bitXor: Operator;
+export const shiftLeft: Operator;
+export const shiftRight: Operator;
+
+export const radians: Unary;
+export const degrees: Unary;
+export const exp: Unary;
+export const exp2: Unary;
+export const log: Unary;
+export const log2: Unary;
+export const sqrt: Unary;
+export const inversesqrt: Unary;
+export const floor: Unary;
+export const ceil: Unary;
+export const normalize: Unary;
+export const fract: Unary;
+export const sin: Unary;
+export const cos: Unary;
+export const tan: Unary;
+export const asin: Unary;
+export const acos: Unary;
+export const atan: Unary;
+export const abs: Unary;
+export const sign: Unary;
+export const length: Unary;
+export const negate: Unary;
+export const invert: Unary;
+export const dFdx: Unary;
+export const dFdy: Unary;
+export const saturate: Unary;
+export const round: Unary;
+
+export const atan2: Binary;
+export const min: Binary;
+export const max: Binary;
+export const mod: Binary;
+export const step: Binary;
+export const reflect: Binary;
+export const distance: Binary;
+export const dot: Binary;
+export const cross: Binary;
+export const pow: Binary;
+export const pow2: Binary;
+export const pow3: Binary;
+export const pow4: Binary;
+export const transformDirection: Binary;
+
+export const mix: Ternary;
+export const clamp: Ternary;
+export const refract: Ternary;
+export const smoothstep: Ternary;
+export const faceforward: Ternary;
+
+// display
+
+export const frontFacing: Swizzable<FrontFacingNode>;
+export const faceDirection: Swizzable;
+
+// lighting
+
+// utils
+export function element(node: NodeRepresentation, indexNode: NodeRepresentation): Swizzable;
+
+// miscellaneous
+export const dotNV: Swizzable<MathNode>;
+export const transformedNormalWorld: Swizzable<MathNode>;

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

@@ -0,0 +1,128 @@
+import Node from '../core/Node';
+import RangeNode, { RangeModeBound } from '../geometry/RangeNode';
+import { NodeRepresentation, Swizzable } from './ShaderNode';
+import {
+    CubeTexture,
+    InstancedMesh,
+    Light,
+    SkinnedMesh,
+    Texture,
+    TextureEncoding,
+    ToneMapping,
+} from '../../../../src/Three';
+import LightingContextNode, { LightingModelNode } from '../lighting/LightingContextNode';
+import {
+    CheckerNode,
+    ColorAdjustmentNode,
+    ColorSpaceNode,
+    CubeTextureNode,
+    FogNode,
+    FogRangeNode,
+    InstanceNode,
+    LightsNode,
+    MatcapUVNode,
+    MaxMipLevelNode,
+    NormalMapNode,
+    OscNode,
+    ReflectVectorNode,
+    RotateUVNode,
+    SkinningNode,
+    SpriteSheetUVNode,
+    TimerNode,
+    ToneMappingNode,
+} from '../Nodes';
+
+//
+// Node Material Shader Syntax
+//
+
+// shader node base
+
+export * from './ShaderNodeBaseElements';
+
+// functions
+
+export { default as BRDF_GGX } from '../functions/BSDF/BRDF_GGX'; // see https://github.com/tc39/proposal-export-default-from
+export { default as BRDF_Lambert } from '../functions/BSDF/BRDF_Lambert';
+export { default as D_GGX } from '../functions/BSDF/D_GGX';
+export { default as DFGApprox } from '../functions/BSDF/DFGApprox';
+export { default as F_Schlick } from '../functions/BSDF/F_Schlick';
+export { default as V_GGX_SmithCorrelated } from '../functions/BSDF/V_GGX_SmithCorrelated';
+
+export { default as getDistanceAttenuation } from '../functions/light/getDistanceAttenuation';
+
+export { default as getGeometryRoughness } from '../functions/material/getGeometryRoughness';
+export { default as getRoughness } from '../functions/material/getRoughness';
+
+export { default as PhysicalLightingModel } from '../functions/PhysicalLightingModel';
+
+// accessors
+
+export function cubeTexture(
+    value: CubeTexture,
+    uvNode?: NodeRepresentation,
+    levelNode?: NodeRepresentation,
+): Swizzable<CubeTextureNode>;
+export function instance(instanceMesh: InstancedMesh): Swizzable<InstanceNode>;
+export const reflectVector: Swizzable<ReflectVectorNode>;
+export function skinning(skinnedMesh: SkinnedMesh): Swizzable<SkinningNode>;
+
+// display
+
+export function saturation(
+    colorNode: NodeRepresentation,
+    adjustmentNode?: NodeRepresentation,
+): Swizzable<ColorAdjustmentNode>;
+export function vibrance(
+    colorNode: NodeRepresentation,
+    adjustmentNode?: NodeRepresentation,
+): Swizzable<ColorAdjustmentNode>;
+export function hue(colorNode: NodeRepresentation, adjustmentNode?: NodeRepresentation): Swizzable<ColorAdjustmentNode>;
+
+export function colorSpace(node: NodeRepresentation, encoding: TextureEncoding): Swizzable<ColorSpaceNode>;
+export function normalMap(node: Node, scaleNode?: Node): Swizzable<NormalMapNode>;
+export function toneMapping(
+    mapping: ToneMapping,
+    exposure: NodeRepresentation,
+    color: NodeRepresentation,
+): Swizzable<ToneMappingNode>;
+
+// lighting
+
+export function lights(lights: Light[]): Swizzable<LightsNode>;
+export function lightingContext(node: Node, lightingModelNode?: LightingModelNode): Swizzable<LightingContextNode>;
+
+// utils
+
+export const matcapUV: Swizzable<MatcapUVNode>;
+export function maxMipLevel(texture: Texture): Swizzable<MaxMipLevelNode>;
+
+export function oscSine(timeNode?: NodeRepresentation): Swizzable<OscNode>;
+export function oscSquare(timeNode?: NodeRepresentation): Swizzable<OscNode>;
+export function oscTriangle(timeNode?: NodeRepresentation): Swizzable<OscNode>;
+export function oscSawtooth(timeNode?: NodeRepresentation): Swizzable<OscNode>;
+
+export function rotateUV(uvNode: Node, rotationNode: Node, centerNode?: Node): Swizzable<RotateUVNode>;
+
+export function spritesheetUV(
+    countNode: NodeRepresentation,
+    uvNode?: NodeRepresentation,
+    frameNode?: NodeRepresentation,
+): Swizzable<SpriteSheetUVNode>;
+
+export function timerLocal(timeScale: number, value?: number): Swizzable<TimerNode>;
+export function timerGlobal(timeScale: number, value?: number): Swizzable<TimerNode>;
+export function timerDelta(timeScale: number, value?: number): Swizzable<TimerNode>;
+
+// geometry
+
+export function range(min: RangeModeBound, max: RangeModeBound): Swizzable<RangeNode>;
+
+// procedural
+
+export function checker(uvNode?: NodeRepresentation): Swizzable<CheckerNode>;
+
+// fog
+
+export function fog(colorNode: NodeRepresentation, factorNode: NodeRepresentation): Swizzable<FogNode>;
+export function rangeFog(colorNode: Node, nearNode: Node, farNode: Node): Swizzable<FogRangeNode>;

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

@@ -0,0 +1,9 @@
+import Node from '../core/Node';
+import { TempNode } from '../Nodes';
+
+export default class ArrayElementNode extends TempNode {
+    node: Node;
+    indexNode: Node;
+
+    constructor(node: Node, indexNode: Node);
+}

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

@@ -0,0 +1,8 @@
+import Node from '../core/Node';
+import { NodeTypeOption } from '../Nodes';
+
+export default class ConvertNode extends Node {
+    node: Node;
+    convertTo: NodeTypeOption;
+    constructor(node: Node, convertTo: NodeTypeOption);
+}

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

@@ -0,0 +1,10 @@
+import Node from '../core/Node';
+import { TempNode } from '../Nodes';
+
+/**
+ * This node constructs given type from elements, like vec3(a,b,c)
+ */
+export default class JoinNode extends TempNode {
+    nodes: Node[];
+    constructor(nodes: Node[]);
+}

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

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

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

@@ -0,0 +1,7 @@
+import UniformNode from '../core/UniformNode';
+import { Texture } from '../../../../src/Three';
+
+export default class MaxMipLevelNode extends UniformNode {
+    texture: Texture;
+    constructor(texture: Texture);
+}

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

@@ -0,0 +1,19 @@
+import Node from '../core/Node';
+
+export type OscNodeMethod =
+    | typeof OscNode.SINE
+    | typeof OscNode.SQUARE
+    | typeof OscNode.TRIANGLE
+    | typeof OscNode.SAWTOOTH;
+
+export default class OscNode extends Node {
+    static SINE: 'sine';
+    static SQUARE: 'square';
+    static TRIANGLE: 'triangle';
+    static SAWTOOTH: 'sawtooth';
+
+    method: OscNodeMethod;
+    timeNode: Node;
+
+    constructor(method: OscNodeMethod, timeNode?: Node);
+}

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

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

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

@@ -0,0 +1,16 @@
+import { SwizzleOption } from '../core/constants';
+import Node from '../core/Node';
+
+/** swizzle node */
+export default class SplitNode extends Node {
+    node: Node;
+    components: string;
+
+    /**
+     *
+     * @param node the input node
+     * @param components swizzle like string, default = "x"
+     */
+    constructor(node: Node, components?: SwizzleOption);
+    getVectorLength(): number;
+}

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

@@ -0,0 +1,9 @@
+import Node from '../core/Node';
+
+export default class SpriteSheetUVNode extends Node {
+    countNode: Node;
+    uvNode: Node;
+    frameNode: Node;
+
+    constructor(countNode: Node, uvNode?: Node, frameNode?: Node);
+}

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

@@ -0,0 +1,14 @@
+import UniformNode from '../core/UniformNode';
+
+export type TimerNodeScope = typeof TimerNode.LOCAL | typeof TimerNode.GLOBAL | typeof TimerNode.DELTA;
+
+export default class TimerNode extends UniformNode {
+    static LOCAL: 'local';
+    static GLOBAL: 'global';
+    static DELTA: 'delta';
+
+    scope: TimerNodeScope;
+    scale: number;
+
+    constructor(scope?: TimerNodeScope, scale?: number, value?: number);
+}