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

package/three/src/nodes/shadernode/ShaderNode.d.ts

@@ -0,0 +1,226 @@
+import ConstNode from '../core/ConstNode.js';
+import Node from '../core/Node.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+import StackNode from '../core/StackNode.js';
+
+export interface NodeElements {
+	toGlobal: (node: Node) => Node;
+
+	append: typeof append;
+
+	toColor: typeof color;
+	toFloat: typeof float;
+	toInt: typeof int;
+	toUint: typeof uint;
+	toBool: typeof bool;
+	toVec2: typeof vec2;
+	toIvec2: typeof ivec2;
+	toUvec2: typeof uvec2;
+	toBvec2: typeof bvec2;
+	toVec3: typeof vec3;
+	toIvec3: typeof ivec3;
+	toUvec3: typeof uvec3;
+	toBvec3: typeof bvec3;
+	toVec4: typeof vec4;
+	toIvec4: typeof ivec4;
+	toUvec4: typeof uvec4;
+	toBvec4: typeof bvec4;
+	toMat2: typeof mat2;
+	toImat2: typeof imat2;
+	toUmat2: typeof umat2;
+	toBmat2: typeof bmat2;
+	toMat3: typeof mat3;
+	toImat3: typeof imat3;
+	toUmat3: typeof umat3;
+	toBmat3: typeof bmat3;
+	toMat4: typeof mat4;
+	toImat4: typeof imat4;
+	toUmat4: typeof umat4;
+	toBmat4: typeof bmat4;
+
+	element: typeof element;
+	convert: typeof convert;
+}
+
+export function addNodeElement(name: string, nodeElement: unknown): void;
+
+export type SwizzleCharacter = 'x' | 'y' | 'z' | 'w' | 'r' | 'g' | 'b' | 'a' | 's' | 't' | 'p' | 'q';
+
+export type SwizzleOption = Exclude<`${SwizzleCharacter}` | `${SwizzleCharacter}${SwizzleCharacter}` | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}` | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`, 'abs' | 'sqrt'>;
+
+export type Swizzable<T extends Node = Node> = T & {
+	[key in SwizzleOption | number]: ShaderNodeObject<Node>;
+};
+
+export type ShaderNodeObject<T extends Node> = T & {
+	[Key in keyof NodeElements]: T extends { [K in Key]: infer M } ? M : NodeElements[Key] extends (node: T, ...args: infer Args) => infer R ? (...args: Args) => R : never;
+} & {
+	[Key in keyof NodeElements as `${Key}Assign`]: T extends { [K in Key]: infer M } ? M : NodeElements[Key] extends (node: T, ...args: infer Args) => unknown ? (...args: Args) => ShaderNodeObject<T> : never;
+} & Swizzable<T>;
+
+/** anything that can be passed to {@link nodeObject} and returns a proxy */
+export type NodeRepresentation<T extends Node = Node> = number | boolean | Node | ShaderNodeObject<T>;
+
+/** anything that can be passed to {@link nodeObject} */
+export type NodeObjectOption = NodeRepresentation | string;
+
+// same logic as in ShaderNodeObject: number,boolean,node->ShaderNodeObject, otherwise do nothing
+export type NodeObject<T> = T extends Node ? ShaderNodeObject<T> : T extends number | boolean ? ShaderNodeObject<ConstNode<number | boolean>> : T;
+
+// opposite of NodeObject: node -> node|ShaderNodeObject|boolean|number, otherwise do nothing
+type Proxied<T> = T extends Node ? NodeRepresentation<T> : T;
+// https://github.com/microsoft/TypeScript/issues/42435#issuecomment-765557874
+export type ProxiedTuple<T extends readonly [...unknown[]]> = [...{ [index in keyof T]: Proxied<T[index]> }];
+export type ProxiedObject<T> = { [index in keyof T]: Proxied<T[index]> };
+type RemoveTail<T extends readonly [...unknown[]]> = T extends [unknown, ...infer X] ? X : [];
+type RemoveHeadAndTail<T extends readonly [...unknown[]]> = T extends [unknown, ...infer X, unknown] ? X : [];
+
+/**
+ * Temporary type to save signatures of 4 constructors. Each element may be tuple or undefined.
+ *
+ * We use an object instead of tuple or union as it makes stuff easier, especially in Typescript 4.0.
+ */
+interface Construtors<A extends undefined | [...unknown[]], B extends undefined | [...unknown[]], C extends undefined | [...unknown[]], D extends undefined | [...unknown[]]> {
+	a: A;
+	b: B;
+	c: C;
+	d: D;
+}
+
+/**
+ * Returns all constructors
+ *
+ * <https://github.com/microsoft/TypeScript/issues/37079>
+ * <https://stackoverflow.com/a/52761156/1623826>
+ */
+type OverloadedConstructorsOf<T> = T extends {
+	new (...args: infer A1): unknown;
+	new (...args: infer A2): unknown;
+	new (...args: infer A3): unknown;
+	new (...args: infer A4): unknown;
+}
+	? Construtors<A1, A2, A3, A4>
+	: T extends {
+			new (...args: infer A1): unknown;
+			new (...args: infer A2): unknown;
+			new (...args: infer A3): unknown;
+	  }
+	? Construtors<A1, A2, A3, undefined>
+	: T extends {
+			new (...args: infer A1): unknown;
+			new (...args: infer A2): unknown;
+	  }
+	? Construtors<A1, A2, undefined, undefined>
+	: T extends new (...args: infer A) => unknown
+	? Construtors<A, undefined, undefined, undefined>
+	: Construtors<undefined, undefined, undefined, undefined>;
+
+type AnyConstructors = Construtors<any, any, any, any>;
+
+/**
+ * Returns all constructors where the first paramter is assignable to given "scope"
+ */
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+type FilterConstructorsByScope<T extends AnyConstructors, S> = {
+	a: S extends T['a'][0] ? T['a'] : undefined;
+	b: S extends T['b'][0] ? T['b'] : undefined;
+	c: S extends T['c'][0] ? T['c'] : undefined;
+	d: S extends T['d'][0] ? T['d'] : undefined;
+};
+/**
+ * "flattens" the tuple into an union type
+ */
+type ConstructorUnion<T extends AnyConstructors> = Exclude<T['a'], undefined> | Exclude<T['b'], undefined> | Exclude<T['c'], undefined> | Exclude<T['d'], undefined>;
+
+/**
+ * Extract list of possible scopes - union of the first paramter
+ * of all constructors, should it be string
+ */
+type ExtractScopes<T extends AnyConstructors> = (T['a'][0] extends string ? T['a'][0] : never) | (T['b'][0] extends string ? T['b'][0] : never) | (T['c'][0] extends string ? T['c'][0] : never) | (T['d'][0] extends string ? T['d'][0] : never);
+
+type GetConstructorsByScope<T, S> = ConstructorUnion<FilterConstructorsByScope<OverloadedConstructorsOf<T>, S>>;
+type GetConstructors<T> = ConstructorUnion<OverloadedConstructorsOf<T>>;
+type GetPossibleScopes<T> = ExtractScopes<OverloadedConstructorsOf<T>>;
+
+export type ConvertType = (...params: unknown[]) => ShaderNodeObject<Node>;
+
+type NodeArray<T extends NodeObjectOption[]> = { [index in keyof T]: NodeObject<T[index]> };
+type NodeObjects<T> = { [key in keyof T]: T[key] extends NodeObjectOption ? NodeObject<T[key]> : T[key] };
+type ConstructedNode<T> = T extends new (...args: any[]) => infer R ? (R extends Node ? R : never) : never;
+
+export type NodeOrType = Node | string;
+
+export const getConstNodeType: (value: NodeOrType) => string | null;
+
+export class ShaderNode<T = {}, R extends Node = Node> {
+	constructor(jsFunc: (inputs: NodeObjects<T>, builder: NodeBuilder) => NodeRepresentation);
+	call: (inputs: { [key in keyof T]: T[key] extends NodeRepresentation ? ShaderNodeObject<Node> | Node : T[key] }, builder?: NodeBuilder) => ShaderNodeObject<R>;
+}
+
+export function nodeObject<T extends NodeObjectOption>(obj: T): NodeObject<T>;
+export function nodeObjects<T>(obj: T): NodeObjects<T>;
+
+export function nodeArray<T extends NodeObjectOption[]>(obj: readonly [...T]): NodeArray<T>;
+
+export function nodeProxy<T>(nodeClass: T): (...params: ProxiedTuple<GetConstructors<T>>) => ShaderNodeObject<ConstructedNode<T>>;
+
+export function nodeProxy<T, S extends GetPossibleScopes<T>>(nodeClass: T, scope: S): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
+
+export function nodeProxy<T, S extends GetPossibleScopes<T>>(nodeClass: T, scope: S, factor: NodeObjectOption): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
+
+export function nodeImmutable<T>(nodeClass: T, ...params: ProxiedTuple<GetConstructors<T>>): ShaderNodeObject<ConstructedNode<T>>;
+
+export function tslFn<R extends Node = ShaderNodeObject<Node>>(jsFunc: () => R): () => R;
+export function tslFn<T extends any[], R extends Node = ShaderNodeObject<Node>>(jsFunc: (args: T) => R): (...args: ProxiedTuple<T>) => R;
+export function tslFn<T extends { [key: string]: unknown }, R extends Node = ShaderNodeObject<Node>>(jsFunc: (args: T) => R): (args: ProxiedObject<T>) => R;
+
+export const setCurrentStack: (stack: StackNode | null) => void;
+
+export const getCurrentStack: () => StackNode | null;
+
+export const If: (boolNode: Node, method: () => void) => void;
+
+export function append(node: Node): Node;
+
+export const color: ConvertType;
+
+export const float: ConvertType;
+export const int: ConvertType;
+export const uint: ConvertType;
+export const bool: ConvertType;
+
+export const vec2: ConvertType;
+export const ivec2: ConvertType;
+export const uvec2: ConvertType;
+export const bvec2: ConvertType;
+
+export const vec3: ConvertType;
+export const ivec3: ConvertType;
+export const uvec3: ConvertType;
+export const bvec3: ConvertType;
+
+export const vec4: ConvertType;
+export const ivec4: ConvertType;
+export const uvec4: ConvertType;
+export const bvec4: ConvertType;
+
+export const mat2: ConvertType;
+export const imat2: ConvertType;
+export const umat2: ConvertType;
+export const bmat2: ConvertType;
+
+export const mat3: ConvertType;
+export const imat3: ConvertType;
+export const umat3: ConvertType;
+export const bmat3: ConvertType;
+
+export const mat4: ConvertType;
+export const imat4: ConvertType;
+export const umat4: ConvertType;
+export const bmat4: ConvertType;
+
+export const string: (value?: string) => ShaderNodeObject<ConstNode<string>>;
+export const arrayBuffer: (value: ArrayBuffer) => ShaderNodeObject<ConstNode<ArrayBuffer>>;
+
+export const element: (node: NodeRepresentation, indexNode: NodeRepresentation) => ShaderNodeObject<Node>;
+export const convert: (node: NodeRepresentation, types: string) => ShaderNodeObject<Node>;

