@types/three 0.144.0 → 0.146.0

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Fri, 02 Sep 2022 10:02:40 GMT
+ * Last updated: Mon, 07 Nov 2022 20:26:35 GMT
  * Dependencies: [@types/webxr](https://npmjs.com/package/@types/webxr)
  * Global values: `THREE`
 

three/examples/jsm/animation/CCDIKSolver.d.ts

@@ -21,5 +21,6 @@ export class CCDIKSolver {
 }
 
 export class CCDIKHelper extends Object3D {
-    constructor(mesh: SkinnedMesh, iks: IKS[]);
+    constructor(mesh: SkinnedMesh, iks?: IKS[], sphereSize?: number);
+    dispose(): void;
 }

three/examples/jsm/animation/MMDPhysics.d.ts

@@ -115,5 +115,10 @@ export class Constraint {
 }
 
 export class MMDPhysicsHelper extends Object3D {
-    constructor();
+    mesh: THREE.SkinnedMesh;
+    physics: MMDPhysics;
+    materials: [THREE.MeshBasicMaterial, THREE.MeshBasicMaterial, THREE.MeshBasicMaterial];
+
+    constructor(mesh: THREE.SkinnedMesh, physics: MMDPhysics);
+    dispose(): void;
 }

three/examples/jsm/csm/CSMHelper.d.ts

@@ -23,4 +23,5 @@ export class CSMHelper<TCSM extends CSM = CSM> extends Group {
     shadowLines: Box3Helper[];
     updateVisibility(): void;
     update(): void;
+    dispose(): void;
 }

three/examples/jsm/helpers/OctreeHelper.d.ts

@@ -11,4 +11,7 @@ export class OctreeHelper extends LineSegments {
      * @default 'OctreeHelper'
      */
     type: 'OctreeHelper' | string;
+
+    update(): void;
+    dispose(): void;
 }

three/examples/jsm/helpers/VertexNormalsHelper.d.ts

@@ -7,4 +7,6 @@ export class VertexNormalsHelper extends LineSegments {
     size: number;
 
     update(): void;
+
+    dispose(): void;
 }

three/examples/jsm/helpers/VertexTangentsHelper.d.ts

@@ -7,4 +7,6 @@ export class VertexTangentsHelper extends LineSegments {
     size: number;
 
     update(): void;
+
+    dispose(): void;
 }

three/examples/jsm/loaders/PCDLoader.d.ts

@@ -11,5 +11,5 @@ export class PCDLoader extends Loader {
         onError?: (event: ErrorEvent) => void,
     ): void;
     loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Points>;
-    parse(data: ArrayBuffer | string, url: string): Points;
+    parse(data: ArrayBuffer | string): Points;
 }

three/examples/jsm/loaders/RGBELoader.d.ts

@@ -7,7 +7,6 @@ export interface RGBE {
     header: string;
     gamma: number;
     exposure: number;
-    format: PixelFormat;
     type: TextureDataType;
 }
 

three/examples/jsm/loaders/USDZLoader.d.ts

@@ -0,0 +1,18 @@
+import { Loader, LoadingManager, Mesh } from '../../../src/Three';
+
+export class USDAParser {
+    parse(text: string): object;
+}
+
+export class USDZLoader extends Loader {
+    constructor(manager?: LoadingManager);
+
+    load(
+        url: string,
+        onLoad: (usdz: Mesh) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (event: ErrorEvent) => void,
+    ): void;
+
+    parse(buffer: ArrayBuffer | string): THREE.Group;
+}

three/examples/jsm/nodes/Nodes.d.ts

@@ -18,7 +18,7 @@ import NodeFunctionInput from './core/NodeFunctionInput';
 import NodeKeywords from './core/NodeKeywords';
 import NodeUniform from './core/NodeUniform';
 import NodeVar from './core/NodeVar';
-import NodeVary from './core/NodeVary';
+import NodeVarying from './core/NodeVarying';
 import PropertyNode from './core/PropertyNode';
 import TempNode from './core/TempNode';
 import UniformNode from './core/UniformNode';
@@ -26,6 +26,7 @@ import VarNode from './core/VarNode';
 import VaryNode from './core/VaryNode';
 
 // accessors
+import BitangentNode, { BitangentNodeScope } from './accessors/BitangentNode';
 import BufferNode from './accessors/BufferNode';
 import CameraNode, { CameraNodeScope } from './accessors/CameraNode';
 import CubeTextureNode from './accessors/CubeTextureNode';
