@nativescript/canvas-three 2.0.0-webgpu.33 → 2.0.0-webgpu.35

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

@@ -1,9 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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>;