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

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

@@ -0,0 +1,9 @@
+import Node from '../core/Node.js';
+import VarNode from '../core/VarNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export const reflectView: ShaderNodeObject<Node>;
+export const refractView: ShaderNodeObject<Node>;
+
+export const reflectVector: ShaderNodeObject<VarNode>;
+export const refractVector: ShaderNodeObject<VarNode>;

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

@@ -0,0 +1,11 @@
+import Renderer from '../../renderers/common/Renderer.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import ReferenceNode from './ReferenceNode.js';
+
+export default class RendererReferenceNode extends ReferenceNode<Renderer> {
+	renderer: Renderer | null;
+
+	constructor(property: string, inputType: string, renderer?: Renderer | null);
+}
+
+export const rendererReference: (name: string, type: string, renderer?: Renderer | null) => ShaderNodeObject<RendererReferenceNode>;

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

@@ -0,0 +1,20 @@
+import { SkinnedMesh } from '../../objects/SkinnedMesh.js';
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class SkinningNode extends Node {
+	skinnedMesh: SkinnedMesh;
+	useReference: boolean;
+
+	skinIndexNode: Node;
+	skinWeightNode: Node;
+
+	bindMatrixNode: Node;
+	bindMatrixInverseNode: Node;
+	boneMatricesNode: Node;
+
+	constructor(skinnedMesh: SkinnedMesh, useReference?: boolean);
+}
+
+export const skinning: (skinnedMesh: SkinnedMesh) => ShaderNodeObject<SkinningNode>;
+export const skinningReference: (skinnedMesh: SkinnedMesh) => ShaderNodeObject<SkinningNode>;

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

@@ -0,0 +1,26 @@
+import StorageBufferAttribute from '../../renderers/common/StorageBufferAttribute.js';
+import StorageInstancedBufferAttribute from '../../renderers/common/StorageInstancedBufferAttribute.js';
+import { GPUBufferBindingType } from '../../renderers/webgpu/utils/WebGPUConstants.js';
+import { NodeOrType, NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import StorageArrayElementNode from '../utils/StoargeArrayElementNode.js';
+import BufferNode from './BufferNode.js';
+
+export default class StorageBufferNode extends BufferNode {
+	readonly isStorageBufferNode: true;
+	bufferObject: boolean;
+
+	access: GPUBufferBindingType;
+
+	constructor(value: StorageBufferAttribute | StorageInstancedBufferAttribute, bufferType: string, bufferCount?: number);
+
+	element(indexNode: NodeRepresentation): ShaderNodeObject<StorageArrayElementNode>;
+
+	setBufferObject(value: boolean): this;
+
+	setAccess(value: GPUBufferBindingType): this;
+
+	toReadOnly(): this;
+}
+
+export const storage: (value: StorageBufferAttribute | StorageInstancedBufferAttribute, nodeOrType: NodeOrType, count: number) => ShaderNodeObject<StorageBufferNode>;
+export const storageObject: (value: StorageBufferAttribute | StorageInstancedBufferAttribute, nodeOrType: NodeOrType, count: number) => ShaderNodeObject<StorageBufferNode>;

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

@@ -0,0 +1,28 @@
+import { GPUStorageTextureAccess } from '../../renderers/webgpu/utils/WebGPUConstants.js';
+import { Texture } from '../../textures/Texture.js';
+import Node from '../core/Node.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import TextureNode from './TextureNode.js';
+
+export default class StorageTextureNode extends TextureNode {
+	storeNode: Node | null;
+
+	readonly isStorageTextureNode: true;
+
+	access: GPUStorageTextureAccess;
+
+	constructor(value: Texture, uvNode?: ShaderNodeObject<Node> | null, storeNode?: Node | null);
+
+	setAccess(value: GPUStorageTextureAccess): this;
+
+	toReadOnly(): this;
+
+	toWriteOnly(): this;
+
+	generateStore(builder: NodeBuilder): void;
+}
+
+export const storageTexture: (value: Texture, uvNode?: NodeRepresentation, storeNode?: NodeRepresentation) => ShaderNodeObject<StorageTextureNode>;
+
+export const textureStore: (value: Texture, uvNode?: NodeRepresentation, storeNode?: NodeRepresentation) => ShaderNodeObject<StorageTextureNode>;

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

@@ -0,0 +1,12 @@
+import AttributeNode from '../core/AttributeNode.js';
+import VarNode from '../core/VarNode.js';
+import VaryingNode from '../core/VaryingNode.js';
+import MathNode from '../math/MathNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export const tangentGeometry: ShaderNodeObject<AttributeNode>;
+export const tangentLocal: ShaderNodeObject<VaryingNode>;
+export const tangentView: ShaderNodeObject<MathNode>;
+export const tangentWorld: ShaderNodeObject<MathNode>;
+export const transformedTangentView: ShaderNodeObject<VarNode>;
+export const transformedTangentWorld: ShaderNodeObject<MathNode>;

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

@@ -0,0 +1,13 @@
+import { CubeTexture } from '../../textures/CubeTexture.js';
+import { Texture } from '../../textures/Texture.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import TextureNode from './TextureNode.js';
+
+export default class Texture3DNode extends TextureNode {
+	readonly isTexture3DNode: true;
+
+	constructor(value: Texture, uvNode?: ShaderNodeObject<Node> | null, levelNode?: ShaderNodeObject<Node> | null);
+}
+
+export const texture3D: (value: Texture, uvNode?: NodeRepresentation, levelNode?: NodeRepresentation) => ShaderNodeObject<Texture3DNode>;

package/three/src/nodes/accessors/TextureBicubicNode.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 TextureBicubicNode extends TempNode {
+	textureNode: Node;
+	blurNode: Node;
+
+	constructor(textureNode: Node, blurNode?: Node);
+}
+
+export const textureBicubic: (textureNode: Node, blurNode?: NodeRepresentation) => ShaderNodeObject<TextureBicubicNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		bicubic: typeof textureBicubic;
+	}
+}

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