package/three/src/nodes/utils/ArrayElementNode.d.ts

@@ -0,0 +1,9 @@
+import Node from '../core/Node.js';
+import { TempNode } from '../Nodes.js';
+
+export default class ArrayElementNode extends TempNode {
+	node: Node;
+	indexNode: Node;
+
+	constructor(node: Node, indexNode: Node);
+}

package/three/src/nodes/utils/ConvertNode.d.ts

@@ -0,0 +1,7 @@
+import Node from '../core/Node.js';
+
+export default class ConvertNode extends Node {
+	node: Node;
+	convertTo: string;
+	constructor(node: Node, convertTo: string);
+}

package/three/src/nodes/utils/DiscardNode.d.ts

@@ -0,0 +1,17 @@
+import Node from '../core/Node.js';
+import CondNode from '../math/CondNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class DiscardNode extends CondNode {
+	constructor(condNode: Node);
+}
+
+export const inlineDiscard: (condNode: NodeRepresentation) => ShaderNodeObject<DiscardNode>;
+export const discard: (condNode: NodeRepresentation) => ShaderNodeObject<Node>;
+export const Return: (condNode: NodeRepresentation) => ShaderNodeObject<Node>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		discard: typeof discard;
+	}
+}

package/three/src/nodes/utils/EquirectUVNode.d.ts

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

