@types/three 0.157.1 → 0.157.2

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

@@ -0,0 +1,310 @@
+import TextureNode from '../accessors/TextureNode.js';
+import Node from '../core/Node.js';
+
+// shader node utils
+import {
+    ShaderNode,
+    nodeObject,
+    nodeObjects,
+    nodeArray,
+    nodeProxy,
+    nodeImmutable,
+    ConvertType,
+    Swizzable,
+    NodeRepresentation,
+    NodeOrType,
+    ProxiedObject,
+    ProxiedTuple,
+} from './ShaderNode.js';
+import { Material, Texture } from '../../../../src/Three.js';
+import { NodeTypeOption, NodeUserData, NodeValueOption } from '../core/constants.js';
+import { NodeBuilderContext } from '../core/NodeBuilder.js';
+import {
+    BitangentNode,
+    BufferNode,
+    BypassNode,
+    CacheNode,
+    CameraNode,
+    CodeNode,
+    CodeNodeInclude,
+    ComputeNode,
+    ContextNode,
+    ExpressionNode,
+    FrontFacingNode,
+    FunctionCallNode,
+    FunctionNode,
+    FunctionNodeArguments,
+    MaterialNode,
+    MaterialReferenceNode,
+    MathNode,
+    MaxMipLevelNode,
+    ModelNode,
+    ModelViewProjectionNode,
+    NormalNode,
+    PointUVNode,
+    PositionNode,
+    PropertyNode,
+    ReferenceNode,
+    TangentNode,
+    UserDataNode,
+    UVNode,
+    VarNode,
+    VaryingNode,
+} from '../Nodes.js';
+import StorageBufferNode from '../accessors/StorageBufferNode.js';
+import NodeCache from '../core/NodeCache.js';
+
+// 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 convert(node: NodeRepresentation, types: NodeTypeOption): Swizzable;
+export function maxMipLevel(texture: Texture): Swizzable<MaxMipLevelNode>;
+
+export function bypass(returnNode: NodeRepresentation, callNode: NodeRepresentation): Swizzable<BypassNode>;
+export function cache(node: Node, cache?: NodeCache): Swizzable<CacheNode>;
+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>];
+
+export function func<P extends FunctionNodeArguments>(
+    code: string,
+    includes?: CodeNodeInclude[],
+    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+): { call: (...params: Fn<P>) => Swizzable };
+
+export function fn<P extends FunctionNodeArguments>(
+    code: string,
+    includes?: CodeNodeInclude[],
+    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+): (...params: Fn<P>) => Swizzable;
+
+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<VaryingNode>;
+
+// 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 tangentGeometry: Swizzable<TangentNode>;
+export const tangentLocal: Swizzable<TangentNode>;
+export const tangentView: Swizzable<TangentNode>;
+export const tangentWorld: Swizzable<TangentNode>;
+export const transformedTangentView: Swizzable<MathNode>;
+export const transformedTangentWorld: Swizzable<MathNode>;
+
+export const bitangentGeometry: Swizzable<BitangentNode>;
+export const bitangentLocal: Swizzable<BitangentNode>;
+export const bitangentView: Swizzable<BitangentNode>;
+export const bitangentWorld: Swizzable<BitangentNode>;
+export const transformedBitangentView: Swizzable<MathNode>;
+export const transformedBitangentWorld: Swizzable<MathNode>;
+
+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 positionWorldDirection: 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 round: Unary;
+export const reciprocal: 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 lumaCoeffs: Swizzable<MathNode>;
+export const luminance: Binary;
+export const difference: Binary;
+export const dotNV: Swizzable<MathNode>;
+export const TBNViewMatrix: Swizzable<MathNode>;

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

