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

package/three/src/nodes/loaders/NodeLoader.d.ts

@@ -0,0 +1,16 @@
+import { Loader } from '../../loaders/Loader.js';
+import { LoadingManager } from '../../loaders/LoadingManager.js';
+import { Texture } from '../../textures/Texture.js';
+import { Node } from '../Nodes.js';
+
+export interface NodeLoaderResult {
+	[hash: string]: Node;
+}
+
+export default class NodeLoader extends Loader<NodeLoaderResult> {
+	constructor(manager?: LoadingManager);
+
+	parseNodes(json: unknown): NodeLoaderResult;
+	parse(json: unknown): Node;
+	setTextures(textures: { [key: string]: Texture }): this;
+}

package/three/src/nodes/loaders/NodeMaterialLoader.d.ts

@@ -0,0 +1,8 @@
+import { MaterialLoader } from '../../loaders/MaterialLoader.js';
+import { NodeLoaderResult } from './NodeLoader.js';
+
+export default class NodeMaterialLoader extends MaterialLoader {
+	nodes: NodeLoaderResult;
+
+	setNodes(value: NodeLoaderResult): this;
+}

package/three/src/nodes/loaders/NodeObjectLoader.d.ts

@@ -0,0 +1,10 @@
+import { ObjectLoader } from '../../loaders/ObjectLoader.js';
+import { Material } from '../../materials/Material.js';
+import { Texture } from '../../textures/Texture.js';
+import { NodeLoaderResult } from './NodeLoader.js';
+
+export default class NodeObjectLoader extends ObjectLoader {
+	parseNodes(json: unknown, textures: { [key: string]: Texture }): NodeLoaderResult;
+
+	parseMaterials(json: unknown, textures: { [key: string]: Texture }): { [key: string]: Material };
+}

package/three/src/nodes/materials/Line2NodeMaterial.d.ts

@@ -0,0 +1,53 @@
+import { LineDashedMaterialParameters } from '../../materials/LineDashedMaterial.js';
+import { Color } from '../../math/Color.js';
+import { Texture } from '../../textures/Texture.js';
+import Node from '../core/Node.js';
+import NodeMaterial, { NodeMaterialParameters } from './NodeMaterial.js';
+
+export interface Line2NodeMaterialParameters extends NodeMaterialParameters, LineDashedMaterialParameters {
+	dashed?: boolean | undefined;
+}
+
+export default class Line2NodeMaterial extends NodeMaterial {
+	lights: boolean;
+
+	// Properties from LineDashedMaterial
+	readonly isLineDashedMaterial: true;
+	scale: number;
+	dashSize: number;
+	gapSize: number;
+
+	// Properties from LineBasicMaterial
+	readonly isLineBasicMaterial: true;
+	color: Color;
+	fog: boolean;
+	linewidth: number;
+	linecap: string;
+	linejoin: string;
+	map: Texture | null;
+
+	useAlphaToCoverage: boolean;
+	useColor: boolean;
+	useDash: boolean;
+	useWorldUnits: boolean;
+
+	dashOffset: number;
+	lineWidth: number;
+
+	lineColorNode: Node | null;
+
+	offsetNode: Node | null;
+	dashScaleNode: Node | null;
+	dashSizeNode: Node | null;
+	gapSizeNode: Node | null;
+
+	constructor(parameters?: Line2NodeMaterialParameters);
+
+	setupShaders(): void;
+
+	get worldUnits(): boolean;
+	set worldUnits(value: boolean);
+
+	get dashed(): boolean;
+	set dashed(value: boolean);
+}

package/three/src/nodes/materials/LineBasicNodeMaterial.d.ts

@@ -0,0 +1,21 @@
+import { LineBasicMaterialParameters } from '../../materials/LineBasicMaterial.js';
+import { Color } from '../../math/Color.js';
+import { Texture } from '../../textures/Texture.js';
+import NodeMaterial, { NodeMaterialParameters } from './NodeMaterial.js';
+
+export interface LineBasicNodeMaterialParameters extends NodeMaterialParameters, LineBasicMaterialParameters {}
+
+export default class LineBasicNodeMaterial extends NodeMaterial {
+	readonly isLineBasicNodeMaterial: true;
+
+	// Properties from LineBasicMaterial
+	readonly isLineBasicMaterial: true;
+	color: Color;
+	fog: boolean;
+	linewidth: number;
+	linecap: string;
+	linejoin: string;
+	map: Texture | null;
+
+	constructor(parameters?: LineBasicNodeMaterialParameters);
+}