package/three/src/nodes/utils/JoinNode.d.ts

@@ -0,0 +1,10 @@
+import Node from '../core/Node.js';
+import { TempNode } from '../Nodes.js';
+
+/**
+ * This node constructs given type from elements, like vec3(a,b,c)
+ */
+export default class JoinNode extends TempNode {
+	nodes: Node[];
+	constructor(nodes: Node[]);
+}

package/three/src/nodes/utils/MatcapUVNode.d.ts

@@ -0,0 +1,8 @@
+import TempNode from '../core/TempNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class MatcapUVNode extends TempNode {
+	constructor();
+}
+
+export const matcapUV: ShaderNodeObject<MatcapUVNode>;

package/three/src/nodes/utils/MaxMipLevelNode.d.ts

@@ -0,0 +1,14 @@
+import { Texture } from '../../textures/Texture.js';
+import TextureNode from '../accessors/TextureNode.js';
+import UniformNode from '../core/UniformNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class MaxMipLevelNode extends UniformNode<0> {
+	constructor(textureNode: TextureNode);
+
+	get textureNode(): TextureNode;
+
+	get texture(): Texture;
+}
+
+export const maxMipLevel: (texture: Texture) => ShaderNodeObject<MaxMipLevelNode>;

package/three/src/nodes/utils/OscNode.d.ts

