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

package/three/src/nodes/Nodes.d.ts

@@ -0,0 +1,231 @@
+// constants
+export * from './core/constants.js';
+
+// core
+export { assign, default as AssignNode } from './core/AssignNode.js';
+export { attribute, default as AttributeNode } from './core/AttributeNode.js';
+export { bypass, default as BypassNode } from './core/BypassNode.js';
+export { cache, default as CacheNode } from './core/CacheNode.js';
+export { default as ConstNode } from './core/ConstNode.js';
+export { context, default as ContextNode, label } from './core/ContextNode.js';
+export { default as IndexNode, drawIndex, IndexNodeScope, instanceIndex, vertexIndex } from './core/IndexNode.js';
+export { default as LightingModel, LightingModelDirectInput, LightingModelIndirectInput, LightingModelReflectedLight } from './core/LightingModel.js';
+export { default as MRTNode, mrt } from './core/MRTNode.js';
+export { default as Node } from './core/Node.js';
+export { default as NodeAttribute } from './core/NodeAttribute.js';
+export { default as NodeBuilder } from './core/NodeBuilder.js';
+export { default as NodeCache } from './core/NodeCache.js';
+export { default as NodeCode } from './core/NodeCode.js';
+export { default as NodeFrame } from './core/NodeFrame.js';
+export { default as NodeFunctionInput } from './core/NodeFunctionInput.js';
+export { default as NodeKeywords } from './core/NodeKeywords.js';
+export { default as NodeUniform } from './core/NodeUniform.js';
+export { default as NodeVar } from './core/NodeVar.js';
+export { default as NodeVarying } from './core/NodeVarying.js';
+export { default as OutputStructNode, outputStruct } from './core/OutputStructNode.js';
+export { alphaT, anisotropy, anisotropyB, anisotropyT, clearcoat, clearcoatRoughness, dashSize, default as PropertyNode, diffuseColor, emissive, gapSize, iridescence, iridescenceIOR, iridescenceThickness, metalness, output, pointWidth, property, roughness, sheen, sheenRoughness, shininess, specularColor, varyingProperty } from './core/PropertyNode.js';
+export { default as StackNode } from './core/StackNode.js';
+export { default as TempNode } from './core/TempNode.js';
+export { default as UniformGroupNode, frameGroup, objectGroup, renderGroup, uniformGroup } from './core/UniformGroupNode.js';
+export { default as UniformNode, uniform } from './core/UniformNode.js';
+export { default as VarNode, temp } from './core/VarNode.js';
+export { default as VaryingNode, varying } from './core/VaryingNode.js';
+
+import * as NodeUtils from './core/NodeUtils.js';
+export { NodeUtils };
+
+// math
+export { abs, acos, all, any, asin, atan, atan2, bitcast, cbrt, ceil, clamp, cos, cross, default as MathNode, degrees, dFdx, dFdy, difference, distance, dot, EPSILON, equals, exp, exp2, faceForward, floor, fract, fwidth, INFINITY, inverseSqrt, length, lengthSq, log, log2, MathNodeMethod, MathNodeMethod1, MathNodeMethod2, MathNodeMethod3, max, min, mix, mod, negate, normalize, oneMinus, PI, PI2, pow, pow2, pow3, pow4, radians, rand, reciprocal, reflect, refract, round, saturate, sign, sin, smoothstep, sqrt, step, tan, transformDirection, transpose, trunc } from './math/MathNode.js';
+
+export { cond, default as CondNode } from './math/CondNode.js';
+export { default as HashNode, hash } from './math/HashNode.js';
+export { add, and, bitAnd, bitNot, bitOr, bitXor, default as OperatorNode, div, equal, greaterThan, greaterThanEqual, lessThan, lessThanEqual, mul, not, OperatorNodeOp, or, remainder, shiftLeft, shiftRight, sub, xor } from './math/OperatorNode.js';
+
+// math utils
+export { gain, parabola, pcurve, sinc } from './math/MathUtils.js';
+export { triNoise3D } from './math/TriNoise3D.js';
+
+// utils
+export { default as ArrayElementNode } from './utils/ArrayElementNode.js';
+export { default as ConvertNode } from './utils/ConvertNode.js';
+export { default as DiscardNode, discard, Return } from './utils/DiscardNode.js';
+export { default as EquirectUVNode, equirectUV } from './utils/EquirectUVNode.js';
+export { default as JoinNode } from './utils/JoinNode.js';
+export { default as MatcapUVNode, matcapUV } from './utils/MatcapUVNode.js';
+export { default as MaxMipLevelNode, maxMipLevel } from './utils/MaxMipLevelNode.js';
+export { default as OscNode, OscNodeMethod, oscSawtooth, oscSine, oscSquare, oscTriangle } from './utils/OscNode.js';
+export { colorToDirection, default as PackingNode, directionToColor } from './utils/PackingNode.js';
+export { default as ReflectorNode, reflector, ReflectorNodeParameters } from './utils/ReflectorNode.js';
+export { default as RemapNode, remap, remapClamp } from './utils/RemapNode.js';
+export { default as RotateNode, rotate } from './utils/RotateNode.js';
+export { default as RotateUVNode, rotateUV } from './utils/RotateUVNode.js';
+export { default as RTTNode, rtt, RTTNodeOptions } from './utils/RTTNode.js';
+export { default as SplitNode } from './utils/SplitNode.js';
+export { default as SpriteSheetUVNode, spritesheetUV } from './utils/SpriteSheetUVNode.js';
+export { default as StorageArrayElementNode } from './utils/SpriteSheetUVNode.js';
+export { default as TimerNode, frameId, timerDelta, timerGlobal, timerLocal, TimerNodeScope } from './utils/TimerNode.js';
+export { default as TriplanarTexturesNode, triplanarTexture, triplanarTextures } from './utils/TriplanarTexturesNode.js';
+
+// shader node
+export * from './shadernode/ShaderNode.js';
+
+// accessors
+export { parallaxDirection, parallaxUV, TBNViewMatrix, transformedBentNormalView } from './accessors/AccessorsUtils.js';
+export { batch, default as BatchNode } from './accessors/BatchNode.js';
+export * from './accessors/BitangentNode.js';
+export { buffer, default as BufferNode } from './accessors/BufferNode.js';
+export * from './accessors/CameraNode.js';
+export { cubeTexture, default as CubeTextureNode } from './accessors/CubeTextureNode.js';
+export { default as InstanceNode, instance } from './accessors/InstanceNode.js';
+export {
+	default as MaterialNode,
+	materialAlphaTest,
+	materialAnisotropy,
+	materialAnisotropyVector,
+	materialAOMap,
+	materialClearcoat,
+	materialClearcoatNormal,
+	materialClearcoatRoughness,
+	materialColor,
+	materialDispersion,
+	materialEmissive,
+	materialIridescence,
+	materialIridescenceIOR,
+	materialIridescenceThickness,
+	materialLightMap,
+	materialLineDashOffset,
+	materialLineDashSize,
+	materialLineGapSize,
+	materialLineScale,
+	materialLineWidth,
+	materialMetalness,
+	MaterialNodeScope,
+	materialNormal,
+	materialOpacity,
+	materialPointWidth,
+	materialReflectivity,
+	materialRotation,
+	materialRoughness,
+	materialSheen,
+	materialSheenRoughness,
+	materialShininess,
+	materialSpecular,
+	materialSpecularStrength,
+} from './accessors/MaterialNode.js';
+export { default as MaterialReferenceNode, materialReference } from './accessors/MaterialReferenceNode.js';
+export { default as ModelNode, modelDirection, modelNormalMatrix, modelPosition, modelScale, modelViewMatrix, modelViewPosition, modelWorldMatrix, modelWorldMatrixInverse } from './accessors/ModelNode.js';
+export { default as ModelViewProjectionNode, modelViewProjection } from './accessors/ModelViewProjectionNode.js';
+export * from './accessors/NormalNode.js';
+export { default as Object3DNode, objectDirection, objectNormalMatrix, objectPosition, objectScale, objectViewMatrix, objectViewPosition, objectWorldMatrix } from './accessors/Object3DNode.js';
+export { default as PointUVNode, pointUV } from './accessors/PointUVNode.js';
+export * from './accessors/PositionNode.js';
+export { default as ReferenceNode, reference, referenceBuffer } from './accessors/ReferenceNode.js';
+export * from './accessors/ReflectVectorNode.js';
+export { default as RendererReferenceNode, rendererReference } from './accessors/RendererReferenceNode.js';
+export { default as SkinningNode, skinning, skinningReference } from './accessors/SkinningNode.js';
+export { default as StorageBufferNode, storage, storageObject } from './accessors/StorageBufferNode.js';
+export { default as StorageTextureNode, storageTexture, textureStore } from './accessors/StorageTextureNode.js';
+export * from './accessors/TangentNode.js';
+export { default as Texture3DNode, texture3D } from './accessors/Texture3DNode.js';
+export { default as TextureBicubicNode, textureBicubic } from './accessors/TextureBicubicNode.js';
+export { default as TextureNode, sampler, texture } from './accessors/TextureNode.js';
+export { default as UniformsNode, uniforms } from './accessors/UniformsNode.js';
+export { default as UserDataNode, userData } from './accessors/UserDataNode.js';
+export * from './accessors/UVNode.js';
+export { default as VertexColorNode, vertexColor } from './accessors/VertexColorNode.js';
+
+// display
+export { afterImage, default as AfterImageNode } from './display/AfterImageNode.js';
+export { anamorphic, default as AnamorphicNode } from './display/AnamorphicNode.js';
+export { BlendMode, burn, default as BlendModeNode, dodge, overlay, screen } from './display/BlendModeNode.js';
+export { bloom, default as BloomNode } from './display/BloomNode.js';
+export { ColorAdjustmentMethod, default as ColorAdjustmentNode, hue, luminance, saturation, threshold, vibrance } from './display/ColorAdjustmentNode.js';
+export { ColorSpaceNodeMethod, colorSpaceToLinear, default as ColorSpaceNode, linearToColorSpace, linearTosRGB, sRGBToLinear } from './display/ColorSpaceNode.js';
+export { default as DenoiseNode, denoise } from './display/DenoiseNode.js';
+export { default as DepthOfFieldNode, dof } from './display/DepthOfFieldNode.js';
+export { default as DotScreenNode, dotScreen } from './display/DotScreenNode.js';
+export { default as FilmNode, film } from './display/FilmNode.js';
+export { default as FrontFacingNode, faceDirection, frontFacing } from './display/FrontFacingNode.js';
+export { default as FXAANode, fxaa } from './display/FXAANode.js';
+export { default as GaussianBlurNode, gaussianBlur } from './display/GaussianBlurNode.js';
+export { ao, default as GTAONode } from './display/GTAONode.js';
+export { default as Lut3DNode, lut3D } from './display/Lut3DNode.js';
+export { default as NormalMapNode, normalMap } from './display/NormalMapNode.js';
+export { default as PixelationPassNode, pixelationPass } from './display/PixelationPassNode.js';
+export { default as PosterizeNode, posterize } from './display/PosterizeNode.js';
+export { default as RenderOutputNode, renderOutput } from './display/RenderOutputNode.js';
+export { default as RGBShiftNode, rgbShift } from './display/RGBShiftNode.js';
+export { default as SobelOperatorNode, sobel } from './display/SobelOperatorNode.js';
+export { default as ToneMappingNode, toneMapping } from './display/ToneMappingNode.js';
+export { default as TransitionNode, transition } from './display/TransitionNode.js';
+export { default as ViewportDepthNode, depth, linearDepth, orthographicDepthToViewZ, perspectiveDepthToViewZ, ViewportDepthNodeScope, viewportLinearDepth, viewZToOrthographicDepth, viewZToPerspectiveDepth } from './display/ViewportDepthNode.js';
+export { default as ViewportDepthTextureNode, viewportDepthTexture } from './display/ViewportDepthTextureNode.js';
+export { default as ViewportNode, viewportBottomLeft, viewportBottomRight, viewportCoordinate, viewportResolution, viewportTopLeft, viewportTopRight } from './display/ViewportNode.js';
+export { default as ViewportSharedTextureNode, viewportSharedTexture } from './display/ViewportSharedTextureNode.js';
+export { default as ViewportTextureNode, viewportMipTexture, viewportTexture } from './display/ViewportTextureNode.js';
+
+export { default as PassNode, depthPass, pass, PassNodeScope, passTexture } from './display/PassNode.js';
+
+// code
+export { code, CodeNodeInclude, default as CodeNode, glsl, js, wgsl } from './code/CodeNode.js';
+export { default as ExpressionNode, expression } from './code/ExpressionNode.js';
+export { call, default as FunctionCallNode } from './code/FunctionCallNode.js';
+export { default as FunctionNode, Fn, FunctionNodeArguments, glslFn, wgslFn } from './code/FunctionNode.js';
+
+// fog
+export { default as FogExp2Node, densityFog } from './fog/FogExp2Node.js';
+export { default as FogNode, fog } from './fog/FogNode.js';
+export { default as FogRangeNode, rangeFog } from './fog/FogRangeNode.js';
+
+// geometry
+export { default as RangeNode, range, RangeModeBound } from './geometry/RangeNode.js';
+
+// gpgpu
+export { compute, default as ComputeNode } from './gpgpu/ComputeNode.js';
+
+// lighting
+export { default as AnalyticLightNode } from './lighting/AnalyticLightNode.js';
+export { default as AONode } from './lighting/AONode.js';
+export { default as BasicEnvironmentNode } from './lighting/BasicEnvironmentNode.js';
+export { default as EnvironmentNode } from './lighting/EnvironmentNode.js';
+export { default as HemisphereLightNode } from './lighting/HemisphereLightNode.js';
+export { default as IrradianceNode } from './lighting/IrradianceNode.js';
+export { default as LightingContextNode, lightingContext } from './lighting/LightingContextNode.js';
+export { default as LightingNode } from './lighting/LightingNode.js';
+export { default as LightsNode, lights } from './lighting/LightsNode.js';
+export { default as PointLightNode } from './lighting/PointLightNode.js';
+export { default as RectAreaLightNode, RectAreaLightTexturesLib } from './lighting/RectAreaLightNode.js';
+export { default as SpotLightNode } from './lighting/SpotLightNode.js';
+
+// pmrem
+export { default as PMREMNode, pmremTexture } from './pmrem/PMREMNode.js';
+
+// procedural
+export { checker, default as CheckerNode } from './procedural/CheckerNode.js';
+
+// loaders
+export { default as NodeLoader } from './loaders/NodeLoader.js';
+export { default as NodeMaterialLoader } from './loaders/NodeMaterialLoader.js';
+export { default as NodeObjectLoader } from './loaders/NodeObjectLoader.js';
+
+// materials
+export * from './materials/Materials.js';
+
+// materialX
+export * from './materialx/MaterialXNodes.js';
+
+// functions
+export { default as BRDF_GGX } from './functions/BSDF/BRDF_GGX.js';
+export { default as BRDF_Lambert } from './functions/BSDF/BRDF_Lambert.js';
+export { default as D_GGX } from './functions/BSDF/D_GGX.js';
+export { default as DFGApprox } from './functions/BSDF/DFGApprox.js';
+export { default as F_Schlick } from './functions/BSDF/F_Schlick.js';
+export { default as V_GGX_SmithCorrelated } from './functions/BSDF/V_GGX_SmithCorrelated.js';
+
+export { getDistanceAttenuation } from './lighting/LightUtils.js';
+
+export { default as getGeometryRoughness } from './functions/material/getGeometryRoughness.js';
+export { default as getRoughness } from './functions/material/getRoughness.js';
+
+export { default as PhongLightingModel } from './functions/PhongLightingModel.js';
+export { default as PhysicalLightingModel } from './functions/PhysicalLightingModel.js';

