@nativescript/canvas-three 2.0.0-webgpu.3 → 2.0.0-webgpu.31

package/three/src/nodes/display/SobelOperatorNode.d.ts

@@ -0,0 +1,17 @@
+import TextureNode from '../accessors/TextureNode.js';
+import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class SobelOperatorNode extends TempNode {
+	textureNode: TextureNode;
+
+	constructor(textureNode: TextureNode);
+}
+
+export const sobel: (node: NodeRepresentation) => ShaderNodeObject<SobelOperatorNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		sobel: typeof sobel;
+	}
+}

package/three/src/nodes/display/ToneMappingNode.d.ts

@@ -0,0 +1,25 @@
+import { ToneMapping } from '../../constants.js';
+import RendererReferenceNode from '../accessors/RendererReferenceNode.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+// exposure only
+export const LinearToneMappingNode: Node;
+
+export default class ToneMappingNode extends TempNode {
+	toneMapping: ToneMapping;
+	exposureNode: Node;
+	colorNode: Node | null;
+
+	constructor(toneMapping: ToneMapping, exposureNode?: Node, colorNode?: Node | null);
+}
+
+export const toneMapping: (mapping: ToneMapping, exposure: NodeRepresentation, color?: NodeRepresentation) => ShaderNodeObject<ToneMappingNode>;
+export const toneMappingExposure: ShaderNodeObject<RendererReferenceNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		toneMapping: (color: NodeRepresentation, mapping?: NodeRepresentation, exposure?: NodeRepresentation) => ShaderNodeObject<ToneMappingNode>;
+	}
+}

package/three/src/nodes/display/TransitionNode.d.ts

@@ -0,0 +1,27 @@
+import TextureNode from '../accessors/TextureNode.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import UniformNode from '../core/UniformNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+declare class TransitionNode extends TempNode {
+	textureNodeA: TextureNode;
+	textureNodeB: TextureNode;
+	mixTextureNode: TextureNode;
+
+	mixRatioNode: Node;
+	thresholdNode: Node;
+	useTextureNode: Node;
+
+	constructor(textureNodeA: TextureNode, textureNodeB: TextureNode, mixTextureNode: TextureNode, mixRatioNode: Node, thresholdNode: Node, useTextureNode: Node);
+}
+
+export const transition: (node: NodeRepresentation, nodeB: NodeRepresentation, mixTexture: NodeRepresentation, mixRatio: UniformNode<number>, threshold: UniformNode<number>, useTexture: UniformNode<number>) => ShaderNodeObject<TransitionNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		transition: typeof transition;
+	}
+}
+
+export default TransitionNode;

package/three/src/nodes/display/ViewportDepthNode.d.ts

@@ -0,0 +1,28 @@
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class ViewportDepthNode extends Node {
+	scope: ViewportDepthNodeScope;
+	valueNode: Node;
+
+	readonly isViewportDepthNode: true;
+
+	constructor(scope: ViewportDepthNodeScope, valueNode?: Node | null);
+
+	static DEPTH: 'depth';
+	static LINEAR_DEPTH: 'linearDepth';
+}
+
+export type ViewportDepthNodeScope = typeof ViewportDepthNode.DEPTH | typeof ViewportDepthNode.LINEAR_DEPTH;
+
+export const viewZToOrthographicDepth: (viewZ: Node, near: Node, far: Node) => Node;
+
+export const orthographicDepthToViewZ: (depth: Node, near: Node, far: Node) => Node;
+
+export const viewZToPerspectiveDepth: (viewZ: Node, near: Node, far: Node) => Node;
+
+export const perspectiveDepthToViewZ: (depth: Node, near: Node, far: Node) => Node;
+
+export const depth: ShaderNodeObject<ViewportDepthNode>;
+export const linearDepth: (valueNode?: Node | null) => ShaderNodeObject<ViewportDepthNode>;
+export const viewportLinearDepth: ShaderNodeObject<ViewportDepthNode>;

package/three/src/nodes/display/ViewportDepthTextureNode.d.ts

@@ -0,0 +1,9 @@
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import ViewportTextureNode from './ViewportTextureNode.js';
+
+export default class ViewportDepthTextureNode extends ViewportTextureNode {
+	constructor(uvNode?: Node, levelNode?: Node | null);
+}
+
+export const viewportDepthTexture: (uvNode?: NodeRepresentation, levelNode?: NodeRepresentation) => ShaderNodeObject<ViewportDepthTextureNode>;