@@ -0,0 +1,21 @@
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export type OscNodeMethod = typeof OscNode.SINE | typeof OscNode.SQUARE | typeof OscNode.TRIANGLE | typeof OscNode.SAWTOOTH;
+
+export default class OscNode extends Node {
+	static SINE: 'sine';
+	static SQUARE: 'square';
+	static TRIANGLE: 'triangle';
+	static SAWTOOTH: 'sawtooth';
+
+	method: OscNodeMethod;
+	timeNode: Node;
+
+	constructor(method: OscNodeMethod, timeNode?: Node);
+}
+
+export const oscSine: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;
+export const oscSquare: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;
+export const oscTriangle: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;
+export const oscSawtooth: (timeNode?: NodeRepresentation) => ShaderNodeObject<OscNode>;

package/three/src/nodes/utils/PackingNode.d.ts

@@ -0,0 +1,24 @@
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export type PackingNodeScope = typeof PackingNode.DIRECTION_TO_COLOR | typeof PackingNode.COLOR_TO_DIRECTION;
+
+declare class PackingNode extends TempNode {
+	constructor(scope: PackingNodeScope, node: Node);
+
+	static DIRECTION_TO_COLOR: 'directionToColor';
+	static COLOR_TO_DIRECTION: 'colorToDirection';
+}
+
+export default PackingNode;
+
+export const directionToColor: (node: NodeRepresentation) => ShaderNodeObject<PackingNode>;
+export const colorToDirection: (node: NodeRepresentation) => ShaderNodeObject<PackingNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		directionToColor: typeof directionToColor;
+		colorToDirection: typeof colorToDirection;
+	}
+}

package/three/src/nodes/utils/RTTNode.d.ts