@@ -0,0 +1,37 @@
+import { Texture } from '../../textures/Texture.js';
+import Node from '../core/Node.js';
+import UniformNode from '../core/UniformNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class TextureNode extends UniformNode<Texture> {
+	readonly isTextureNode: true;
+
+	uvNode: ShaderNodeObject<Node> | null;
+	levelNode: ShaderNodeObject<Node> | null;
+	biasNode: ShaderNodeObject<Node> | null;
+	compareNode: Node | null;
+	depthNode: Node | null;
+	gradNode: Node | null;
+
+	sampler: boolean;
+	updateMatrix: boolean;
+
+	referenceNode: Node | null;
+
+	constructor(value: Texture, uvNode?: ShaderNodeObject<Node> | null, levelNode?: ShaderNodeObject<Node> | null, biasNode?: ShaderNodeObject<Node> | null);
+
+	getDefaultUV(): Node;
+
+	grad(gradeNodeX: NodeRepresentation, gradeNodeY: NodeRepresentation): ShaderNodeObject<Node>;
+
+	clone(): this;
+}
+
+export const texture: (value: Texture, uvNode?: NodeRepresentation, levelNode?: NodeRepresentation, biasNode?: NodeRepresentation) => ShaderNodeObject<TextureNode>;
+export const sampler: (aTexture: Texture | TextureNode) => ShaderNodeObject<Node>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		texture: typeof texture;
+	}
+}

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

@@ -0,0 +1,4 @@
+import AttributeNode from '../core/AttributeNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export const uv: (index?: number) => ShaderNodeObject<AttributeNode>;

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

@@ -0,0 +1,23 @@
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import ArrayElementNode from '../utils/ArrayElementNode.js';
+import BufferNode from './BufferNode.js';
+
+declare class UniformsElementNode extends ArrayElementNode {
+	constructor(arrayBuffer: Node, indexNode: Node);
+}
+
+export default class UniformsNode extends BufferNode {
+	array: unknown[];
+	elementType: string | null;
+
+	readonly isArrayBufferNode: true;
+
+	constructor(value: unknown[], elementType?: string | null);
+
+	getElementLength(): number;
+
+	element(indexNode: number): ShaderNodeObject<UniformsElementNode>;
+}
+
+export const uniforms: (values: unknown[], nodeType?: string | null) => ShaderNodeObject<UniformsNode>;

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