package/three/src/nodes/display/ViewportNode.d.ts

@@ -0,0 +1,25 @@
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export type ViewportNodeScope = typeof ViewportNode.COORDINATE | typeof ViewportNode.RESOLUTION | typeof ViewportNode.TOP_LEFT | typeof ViewportNode.BOTTOM_LEFT | typeof ViewportNode.TOP_RIGHT | typeof ViewportNode.BOTTOM_RIGHT;
+
+export default class ViewportNode extends Node {
+	static COORDINATE: 'coordinate';
+	static RESOLUTION: 'resolution';
+	static TOP_LEFT: 'topLeft';
+	static BOTTOM_LEFT: 'bottomLeft';
+	static TOP_RIGHT: 'topRight';
+	static BOTTOM_RIGHT: 'bottomRight';
+
+	scope: ViewportNodeScope;
+	isViewportNode: true;
+
+	constructor(scope: ViewportNodeScope);
+}
+
+export const viewportCoordinate: ShaderNodeObject<ViewportNode>;
+export const viewportResolution: ShaderNodeObject<ViewportNode>;
+export const viewportTopLeft: ShaderNodeObject<ViewportNode>;
+export const viewportBottomLeft: ShaderNodeObject<ViewportNode>;
+export const viewportTopRight: ShaderNodeObject<ViewportNode>;
+export const viewportBottomRight: ShaderNodeObject<ViewportNode>;

package/three/src/nodes/display/ViewportSharedTextureNode.d.ts

@@ -0,0 +1,15 @@
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import ViewportTextureNode from './ViewportTextureNode.js';
+
+export default class ViewportSharedTextureNode extends ViewportTextureNode {
+	constructor(uvNode?: Node, levelNode?: Node | null);
+}
+
+export const viewportSharedTexture: (uvNode?: Node, levelNode?: Node | null) => ShaderNodeObject<ViewportSharedTextureNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		viewportSharedTexture: typeof viewportSharedTexture;
+	}
+}

package/three/src/nodes/display/ViewportTextureNode.d.ts

@@ -0,0 +1,25 @@
+import { FramebufferTexture } from '../../textures/FramebufferTexture.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { NodeUpdateType } from '../core/constants.js';
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class ViewportTextureNode extends TextureNode {
+	generateMipmaps: boolean;
+
+	readonly isOutputTextureNode: true;
+
+	updateBeforeType: NodeUpdateType;
+
+	constructor(uvNode?: Node, levelNode?: Node | null, framebufferTexture?: FramebufferTexture | null);
+}
+
+export const viewportTexture: (uvNode?: Node, levelNode?: Node | null, framebufferTexture?: FramebufferTexture | null) => ShaderNodeObject<ViewportTextureNode>;
+export const viewportMipTexture: (uvNode?: Node, levelNode?: Node | null, framebufferTexture?: FramebufferTexture | null) => ShaderNodeObject<Node>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		viewportTexture: typeof viewportTexture;
+		viewportMipTexture: typeof viewportMipTexture;
+	}
+}

package/three/src/nodes/fog/FogExp2Node.d.ts

@@ -0,0 +1,18 @@
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import FogNode from './FogNode.js';
+
+export default class FogExp2Node extends FogNode {
+	isFogExp2Node: true;
+	densityNode: Node;
+
+	constructor(colorNode: Node, densityNode: Node);
+}
+
+export const densityFog: (colorNode: Node, densityNode: Node) => ShaderNodeObject<FogExp2Node>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		densityFog: typeof densityFog;
+	}
+}

package/three/src/nodes/fog/FogNode.d.ts

@@ -0,0 +1,21 @@
+import Node from '../core/Node.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class FogNode extends Node {
+	isFogNode: true;
+	colorNode: Node | null;
+	factorNode: Node | null;
+
+	constructor(colorNode: Node | null, factorNode: Node | null);
+
+	getViewZNode(builder: NodeBuilder): Node;
+}
+
+export const fog: (colorNode: NodeRepresentation | null, factorNode: NodeRepresentation | null) => ShaderNodeObject<FogNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		fog: typeof fog;
+	}
+}

package/three/src/nodes/fog/FogRangeNode.d.ts