package/three/src/nodes/materials/Materials.d.ts

@@ -0,0 +1,15 @@
+export { default as Line2NodeMaterial } from './Line2NodeMaterial.js';
+export { default as LineBasicNodeMaterial } from './LineBasicNodeMaterial.js';
+export { default as MeshBasicNodeMaterial } from './MeshBasicNodeMaterial.js';
+export { default as MeshMatcapNodeMaterial } from './MeshMatcapNodeMaterial.js';
+export { default as MeshNormalNodeMaterial } from './MeshNormalNodeMaterial.js';
+export { default as MeshPhongNodeMaterial } from './MeshPhongNodeMaterial.js';
+export { default as MeshPhysicalNodeMaterial } from './MeshPhysicalNodeMaterial.js';
+export { default as MeshSSSPhysicalNodeMaterial } from './MeshSSSNodeMaterial.js';
+export { default as MeshStandardNodeMaterial } from './MeshStandardNodeMaterial.js';
+export { default as MeshToonNodeMaterial } from './MeshToonNodeMaterial.js';
+export { addNodeMaterial, createNodeMaterialFromType, default as NodeMaterial } from './NodeMaterial.js';
+export { default as PointsNodeMaterial } from './PointsNodeMaterial.js';
+export { default as ShadowNodeMaterial } from './ShadowNodeMaterial.js';
+export { default as SpriteNodeMaterial } from './SpriteNodeMaterial.js';
+export { default as VolumeNodeMaterial } from './VolumeNodeMaterial.js';

package/three/src/nodes/materials/MeshBasicNodeMaterial.d.ts

@@ -0,0 +1,35 @@
+import { Combine } from '../../constants.js';
+import { MeshBasicMaterialParameters } from '../../materials/MeshBasicMaterial.js';
+import { Color } from '../../math/Color.js';
+import { Euler } from '../../math/Euler.js';
+import { Texture } from '../../textures/Texture.js';
+import NodeMaterial, { NodeMaterialParameters } from './NodeMaterial.js';
+
+export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshBasicMaterialParameters {}
+
+export default class MeshBasicNodeMaterial extends NodeMaterial {
+	readonly isMeshBasicNodeMaterial: true;
+
+	// Properties from MeshBasicMaterial
+	readonly isMeshBasicMaterial: true;
+	color: Color;
+	map: Texture | null;
+	lightMap: Texture | null;
+	lightMapIntensity: number;
+	aoMap: Texture | null;
+	aoMapIntensity: number;
+	specularMap: Texture | null;
+	alphaMap: Texture | null;
+	envMap: Texture | null;
+	envMapRotation: Euler;
+	combine: Combine;
+	reflectivity: number;
+	refractionRatio: number;
+	wireframe: boolean;
+	wireframeLinewidth: number;
+	wireframeLinecap: string;
+	wireframeLinejoin: string;
+	fog: boolean;
+
+	constructor(parameters?: MeshBasicNodeMaterialParameters);
+}

package/three/src/nodes/materials/MeshMatcapNodeMaterial.d.ts

@@ -0,0 +1,31 @@
+import { NormalMapTypes } from '../../constants.js';
+import { MeshMatcapMaterialParameters } from '../../materials/MeshMatcapMaterial.js';
+import { Color } from '../../math/Color.js';
+import { Vector2 } from '../../math/Vector2.js';
+import { Texture } from '../../textures/Texture.js';
+import NodeMaterial, { NodeMaterialParameters } from './NodeMaterial.js';
+
+export interface MeshMatcapNodeMaterialParameters extends NodeMaterialParameters, MeshMatcapMaterialParameters {}
+
+export default class MeshMatcapNodeMaterial extends NodeMaterial {
+	readonly isMeshMatcapNodeMaterial: true;
+
+	// Properties from MeshMatcapMaterial
+	readonly isMeshMatcapMaterial: true;
+	color: Color;
+	matcap: Texture | null;
+	map: Texture | null;
+	bumpMap: Texture | null;
+	bumpScale: number;
+	normalMap: Texture | null;
+	normalMapType: NormalMapTypes;
+	normalScale: Vector2;
+	displacementMap: Texture | null;
+	displacementScale: number;
+	displacementBias: number;
+	alphaMap: Texture | null;
+	flatShading: boolean;
+	fog: boolean;
+
+	constructor(paramters: MeshMatcapNodeMaterialParameters);
+}