package/three/src/nodes/accessors/AccessorsUtils.d.ts

@@ -0,0 +1,9 @@
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export const TBNViewMatrix: ShaderNodeObject<Node>;
+
+export const parallaxDirection: ShaderNodeObject<Node>;
+export const parallaxUV: (uv: ShaderNodeObject<Node>, scale: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const transformedBentNormalView: ShaderNodeObject<Node>;

package/three/src/nodes/accessors/BatchNode.d.ts

@@ -0,0 +1,14 @@
+import { BatchedMesh } from '../../objects/BatchedMesh.js';
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class BatchNode extends Node {
+	batchMesh: BatchedMesh;
+
+	instanceColorNode: Node | null;
+	batchingIdNode: Node | null;
+
+	constructor(batchMesh: BatchedMesh);
+}
+
+export const batch: (batchMesh: BatchedMesh) => ShaderNodeObject<BatchNode>;

package/three/src/nodes/accessors/BitangentNode.d.ts

@@ -0,0 +1,9 @@
+import MathNode from '../math/MathNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export const bitangentGeometry: ShaderNodeObject<MathNode>;
+export const bitangentLocal: ShaderNodeObject<MathNode>;
+export const bitangentView: ShaderNodeObject<MathNode>;
+export const bitangentWorld: ShaderNodeObject<MathNode>;
+export const transformedBitangentView: ShaderNodeObject<MathNode>;
+export const transformedBitangentWorld: ShaderNodeObject<MathNode>;

package/three/src/nodes/accessors/BufferAttributeNode.d.ts

@@ -0,0 +1,28 @@
+import { Usage } from '../../constants.js';
+import { BufferAttribute, TypedArray } from '../../core/BufferAttribute.js';
+import { InterleavedBuffer } from '../../core/InterleavedBuffer.js';
+import { InterleavedBufferAttribute } from '../../core/InterleavedBufferAttribute.js';
+import InputNode from '../core/InputNode.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+declare class BufferAttributeNode extends InputNode<TypedArray | InterleavedBuffer | BufferAttribute> {
+	readonly isBufferNode: true;
+	bufferType: string | null;
+	bufferStride: number;
+	bufferOffset: number;
+	usage: Usage;
+	instanced: boolean;
+	attribute: BufferAttribute | InterleavedBufferAttribute | null;
+	constructor(value: TypedArray | InterleavedBuffer | BufferAttribute, bufferType?: string | null, bufferStride?: number, bufferOffset?: number);
+	getHash(builder: NodeBuilder): string;
+	getNodeType(builder: NodeBuilder): string | null;
+	setup(builder: NodeBuilder): void;
+	generate(builder: NodeBuilder): string | null | undefined;
+	getInputType(): string;
+	setUsage(value: Usage): this;
+	setInstanced(value: boolean): this;
+}
+export default BufferAttributeNode;
+export declare const bufferAttribute: (array: TypedArray | InterleavedBuffer | BufferAttribute, type?: string | null, stride?: number, offset?: number) => import('../shadernode/ShaderNode.js').ShaderNodeObject<BufferAttributeNode>;
+export declare const dynamicBufferAttribute: (array: TypedArray | InterleavedBuffer | BufferAttribute, type?: string | null, stride?: number, offset?: number) => import('../shadernode/ShaderNode.js').ShaderNodeObject<BufferAttributeNode>;
+export declare const instancedBufferAttribute: (array: TypedArray | InterleavedBuffer | BufferAttribute, type?: string | null, stride?: number, offset?: number) => import('../shadernode/ShaderNode.js').ShaderNodeObject<BufferAttributeNode>;
+export declare const instancedDynamicBufferAttribute: (array: TypedArray | InterleavedBuffer | BufferAttribute, type?: string | null, stride?: number, offset?: number) => import('../shadernode/ShaderNode.js').ShaderNodeObject<BufferAttributeNode>;