@@ -0,0 +1,166 @@
+import Node from '../core/Node.js';
+import RangeNode, { RangeModeBound } from '../geometry/RangeNode.js';
+import { NodeRepresentation, Swizzable } from './ShaderNode.js';
+import {
+    CubeTexture,
+    InstancedMesh,
+    Light,
+    SkinnedMesh,
+    Texture,
+    TextureEncoding,
+    ToneMapping,
+} from '../../../../src/Three.js';
+import LightingContextNode, { LightingModelNode } from '../lighting/LightingContextNode.js';
+import {
+    BlendModeNode,
+    CheckerNode,
+    ColorAdjustmentNode,
+    ColorSpaceNode,
+    CubeTextureNode,
+    EquirectUVNode,
+    FogNode,
+    FogRangeNode,
+    FogExp2Node,
+    InstanceNode,
+    LightsNode,
+    MatcapUVNode,
+    NormalMapNode,
+    OscNode,
+    PosterizeNode,
+    RemapNode,
+    ReflectVectorNode,
+    RotateUVNode,
+    SkinningNode,
+    SpriteSheetUVNode,
+    TimerNode,
+    ToneMappingNode,
+    TriplanarTexturesNode,
+    SpecularMIPLevelNode,
+    ViewportNode,
+} from '../Nodes.js';
+
+//
+// Node Material Shader Syntax
+//
+
+// shader node base
+
+export * from './ShaderNodeBaseElements.js';
+
+// functions
+
+export { default as BRDF_GGX } from '../functions/BSDF/BRDF_GGX.js'; // see https://github.com/tc39/proposal-export-default-from
+export { default as BRDF_Lambert } from '../functions/BSDF/BRDF_Lambert.js';
+export { default as D_GGX } from '../functions/BSDF/D_GGX.js';
+export { default as DFGApprox } from '../functions/BSDF/DFGApprox.js';
+export { default as F_Schlick } from '../functions/BSDF/F_Schlick.js';
+export { default as V_GGX_SmithCorrelated } from '../functions/BSDF/V_GGX_SmithCorrelated.js';
+
+export { default as getGeometryRoughness } from '../functions/material/getGeometryRoughness.js';
+export { default as getRoughness } from '../functions/material/getRoughness.js';
+
+export { default as PhysicalLightingModel } from '../functions/PhysicalLightingModel.js';
+
+// 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 burn(baseNode: NodeRepresentation, blendNode?: NodeRepresentation): Swizzable<BlendModeNode>;
+export function dodge(baseNode: NodeRepresentation, blendNode?: NodeRepresentation): Swizzable<BlendModeNode>;
+export function overlay(baseNode: NodeRepresentation, blendNode?: NodeRepresentation): Swizzable<BlendModeNode>;
+export function screen(baseNode: NodeRepresentation, blendNode?: NodeRepresentation): Swizzable<BlendModeNode>;
+
+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>;
+
+export function posterize(sourceNode: NodeRepresentation, stepsNode: NodeRepresentation): Swizzable<PosterizeNode>;
+
+export const viewportCoordinate: Swizzable<ViewportNode>;
+export const viewportResolution: Swizzable<ViewportNode>;
+export const viewportTopLeft: Swizzable<ViewportNode>;
+export const viewportBottomLeft: Swizzable<ViewportNode>;
+export const viewportTopRight: Swizzable<ViewportNode>;
+export const viewportBottomRight: Swizzable<ViewportNode>;
+
+// lighting
+
+export function lights(lights: Light[]): Swizzable<LightsNode>;
+export function lightingContext(node: Node, lightingModelNode?: LightingModelNode): Swizzable<LightingContextNode>;
+
+// utils
+
+export const matcapUV: Swizzable<MatcapUVNode>;
+export const equirectUV: Swizzable<EquirectUVNode>;
+
+export function specularMIPLevel(): Swizzable<SpecularMIPLevelNode>;
+
+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 remap(node: Node, inLowNode: Node): Swizzable<RemapNode>;
+export function remapClamp(node: Node, inLowNode: Node): Swizzable<RemapNode>;
+
+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>;
+export const frameId: Swizzable<TimerNode>;
+export function triplanarTextures(
+    textureXNode: NodeRepresentation,
+    textureYNode?: NodeRepresentation,
+    textureZNode?: NodeRepresentation,
+    scaleNode?: NodeRepresentation,
+    positionNode?: NodeRepresentation,
+    normalNode?: NodeRepresentation,
+): Swizzable<TriplanarTexturesNode>;
+export function triplanarTexture(
+    texture: NodeRepresentation,
+    ...params: NodeRepresentation[]
+): Swizzable<TriplanarTexturesNode>;
+
+// 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>;
+export function exp2Fog(colorNode: Node, densityNode: Node): Swizzable<FogExp2Node>;

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