package/three/src/nodes/materials/MeshNormalNodeMaterial.d.ts

@@ -0,0 +1,27 @@
+import { NormalMapTypes } from '../../constants.js';
+import { MeshNormalMaterialParameters } from '../../materials/MeshNormalMaterial.js';
+import { Vector2 } from '../../math/Vector2.js';
+import { Texture } from '../../textures/Texture.js';
+import NodeMaterial, { NodeMaterialParameters } from './NodeMaterial.js';
+
+export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshNormalMaterialParameters {}
+
+export default class MeshNormalNodeMaterial extends NodeMaterial {
+	readonly isMeshNormalNodeMaterial: true;
+
+	// Properties from MeshNormalMaterial
+	readonly isMeshNormalMaterial: true;
+	bumpMap: Texture | null;
+	bumpScale: number;
+	normalMap: Texture | null;
+	normalMapType: NormalMapTypes;
+	normalScale: Vector2;
+	displacementMap: Texture | null;
+	displacementScale: number;
+	displacementBias: number;
+	wireframe: boolean;
+	wireframeLinewidth: number;
+	flatShading: boolean;
+
+	constructor(parameters?: MeshBasicNodeMaterialParameters);
+}

package/three/src/nodes/materials/MeshPhongNodeMaterial.d.ts

@@ -0,0 +1,55 @@
+import { Combine, NormalMapTypes } from '../../constants.js';
+import { MeshPhongMaterialParameters } from '../../materials/MeshPhongMaterial.js';
+import { Color } from '../../math/Color.js';
+import { Euler } from '../../math/Euler.js';
+import { Vector2 } from '../../math/Vector2.js';
+import { Texture } from '../../textures/Texture.js';
+import Node from '../core/Node.js';
+import NodeMaterial, { NodeMaterialParameters } from './NodeMaterial.js';
+
+export interface MeshPhongNodeMaterialParameters extends NodeMaterialParameters, MeshPhongMaterialParameters {}
+
+export default class MeshPhongNodeMaterial extends NodeMaterial {
+	readonly isMeshPhongNodeMaterial: true;
+
+	shininessNode: Node | null;
+	specularNode: Node | null;
+
+	// Properties from MeshPhongMaterial
+	readonly isMeshPhongMaterial: true;
+	color: Color;
+	specular: Color;
+	shininess: number;
+	map: Texture | null;
+	lightMap: Texture | null;
+	lightMapIntensity: number;
+	aoMap: Texture | null;
+	aoMapIntensity: number;
+	emissive: Color;
+	emissiveIntensity: number;
+	emissiveMap: Texture | null;
+	bumpMap: Texture | null;
+	bumpScale: number;
+	normalMap: Texture | null;
+	normalMapType: NormalMapTypes;
+	normalScale: Vector2;
+	displacementMap: Texture | null;
+	displacementScale: number;
+	displacementBias: number;
+	specularMap: Texture | null;
+	alphaMap: Texture | null;
+	envMap: Texture | null;
+	envMapRotation: Euler;
+	combine: Combine;
+	reflectivity: number;
+	refractionRatio: number;
+	wireframe: boolean;
+	wireframeLinewidth: number;
+	wireframeLinecap: string;
+	wireframeLinejoin: string;
+	flatShading: boolean;
+	metal: boolean;
+	fog: boolean;
+
+	constructor(parameters?: MeshPhongNodeMaterialParameters);
+}

package/three/src/nodes/materials/MeshPhysicalNodeMaterial.d.ts