@@ -0,0 +1,19 @@
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import FogNode from './FogNode.js';
+
+export default class FogRangeNode extends FogNode {
+	isFogRangeNode: true;
+	nearNode: Node | null;
+	farNode: Node | null;
+
+	constructor(colorNode: Node | null, nearNode: Node | null, farNode: Node | null);
+}
+
+export const rangeFog: (colorNode: NodeRepresentation | null, nearNode: NodeRepresentation | null, farNode: NodeRepresentation | null) => ShaderNodeObject<FogRangeNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		rangeFog: typeof rangeFog;
+	}
+}

package/three/src/nodes/functions/BSDF/BRDF_GGX.d.ts

@@ -0,0 +1,7 @@
+import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
+
+declare const BRDF_GGX: (args: { lightDirection: Node; f0: Node; f90: Node; roughness: Node; f?: Node; USE_IRIDESCENCE?: Node; USE_ANISOTROPY?: Node }) => ShaderNodeObject<OperatorNode>;
+
+export default BRDF_GGX;

package/three/src/nodes/functions/BSDF/BRDF_Lambert.d.ts

@@ -0,0 +1,7 @@
+import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
+
+declare const BRDF_Lambert: (args: { diffuseColor: Node }) => ShaderNodeObject<OperatorNode>;
+
+export default BRDF_Lambert;

package/three/src/nodes/functions/BSDF/BRDF_Sheen.d.ts

@@ -0,0 +1,7 @@
+import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
+
+declare const BRDF_Sheen: (args: { lightDirection: Node }) => ShaderNodeObject<OperatorNode>;
+
+export default BRDF_Sheen;

package/three/src/nodes/functions/BSDF/DFGApprox.d.ts

@@ -0,0 +1,11 @@
+import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
+
+// Analytical approximation of the DFG LUT, one half of the
+// split-sum approximation used in indirect specular lighting.
+// via 'environmentBRDF' from "Physically Based Shading on Mobile"
+// https://www.unrealengine.com/blog/physically-based-shading-on-mobile
+declare const DFGApprox: (args: { roughness: Node; dotNV: Node }) => ShaderNodeObject<OperatorNode>;
+
+export default DFGApprox;

package/three/src/nodes/functions/BSDF/D_GGX.d.ts

@@ -0,0 +1,10 @@
+import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
+
+// Microfacet Models for Refraction through Rough Surfaces - equation (33)
+// http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
+// alpha is "roughness squared" in Disney’s reparameterization
+declare const D_GGX: (args: { alpha: Node; dotNH: Node }) => ShaderNodeObject<OperatorNode>;
+
+export default D_GGX;

package/three/src/nodes/functions/BSDF/D_GGX_Anisotropic.d.ts

@@ -0,0 +1,8 @@
+import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
+
+// https://google.github.io/filament/Filament.md.html#materialsystem/anisotropicmodel/anisotropicspecularbrdf
+declare const D_GGX_Anisotropic: (args: { alphaT: Node; alphaB: Node; dotNH: Node; dotTH: Node; dotBH: Node }) => ShaderNodeObject<OperatorNode>;
+
+export default D_GGX_Anisotropic;

package/three/src/nodes/functions/BSDF/F_Schlick.d.ts

@@ -0,0 +1,7 @@
+import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
+
+declare const F_Schlick: (args: { f0: Node; f90: Node; dotVH: Node }) => ShaderNodeObject<OperatorNode>;
+
+export default F_Schlick;

package/three/src/nodes/functions/BSDF/LTC.d.ts

@@ -0,0 +1,7 @@
+import Node from '../../core/Node.js';
+
+declare const LTC_Uv: (args: { N: Node; V: Node; roughness: Node }) => Node;
+
+declare const LTC_Evaluate: (args: { N: Node; V: Node; P: Node; mInv: Node; p0: Node; p1: Node; p2: Node; p3: Node }) => Node;
+
+export { LTC_Evaluate, LTC_Uv };

package/three/src/nodes/functions/BSDF/V_GGX_SmithCorrelated.d.ts

@@ -0,0 +1,7 @@
+import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
+
+declare const V_GGX_SmithCorrelated: (inputs: { alpha: Node; dotNL: Node; dotNV: Node }) => ShaderNodeObject<OperatorNode>;
+
+export default V_GGX_SmithCorrelated;

package/three/src/nodes/functions/BSDF/V_GGX_SmithCorrelated_Anisotropic.d.ts