@@ -0,0 +1,9 @@
+import Node from '../core/Node.js';
+import { TempNode } from '../Nodes.js';
+
+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.js';
+import { NodeTypeOption } from '../Nodes.js';
+
+export default class ConvertNode extends Node {
+    node: Node;
+    convertTo: NodeTypeOption;
+    constructor(node: Node, convertTo: NodeTypeOption);
+}

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

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

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

@@ -0,0 +1,10 @@
+import Node from '../core/Node.js';
+import { TempNode } from '../Nodes.js';
+
+/**
+ * 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.js';
+
+export default class MatcapUVNode extends TempNode {
+    constructor();
+}

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

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

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

@@ -0,0 +1,19 @@
+import Node from '../core/Node.js';
+
+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/RemapNode.d.ts

@@ -0,0 +1,13 @@
+import Node from '../core/Node.js';
+
+export default class RemapNode extends Node {
+    node: Node;
+    inLowNode: Node;
+    inHighNode: Node;
+    outLowNode: Node;
+    outHighNode: Node;
+
+    doClamp: boolean;
+
+    constructor(node: Node, inLowNode: Node, inHighNode: Node, outLowNode: Node, outHighNode: Node);
+}

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

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

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

@@ -0,0 +1,8 @@
+import { Node, TextureNode } from '../Nodes.js';
+
+export default class SpecularMIPLevelNode extends Node {
+    textureNode: TextureNode;
+    roughnessNode: Node | null;
+
+    constructor(textureNode: TextureNode, roughnessNode?: Node | null);
+}

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

@@ -0,0 +1,16 @@
+import { SwizzleOption } from '../core/constants.js';
+import Node from '../core/Node.js';
+
+/** 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.js';
+
+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,19 @@
+import UniformNode from '../core/UniformNode.js';
+
+export type TimerNodeScope =
+    | typeof TimerNode.LOCAL
+    | typeof TimerNode.GLOBAL
+    | typeof TimerNode.DELTA
+    | typeof TimerNode.FRAME;
+
+export default class TimerNode extends UniformNode {
+    static LOCAL: 'local';
+    static GLOBAL: 'global';
+    static DELTA: 'delta';
+    static FRAME: 'frame';
+
+    scope: TimerNodeScope;
+    scale: number;
+
+    constructor(scope?: TimerNodeScope, scale?: number, value?: number);
+}

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

@@ -0,0 +1,22 @@
+import Node from '../core/Node.js';
+import { PositionNode, Swizzable, TextureNode } from '../Nodes.js';
+
+export default class TriplanarTexturesNode extends Node {
+    textureXNode: TextureNode;
+    textureYNode: TextureNode | null;
+    textureZNode: TextureNode | null;
+
+    scaleNode: Swizzable;
+
+    positionNode: Swizzable<PositionNode>;
+    normalNode: Swizzable<PositionNode>;
+
+    constructor(
+        textureXNode: Node,
+        textureYNode?: TextureNode | null,
+        textureZNode?: TextureNode | null,
+        scaleNode?: Swizzable,
+        positionNode?: Swizzable<PositionNode>,
+        normalNode?: Swizzable<PositionNode>,
+    );
+}

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

@@ -0,0 +1,13 @@
+import { Mesh, IcosahedronGeometry, ShaderMaterial, Texture } from '../../../src/Three.js';
+
+export class GroundProjectedSkybox extends Mesh<IcosahedronGeometry, ShaderMaterial> {
+    constructor(texture: Texture, options?: { height?: number; radius?: number });
+
+    set radius(radius: number);
+
+    get radius(): number;
+
+    set height(height: number);
+
+    get height(): number;
+}