@@ -41,6 +42,7 @@ import PositionNode, { PositionNodeScope } from './accessors/PositionNode';
 import ReferenceNode from './accessors/ReferenceNode';
 import ReflectVectorNode from './accessors/ReflectVectorNode';
 import SkinningNode from './accessors/SkinningNode';
+import TangentNode, { TangentNodeScope } from './accessors/TangentNode';
 import TextureNode from './accessors/TextureNode';
 import UVNode from './accessors/UVNode';
 import UserDataNode from './accessors/UserDataNode';
@@ -52,10 +54,12 @@ import RangeNode, { RangeModeBound } from './geometry/RangeNode';
 import ComputeNode from './gpgpu/ComputeNode';
 
 // display
+import BlendModeNode, { BlendMode } from './display/BlendModeNode';
 import ColorAdjustmentNode, { ColorAdjustmentMethod } from './display/ColorAdjustmentNode';
 import ColorSpaceNode, { ColorSpaceNodeMethod } from './display/ColorSpaceNode';
 import FrontFacingNode from './display/FrontFacingNode';
 import NormalMapNode from './display/NormalMapNode';
+import PosterizeNode from './display/PosterizeNode';
 import ToneMappingNode from './display/ToneMappingNode';
 
 // math
@@ -77,14 +81,17 @@ import AnalyticLightNode from './lighting/AnalyticLightNode';
 
 import ArrayElementNode from './utils/ArrayElementNode';
 import ConvertNode from './utils/ConvertNode';
+import EquirectUVNode from './utils/EquirectUVNode';
 import JoinNode from './utils/JoinNode';
 import MatcapUVNode from './utils/MatcapUVNode';
 import MaxMipLevelNode from './utils/MaxMipLevelNode';
 import OscNode, { OscNodeMethod } from './utils/OscNode';
+import RemapNode from './utils/RemapNode';
 import RotateUVNode from './utils/RotateUVNode';
 import SplitNode from './utils/SplitNode';
 import SpriteSheetUVNode from './utils/SpriteSheetUVNode';
 import TimerNode, { TimerNodeScope } from './utils/TimerNode';
+import TriplanarTexturesNode from './utils/TriplanarTexturesNode';
 
 // loaders
 import NodeLoader from './loaders/NodeLoader';