package/three/src/nodes/accessors/BufferNode.d.ts

@@ -0,0 +1,13 @@
+import UniformNode from '../core/UniformNode.js';
+import { NodeOrType, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class BufferNode extends UniformNode<unknown> {
+	isBufferNode: true;
+
+	bufferType: string;
+	bufferCount: number;
+
+	constructor(value: unknown, bufferType: string, bufferCount?: number);
+}
+
+export const buffer: (value: unknown, nodeOrType: NodeOrType, count: number) => ShaderNodeObject<BufferNode>;

package/three/src/nodes/accessors/CameraNode.d.ts

@@ -0,0 +1,15 @@
+import { Matrix3 } from '../../math/Matrix3.js';
+import { Matrix4 } from '../../math/Matrix4.js';
+import { Vector3 } from '../../math/Vector3.js';
+import UniformNode from '../core/UniformNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export const cameraNear: ShaderNodeObject<UniformNode<number>>;
+export const cameraFar: ShaderNodeObject<UniformNode<number>>;
+export const cameraLogDepth: ShaderNodeObject<UniformNode<number>>;
+export const cameraProjectionMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
+export const cameraProjectionMatrixInverse: ShaderNodeObject<UniformNode<Matrix4>>;
+export const cameraViewMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
+export const cameraWorldMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
+export const cameraNormalMatrix: ShaderNodeObject<UniformNode<Matrix3>>;
+export const cameraPosition: ShaderNodeObject<UniformNode<Vector3>>;

package/three/src/nodes/accessors/ClippingNode.d.ts

@@ -0,0 +1,16 @@
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export type ClippingNodeScope = typeof ClippingNode.ALPHA_TO_COVERAGE | typeof ClippingNode.DEFAULT;
+
+export default class ClippingNode extends Node {
+	scope: ClippingNodeScope;
+
+	constructor(scope?: ClippingNodeScope);
+
+	static ALPHA_TO_COVERAGE: 'alphaToCoverage';
+	static DEFAULT: 'default';
+}
+
+export const clipping: () => ShaderNodeObject<ClippingNode>;
+export const clippingAlpha: () => ShaderNodeObject<ClippingNode>;

package/three/src/nodes/accessors/CubeTextureNode.d.ts

@@ -0,0 +1,24 @@
+import { CubeTexture } from '../../textures/CubeTexture.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import TextureNode from './TextureNode.js';
+
+declare class CubeTextureNode extends TextureNode {
+	isCubeTextureNode: boolean;
+	uvNode: ShaderNodeObject<Node> | null;
+	levelNode: ShaderNodeObject<Node> | null;
+
+	constructor(value: CubeTexture, uvNode?: ShaderNodeObject<Node> | null, levelNode?: ShaderNodeObject<Node> | null, biasNode?: ShaderNodeObject<Node> | null);
+
+	getDefaultUV(): Node;
+}
+
+export default CubeTextureNode;
+
+export const cubeTexture: (value: CubeTexture, uvNode?: NodeRepresentation, levelNode?: NodeRepresentation, biasNode?: NodeRepresentation) => ShaderNodeObject<CubeTextureNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		cubeTexture: typeof cubeTexture;
+	}
+}