@@ -0,0 +1,87 @@
+import { MeshPhysicalMaterialParameters } from '../../materials/MeshPhysicalMaterial.js';
+import { Color } from '../../math/Color.js';
+import { Vector2 } from '../../math/Vector2.js';
+import { Texture } from '../../textures/Texture.js';
+import Node from '../core/Node.js';
+import MeshStandardNodeMaterial, { MeshStandardNodeMaterialParameters } from './MeshStandardNodeMaterial.js';
+
+export interface MeshPhysicalNodeMaterialParameters extends MeshStandardNodeMaterialParameters, MeshPhysicalMaterialParameters {}
+
+export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
+	readonly isMeshPhysicalNodeMaterial: true;
+
+	clearcoatNode: Node | null;
+	clearcoatRoughnessNode: Node | null;
+	clearcoatNormalNode: Node | null;
+
+	sheenNode: Node | null;
+	sheenRoughnessNode: Node | null;
+
+	iridescenceNode: Node | null;
+	iridescenceIORNode: Node | null;
+	iridescenceThicknessNode: Node | null;
+
+	iorNode: Node | null;
+
+	specularIntensityNode: Node | null;
+	specularColorNode: Node | null;
+
+	transmissionNode: Node | null;
+	thicknessNode: Node | null;
+	attenuationDistanceNode: Node | null;
+	attenuationColorNode: Node | null;
+	dispersionNode: Node | null;
+
+	anisotropyNode: Node | null;
+
+	// Properties from MeshPhysicalMaterial
+	readonly isMeshPhysicalMaterial: true;
+	anisotropyRotation: number;
+	anisotropyMap: Texture | null;
+	clearcoatMap: Texture | null;
+	clearcoatRoughness: number;
+	clearcoatRoughnessMap: Texture | null;
+	clearcoatNormalScale: Vector2;
+	clearcoatNormalMap: Texture | null;
+	ior: number;
+	get reflectivity(): number;
+	set reflectivity(reflectivity: number);
+	iridescenceMap: Texture | null;
+	iridescenceIOR: number;
+	iridescenceThicknessRange: [number, number];
+	iridescenceThicknessMap: Texture | null;
+	sheenColor: Color;
+	sheenColorMap: Texture | null;
+	sheenRoughness: number;
+	sheenRoughnessMap: Texture | null;
+	transmissionMap: Texture | null;
+	thickness: number;
+	thicknessMap: Texture | null;
+	attenuationDistance: number;
+	attenuationColor: Color;
+	specularIntensity: number;
+	specularIntensityMap: Texture | null;
+	specularColor: Color;
+	specularColorMap: Texture | null;
+	get anisotropy(): number;
+	set anisotropy(value: number);
+	get clearcoat(): number;
+	set clearcoat(value: number);
+	get iridescence(): number;
+	set iridescence(value: number);
+	get dispersion(): number;
+	set dispersion(value: number);
+	get sheen(): number;
+	set sheen(value: number);
+	get transmission(): number;
+	set transmission(value: number);
+
+	constructor(parameters?: MeshPhysicalNodeMaterialParameters);
+
+	get useClearcoat(): boolean;
+	get useIridescence(): boolean;
+	get useSheen(): boolean;
+	get useAnisotropy(): boolean;
+	get useTransmission(): boolean;
+	get useDispersion(): boolean;
+}

package/three/src/nodes/materials/MeshSSSNodeMaterial.d.ts

@@ -0,0 +1,16 @@
+import ConstNode from '../core/ConstNode.js';
+import Node from '../core/Node.js';
+import MeshPhysicalNodeMaterial, { MeshPhysicalNodeMaterialParameters } from './MeshPhysicalNodeMaterial.js';
+
+export default class MeshSSSNodeMaterial extends MeshPhysicalNodeMaterial {
+	thicknessColorNode: Node | null;
+	thicknessDistortionNode: ConstNode<number>;
+	thicknessAmbientNode: ConstNode<number>;
+	thicknessAttenuationNode: ConstNode<number>;
+	thicknessPowerNode: ConstNode<number>;
+	thicknessScaleNode: ConstNode<number>;
+
+	constructor(parameters?: MeshPhysicalNodeMaterialParameters);
+
+	get useSSS(): boolean;
+}

package/three/src/nodes/materials/MeshStandardNodeMaterial.d.ts