@@ -129,7 +136,7 @@ export {
     NodeKeywords,
     NodeUniform,
     NodeVar,
-    NodeVary,
+    NodeVarying,
     PropertyNode,
     TempNode,
     UniformNode,
@@ -141,6 +148,8 @@ export {
     // gpgpu
     ComputeNode,
     // accessors
+    BitangentNode,
+    BitangentNodeScope,
     BufferNode,
     CameraNode,
     CameraNodeScope,
@@ -161,16 +170,21 @@ export {
     ReferenceNode,
     ReflectVectorNode,
     SkinningNode,
+    TangentNode,
+    TangentNodeScope,
     TextureNode,
     UVNode,
     UserDataNode,
     // display
+    BlendModeNode,
+    BlendMode,
     ColorAdjustmentNode,
     ColorAdjustmentMethod,
     ColorSpaceNode,
     ColorSpaceNodeMethod,
     FrontFacingNode,
     NormalMapNode,
+    PosterizeNode,
     ToneMappingNode,
     // math
     MathNode,
@@ -194,16 +208,19 @@ export {
     // utils
     ArrayElementNode,
     ConvertNode,
+    EquirectUVNode,
     JoinNode,
     MatcapUVNode,
     MaxMipLevelNode,
     OscNode,
     OscNodeMethod,
+    RemapNode,
     RotateUVNode,
     SplitNode,
     SpriteSheetUVNode,
     TimerNode,
     TimerNodeScope,
+    TriplanarTexturesNode,
     // procedural
     CheckerNode,
     // fog

three/examples/jsm/nodes/accessors/BitangentNode.d.ts

@@ -0,0 +1,18 @@
+import Node from '../core/Node';
+
+export type BitangentNodeScope =
+    | typeof BitangentNode.LOCAL
+    | typeof BitangentNode.VIEW
+    | typeof BitangentNode.WORLD
+    | typeof BitangentNode.GEOMETRY;
+
+export default class BitangentNode extends Node {
+    static GEOMETRY: 'geometry';
+    static LOCAL: 'local';
+    static VIEW: 'view';
+    static WORLD: 'world';
+
+    scope: BitangentNodeScope;
+
+    constructor(scope?: BitangentNodeScope);
+}

three/examples/jsm/nodes/accessors/NormalNode.d.ts

@@ -1,15 +1,10 @@
 import Node from '../core/Node';
 
-export type NormalNodeScope =
-    | typeof NormalNode.GEOMETRY
-    | typeof NormalNode.LOCAL
-    | typeof NormalNode.WORLD
-    | typeof NormalNode.VIEW;
+export type NormalNodeScope = typeof NormalNode.GEOMETRY | typeof NormalNode.LOCAL | typeof NormalNode.VIEW;
 
 export default class NormalNode extends Node {
     static GEOMETRY: 'geometry';
     static LOCAL: 'local';
-    static WORLD: 'world';
     static VIEW: 'view';
     scope: NormalNodeScope;
 

three/examples/jsm/nodes/accessors/PositionNode.d.ts

@@ -4,6 +4,7 @@ export type PositionNodeScope =
     | typeof PositionNode.GEOMETRY
     | typeof PositionNode.LOCAL
     | typeof PositionNode.WORLD
+    | typeof PositionNode.WORLD_DIRECTION
     | typeof PositionNode.VIEW
     | typeof PositionNode.VIEW_DIRECTION;
 
@@ -11,6 +12,7 @@ export default class PositionNode extends Node {
     static GEOMETRY: 'geometry';
     static LOCAL: 'local';
     static WORLD: 'world';
+    static WORLD_DIRECTION: 'worldDirection';
     static VIEW: 'view';
     static VIEW_DIRECTION: 'viewDirection';
     scope: PositionNodeScope;

three/examples/jsm/nodes/accessors/TangentNode.d.ts

@@ -0,0 +1,18 @@
+import Node from '../core/Node.js';
+
+export type TangentNodeScope =
+    | typeof TangentNode.LOCAL
+    | typeof TangentNode.VIEW
+    | typeof TangentNode.WORLD
+    | typeof TangentNode.GEOMETRY;
+
+export default class TangentNode extends Node {
+    static GEOMETRY: 'geometry';
+    static LOCAL: 'local';
+    static VIEW: 'view';
+    static WORLD: 'world';
+
+    scope: TangentNodeScope;
+
+    constructor(scope?: TangentNodeScope);
+}

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

@@ -17,7 +17,7 @@ import NodeAttribute from './NodeAttribute';
 import NodeParser from './NodeParser';
 import NodeUniform from './NodeUniform';
 import NodeVar from './NodeVar';
-import NodeVary from './NodeVary';
+import NodeVarying from './NodeVarying';
 
 export type BuildStageOption = 'construct' | 'analyze' | 'generate';
 
@@ -82,7 +82,7 @@ export default abstract class NodeBuilder {
     abstract getCubeTextureLevel(textureProperty: string, uvSnippet: string, levelSnippet: string): string;
 
     // @TODO: rename to .generateConst()
-    getConst(type: NodeTypeOption, value: unknown): Node;
+    getConst(type: NodeTypeOption, value?: unknown): Node;
     getType(type: NodeTypeOption): NodeTypeOption;
 
     generateMethod(method: string): string;
@@ -105,7 +105,7 @@ export default abstract class NodeBuilder {
     getNodeProperties(node: Node, shaderStage?: NodeShaderStageOption): AnyObject;
     getUniformFromNode(node: Node, shaderStage: NodeShaderStageOption, type: NodeTypeOption): NodeUniform;
     getVarFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): NodeVar;
-    getVaryFromNode(node: Node, type: NodeTypeOption): NodeVary;
+    getVaryFromNode(node: Node, type: NodeTypeOption): NodeVarying;
     getCodeFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): string;
     addFlowCode(code: string): void;
     getFlowData(node: Node, shaderStage: NodeShaderStageOption): FlowData;
@@ -117,6 +117,7 @@ export default abstract class NodeBuilder {
         output?: string | null,
         propertyName?: string,
     ): FlowData;
+    hasGeometryAttribute(name: string): boolean;
     abstract getAttributes(shaderStage: NodeShaderStageOption): string;
     abstract getVarys(shaderStage: NodeShaderStageOption): string;
     getVars(shaderStage: NodeShaderStageOption): string;

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

@@ -0,0 +1,8 @@
+import NodeVar from './NodeVar';
+
+export default class NodeVarying extends NodeVar {
+    needsInterpolation: false;
+    isNodeVarying: true;
+
+    constructor(name: string, type: string);
+}

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

@@ -2,14 +2,14 @@ import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from '../../../../
 
 // disable automatic export, we have some private declarations
 export const NodeShaderStage: {
-    Vertex: 'vertex';
-    Fragment: 'fragment';
+    VERTEX: 'vertex';
+    FRAGMENT: 'fragment';
 };
 
 export const NodeUpdateType: {
-    None: 'none';
-    Frame: 'frame';
-    Object: 'object';
+    NONE: 'none';
+    FRAME: 'frame';
+    OBJECT: 'object';
 };
 
 export type NodeValueOption = Color | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4 | boolean | number;
@@ -66,12 +66,12 @@ export interface AnyObject {
 export type AnyJson = any;
 
 export const NodeType: {
-    Boolean: 'bool';
-    Integer: 'int';
-    Float: 'float';
-    Vector2: 'vec2';
-    Vector3: 'vec3';
-    Vector4: 'vec4';
-    Matrix3: 'mat3';
-    Matrix4: 'mat4';
+    BOOLEAN: 'bool';
+    INTEGER: 'int';
+    FLOAT: 'float';
+    VECTOR2: 'vec2';
+    VECTOR3: 'vec3';
+    VECTOR4: 'vec4';
+    MATRIX3: 'mat3';
+    MATRIX4: 'mat4';
 };

three/examples/jsm/nodes/display/BlendModeNode.d.ts

@@ -0,0 +1,32 @@
+import TempNode from '../core/TempNode';
+import { ShaderNode } from '../shadernode/ShaderNodeBaseElements';
+import { Node } from '../Nodes';
+
+export const BurnNode: ShaderNode<{ base: Node; blendNode: Node }>;
+
+export const DodgeNode: ShaderNode<{ base: Node; blendNode: Node }>;
+
+export const ScreenNode: ShaderNode<{ base: Node; blendNode: Node }>;
+
+export const OverlayNode: ShaderNode<{ base: Node; blendNode: Node }>;
+
+export type BlendMode =
+    | typeof BlendModeNode.BURN
+    | typeof BlendModeNode.DODGE
+    | typeof BlendModeNode.SCREEN
+    | typeof BlendModeNode.OVERLAY;
+
+export default class BlendModeNode extends TempNode {
+    static BURN: 'burn';
+    static DODGE: 'dodge';
+    static SCREEN: 'screen';
+    static OVERLAY: 'overlay';
+
+    baseNode: Node;
+    blendMode: BlendMode;
+    blendNode: Node;
+
+    constructor(blendMode: BlendMode, baseNode: Node, blendNode: Node);
+
+    construct(): Node;
+}

three/examples/jsm/nodes/display/PosterizeNode.d.ts

@@ -0,0 +1,8 @@
+import Node from '../core/Node';
+
+export default class PosterizeNode extends Node {
+    sourceNode: Node;
+    stepsNode: Node;
+
+    constructor(sourceNode: Node, stepsNode: Node);
+}

three/examples/jsm/nodes/materialx/MaterialXNodes.d.ts

@@ -0,0 +1,94 @@
+import { mx_hsvtorgb, mx_rgbtohsv } from './lib/mx_hsv';
+import { Swizzable } from '../shadernode/ShaderNodeElements';
+import { UVNode, MathNode } from '../Nodes';
+import { NodeRepresentation } from '../shadernode/ShaderNode';
+
+export function mx_aastep(threshold?: NodeRepresentation, value?: NodeRepresentation): Swizzable<MathNode>;
+
+export function mx_ramplr(
+    valuel?: NodeRepresentation,
+    valuer?: NodeRepresentation,
+    texcoord?: Swizzable<UVNode>,
+): Swizzable<MathNode>;
+export function mx_ramptb(
+    valuet?: NodeRepresentation,
+    valueb?: NodeRepresentation,
+    texcoord?: Swizzable<UVNode>,
+): Swizzable<MathNode>;
+
+export function mx_splitlr(
+    valuel?: NodeRepresentation,
+    valuer?: NodeRepresentation,
+    center?: NodeRepresentation,
+    texcoord?: Swizzable<UVNode>,
+): Swizzable<MathNode>;
+export function mx_splittb(
+    valuet?: NodeRepresentation,
+    valueb?: NodeRepresentation,
+    center?: NodeRepresentation,
+    texcoord?: Swizzable<UVNode>,
+): Swizzable<MathNode>;
+
+export function mx_transform_uv(
+    uv_scale?: NodeRepresentation,
+    uv_offset?: NodeRepresentation,
+    uv_geo?: Swizzable<UVNode>,
+): Swizzable;
+
+export function mx_noise_float(
+    texcoord?: Swizzable<UVNode>,
+    amplitude?: NodeRepresentation,
+    pivot?: NodeRepresentation,
+): Swizzable;
+export function mx_noise_vec2(
+    texcoord?: Swizzable<UVNode>,
+    amplitude?: NodeRepresentation,
+    pivot?: NodeRepresentation,
+): Swizzable;
+export function mx_noise_vec3(
+    texcoord?: Swizzable<UVNode>,
+    amplitude?: NodeRepresentation,
+    pivot?: NodeRepresentation,
+): Swizzable;
+export function mx_noise_vec4(
+    texcoord?: Swizzable<UVNode>,
+    amplitude?: NodeRepresentation,
+    pivot?: NodeRepresentation,
+): Swizzable;
+
+export function mx_worley_noise_float(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
+export function mx_worley_noise_vec2(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
+export function mx_worley_noise_vec3(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
+
+export function mx_cell_noise_float(texcoord?: Swizzable<UVNode>): Swizzable;
+
+export function mx_fractal_noise_float(
+    position?: Swizzable<UVNode>,
+    octaves?: NodeRepresentation,
+    lacunarity?: NodeRepresentation,
+    diminish?: NodeRepresentation,
+    amplitude?: NodeRepresentation,
+): Swizzable;
+export function mx_fractal_noise_vec2(
+    position?: Swizzable<UVNode>,
+    octaves?: NodeRepresentation,
+    lacunarity?: NodeRepresentation,
+    diminish?: NodeRepresentation,
+    amplitude?: NodeRepresentation,
+): Swizzable;
+export function mx_fractal_noise_vec3(
+    position?: Swizzable<UVNode>,
+    octaves?: NodeRepresentation,
+    lacunarity?: NodeRepresentation,
+    diminish?: NodeRepresentation,
+    amplitude?: NodeRepresentation,
+): Swizzable;
+export function mx_fractal_noise_vec4(
+    position?: Swizzable<UVNode>,
+    octaves?: NodeRepresentation,
+    lacunarity?: NodeRepresentation,
+    diminish?: NodeRepresentation,
+    amplitude?: NodeRepresentation,
+): Swizzable;
+
+export { mx_hsvtorgb, mx_rgbtohsv };

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

@@ -1,4 +1,4 @@
-import { Fn, Node, Swizzable } from '../../../Nodes';
+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 → lib}/mx_noise.d.ts

@@ -1,4 +1,4 @@
-import { Fn, Node, Swizzable } from '../../../Nodes';
+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;

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

@@ -27,7 +27,6 @@ export type MathNodeMethod1 =
     | typeof MathNode.INVERT
     | typeof MathNode.DFDX
     | typeof MathNode.DFDY
-    | typeof MathNode.SATURATE
     | typeof MathNode.ROUND;
 
 export type MathNodeMethod2 =
@@ -80,8 +79,8 @@ export default class MathNode extends TempNode {
     static INVERT: 'invert';
     static DFDX: 'dFdx';
     static DFDY: 'dFdy';
-    static SATURATE: 'saturate';
     static ROUND: 'round';
+    static RECIPROCAL: 'reciprocal';
 
     // 2 inputs
 

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

@@ -20,6 +20,7 @@ import { Material, Texture } from '../../../../src/Three';
 import { NodeTypeOption, NodeUserData, NodeValueOption } from '../core/constants';
 import { NodeBuilderContext } from '../core/NodeBuilder';
 import {
+    BitangentNode,
     BufferNode,
     BypassNode,
     CameraNode,
@@ -43,6 +44,7 @@ import {
     PositionNode,
     PropertyNode,
     ReferenceNode,
+    TangentNode,
     UserDataNode,
     UVNode,
     VarNode,
@@ -91,6 +93,8 @@ export function uniform(nodeOrType: Node | Swizzable | NodeValueOption): Swizzab
 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 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>;
@@ -164,6 +168,20 @@ 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>;
@@ -173,6 +191,7 @@ 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>;
 
@@ -246,8 +265,8 @@ 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 reciprocal: Unary;
 
 export const atan2: Binary;
 export const min: Binary;
@@ -281,5 +300,8 @@ export const faceDirection: Swizzable;
 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 transformedNormalWorld: Swizzable<MathNode>;
+export const TBNViewMatrix: Swizzable<MathNode>;