@@ -0,0 +1,7 @@
+import Node from '../../core/Node.js';
+import MathNode from '../../math/MathNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
+
+declare const V_GGX_SmithCorrelated: (inputs: { alphaT: Node; alphaB: Node; dotTV: Node; dotBV: Node; dotTL: Node; dotBL: Node; dotNV: Node; dotNL: Node }) => ShaderNodeObject<MathNode>;
+
+export default V_GGX_SmithCorrelated;

package/three/src/nodes/functions/BasicLightingModel.d.ts

@@ -0,0 +1,7 @@
+import LightingModel from '../core/LightingModel.js';
+
+declare class BasicLightingModel extends LightingModel {
+	constructor();
+}
+
+export default BasicLightingModel;

package/three/src/nodes/functions/PhongLightingModel.d.ts

@@ -0,0 +1,7 @@
+import BasicLightingModel from './BasicLightingModel.js';
+
+export default class PhongLightingModel extends BasicLightingModel {
+	specular: boolean;
+
+	constructor(specular?: boolean);
+}

package/three/src/nodes/functions/PhysicalLightingModel.d.ts

@@ -0,0 +1,23 @@
+import LightingModel from '../core/LightingModel.js';
+import Node from '../core/Node.js';
+
+export default class PhysicalLightingModel extends LightingModel {
+	clearcoat: boolean;
+	sheen: boolean;
+	iridescence: boolean;
+	anisotropy: boolean;
+	transmission: boolean;
+	dispersion: boolean;
+
+	clearcoatRadiance: Node | null;
+	clearcoatSpecularDirect: Node | null;
+	clearcoatSpecularIndirect: Node | null;
+	sheenSpecularDirect: Node | null;
+	sheenSpecularIndirect: Node | null;
+	iridescenceFresnel: Node | null;
+	iridescenceF0: Node | null;
+
+	constructor(clearcoat?: boolean, sheen?: boolean, iridescence?: boolean, anisotropy?: boolean, transmission?: boolean, dispersion?: boolean);
+
+	computeMultiscattering(singleScatter: Node, multiScatter: Node, specularF90: Node): void;
+}

package/three/src/nodes/functions/ShadowMaskModel.d.ts

@@ -0,0 +1,9 @@
+import LightingModel from '../core/LightingModel.js';
+import VarNode from '../core/VarNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class ShadowMaskModel extends LightingModel {
+	shadowNode: ShaderNodeObject<VarNode>;
+
+	constructor();
+}

package/three/src/nodes/functions/ToonLightingModel.d.ts

@@ -0,0 +1,3 @@
+import LightingModel from '../core/LightingModel.js';
+
+export default class ToonLightingModel extends LightingModel {}

package/three/src/nodes/functions/material/getGeometryRoughness.d.ts

@@ -0,0 +1,6 @@
+import MathNode from '../../math/MathNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
+
+declare const getGeometryRoughness: () => ShaderNodeObject<MathNode>;
+
+export default getGeometryRoughness;

package/three/src/nodes/functions/material/getRoughness.d.ts

@@ -0,0 +1,7 @@
+import Node from '../../core/Node.js';
+import MathNode from '../../math/MathNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
+
+declare const getRoughness: (args: { roughness: Node }) => ShaderNodeObject<MathNode>;
+
+export default getRoughness;

package/three/src/nodes/geometry/RangeNode.d.ts

@@ -0,0 +1,19 @@
+import { Color } from '../../math/Color.js';
+import { Vector2 } from '../../math/Vector2.js';
+import { Vector3 } from '../../math/Vector3.js';
+import { Vector4 } from '../../math/Vector4.js';
+import Node from '../core/Node.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export type RangeModeBound = number | Color | Vector2 | Vector3 | Vector4;
+
+export default class RangeNode extends Node {
+	min: RangeModeBound;
+	max: RangeModeBound;
+
+	constructor(min: RangeModeBound, max: RangeModeBound);
+	getVectorLength(builder: NodeBuilder): number;
+}
+
+export const range: (min: RangeModeBound, max: RangeModeBound) => ShaderNodeObject<RangeNode>;

package/three/src/nodes/gpgpu/ComputeNode.d.ts

@@ -0,0 +1,20 @@
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class ComputeNode extends Node {
+	isComputeNode: true;
+
+	count: number;
+	workgroupSize: number[];
+	dispatchCount: number;
+
+	constructor(computeNode: Node, count: number, workgroupSize?: number[]);
+}
+
+export const compute: (node: NodeRepresentation, count: number, workgroupSize: number[]) => ShaderNodeObject<ComputeNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		compute: typeof compute;
+	}
+}