@@ -0,0 +1,55 @@
+import { NormalMapTypes } from '../../constants.js';
+import { MeshStandardMaterialParameters } from '../../materials/MeshStandardMaterial.js';
+import { Color } from '../../math/Color.js';
+import { Euler } from '../../math/Euler.js';
+import { Vector2 } from '../../math/Vector2.js';
+import { Texture } from '../../textures/Texture.js';
+import Node from '../core/Node.js';
+import NodeMaterial, { NodeMaterialParameters } from './NodeMaterial.js';
+
+export interface MeshStandardNodeMaterialParameters extends NodeMaterialParameters, MeshStandardMaterialParameters {}
+
+export default class MeshStandardNodeMaterial extends NodeMaterial {
+	readonly isMeshStandardNodeMaterial: true;
+
+	emissiveNode: Node | null;
+
+	metalnessNode: Node | null;
+	roughnessNode: Node | null;
+
+	// Properties from MeshStandardMaterial
+	readonly isMeshStandardMaterial: true;
+	color: Color;
+	roughness: number;
+	metalness: number;
+	map: Texture | null;
+	lightMap: Texture | null;
+	lightMapIntensity: number;
+	aoMap: Texture | null;
+	aoMapIntensity: number;
+	emissive: Color;
+	emissiveIntensity: number;
+	emissiveMap: Texture | null;
+	bumpMap: Texture | null;
+	bumpScale: number;
+	normalMap: Texture | null;
+	normalMapType: NormalMapTypes;
+	normalScale: Vector2;
+	displacementMap: Texture | null;
+	displacementScale: number;
+	displacementBias: number;
+	roughnessMap: Texture | null;
+	metalnessMap: Texture | null;
+	alphaMap: Texture | null;
+	envMap: Texture | null;
+	envMapRotation: Euler;
+	envMapIntensity: number;
+	wireframe: boolean;
+	wireframeLinewidth: number;
+	wireframeLinecap: string;
+	wireframeLinejoin: string;
+	flatShading: boolean;
+	fog: boolean;
+
+	constructor(paramters?: MeshStandardNodeMaterialParameters);
+}

package/three/src/nodes/materials/MeshToonNodeMaterial.d.ts

@@ -0,0 +1,41 @@
+import { NormalMapTypes } from '../../constants.js';
+import { MeshToonMaterialParameters } from '../../materials/MeshToonMaterial.js';
+import { Color } from '../../math/Color.js';
+import { Vector2 } from '../../math/Vector2.js';
+import { Texture } from '../../textures/Texture.js';
+import NodeMaterial, { NodeMaterialParameters } from './NodeMaterial.js';
+
+export interface MeshToonNodeMaterialParameters extends NodeMaterialParameters, MeshToonMaterialParameters {}
+
+export default class MeshToonNodeMaterial extends NodeMaterial {
+	readonly isMeshToonNodeMaterial: true;
+
+	// Properties from MeshToonMaterial
+	readonly isMeshToonMaterial: true;
+	color: Color;
+	gradientMap: Texture | null;
+	map: Texture | null;
+	lightMap: Texture | null;
+	lightMapIntensity: number;
+	aoMap: Texture | null;
+	aoMapIntensity: number;
+	emissive: Color;
+	emissiveIntensity: number;
+	emissiveMap: Texture | null;
+	bumpMap: Texture | null;
+	bumpScale: number;
+	normalMap: Texture | null;
+	normalMapType: NormalMapTypes;
+	normalScale: Vector2;
+	displacementMap: Texture | null;
+	displacementScale: number;
+	displacementBias: number;
+	alphaMap: Texture | null;
+	wireframe: boolean;
+	wireframeLinewidth: number;
+	wireframeLinecap: string;
+	wireframeLinejoin: string;
+	fog: boolean;
+
+	constructor(paramters: MeshToonNodeMaterialParameters);
+}

package/three/src/nodes/materials/NodeMaterial.d.ts