package/three/src/nodes/accessors/InstanceNode.d.ts

@@ -0,0 +1,13 @@
+import { InstancedMesh } from '../../objects/InstancedMesh.js';
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class InstanceNode extends Node {
+	instanceMesh: InstancedMesh;
+	instanceMatrixNode: Node | null;
+	instanceColorNode: Node | null;
+
+	constructor(instanceMesh: InstancedMesh);
+}
+
+export const instance: (instanceMesh: InstancedMesh) => ShaderNodeObject<InstanceNode>;

package/three/src/nodes/accessors/MaterialNode.d.ts

@@ -0,0 +1,130 @@
+import { Vector2 } from '../../math/Vector2.js';
+import Node from '../core/Node.js';
+import UniformNode from '../core/UniformNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export type MaterialNodeScope =
+	| typeof MaterialNode.ALPHA_TEST
+	| typeof MaterialNode.COLOR
+	| typeof MaterialNode.OPACITY
+	| typeof MaterialNode.SHININESS
+	| typeof MaterialNode.SPECULAR
+	| typeof MaterialNode.SPECULAR_STRENGTH
+	| typeof MaterialNode.SPECULAR_INTENSITY
+	| typeof MaterialNode.SPECULAR_COLOR
+	| typeof MaterialNode.REFLECTIVITY
+	| typeof MaterialNode.ROUGHNESS
+	| typeof MaterialNode.METALNESS
+	| typeof MaterialNode.NORMAL
+	| typeof MaterialNode.CLEARCOAT
+	| typeof MaterialNode.CLEARCOAT_ROUGHNESS
+	| typeof MaterialNode.CLEARCOAT_NORMAL
+	| typeof MaterialNode.EMISSIVE
+	| typeof MaterialNode.ROTATION
+	| typeof MaterialNode.SHEEN
+	| typeof MaterialNode.SHEEN_ROUGHNESS
+	| typeof MaterialNode.ANISOTROPY
+	| typeof MaterialNode.IRIDESCENCE
+	| typeof MaterialNode.IRIDESCENCE_IOR
+	| typeof MaterialNode.IRIDESCENCE_THICKNESS
+	| typeof MaterialNode.IOR
+	| typeof MaterialNode.TRANSMISSION
+	| typeof MaterialNode.THICKNESS
+	| typeof MaterialNode.ATTENUATION_DISTANCE
+	| typeof MaterialNode.ATTENUATION_COLOR
+	| typeof MaterialNode.LINE_SCALE
+	| typeof MaterialNode.LINE_DASH_SIZE
+	| typeof MaterialNode.LINE_GAP_SIZE
+	| typeof MaterialNode.LINE_WIDTH
+	| typeof MaterialNode.LINE_DASH_OFFSET
+	| typeof MaterialNode.POINT_WIDTH
+	| typeof MaterialNode.DISPERSION
+	| typeof MaterialNode.LIGHT_MAP
+	| typeof MaterialNode.AO_MAP
+	| typeof MaterialNode.REFRACTION_RATIO;
+
+export default class MaterialNode extends Node {
+	static ALPHA_TEST: 'alphaTest';
+	static COLOR: 'color';
+	static OPACITY: 'opacity';
+	static SHININESS: 'shininess';
+	static SPECULAR: 'specular';
+	static SPECULAR_STRENGTH: 'specularStrength';
+	static SPECULAR_INTENSITY: 'specularIntensity';
+	static SPECULAR_COLOR: 'specularColor';
+	static REFLECTIVITY: 'reflectivity';
+	static ROUGHNESS: 'roughness';
+	static METALNESS: 'metalness';
+	static NORMAL: 'normal';
+	static CLEARCOAT: 'clearcoat';
+	static CLEARCOAT_ROUGHNESS: 'clearcoatRoughness';
+	static CLEARCOAT_NORMAL: 'clearcoatNormal';
+	static EMISSIVE: 'emissive';
+	static ROTATION: 'rotation';
+	static SHEEN: 'sheen';
+	static SHEEN_ROUGHNESS: 'sheenRoughness';
+	static ANISOTROPY: 'anisotropy';
+	static IRIDESCENCE: 'iridescence';
+	static IRIDESCENCE_IOR: 'iridescenceIOR';
+	static IRIDESCENCE_THICKNESS: 'iridescenceThickness';
+	static IOR: 'ior';
+	static TRANSMISSION: 'transmission';
+	static THICKNESS: 'thickness';
+	static ATTENUATION_DISTANCE: 'attenuationDistance';
+	static ATTENUATION_COLOR: 'attenuationColor';
+	static LINE_SCALE: 'scale';
+	static LINE_DASH_SIZE: 'dashSize';
+	static LINE_GAP_SIZE: 'gapSize';
+	static LINE_WIDTH: 'linewidth';
+	static LINE_DASH_OFFSET: 'dashOffset';
+	static POINT_WIDTH: 'pointWidth';
+	static DISPERSION: 'dispersion';
+	static LIGHT_MAP: 'light';
+	static AO_MAP: 'ao';
+	static REFRACTION_RATIO: 'refractionRatio';
+
+	scope: MaterialNodeScope;
+	constructor(scope?: MaterialNodeScope);
+}
+
+export const materialAlphaTest: ShaderNodeObject<MaterialNode>;
+export const materialColor: ShaderNodeObject<MaterialNode>;
+export const materialShininess: ShaderNodeObject<MaterialNode>;
+export const materialEmissive: ShaderNodeObject<MaterialNode>;
+export const materialOpacity: ShaderNodeObject<MaterialNode>;
+export const materialSpecular: ShaderNodeObject<MaterialNode>;
+
+export const materialSpecularIntensity: ShaderNodeObject<MaterialNode>;
+export const materialSpecularColor: ShaderNodeObject<MaterialNode>;
+
+export const materialSpecularStrength: ShaderNodeObject<MaterialNode>;
+export const materialReflectivity: ShaderNodeObject<MaterialNode>;
+export const materialRoughness: ShaderNodeObject<MaterialNode>;
+export const materialMetalness: ShaderNodeObject<MaterialNode>;
+export const materialNormal: ShaderNodeObject<MaterialNode>;
+export const materialClearcoat: ShaderNodeObject<MaterialNode>;
+export const materialClearcoatRoughness: ShaderNodeObject<MaterialNode>;
+export const materialClearcoatNormal: ShaderNodeObject<MaterialNode>;
+export const materialRotation: ShaderNodeObject<MaterialNode>;
+export const materialSheen: ShaderNodeObject<MaterialNode>;
+export const materialSheenRoughness: ShaderNodeObject<MaterialNode>;
+export const materialAnisotropy: ShaderNodeObject<MaterialNode>;
+export const materialIridescence: ShaderNodeObject<MaterialNode>;
+export const materialIridescenceIOR: ShaderNodeObject<MaterialNode>;
+export const materialIridescenceThickness: ShaderNodeObject<MaterialNode>;
+export const materialTransmission: ShaderNodeObject<MaterialNode>;
+export const materialThickness: ShaderNodeObject<MaterialNode>;
+export const materialIOR: ShaderNodeObject<MaterialNode>;
+export const materialAttenuationDistance: ShaderNodeObject<MaterialNode>;
+export const materialAttenuationColor: ShaderNodeObject<MaterialNode>;
+export const materialLineScale: ShaderNodeObject<MaterialNode>;
+export const materialLineDashSize: ShaderNodeObject<MaterialNode>;
+export const materialLineGapSize: ShaderNodeObject<MaterialNode>;
+export const materialLineWidth: ShaderNodeObject<MaterialNode>;
+export const materialLineDashOffset: ShaderNodeObject<MaterialNode>;
+export const materialPointWidth: ShaderNodeObject<MaterialNode>;
+export const materialDispersion: ShaderNodeObject<MaterialNode>;
+export const materialLightMap: ShaderNodeObject<MaterialNode>;
+export const materialAOMap: ShaderNodeObject<MaterialNode>;
+export const materialRefractionRatio: ShaderNodeObject<MaterialNode>;
+export const materialAnisotropyVector: ShaderNodeObject<UniformNode<Vector2>>;