@@ -0,0 +1,11 @@
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import ReferenceNode from './ReferenceNode.js';
+
+export type NodeUserData = Record<string, any>;
+
+export default class UserDataNode extends ReferenceNode<NodeUserData> {
+	userData: NodeUserData | null;
+	constructor(property: string, inputType: string, userData?: NodeUserData | null);
+}
+
+export const userData: (name: string, inputType: string, userData?: NodeUserData) => ShaderNodeObject<UserDataNode>;

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

@@ -0,0 +1,12 @@
+import AttributeNode from '../core/AttributeNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class VertexColorNode extends AttributeNode {
+	readonly isVertexColorNode: true;
+
+	index: number;
+
+	constructor(index?: number);
+}
+
+export const vertexColor: (index?: number) => ShaderNodeObject<VertexColorNode>;

package/three/src/nodes/code/CodeNode.d.ts

@@ -0,0 +1,23 @@
+import Node from '../core/Node.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export interface CodeNodeInclude {
+	build(builder: NodeBuilder): void;
+}
+
+export default class CodeNode extends Node {
+	isCodeNode: true;
+	code: string;
+	language: string;
+
+	constructor(code?: string, includes?: CodeNodeInclude[], language?: string);
+
+	setIncludes(includes: CodeNodeInclude[]): this;
+	getIncludes(builder: NodeBuilder): CodeNodeInclude[];
+}
+
+export const code: (code: string, includes?: CodeNodeInclude[], language?: string) => ShaderNodeObject<CodeNode>;
+export const js: (src: string, includes?: CodeNodeInclude[]) => ShaderNodeObject<CodeNode>;
+export const wgsl: (src: string, includes?: CodeNodeInclude[]) => ShaderNodeObject<CodeNode>;
+export const glsl: (src: string, includes?: CodeNodeInclude[]) => ShaderNodeObject<CodeNode>;

package/three/src/nodes/code/ExpressionNode.d.ts

@@ -0,0 +1,9 @@
+import TempNode from '../core/TempNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class ExpressionNode extends TempNode {
+	snipped: string; /* sic */
+	constructor(snipped?: string, nodeType?: string);
+}
+
+export const expression: (snipped?: string, nodeType?: string) => ShaderNodeObject<ExpressionNode>;

package/three/src/nodes/code/FunctionCallNode.d.ts

@@ -0,0 +1,22 @@
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { ProxiedObject, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import FunctionNode, { FunctionNodeArguments } from './FunctionNode.js';
+
+export default class FunctionCallNode<P extends Node[] | { [name: string]: Node }> extends TempNode {
+	functionNode: FunctionNode<P>;
+	parameters: { [name: string]: Node };
+
+	constructor(functionNode?: FunctionNode<P>, parameters?: P);
+
+	setParameters(parameters: P): this;
+	getParameters(): P;
+}
+
+export const call: <P extends FunctionNodeArguments>(functionNode?: FunctionNode<P>, parameters?: ProxiedObject<P>) => ShaderNodeObject<FunctionCallNode<P>>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		call: typeof call;
+	}
+}

package/three/src/nodes/code/FunctionNode.d.ts