@@ -0,0 +1,124 @@
+import { LineBasicMaterial } from '../../materials/LineBasicMaterial.js';
+import { Material, MaterialParameters } from '../../materials/Material.js';
+import { MeshBasicMaterial } from '../../materials/MeshBasicMaterial.js';
+import { MeshMatcapMaterial } from '../../materials/MeshMatcapMaterial.js';
+import { MeshNormalMaterial } from '../../materials/MeshNormalMaterial.js';
+import { MeshPhongMaterial } from '../../materials/MeshPhongMaterial.js';
+import { MeshPhysicalMaterial } from '../../materials/MeshPhysicalMaterial.js';
+import { MeshStandardMaterial } from '../../materials/MeshStandardMaterial.js';
+import { MeshToonMaterial } from '../../materials/MeshToonMaterial.js';
+import { PointsMaterial } from '../../materials/PointsMaterial.js';
+import { ShadowMaterial } from '../../materials/ShadowMaterial.js';
+import { SpriteMaterial } from '../../materials/SpriteMaterial.js';
+import ClippingNode from '../accessors/ClippingNode.js';
+import LightingModel from '../core/LightingModel.js';
+import MRTNode from '../core/MRTNode.js';
+import Node from '../core/Node.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+import LightsNode from '../lighting/LightsNode.js';
+import LineBasicNodeMaterial from './LineBasicNodeMaterial.js';
+import MeshBasicNodeMaterial from './MeshBasicNodeMaterial.js';
+import MeshMatcapNodeMaterial from './MeshMatcapNodeMaterial.js';
+import MeshNormalNodeMaterial from './MeshNormalNodeMaterial.js';
+import MeshPhongNodeMaterial from './MeshPhongNodeMaterial.js';
+import MeshPhysicalNodeMaterial from './MeshPhysicalNodeMaterial.js';
+import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
+import MeshToonNodeMaterial from './MeshToonNodeMaterial.js';
+import PointsNodeMaterial from './PointsNodeMaterial.js';
+import ShadowNodeMaterial from './ShadowNodeMaterial.js';
+import SpriteNodeMaterial from './SpriteNodeMaterial.js';
+
+export interface NodeMaterialParameters extends MaterialParameters {
+	normals?: boolean | undefined;
+
+	colorSpaced?: boolean | undefined;
+
+	lightsNode?: LightsNode | null | undefined;
+	envNode?: Node | null | undefined;
+	aoNode?: Node | null | undefined;
+
+	colorNode?: Node | null | undefined;
+	normalNode?: Node | null | undefined;
+	opacityNode?: Node | null | undefined;
+	backdropNode?: Node | null | undefined;
+	backdropAlphaNode?: Node | null | undefined;
+	alphaTestNode?: Node | null | undefined;
+
+	positionNode?: Node | null | undefined;
+
+	depthNode?: Node | null | undefined;
+	shadowNode?: Node | null | undefined;
+
+	outputNode?: Node | null | undefined;
+
+	fragmentNode?: Node | null | undefined;
+	vertexNode?: Node | null | undefined;
+}
+
+export default class NodeMaterial extends Material {
+	readonly isNodeMaterial: true;
+
+	fog: boolean;
+	lights: boolean;
+	normals: boolean;
+
+	lightsNode: LightsNode | null;
+	envNode: Node | null;
+	aoNode: Node | null;
+
+	colorNode: Node | null;
+	normalNode: Node | null;
+	opacityNode: Node | null;
+	backdropNode: Node | null;
+	backdropAlphaNode: Node | null;
+	alphaTestNode: Node | null;
+
+	positionNode: Node | null;
+
+	depthNode: Node | null;
+	shadowNode: Node | null;
+	shadowPositionNode: Node | null;
+
+	outputNode: Node | null;
+	mrtNode: MRTNode | null;
+
+	fragmentNode: Node | null;
+	vertexNode: Node | null;
+
+	constructor();
+
+	build(builder: NodeBuilder): void;
+	setup(builder: NodeBuilder): void;
+	setupClipping(builder: NodeBuilder): ClippingNode | null;
+	setupDepth(builder: NodeBuilder): void;
+	setupPosition(builder: NodeBuilder): Node;
+	setupDiffuseColor(builder: NodeBuilder): void;
+	setupVariants(builder: NodeBuilder): void;
+	setupNormal(builder: NodeBuilder): void;
+	setupEnvironment(builder: NodeBuilder): Node | null;
+	setupLightMap(builder: NodeBuilder): Node | null;
+	setupLights(builder: NodeBuilder): LightsNode;
+	setupOutgoingLight(): Node;
+	setupLightingModel(builder: NodeBuilder): LightingModel;
+	setupLighting(builder: NodeBuilder): Node;
+	setupOutput(builder: NodeBuilder, outputNode: Node): Node;
+
+	setDefaultValues(material: Material): void;
+
+	static fromMaterial(material: LineBasicMaterial): LineBasicNodeMaterial;
+	static fromMaterial(material: MeshBasicMaterial): MeshBasicNodeMaterial;
+	static fromMaterial(material: MeshMatcapMaterial): MeshMatcapNodeMaterial;
+	static fromMaterial(material: MeshNormalMaterial): MeshNormalNodeMaterial;
+	static fromMaterial(material: MeshPhongMaterial): MeshPhongNodeMaterial;
+	static fromMaterial(material: MeshPhysicalMaterial): MeshPhysicalNodeMaterial;
+	static fromMaterial(material: MeshStandardMaterial): MeshStandardNodeMaterial;
+	static fromMaterial(material: MeshToonMaterial): MeshToonNodeMaterial;
+	static fromMaterial(material: PointsMaterial): PointsNodeMaterial;
+	static fromMaterial(material: ShadowMaterial): ShadowNodeMaterial;
+	static fromMaterial(material: SpriteMaterial): SpriteNodeMaterial;
+	static fromMaterial(material: NodeMaterial): NodeMaterial;
+	static fromMaterial(material: Material): NodeMaterial;
+}
+
+export function addNodeMaterial(type: string, nodeMaterial: typeof NodeMaterial): void;
+export function createNodeMaterialFromType(type: string): NodeMaterial;

