@nativescript/canvas-three 2.0.0-webgpu.25 → 2.0.0-webgpu.27

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

@@ -0,0 +1,47 @@
+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,15 @@
+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,25 @@
+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,39 @@
+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,19 @@
+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>;

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

@@ -0,0 +1,114 @@
+import { EventDispatcher } from "../../core/EventDispatcher.js";
+import { NodeUpdateType } from "./constants.js";
+import NodeBuilder from "./NodeBuilder.js";
+import NodeFrame from "./NodeFrame.js";
+interface NodeJSONMeta {
+    textures: {
+        [key: string]: unknown;
+    };
+    images: {
+        [key: string]: unknown;
+    };
+    nodes: {
+        [key: string]: NodeJSONIntermediateOutputData;
+    };
+}
+interface NodeJSONMetadata {
+    version: number;
+    type: "Node";
+    generator: "Node.toJSON";
+}
+interface NodeJSONInputNodes {
+    [property: string]:
+        | string[]
+        | {
+            [index: string]: string | undefined;
+        }
+        | string
+        | undefined;
+}
+export interface NodeJSONInputData {
+    inputNodes?: NodeJSONInputNodes | undefined;
+    meta: {
+        textures: {
+            [key: string]: unknown;
+        };
+        nodes: {
+            [key: string]: Node;
+        };
+    };
+}
+export interface NodeJSONIntermediateOutputData {
+    uuid: string;
+    type: string | undefined;
+    meta?: NodeJSONMeta | undefined;
+    metadata?: NodeJSONMetadata;
+    inputNodes?: NodeJSONInputNodes | undefined;
+    textures?: unknown[];
+    images?: unknown[];
+    nodes?: NodeJSONIntermediateOutputData[];
+}
+interface NodeJSONOutputData {
+    uuid: string;
+    type: string | undefined;
+    metadata?: NodeJSONMetadata;
+    inputNodes?: NodeJSONInputNodes | undefined;
+    textures?: unknown[];
+    images?: unknown[];
+    nodes?: NodeJSONOutputData[];
+}
+declare class Node extends EventDispatcher<{
+    dispose: {};
+}> {
+    nodeType: string | null;
+    updateType: NodeUpdateType;
+    updateBeforeType: NodeUpdateType;
+    updateAfterType: NodeUpdateType;
+    uuid: string;
+    version: number;
+    _cacheKey: string | null;
+    _cacheKeyVersion: number;
+    global: boolean;
+    readonly isNode: true;
+    readonly id: number;
+    self?: this;
+    constructor(nodeType?: string | null);
+    set needsUpdate(value: boolean);
+    get type(): string | undefined;
+    onUpdate(callback: (this: this, frame: NodeFrame) => unknown, updateType: NodeUpdateType): this;
+    onFrameUpdate(callback: (this: this, frame: NodeFrame) => void): this;
+    onRenderUpdate(callback: (this: this, frame: NodeFrame) => void): this;
+    onObjectUpdate(callback: (this: this, frame: NodeFrame) => void): this;
+    onReference(callback: (this: this, frame: NodeBuilder | NodeFrame) => unknown): this;
+    getSelf(): this;
+    updateReference(state: NodeBuilder | NodeFrame): unknown;
+    isGlobal(builder: NodeBuilder): boolean;
+    getChildren(): Generator<Node, void, unknown>;
+    dispose(): void;
+    traverse(callback: (node: Node) => void): void;
+    getCacheKey(force?: boolean): string;
+    getHash(builder: NodeBuilder): string;
+    getUpdateType(): NodeUpdateType;
+    getUpdateBeforeType(): NodeUpdateType;
+    getUpdateAfterType(): NodeUpdateType;
+    getElementType(builder: NodeBuilder): "bool" | "int" | "float" | "vec2" | "vec3" | "vec4" | "uint" | null;
+    getNodeType(builder: NodeBuilder): string | null;
+    getShared(builder: NodeBuilder): Node;
+    setup(builder: NodeBuilder): unknown;
+    increaseUsage(builder: NodeBuilder): number;
+    analyze(builder: NodeBuilder): void;
+    generate(builder: NodeBuilder, output?: string | null): string | null | undefined;
+    updateBefore(frame: NodeFrame): void;
+    updateAfter(frame: NodeFrame): void;
+    update(frame: NodeFrame): void;
+    build(builder: NodeBuilder, output?: string | null): string | null;
+    getSerializeChildren(): Generator<import("./NodeUtils.js").NodeChild, void, unknown>;
+    serialize(json: NodeJSONIntermediateOutputData): void;
+    deserialize(json: NodeJSONInputData): void;
+    toJSON(meta?: NodeJSONMeta | string): NodeJSONOutputData;
+}
+export default Node;
+export declare function addNodeClass(type: string, nodeClass: {
+    new(...args: any[]): Node;
+}): void;
+export declare function createNodeFromType(type: string): Node | undefined;

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

@@ -0,0 +1,9 @@
+import Node from "./Node.js";
+declare class NodeAttribute {
+    readonly isNodeAttribute: true;
+    name: string;
+    type: string | null;
+    node: Node | null;
+    constructor(name: string, type: string | null, node?: Node | null);
+}
+export default NodeAttribute;