@@ -0,0 +1,40 @@
+import { TextureDataType } from '../../constants.js';
+import { RenderTarget } from '../../core/RenderTarget.js';
+import TextureNode from '../accessors/TextureNode.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export interface RTTNodeOptions {
+	type: TextureDataType;
+}
+
+declare class RTTNode extends TextureNode {
+	node: Node;
+	width: number | null;
+	height: number | null;
+
+	renderTarget: RenderTarget | null;
+
+	textureNeedsUpdate: boolean;
+	autoUpdate: boolean;
+
+	pixelRatio?: number;
+
+	constructor(node: Node, width?: number | null, height?: number | null, options?: RTTNodeOptions);
+
+	get autoSize(): boolean;
+
+	setSize(width: number | null, height: number | null): void;
+
+	setPixelRatio(pixelRatio: number): void;
+}
+
+export default RTTNode;
+
+export const rtt: (node: NodeRepresentation, width?: number | null, height?: number | null, options?: RTTNodeOptions) => ShaderNodeObject<RTTNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		toTexture: typeof rtt;
+	}
+}

package/three/src/nodes/utils/ReflectorNode.d.ts

@@ -0,0 +1,32 @@
+import { Camera } from '../../cameras/Camera.js';
+import { Object3D } from '../../core/Object3D.js';
+import { RenderTarget } from '../../core/RenderTarget.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export interface ReflectorNodeParameters {
+	target?: Object3D | undefined;
+	resolution?: number | undefined;
+	generateMipmaps?: boolean | undefined;
+	bounces?: boolean | undefined;
+}
+
+export default class ReflectorNode extends TextureNode {
+	target: Object3D;
+	resolution: number;
+	generateMipmaps: boolean;
+	bounces: boolean;
+
+	virtualCameras: WeakMap<Camera, Camera>;
+	renderTargets: WeakMap<Camera, RenderTarget>;
+
+	constructor(parameters?: ReflectorNodeParameters);
+
+	getTextureNode(): TextureNode;
+
+	getVirtualCamera(camera: Camera): Camera;
+
+	getRenderTarget(camera: Camera): RenderTarget;
+}
+
+export const reflector: (parameters?: ReflectorNodeParameters) => ShaderNodeObject<ReflectorNode>;

package/three/src/nodes/utils/RemapNode.d.ts

@@ -0,0 +1,24 @@
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class RemapNode extends Node {
+	node: Node;
+	inLowNode: Node;
+	inHighNode: Node;
+	outLowNode: Node;
+	outHighNode: Node;
+
+	doClamp: boolean;
+
+	constructor(node: Node, inLowNode: Node, inHighNode: Node, outLowNode?: Node, outHighNode?: Node);
+}
+
+export const remap: (node: Node, inLowNode: NodeRepresentation, inHighNode: NodeRepresentation, outLowNode?: NodeRepresentation, outHighNode?: NodeRepresentation) => ShaderNodeObject<RemapNode>;
+export const remapClamp: (node: Node, inLowNode: NodeRepresentation, inHighNode: NodeRepresentation, outLowNode?: NodeRepresentation, outHighNode?: NodeRepresentation) => ShaderNodeObject<RemapNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		remap: typeof remap;
+		remapClamp: typeof remapClamp;
+	}
+}

package/three/src/nodes/utils/RotateNode.d.ts

@@ -0,0 +1,18 @@
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class RotateNode extends TempNode {
+	positionNode: Node;
+	rotationNode: Node;
+
+	constructor(positionNode: Node, rotationNode: Node);
+}
+
+export const rotate: (positionNode: NodeRepresentation, rotationNode: NodeRepresentation) => ShaderNodeObject<RotateNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		rotate: typeof rotate;
+	}
+}

package/three/src/nodes/utils/RotateUVNode.d.ts

@@ -0,0 +1,19 @@
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class RotateUVNode extends TempNode {
+	uvNode: Node;
+	rotationNode: Node;
+	centerNode: Node;
+
+	constructor(uvNode: Node, rotationNode: Node, centerNode?: Node);
+}
+
+export const rotateUV: (uvNode: Node, rotationNode: Node, centerNode?: Node) => ShaderNodeObject<RotateUVNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		rotateUV: typeof rotateUV;
+	}
+}

package/three/src/nodes/utils/SplitNode.d.ts