package/three/src/nodes/materials/PointsNodeMaterial.d.ts

@@ -0,0 +1,21 @@
+import { PointsMaterialParameters } from '../../materials/PointsMaterial.js';
+import { Color } from '../../math/Color.js';
+import { Texture } from '../../textures/Texture.js';
+import NodeMaterial, { NodeMaterialParameters } from './NodeMaterial.js';
+
+export interface PointsNodeMaterialParameters extends NodeMaterialParameters, PointsMaterialParameters {}
+
+export default class PointsNodeMaterial extends NodeMaterial {
+	readonly isPointsNodeMaterial: true;
+
+	// Properties from PointsMaterial
+	readonly isPointsMaterial: true;
+	color: Color;
+	map: Texture | null;
+	alphaMap: Texture | null;
+	size: number;
+	sizeAttenuation: boolean;
+	fog: boolean;
+
+	constructor(parameters?: PointsNodeMaterialParameters);
+}

package/three/src/nodes/materials/ShadowNodeMaterial.d.ts

@@ -0,0 +1,16 @@
+import { ShadowMaterialParameters } from '../../materials/ShadowMaterial.js';
+import { Color } from '../../math/Color.js';
+import NodeMaterial, { NodeMaterialParameters } from './NodeMaterial.js';
+
+export interface ShadowNodeMaterialParameters extends NodeMaterialParameters, ShadowMaterialParameters {}
+
+export default class ShadowNodeMaterial extends NodeMaterial {
+	readonly isShadowNodeMaterial: true;
+
+	// Properties from ShadowMaterial
+	readonly isShadowMaterial: true;
+	color: Color;
+	fog: boolean;
+
+	constructor(parameters?: ShadowNodeMaterialParameters);
+}

package/three/src/nodes/materials/SpriteNodeMaterial.d.ts

@@ -0,0 +1,25 @@
+import { SpriteMaterialParameters } from '../../materials/SpriteMaterial.js';
+import { Color } from '../../math/Color.js';
+import { Texture } from '../../textures/Texture.js';
+import Node from '../core/Node.js';
+import NodeMaterial, { NodeMaterialParameters } from './NodeMaterial.js';
+
+export interface SpriteNodeMaterialParameters extends NodeMaterialParameters, SpriteMaterialParameters {}
+
+export default class SpriteNodeMaterial extends NodeMaterial {
+	isSpriteNodeMaterial: true;
+
+	rotationNode: Node | null;
+	scaleNode: Node | null;
+
+	// Properties from SpriteMaterial
+	readonly isSpriteMaterial: true;
+	color: Color;
+	map: Texture | null;
+	alphaMap: Texture | null;
+	rotation: number;
+	sizeAttenuation: boolean;
+	fog: boolean;
+
+	constructor(parameters?: SpriteNodeMaterialParameters);
+}