@@ -0,0 +1,38 @@
+import Node from '../core/Node.js';
+import NodeBuilder from '../core/NodeBuilder.js';
+import NodeFunction from '../core/NodeFunction.js';
+import NodeFunctionInput from '../core/NodeFunctionInput.js';
+import { ProxiedObject, ProxiedTuple, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import CodeNode, { CodeNodeInclude } from './CodeNode.js';
+import FunctionCallNode from './FunctionCallNode.js';
+
+export type FunctionNodeArguments = Node[] | { [name: string]: Node };
+
+export default class FunctionNode<P extends Node[] | { [name: string]: Node }> extends CodeNode {
+	keywords: { [key: string]: Node };
+	constructor(code?: string, includes?: CodeNodeInclude[], language?: string);
+
+	getInputs(builder: NodeBuilder): NodeFunctionInput[];
+	getNodeFunction(builder: NodeBuilder): NodeFunction;
+	call(parameters: P): FunctionCallNode<P>;
+}
+
+export type Fn<P extends FunctionNodeArguments> = P extends readonly [...unknown[]] ? ProxiedTuple<P> : readonly [ProxiedObject<P>];
+
+export const nativeFn: <P extends FunctionNodeArguments>(
+	code: string,
+	includes?: CodeNodeInclude[],
+	language?: string
+	// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+) => (...params: Fn<P>) => ShaderNodeObject<Node>;
+
+export const glslFn: <P extends FunctionNodeArguments>(
+	code: string,
+	includes?: CodeNodeInclude[]
+	// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+) => (...params: Fn<P>) => ShaderNodeObject<Node>;
+export const wgslFn: <P extends FunctionNodeArguments>(
+	code: string,
+	includes?: CodeNodeInclude[]
+	// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+) => (...params: Fn<P>) => ShaderNodeObject<Node>;

package/three/src/nodes/core/AssignNode.d.ts

@@ -0,0 +1,18 @@
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+import NodeBuilder from './NodeBuilder.js';
+import TempNode from './TempNode.js';
+
+export default class AssignNode extends TempNode {
+	constructor(targetNode: Node, sourceNode: Node);
+
+	needsSplitAssign(builder: NodeBuilder): boolean;
+}
+
+export const assign: (targetNode: NodeRepresentation, sourceNode: NodeRepresentation) => ShaderNodeObject<AssignNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		assign: typeof assign;
+	}
+}

package/three/src/nodes/core/AttributeNode.d.ts

@@ -0,0 +1,15 @@
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+import NodeBuilder from './NodeBuilder.js';
+
+export default class AttributeNode extends Node {
+	defaultNode: Node | null;
+
+	constructor(attributeName: string, nodeType?: string | null, defaultNode?: Node | null);
+
+	setAttributeName(attributeName: string): this;
+
+	getAttributeName(builder: NodeBuilder): string;
+}
+
+export const attribute: (name: string, nodeType?: string | null, defaultNode?: NodeRepresentation) => ShaderNodeObject<AttributeNode>;

package/three/src/nodes/core/BypassNode.d.ts

@@ -0,0 +1,18 @@
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+
+export default class BypassNode extends Node {
+	isBypassNode: true;
+	outputNode: Node;
+	callNode: Node;
+
+	constructor(returnNode: Node, callNode: Node);
+}
+
+export const bypass: (returnNode: NodeRepresentation, callNode: NodeRepresentation) => ShaderNodeObject<BypassNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		bypass: typeof bypass;
+	}
+}

package/three/src/nodes/core/CacheNode.d.ts

@@ -0,0 +1,20 @@
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+import NodeCache from './NodeCache.js';
+
+export default class CacheNode extends Node {
+	node: Node;
+	parent: boolean;
+
+	readonly isCacheNode: true;
+
+	constructor(node: Node, parent?: boolean);
+}
+
+export const cache: (node: Node, cache?: NodeCache) => ShaderNodeObject<CacheNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		cache: typeof cache;
+	}
+}

package/three/src/nodes/core/ConstNode.d.ts

@@ -0,0 +1,9 @@
+import InputNode from './InputNode.js';
+import NodeBuilder from './NodeBuilder.js';
+
+export default class ConstNode<Value> extends InputNode<Value> {
+	isConstNode: true;
+	constructor(value: Value, nodeType?: string | null);
+
+	generateConst(builder: NodeBuilder): string;
+}

package/three/src/nodes/core/ContextNode.d.ts