package/three/src/nodes/accessors/MaterialReferenceNode.d.ts

@@ -0,0 +1,9 @@
+import { Material } from '../../materials/Material.js';
+import { NodeOrType, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import ReferenceNode from './ReferenceNode.js';
+
+export default class MaterialReferenceNode extends ReferenceNode<Material | null> {
+	constructor(property: string, inputType: string, material?: Material | null);
+}
+
+export const materialReference: (name: string, nodeOrType: NodeOrType, material?: Material | null) => ShaderNodeObject<MaterialReferenceNode>;

package/three/src/nodes/accessors/ModelNode.d.ts

@@ -0,0 +1,20 @@
+import { Matrix4 } from '../../math/Matrix4.js';
+import { UniformNode } from '../Nodes.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Object3DNode from './Object3DNode.js';
+
+/**
+ * Similar to {@link Object3DNode} but the object comes from {@link NodeFrame}
+ */
+export default class ModelNode extends Object3DNode {
+	constructor(scope?: string);
+}
+
+export const modelDirection: ShaderNodeObject<ModelNode>;
+export const modelViewMatrix: ShaderNodeObject<ModelNode>;
+export const modelNormalMatrix: ShaderNodeObject<ModelNode>;
+export const modelWorldMatrix: ShaderNodeObject<ModelNode>;
+export const modelPosition: ShaderNodeObject<ModelNode>;
+export const modelScale: ShaderNodeObject<ModelNode>;
+export const modelViewPosition: ShaderNodeObject<ModelNode>;
+export const modelWorldMatrixInverse: ShaderNodeObject<UniformNode<Matrix4>>;

package/three/src/nodes/accessors/ModelViewProjectionNode.d.ts

@@ -0,0 +1,8 @@
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class ModelViewProjectionNode extends Node {
+	constructor(positionNode?: Node);
+}
+
+export const modelViewProjection: (position?: NodeRepresentation) => ShaderNodeObject<ModelViewProjectionNode>;

package/three/src/nodes/accessors/NormalNode.d.ts

@@ -0,0 +1,12 @@
+import AttributeNode from '../core/AttributeNode.js';
+import PropertyNode from '../core/PropertyNode.js';
+import VarNode from '../core/VarNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export const normalGeometry: ShaderNodeObject<AttributeNode>;
+export const normalLocal: ShaderNodeObject<VarNode>;
+export const normalView: ShaderNodeObject<VarNode>;
+export const normalWorld: ShaderNodeObject<VarNode>;
+export const transformedNormalView: ShaderNodeObject<PropertyNode>;
+export const transformedNormalWorld: ShaderNodeObject<VarNode>;
+export const transformedClearcoatNormalView: ShaderNodeObject<PropertyNode>;

package/three/src/nodes/accessors/Object3DNode.d.ts

@@ -0,0 +1,26 @@
+import { Object3D } from '../../core/Object3D.js';
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class Object3DNode extends Node {
+	scope: string;
+	object3d: Object3D | null;
+
+	constructor(scope?: string, object3d?: Object3D | null);
+
+	static VIEW_MATRIX: 'viewMatrix';
+	static NORMAL_MATRIX: 'normalMatrix';
+	static WORLD_MATRIX: 'worldMatrix';
+	static POSITION: 'position';
+	static SCALE: 'scale';
+	static VIEW_POSITION: 'viewPosition';
+	static DIRECTION: 'direction';
+}
+
+export const objectDirection: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;
+export const objectViewMatrix: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;
+export const objectNormalMatrix: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;
+export const objectWorldMatrix: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;
+export const objectPosition: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;
+export const objectScale: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;
+export const objectViewPosition: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;

package/three/src/nodes/accessors/PointUVNode.d.ts

@@ -0,0 +1,10 @@
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class PointUVNode extends Node {
+	isPointUVNode: true;
+
+	constructor();
+}
+
+export const pointUV: ShaderNodeObject<PointUVNode>;

package/three/src/nodes/accessors/PositionNode.d.ts

@@ -0,0 +1,9 @@
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export const positionGeometry: ShaderNodeObject<Node>;
+export const positionLocal: ShaderNodeObject<Node>;
+export const positionWorld: ShaderNodeObject<Node>;
+export const positionWorldDirection: ShaderNodeObject<Node>;
+export const positionView: ShaderNodeObject<Node>;
+export const positionViewDirection: ShaderNodeObject<Node>;

package/three/src/nodes/accessors/ReferenceNode.d.ts

@@ -0,0 +1,22 @@
+import Node from '../core/Node.js';
+import { NodeOrType, NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class ReferenceNode<T> extends Node {
+	property: string;
+
+	uniformType: string;
+
+	object: T;
+	count: number | null;
+
+	properties: string[];
+	reference: T | null;
+	node: Node | null;
+
+	constructor(property: string, uniformType: string, object?: T | null, count?: number | null);
+
+	setNodeType(uniformType: string): void;
+}
+
+export const reference: <T>(name: string, nodeOrType: NodeOrType, object: T) => ShaderNodeObject<ReferenceNode<T>>;
+export const referenceBuffer: <T>(name: string, nodeOrType: NodeOrType, count: NodeRepresentation, object: T) => ShaderNodeObject<ReferenceNode<T>>;