@types/three 0.164.1 → 0.166.0

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

@@ -7,12 +7,34 @@ export const mx_select: (
     t_immutable: NodeRepresentation,
     f_immutable: NodeRepresentation,
 ) => ShaderNodeObject<Node>;
+
 export const mx_negate_if: (
     val_immutable: NodeRepresentation,
     b_immutable: NodeRepresentation,
 ) => ShaderNodeObject<Node>;
+
 export const mx_floor: (x_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
 export const mx_floorfrac: (x_immutable: NodeRepresentation, i: ShaderNodeObject<VarNode>) => ShaderNodeObject<Node>;
+
+export const mx_bilerp_0: (
+    v0_immutable: NodeRepresentation,
+    v1_immutable: NodeRepresentation,
+    v2_immutable: NodeRepresentation,
+    v3_immutable: NodeRepresentation,
+    s_immutable: NodeRepresentation,
+    t_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const mx_bilerp_1: (
+    v0_immutable: NodeRepresentation,
+    v1_immutable: NodeRepresentation,
+    v2_immutable: NodeRepresentation,
+    v3_immutable: NodeRepresentation,
+    s_immutable: NodeRepresentation,
+    t_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
 export const mx_bilerp: (
     v0_immutable: NodeRepresentation,
     v1_immutable: NodeRepresentation,
@@ -21,6 +43,35 @@ export const mx_bilerp: (
     s_immutable: NodeRepresentation,
     t_immutable: NodeRepresentation,
 ) => ShaderNodeObject<Node>;
+
+export const mx_trilerp_0: (
+    v0_immutable: NodeRepresentation,
+    v1_immutable: NodeRepresentation,
+    v2_immutable: NodeRepresentation,
+    v3_immutable: NodeRepresentation,
+    v4_immutable: NodeRepresentation,
+    v5_immutable: NodeRepresentation,
+    v6_immutable: NodeRepresentation,
+    v7_immutable: NodeRepresentation,
+    s_immutable: NodeRepresentation,
+    t_immutable: NodeRepresentation,
+    r_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const mx_trilerp_1: (
+    v0_immutable: NodeRepresentation,
+    v1_immutable: NodeRepresentation,
+    v2_immutable: NodeRepresentation,
+    v3_immutable: NodeRepresentation,
+    v4_immutable: NodeRepresentation,
+    v5_immutable: NodeRepresentation,
+    v6_immutable: NodeRepresentation,
+    v7_immutable: NodeRepresentation,
+    s_immutable: NodeRepresentation,
+    t_immutable: NodeRepresentation,
+    r_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
 export const mx_trilerp: (
     v0_immutable: NodeRepresentation,
     v1_immutable: NodeRepresentation,
@@ -34,33 +85,105 @@ export const mx_trilerp: (
     t_immutable: NodeRepresentation,
     r_immutable: NodeRepresentation,
 ) => ShaderNodeObject<Node>;
+
+export const mx_gradient_float_0: (
+    hash_immutable: NodeRepresentation,
+    x_immutable: NodeRepresentation,
+    y_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const mx_gradient_float_1: (
+    hash_immutable: NodeRepresentation,
+    x_immutable: NodeRepresentation,
+    y_immutable: NodeRepresentation,
+    z_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
 export const mx_gradient_float: (
     hash_immutable: NodeRepresentation,
     x_immutable: NodeRepresentation,
     y_immutable: NodeRepresentation,
     z_immutable?: NodeRepresentation,
 ) => ShaderNodeObject<Node>;
+
+export const mx_gradient_vec3_0: (
+    hash_immutable: NodeRepresentation,
+    x_immutable: NodeRepresentation,
+    y_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const mx_gradient_vec3_1: (
+    hash_immutable: NodeRepresentation,
+    x_immutable: NodeRepresentation,
+    y_immutable: NodeRepresentation,
+    z_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
 export const mx_gradient_vec3: (
     hash_immutable: NodeRepresentation,
     x_immutable: NodeRepresentation,
     y_immutable: NodeRepresentation,
     z_immutable?: NodeRepresentation,
 ) => ShaderNodeObject<Node>;
+
+export const mx_gradient_scale2d_0: (v_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_gradient_scale3d_0: (v_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_gradient_scale2d_1: (v_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
 export const mx_gradient_scale2d: (v_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_gradient_scale3d_1: (v_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
 export const mx_gradient_scale3d: (v_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
 export const mx_rotl32: (x_immutable: NodeRepresentation, k_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
 export const mx_bjmix: (
     a: ShaderNodeObject<VarNode>,
     b: ShaderNodeObject<VarNode>,
     c: ShaderNodeObject<VarNode>,
 ) => ShaderNodeObject<Node>;
+
 export const mx_bjfinal: (
     a_immutable: NodeRepresentation,
     b_immutable: NodeRepresentation,
     c_immutable: NodeRepresentation,
 ) => ShaderNodeObject<Node>;
+
 export const mx_bits_to_01: (bits_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
 export const mx_fade: (t_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_hash_int_0: (x_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_hash_int_1: (
+    x_immutable: NodeRepresentation,
+    y_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const mx_hash_int_2: (
+    x_immutable: NodeRepresentation,
+    y_immutable: NodeRepresentation,
+    z_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const mx_hash_int_3: (
+    x_immutable: NodeRepresentation,
+    y_immutable: NodeRepresentation,
+    z_immutable: NodeRepresentation,
+    xx_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const mx_hash_int_4: (
+    x_immutable: NodeRepresentation,
+    y_immutable: NodeRepresentation,
+    z_immutable: NodeRepresentation,
+    xx_immutable: NodeRepresentation,
+    yy_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
 export const mx_hash_int: (
     x_immutable: NodeRepresentation,
     y_immutable?: NodeRepresentation,
@@ -68,39 +191,107 @@ export const mx_hash_int: (
     xx_immutable?: NodeRepresentation,
     yy_immutable?: NodeRepresentation,
 ) => ShaderNodeObject<Node>;
+
+export const mx_hash_vec3_0: (
+    x_immutable: NodeRepresentation,
+    y_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const mx_hash_vec3_1: (
+    x_immutable: NodeRepresentation,
+    y_immutable: NodeRepresentation,
+    z_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
 export const mx_hash_vec3: (
     x_immutable: NodeRepresentation,
     y_immutable: NodeRepresentation,
     z_immutable?: NodeRepresentation,
 ) => ShaderNodeObject<Node>;
+
+export const mx_perlin_noise_float_0: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_perlin_noise_float_1: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
 export const mx_perlin_noise_float: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_perlin_noise_vec3_0: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_perlin_noise_vec3_1: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
 export const mx_perlin_noise_vec3: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_float_0: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_float_1: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_float_2: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_float_3: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
 export const mx_cell_noise_float: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_vec3_0: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_vec3_1: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_vec3_2: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_vec3_3: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
 export const mx_cell_noise_vec3: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
 export const mx_fractal_noise_float: (
     p_immutable: NodeRepresentation,
     octaves_immutable: NodeRepresentation,
     lacunarity_immutable: NodeRepresentation,
     diminish_immutable: NodeRepresentation,
 ) => ShaderNodeObject<Node>;
+
 export const mx_fractal_noise_vec3: (
     p_immutable: NodeRepresentation,
     octaves_immutable: NodeRepresentation,
     lacunarity_immutable: NodeRepresentation,
     diminish_immutable: NodeRepresentation,
 ) => ShaderNodeObject<Node>;
+
 export const mx_fractal_noise_vec2: (
     p_immutable: NodeRepresentation,
     octaves_immutable: NodeRepresentation,
     lacunarity_immutable: NodeRepresentation,
     diminish_immutable: NodeRepresentation,
 ) => ShaderNodeObject<Node>;
+
 export const mx_fractal_noise_vec4: (
     p_immutable: NodeRepresentation,
     octaves_immutable: NodeRepresentation,
     lacunarity_immutable: NodeRepresentation,
     diminish_immutable: NodeRepresentation,
 ) => ShaderNodeObject<Node>;
+
+export const mx_worley_distance_0: (
+    p_immutable: NodeRepresentation,
+    x_immutable: NodeRepresentation,
+    y_immutable: NodeRepresentation,
+    z_immutable: NodeRepresentation,
+    xoff_immutable: NodeRepresentation,
+    yoff_immutable: NodeRepresentation,
+    jitter_immutable: NodeRepresentation,
+    metric_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const mx_worley_distance_1: (
+    p_immutable: NodeRepresentation,
+    x_immutable: NodeRepresentation,
+    y_immutable: NodeRepresentation,
+    z_immutable: NodeRepresentation,
+    xoff_immutable: NodeRepresentation,
+    yoff_immutable: NodeRepresentation,
+    zoff_immutable: NodeRepresentation,
+    jitter_immutable: NodeRepresentation,
+    metric_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
 export const mx_worley_distance: (
     p_immutable: NodeRepresentation,
     x_immutable: NodeRepresentation,
@@ -110,18 +301,57 @@ export const mx_worley_distance: (
     yoff_immutable: NodeRepresentation,
     zoff_immutable: NodeRepresentation,
     jitter_immutable: NodeRepresentation,
+    metric_immutable?: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const mx_worley_noise_float_0: (
+    p_immutable: NodeRepresentation,
+    jitter_immutable: NodeRepresentation,
+    metric_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const mx_worley_noise_vec2_0: (
+    p_immutable: NodeRepresentation,
+    jitter_immutable: NodeRepresentation,
     metric_immutable: NodeRepresentation,
 ) => ShaderNodeObject<Node>;
+
+export const mx_worley_noise_vec3_0: (
+    p_immutable: NodeRepresentation,
+    jitter_immutable: NodeRepresentation,
+    metric_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const mx_worley_noise_float_1: (
+    p_immutable: NodeRepresentation,
+    jitter_immutable: NodeRepresentation,
+    metric_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
 export const mx_worley_noise_float: (
     p_immutable: NodeRepresentation,
     jitter_immutable: NodeRepresentation,
     metric_immutable: NodeRepresentation,
 ) => ShaderNodeObject<Node>;
+
+export const mx_worley_noise_vec2_1: (
+    p_immutable: NodeRepresentation,
+    jitter_immutable: NodeRepresentation,
+    metric_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
 export const mx_worley_noise_vec2: (
     p_immutable: NodeRepresentation,
     jitter_immutable: NodeRepresentation,
     metric_immutable: NodeRepresentation,
 ) => ShaderNodeObject<Node>;
+
+export const mx_worley_noise_vec3_1: (
+    p_immutable: NodeRepresentation,
+    jitter_immutable: NodeRepresentation,
+    metric_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
 export const mx_worley_noise_vec3: (
     p_immutable: NodeRepresentation,
     jitter_immutable: NodeRepresentation,

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

@@ -32,7 +32,8 @@ export type MathNodeMethod1 =
     | typeof MathNode.RECIPROCAL
     | typeof MathNode.TRUNC
     | typeof MathNode.FWIDTH
-    | typeof MathNode.BITCAST;
+    | typeof MathNode.BITCAST
+    | typeof MathNode.TRANSPOSE;
 
 export type MathNodeMethod2 =
     | typeof MathNode.ATAN2
@@ -93,6 +94,7 @@ export default class MathNode extends TempNode {
     static TRUNC: "trunc";
     static FWIDTH: "fwidth";
     static BITCAST: "bitcast";
+    static TRANSPOSE: "transpose";
 
     // 2 inputs
 
@@ -167,6 +169,7 @@ export const reciprocal: Unary;
 export const trunc: Unary;
 export const fwidth: Unary;
 export const bitcast: Unary;
+export const transpose: Unary;
 
 type Binary = (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;
 
@@ -261,5 +264,6 @@ declare module "../shadernode/ShaderNode.js" {
         difference: typeof difference;
         saturate: typeof saturate;
         cbrt: typeof cbrt;
+        transpose: typeof transpose;
     }
 }

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

@@ -1,42 +1,42 @@
-import { AnyObject, NodeTypeOption, SwizzleOption } from "../core/constants.js";
 import ConstNode from "../core/ConstNode.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
+import StackNode from "../core/StackNode.js";
 
 export interface NodeElements {
+    toGlobal: (node: Node) => Node;
+
     append: typeof append;
 
-    color: typeof color;
-    float: typeof float;
-    int: typeof int;
-    uint: typeof uint;
-    bool: typeof bool;
-    vec2: typeof vec2;
-    ivec2: typeof ivec2;
-    uvec2: typeof uvec2;
-    bvec2: typeof bvec2;
-    vec3: typeof vec3;
-    ivec3: typeof ivec3;
-    uvec3: typeof uvec3;
-    bvec3: typeof bvec3;
-    vec4: typeof vec4;
-    ivec4: typeof ivec4;
-    uvec4: typeof uvec4;
-    bvec4: typeof bvec4;
-    mat2: typeof mat2;
-    imat2: typeof imat2;
-    umat2: typeof umat2;
-    bmat2: typeof bmat2;
-    mat3: typeof mat3;
-    imat3: typeof imat3;
-    umat3: typeof umat3;
-    bmat3: typeof bmat3;
-    mat4: typeof mat4;
-    imat4: typeof imat4;
-    umat4: typeof umat4;
-    bmat4: typeof bmat4;
-    string: typeof string;
-    arrayBuffer: typeof arrayBuffer;
+    toColor: typeof color;
+    toFloat: typeof float;
+    toInt: typeof int;
+    toUint: typeof uint;
+    toBool: typeof bool;
+    toVec2: typeof vec2;
+    toIvec2: typeof ivec2;
+    toUvec2: typeof uvec2;
+    toBvec2: typeof bvec2;
+    toVec3: typeof vec3;
+    toIvec3: typeof ivec3;
+    toUvec3: typeof uvec3;
+    toBvec3: typeof bvec3;
+    toVec4: typeof vec4;
+    toIvec4: typeof ivec4;
+    toUvec4: typeof uvec4;
+    toBvec4: typeof bvec4;
+    toMat2: typeof mat2;
+    toImat2: typeof imat2;
+    toUmat2: typeof umat2;
+    toBmat2: typeof bmat2;
+    toMat3: typeof mat3;
+    toImat3: typeof imat3;
+    toUmat3: typeof umat3;
+    toBmat3: typeof bmat3;
+    toMat4: typeof mat4;
+    toImat4: typeof imat4;
+    toUmat4: typeof umat4;
+    toBmat4: typeof bmat4;
 
     element: typeof element;
     convert: typeof convert;
@@ -44,6 +44,16 @@ export interface NodeElements {
 
 export function addNodeElement(name: string, nodeElement: unknown): void;
 
+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"
+>;
+
 export type Swizzable<T extends Node = Node> =
     & T
     & {
@@ -57,6 +67,12 @@ export type ShaderNodeObject<T extends Node> =
             : NodeElements[Key] extends (node: T, ...args: infer Args) => infer R ? (...args: Args) => R
             : never;
     }
+    & {
+        [Key in keyof NodeElements as `${Key}Assign`]: T extends { [K in Key]: infer M } ? M
+            : NodeElements[Key] extends (node: T, ...args: infer Args) => unknown
+                ? (...args: Args) => ShaderNodeObject<T>
+            : never;
+    }
     & Swizzable<T>;
 
 /** anything that can be passed to {@link nodeObject} and returns a proxy */
@@ -160,9 +176,9 @@ type NodeArray<T extends NodeObjectOption[]> = { [index in keyof T]: NodeObject<
 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 type NodeOrType = Node | string;
 
-export const getConstNodeType: (value: NodeOrType) => NodeTypeOption | null;
+export const getConstNodeType: (value: NodeOrType) => string | null;
 
 export class ShaderNode<T = {}, R extends Node = Node> {
     constructor(jsFunc: (inputs: NodeObjects<T>, builder: NodeBuilder) => NodeRepresentation);
@@ -201,10 +217,16 @@ export function tslFn<R extends Node = ShaderNodeObject<Node>>(jsFunc: () => R):
 export function tslFn<T extends any[], R extends Node = ShaderNodeObject<Node>>(
     jsFunc: (args: T) => R,
 ): (...args: ProxiedTuple<T>) => R;
-export function tslFn<T extends AnyObject, R extends Node = ShaderNodeObject<Node>>(
+export function tslFn<T extends { [key: string]: unknown }, R extends Node = ShaderNodeObject<Node>>(
     jsFunc: (args: T) => R,
 ): (args: ProxiedObject<T>) => R;
 
+export const setCurrentStack: (stack: StackNode | null) => void;
+
+export const getCurrentStack: () => StackNode | null;
+
+export const If: (boolNode: Node, method: () => void) => void;
+
 export function append(node: Node): Node;
 
 export const color: ConvertType;
@@ -248,4 +270,4 @@ export const string: (value?: string) => ShaderNodeObject<ConstNode<string>>;
 export const arrayBuffer: (value: ArrayBuffer) => ShaderNodeObject<ConstNode<ArrayBuffer>>;
 
 export const element: (node: NodeRepresentation, indexNode: NodeRepresentation) => ShaderNodeObject<Node>;
-export const convert: (node: NodeRepresentation, types: NodeTypeOption) => ShaderNodeObject<Node>;
+export const convert: (node: NodeRepresentation, types: string) => ShaderNodeObject<Node>;

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

@@ -1,8 +1,7 @@
 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);
+    convertTo: string;
+    constructor(node: Node, convertTo: string);
 }

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

@@ -8,6 +8,7 @@ export default class DiscardNode extends CondNode {
 
 export const inlineDiscard: (condNode: NodeRepresentation) => ShaderNodeObject<DiscardNode>;
 export const discard: (condNode: NodeRepresentation) => ShaderNodeObject<Node>;
+export const Return: (condNode: NodeRepresentation) => ShaderNodeObject<Node>;
 
 declare module "../shadernode/ShaderNode.js" {
     interface NodeElements {

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

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

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

@@ -1,5 +1,5 @@
-import { SwizzleOption } from "../core/constants.js";
 import Node from "../core/Node.js";
+import { SwizzleOption } from "../shadernode/ShaderNode.js";
 
 /** swizzle node */
 export default class SplitNode extends Node {

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

@@ -1,4 +1,3 @@
-import PositionNode from "../accessors/PositionNode.js";
 import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
@@ -10,16 +9,16 @@ export default class TriplanarTexturesNode extends Node {
 
     scaleNode: ShaderNodeObject<Node>;
 
-    positionNode: ShaderNodeObject<PositionNode>;
-    normalNode: ShaderNodeObject<PositionNode>;
+    positionNode: ShaderNodeObject<Node>;
+    normalNode: ShaderNodeObject<Node>;
 
     constructor(
         textureXNode: Node,
         textureYNode?: TextureNode | null,
         textureZNode?: TextureNode | null,
         scaleNode?: ShaderNodeObject<Node>,
-        positionNode?: ShaderNodeObject<PositionNode>,
-        normalNode?: ShaderNodeObject<PositionNode>,
+        positionNode?: ShaderNodeObject<Node>,
+        normalNode?: ShaderNodeObject<Node>,
     );
 }
 

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

@@ -1,6 +1,24 @@
 import { BoxGeometry, Mesh, ShaderMaterial } from "three";
 
+/**
+ * {@link Sky} creates a ready to go sky environment for your scenes.
+ *
+ * @example
+ * const sky = new Sky();
+ * sky.scale.setScalar( 450000 );
+ *
+ * const phi = MathUtils.degToRad( 90 );
+ * const theta = MathUtils.degToRad( 180 );
+ * const sunPosition = new Vector3().setFromSphericalCoords( 1, phi, theta );
+ *
+ * sky.material.uniforms.sunPosition.value = sunPosition;
+ *
+ * scene.add( sky );
+ */
 export class Sky extends Mesh {
+    /**
+     * Create a new {@link Sky} instance.
+     */
     constructor();
 
     geometry: BoxGeometry;

three/examples/jsm/renderers/common/Animation.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="webxr" />
+import Info from "./Info.js";
+import Nodes from "./nodes/Nodes.js";
+declare class Animation {
+    nodes: Nodes;
+    info: Info;
+    animationLoop: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null;
+    requestId: number | null;
+    constructor(nodes: Nodes, info: Info);
+    _init(): void;
+    dispose(): void;
+    setAnimationLoop(callback: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null): void;
+}
+export default Animation;

three/examples/jsm/renderers/common/Attributes.d.ts

@@ -0,0 +1,20 @@
+import { BufferAttribute, InterleavedBuffer, InterleavedBufferAttribute } from "three";
+import Backend from "./Backend.js";
+import { AttributeType } from "./Constants.js";
+import DataMap from "./DataMap.js";
+interface Data {
+    version?: number | undefined;
+}
+declare class Attributes extends DataMap<{
+    attribute: {
+        key: BufferAttribute | InterleavedBufferAttribute;
+        value: Data;
+    };
+}> {
+    backend: Backend;
+    constructor(backend: Backend);
+    delete(attribute: BufferAttribute | InterleavedBufferAttribute): Data;
+    update(attribute: BufferAttribute | InterleavedBufferAttribute, type: AttributeType): void;
+    _getBufferAttribute(attribute: BufferAttribute | InterleavedBufferAttribute): InterleavedBuffer | BufferAttribute;
+}
+export default Attributes;

three/examples/jsm/renderers/common/Background.d.ts

@@ -0,0 +1,22 @@
+import { Mesh, Scene } from "three";
+import DataMap from "./DataMap.js";
+import Nodes from "./nodes/Nodes.js";
+import RenderContext from "./RenderContext.js";
+import Renderer from "./Renderer.js";
+import RenderList from "./RenderList.js";
+interface SceneData {
+    backgroundMesh?: Mesh;
+    backgroundCacheKey: string;
+}
+declare class Background extends DataMap<{
+    scene: {
+        key: Scene;
+        value: SceneData;
+    };
+}> {
+    renderer: Renderer;
+    nodes: Nodes;
+    constructor(renderer: Renderer, nodes: Nodes);
+    update(scene: Scene, renderList: RenderList, renderContext: RenderContext): void;
+}
+export default Background;

three/examples/jsm/renderers/common/BindGroup.d.ts

@@ -0,0 +1,9 @@
+import Binding from "./Binding.js";
+import NodeUniformsGroup from "./nodes/NodeUniformsGroup.js";
+declare class BindGroup {
+    name: string;
+    bindings: NodeUniformsGroup[] | Binding[];
+    id: number;
+    constructor(name?: string, bindings?: NodeUniformsGroup[]);
+}
+export default BindGroup;