@@ -0,0 +1,15 @@
+import Node from '../core/Node.js';
+import { SwizzleOption } from '../shadernode/ShaderNode.js';
+
+/** swizzle node */
+export default class SplitNode extends Node {
+	node: Node;
+	components: string;
+
+	/**
+	 * @param node the input node
+	 * @param components swizzle like string, default = "x"
+	 */
+	constructor(node: Node, components?: SwizzleOption);
+	getVectorLength(): number;
+}

package/three/src/nodes/utils/SpriteSheetUVNode.d.ts

@@ -0,0 +1,12 @@
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class SpriteSheetUVNode extends Node {
+	countNode: Node;
+	uvNode: Node;
+	frameNode: Node;
+
+	constructor(countNode: Node, uvNode?: Node, frameNode?: Node);
+}
+
+export const spritesheetUV: (countNode: NodeRepresentation, uvNode?: NodeRepresentation, frameNode?: NodeRepresentation) => ShaderNodeObject<SpriteSheetUVNode>;

package/three/src/nodes/utils/StoargeArrayElementNode.d.ts

@@ -0,0 +1,22 @@
+import StorageBufferNode from '../accessors/StorageBufferNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import ArrayElementNode from './ArrayElementNode.js';
+
+export default class StorageArrayElementNode extends ArrayElementNode {
+	node: StorageBufferNode;
+
+	readonly isStorageArrayElementNode: true;
+
+	constructor(storageBufferNode: StorageBufferNode, indexNode: Node);
+
+	get storageBufferNode(): StorageBufferNode;
+	set storageBufferNode(value: StorageBufferNode);
+}
+
+export const storageElement: (storageBufferNode: NodeRepresentation, indexNode: NodeRepresentation) => ShaderNodeObject<StorageArrayElementNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		storageElement: typeof storageElement;
+	}
+}

package/three/src/nodes/utils/TimerNode.d.ts

@@ -0,0 +1,21 @@
+import UniformNode from '../core/UniformNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export type TimerNodeScope = typeof TimerNode.LOCAL | typeof TimerNode.GLOBAL | typeof TimerNode.DELTA | typeof TimerNode.FRAME;
+
+export default class TimerNode extends UniformNode<number> {
+	static LOCAL: 'local';
+	static GLOBAL: 'global';
+	static DELTA: 'delta';
+	static FRAME: 'frame';
+
+	scope: TimerNodeScope;
+	scale: number;
+
+	constructor(scope?: TimerNodeScope, scale?: number, value?: number);
+}
+
+export const timerLocal: (timeScale?: number, value?: number) => ShaderNodeObject<TimerNode>;
+export const timerGlobal: (timeScale?: number, value?: number) => ShaderNodeObject<TimerNode>;
+export const timerDelta: (timeScale?: number, value?: number) => ShaderNodeObject<TimerNode>;
+export const frameId: ShaderNodeObject<TimerNode>;

package/three/src/nodes/utils/TriplanarTexturesNode.d.ts

@@ -0,0 +1,25 @@
+import TextureNode from '../accessors/TextureNode.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class TriplanarTexturesNode extends Node {
+	textureXNode: TextureNode;
+	textureYNode: TextureNode | null;
+	textureZNode: TextureNode | null;
+
+	scaleNode: ShaderNodeObject<Node>;
+
+	positionNode: ShaderNodeObject<Node>;
+	normalNode: ShaderNodeObject<Node>;
+
+	constructor(textureXNode: Node, textureYNode?: TextureNode | null, textureZNode?: TextureNode | null, scaleNode?: ShaderNodeObject<Node>, positionNode?: ShaderNodeObject<Node>, normalNode?: ShaderNodeObject<Node>);
+}
+
+export const triplanarTextures: (textureXNode: NodeRepresentation, textureYNode?: NodeRepresentation, textureZNode?: NodeRepresentation, scaleNode?: NodeRepresentation, positionNode?: NodeRepresentation, normalNode?: NodeRepresentation) => ShaderNodeObject<TriplanarTexturesNode>;
+export const triplanarTexture: (texture: NodeRepresentation, ...params: NodeRepresentation[]) => ShaderNodeObject<TriplanarTexturesNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		triplanarTexture: typeof triplanarTexture;
+	}
+}