package/three/src/nodes/lighting/AONode.d.ts

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

package/three/src/nodes/lighting/AnalyticLightNode.d.ts

@@ -0,0 +1,8 @@
+import { Light } from '../../lights/Light.js';
+import LightingNode from './LightingNode.js';
+
+export default class AnalyticLightNode<T extends Light> extends LightingNode {
+	light: T | null;
+
+	constructor(light?: T | null);
+}

package/three/src/nodes/lighting/BasicEnvironmentNode.d.ts

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

package/three/src/nodes/lighting/BasicLightMapNode.d.ts

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

package/three/src/nodes/lighting/EnvironmentNode.d.ts

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

package/three/src/nodes/lighting/HemisphereLightNode.d.ts

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

package/three/src/nodes/lighting/IrradianceNode.d.ts

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

package/three/src/nodes/lighting/LightUtils.d.ts

@@ -0,0 +1,5 @@
+import Node from '../core/Node.js';
+import CondNode from '../math/CondNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export const getDistanceAttenuation: (args: { lightDistance: Node; cutoffDistance: Node; decayExponent: Node }) => ShaderNodeObject<CondNode>;

package/three/src/nodes/lighting/LightingContextNode.d.ts

@@ -0,0 +1,22 @@
+import ContextNode from '../core/ContextNode.js';
+import LightingModel, { LightingModelIndirectInput } from '../core/LightingModel.js';
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class LightingContextNode extends ContextNode {
+	lightingModelNode: LightingModel | null;
+	backdropNode: Node | null;
+	backdropAlphaNode: Node | null;
+
+	constructor(node: Node, lightingModel?: LightingModel | null, backdropNode?: Node | null, backdropAlphaNode?: Node | null);
+
+	getContext(): LightingModelIndirectInput;
+}
+
+export const lightingContext: (node: Node, lightingModelNode?: LightingModel) => ShaderNodeObject<LightingContextNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		lightingContext: typeof lightingContext;
+	}
+}

package/three/src/nodes/lighting/LightingNode.d.ts

@@ -0,0 +1,7 @@
+import Node from '../core/Node.js';
+
+export default abstract class LightingNode extends Node {
+	readonly isLightingNode: true;
+
+	constructor();
+}

package/three/src/nodes/lighting/LightsNode.d.ts

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

package/three/src/nodes/lighting/PointLightNode.d.ts

@@ -0,0 +1,10 @@
+import { PointLight } from '../../lights/PointLight.js';
+import Node from '../core/Node.js';
+import AnalyticLightNode from './AnalyticLightNode.js';
+
+export default class PointLightNode extends AnalyticLightNode<PointLight> {
+	cutoffDistanceNode: Node;
+	decayExponentNode: Node;
+
+	constructor(light?: PointLight | null);
+}

package/three/src/nodes/lighting/RectAreaLightNode.d.ts

@@ -0,0 +1,21 @@
+import { RectAreaLight } from '../../lights/RectAreaLight.js';
+import { DataTexture } from '../../textures/DataTexture.js';
+import Node from '../core/Node.js';
+import AnalyticLightNode from './AnalyticLightNode.js';
+
+export interface RectAreaLightTexturesLib {
+	LTC_HALF_1: DataTexture;
+	LTC_HALF_2: DataTexture;
+
+	LTC_FLOAT_1: DataTexture;
+	LTC_FLOAT_2: DataTexture;
+}
+
+export default class RectAreaLightNode extends AnalyticLightNode<RectAreaLight> {
+	halfHeight: Node;
+	halfWidth: Node;
+
+	constructor(light?: RectAreaLight | null);
+
+	static setLTC(ltc: RectAreaLightTexturesLib): void;
+}

package/three/src/nodes/lighting/SpotLightNode.d.ts

@@ -0,0 +1,15 @@
+import { SpotLight } from '../../lights/SpotLight.js';
+import Node from '../core/Node.js';
+import AnalyticLightNode from './AnalyticLightNode.js';
+
+export default class PointLightNode extends AnalyticLightNode<SpotLight> {
+	directionNode: Node;
+
+	coneCosNode: Node;
+	penumbraCosNode: Node;
+
+	cutoffDistanceNode: Node;
+	decayExponentNode: Node;
+
+	constructor(light?: SpotLight | null);
+}