@@ -0,0 +1,21 @@
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+import { NodeBuilderContext } from './NodeBuilder.js';
+
+export default class ContextNode extends Node {
+	isContextNode: true;
+	node: Node;
+	context: NodeBuilderContext;
+
+	constructor(node: Node, context: NodeBuilderContext);
+}
+
+export const context: (node: NodeRepresentation, context: NodeBuilderContext) => ShaderNodeObject<ContextNode>;
+export const label: (node: NodeRepresentation, label: string) => ShaderNodeObject<ContextNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		context: typeof context;
+		label: typeof label;
+	}
+}

package/three/src/nodes/core/IndexNode.d.ts

@@ -0,0 +1,20 @@
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
+
+export type IndexNodeScope = typeof IndexNode.VERTEX | typeof IndexNode.INSTANCE | typeof IndexNode.DRAW;
+
+export default class IndexNode extends Node {
+	scope: IndexNodeScope;
+
+	readonly isInstanceNode: true;
+
+	constructor(scope: IndexNodeScope);
+
+	static VERTEX: 'vertex';
+	static INSTANCE: 'instance';
+	static DRAW: 'draw';
+}
+
+export const vertexIndex: ShaderNodeObject<IndexNode>;
+export const instanceIndex: ShaderNodeObject<IndexNode>;
+export const drawIndex: ShaderNodeObject<IndexNode>;

package/three/src/nodes/core/InputNode.d.ts

@@ -0,0 +1,15 @@
+import Node from './Node.js';
+import NodeBuilder from './NodeBuilder.js';
+
+export type Precision = 'low' | 'medium' | 'high';
+
+export default abstract class InputNode<Value> extends Node {
+	isInputNode: true;
+	value: Value;
+	precision: Precision | null;
+
+	constructor(value: Value, nodeType?: string | null);
+
+	getInputType(builder: NodeBuilder): string | null;
+	setPrecision(precision: Precision): this;
+}

package/three/src/nodes/core/LightingModel.d.ts

@@ -0,0 +1,46 @@
+import Node from './Node.js';
+import NodeBuilder from './NodeBuilder.js';
+import StackNode from './StackNode.js';
+
+export interface LightingModelReflectedLight {
+	directDiffuse: Node;
+	directSpecular: Node;
+	indirectDiffuse: Node;
+	indirectSpecular: Node;
+}
+
+export interface LightingModelDirectInput {
+	lightDirection: Node;
+	lightColor: Node;
+	reflectedLight: LightingModelReflectedLight;
+}
+
+export interface LightingModelDirectRectAreaInput {
+	lightColor: Node;
+	lightPosition: Node;
+	halfWidth: Node;
+	halfHeight: Node;
+	reflectedLight: LightingModelReflectedLight;
+	ltc_1: Node;
+	ltc_2: Node;
+}
+
+export interface LightingModelIndirectInput {
+	radiance: Node;
+	irradiance: Node;
+	iblIrradiance: Node;
+	ambientOcclusion: Node;
+	reflectedLight: LightingModelReflectedLight;
+	backdrop: Node;
+	backdropAlpha: Node;
+	outgoingLight: Node;
+}
+
+export default class LightingModel {
+	start(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
+	finish(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
+	direct(input: LightingModelDirectInput, stack: StackNode, builder: NodeBuilder): void;
+	directRectArea(input: LightingModelDirectRectAreaInput, stack: StackNode, builder: NodeBuilder): void;
+	indirect(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
+	ambientOcclusion(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
+}

package/three/src/nodes/core/MRTNode.d.ts

@@ -0,0 +1,19 @@
+import { Node } from '../Nodes.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import OutputStructNode from './OutputStructNode.js';
+
+declare class MRTNode extends OutputStructNode {
+	outputNodes: { [name: string]: Node };
+
+	readonly isMRTNode: true;
+
+	constructor(outputNodes: { [name: string]: Node });
+
+	getNode(name: string): Node;
+
+	merge(mrtNode: MRTNode): ShaderNodeObject<MRTNode>;
+}
+
+export default MRTNode;
+
+export const mrt: (outputNodes: { [name: string]: Node }) => ShaderNodeObject<MRTNode>;