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

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

@@ -0,0 +1,143 @@
+import { BufferGeometry } from "../../core/BufferGeometry.js";
+import { Object3D } from "../../core/Object3D.js";
+import { Material } from "../../materials/Material.js";
+import Renderer from "../../renderers/common/Renderer.js";
+import { Texture } from "../../textures/Texture.js";
+import FogNode from "../fog/FogNode.js";
+import LightsNode from "../lighting/LightsNode.js";
+import { NodeShaderStage } from "./constants.js";
+import Node from "./Node.js";
+import NodeAttribute from "./NodeAttribute.js";
+import NodeCache from "./NodeCache.js";
+import NodeParser from "./NodeParser.js";
+import NodeUniform from "./NodeUniform.js";
+import NodeVar from "./NodeVar.js";
+import NodeVarying from "./NodeVarying.js";
+import StackNode from "./StackNode.js";
+
+export type BuildStageOption = "construct" | "analyze" | "generate";
+
+export interface FlowData {
+    code: string;
+}
+
+export interface NodeData {
+    vertex: { [key: string]: unknown };
+    fragment: { [key: string]: unknown };
+    compute: { [key: string]: unknown };
+}
+
+export type NodeBuilderContext = { [key: string]: unknown };
+
+export default abstract class NodeBuilder {
+    object: Object3D;
+    material: Material;
+    geometry: BufferGeometry;
+    renderer: Renderer;
+    parser: NodeParser;
+
+    nodes: Node[];
+    updateNodes: Node[];
+    hashNodes: { [hash: string]: Node };
+
+    lightsNode: LightsNode;
+    fogNode: FogNode;
+
+    vertexShader: string;
+    fragmentShader: string;
+    computeShader: string;
+
+    cache: NodeCache;
+    globalCache: NodeCache;
+
+    /**
+     * @TODO used to be missing. check the actual type later
+     */
+    flowsData: any;
+
+    shaderStage: NodeShaderStage | null;
+    buildStage: BuildStageOption | null;
+    stack: StackNode;
+
+    setHashNode(node: Node, hash: string): void;
+    addNode(node: Node): void;
+    get currentNode(): Node;
+    isFilteredTexture(texture: Texture): boolean;
+    getMethod(method: string): string;
+    getNodeFromHash(hash: string): Node;
+
+    addFlow(shaderStage: NodeShaderStage, node: Node): Node;
+
+    setContext(context: NodeBuilderContext): void;
+    getContext(): NodeBuilderContext;
+    setCache(cache: NodeCache): void;
+    getCache(): NodeCache;
+    getCacheFromNode(node: Node, parent?: boolean): NodeCache;
+    isAvailable(name: string): boolean;
+
+    abstract getInstanceIndex(): string;
+
+    abstract getDrawIndex(): string | null;
+
+    abstract getFrontFacing(): string;
+
+    abstract getFragCoord(): string;
+
+    isFlipY(): boolean;
+
+    // @TODO: rename to .generateConst()
+    getConst(type: string, value?: unknown): Node;
+    getType(type: string): string;
+
+    generateMethod(method: string): string;
+
+    getAttribute(name: string, type: string): NodeAttribute;
+
+    getPropertyName<TValue>(node: NodeVar | NodeUniform<TValue>, shaderStage: NodeShaderStage): string;
+    isVector(type: string): boolean;
+
+    isMatrix(type: string): boolean;
+    isReference(type: string): boolean;
+    getElementType(type: string): string | null;
+    getComponentType(type: string): string | null;
+    getVectorType(type: string): string;
+    getTypeFromLength(length: number): string;
+    getTypeLength(type: string): number;
+    getVectorFromMatrix(type: string): string;
+    getDataFromNode(node: Node, shaderStage?: NodeShaderStage): NodeData;
+    getNodeProperties(node: Node, shaderStage?: NodeShaderStage): { [key: string]: unknown };
+    getUniformFromNode(
+        node: Node,
+        type: string,
+        shaderStage?: NodeShaderStage,
+        name?: string | null,
+    ): NodeUniform<string>;
+    getVarFromNode(node: Node, type: string, shaderStage?: NodeShaderStage): NodeVar;
+    getVaryFromNode(node: Node, type: string): NodeVarying;
+    getCodeFromNode(node: Node, type: string, shaderStage?: NodeShaderStage): string;
+    addFlowCode(code: string): void;
+    getFlowData(node: Node, shaderStage: NodeShaderStage): FlowData;
+    flowNode(node: Node): FlowData;
+    flowChildNode(node: Node, output?: string | null): FlowData;
+    flowNodeFromShaderStage(
+        shaderStage: NodeShaderStage,
+        node: Node,
+        output?: string | null,
+        propertyName?: string,
+    ): FlowData;
+    hasGeometryAttribute(name: string): boolean;
+    abstract getAttributes(shaderStage: NodeShaderStage): string;
+    abstract getVaryings(shaderStage: NodeShaderStage): string;
+    getVars(shaderStage: NodeShaderStage): string;
+    abstract getUniforms(stage: NodeShaderStage): string;
+    getCodes(shaderStage: NodeShaderStage): string;
+    getHash(): string;
+    setShaderStage(shaderStage: NodeShaderStage): void;
+    getShaderStage(): NodeShaderStage;
+    setBuildStage(buildStage: BuildStageOption): void;
+    getBuildStage(): BuildStageOption;
+    abstract buildCode(): void;
+    build(): this;
+    format(snippet: string, fromType: string, toType: string): string;
+    getSignature(): string;
+}

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

@@ -0,0 +1,52 @@
+import { BufferAttribute, TypedArray } from "../../core/BufferAttribute.js";
+import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
+import BufferAttributeNode from "../accessors/BufferAttributeNode.js";
+import Node from "./Node.js";
+import NodeAttribute from "./NodeAttribute.js";
+import NodeCode from "./NodeCode.js";
+import NodeUniform from "./NodeUniform.js";
+import NodeVar from "./NodeVar.js";
+import NodeVarying from "./NodeVarying.js";
+export interface ShaderStageNodeData {
+    properties?:
+        | (
+            & {
+                outputNode: Node | null;
+                initialized?: boolean | undefined;
+            }
+            & {
+                [K in `node${string}`]?: Node | undefined;
+            }
+        )
+        | undefined;
+    bufferAttribute?: NodeAttribute | undefined;
+    structType?: Node | undefined;
+    uniform?: NodeUniform<unknown> | undefined;
+    variable?: NodeVar | undefined;
+    varying?: NodeVarying | undefined;
+    code?: NodeCode | undefined;
+    usageCount?: number | undefined;
+    snippet?: string | undefined;
+    propertyName?: string | undefined;
+    propertySizeName?: string | undefined;
+}
+interface NodeData {
+    vertex?: ShaderStageNodeData | undefined;
+    fragment?: ShaderStageNodeData | undefined;
+    compute?: ShaderStageNodeData | undefined;
+    any?: ShaderStageNodeData | undefined;
+}
+interface BufferAttributeData {
+    node: BufferAttributeNode;
+}
+declare class NodeCache {
+    id: number;
+    nodesData: WeakMap<Node | TypedArray | InterleavedBuffer | BufferAttribute, NodeData | BufferAttributeData>;
+    parent: NodeCache | null;
+    constructor(parent?: NodeCache | null);
+    getData(node: Node): NodeData | undefined;
+    getData(node: TypedArray | InterleavedBuffer | BufferAttribute): BufferAttributeData | undefined;
+    setData(node: Node, data: NodeData): void;
+    setData(node: TypedArray | InterleavedBuffer | BufferAttribute, data: BufferAttributeData): void;
+}
+export default NodeCache;

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

@@ -0,0 +1,4 @@
+export default class NodeCode {
+    isNodeCode: true;
+    constructor(name: string, type: string, code?: string);
+}

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

@@ -0,0 +1,34 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Object3D } from "../../core/Object3D.js";
+import { Material } from "../../materials/Material.js";
+import Renderer from "../../renderers/common/Renderer.js";
+import { Scene } from "../../scenes/Scene.js";
+import Node from "./Node.js";
+
+export default class NodeFrame {
+    time: number;
+    deltaTime: number;
+
+    frameId: number;
+    renderId: number;
+
+    startTime: number | null;
+
+    frameMap: WeakMap<Node, number>;
+    frameBeforeMap: WeakMap<Node, number>;
+    renderMap: WeakMap<Node, number>;
+    renderBeforeMap: WeakMap<Node, number>;
+
+    renderer: Renderer | null;
+    material: Material | null;
+    camera: Camera | null;
+    object: Object3D | null;
+    scene: Scene | null;
+
+    constructor();
+
+    updateBeforeNode(node: Node): void;
+
+    updateNode(node: Node): void;
+    update(): void;
+}

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

@@ -0,0 +1,13 @@
+import NodeFunctionInput from "./NodeFunctionInput.js";
+
+export default abstract class NodeFunction {
+    isNodeFunction: true;
+    type: string;
+    inputs: NodeFunctionInput[];
+    name: string;
+    precision: string;
+
+    constructor(type: string, inputs: NodeFunctionInput[], name?: string, precision?: string);
+
+    abstract getCode(name?: string): string;
+}

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

@@ -0,0 +1,7 @@
+export default class NodeFunctionInput {
+    isNodeFunctionInput: true;
+    count: null | number;
+    qualifier: string;
+    isConst: boolean;
+    constructor(type: string, name: string, count?: number, qualifier?: string, isConst?: boolean);
+}

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

@@ -0,0 +1,17 @@
+import Node from "./Node.js";
+import NodeBuilder from "./NodeBuilder.js";
+declare class NodeKeywords {
+    keywords: string[];
+    nodes: {
+        [name: string]: Node;
+    };
+    keywordsCallback: {
+        [name: string]: (name: string) => Node;
+    };
+    constructor();
+    getNode(name: string): Node;
+    addKeyword(name: string, callback: (name: string) => Node): this;
+    parse(code: string): Node[];
+    include(builder: NodeBuilder, code: string): void;
+}
+export default NodeKeywords;

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

@@ -0,0 +1,5 @@
+import NodeFunction from "./NodeFunction.js";
+declare abstract class NodeParser {
+    abstract parseFunction(source: string): NodeFunction;
+}
+export default NodeParser;

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

@@ -0,0 +1,14 @@
+import UniformNode from "./UniformNode.js";
+declare class NodeUniform<TValue> {
+    readonly isNodeUniform: true;
+    name: string;
+    type: string | null;
+    node: UniformNode<TValue>;
+    needsUpdate: boolean | undefined;
+    constructor(name: string, type: string | null, node: UniformNode<TValue>);
+    get value(): TValue;
+    set value(val: TValue);
+    get id(): number;
+    get groupNode(): import("./UniformGroupNode.js").default;
+}
+export default NodeUniform;

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

@@ -0,0 +1,21 @@
+import { Color } from "../../math/Color.js";
+import { Matrix3 } from "../../math/Matrix3.js";
+import { Matrix4 } from "../../math/Matrix4.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Vector3 } from "../../math/Vector3.js";
+import { Vector4 } from "../../math/Vector4.js";
+import Node from "./Node.js";
+
+export interface NodeChild {
+    property: string;
+    index?: number | string;
+    childNode: Node;
+}
+
+export function getCacheKey(object: Node, force?: boolean): string;
+export function getNodeChildren(object: Node): Generator<NodeChild, void>;
+export function getValueType(value: unknown): string | null;
+export function getValueFromType(
+    type: string,
+    ...params: number[]
+): Color | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4 | boolean | number | string | ArrayBufferLike | null;

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

@@ -0,0 +1,7 @@
+declare class NodeVar {
+    readonly isNodeVar: true;
+    name: string;
+    type: string | null;
+    constructor(name: string, type: string | null);
+}
+export default NodeVar;

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

@@ -0,0 +1,7 @@
+import NodeVar from "./NodeVar.js";
+declare class NodeVarying extends NodeVar {
+    needsInterpolation: boolean;
+    readonly isNodeVarying: true;
+    constructor(name: string, type: string | null);
+}
+export default NodeVarying;

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

@@ -0,0 +1,12 @@
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from "./Node.js";
+
+export default class OutputStructNode extends Node {
+    members: Node[];
+
+    readonly isOutputStructNode: true;
+
+    constructor(...members: Node[]);
+}
+
+export const outputStruct: (...members: Node[]) => ShaderNodeObject<OutputStructNode>;

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

@@ -0,0 +1,43 @@
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from "./Node.js";
+
+export default class PropertyNode extends Node {
+    name: string | null;
+    varying: boolean;
+
+    readonly isPropertyNode: true;
+
+    constructor(nodeType?: string | null, name?: string | null, varying?: boolean);
+}
+
+export const property: (type?: string | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
+export const varyingProperty: (type?: string | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
+
+export const diffuseColor: ShaderNodeObject<PropertyNode>;
+export const emissive: ShaderNodeObject<PropertyNode>;
+export const roughness: ShaderNodeObject<PropertyNode>;
+export const metalness: ShaderNodeObject<PropertyNode>;
+export const clearcoat: ShaderNodeObject<PropertyNode>;
+export const clearcoatRoughness: ShaderNodeObject<PropertyNode>;
+export const sheen: ShaderNodeObject<PropertyNode>;
+export const sheenRoughness: ShaderNodeObject<PropertyNode>;
+export const iridescence: ShaderNodeObject<PropertyNode>;
+export const iridescenceIOR: ShaderNodeObject<PropertyNode>;
+export const iridescenceThickness: ShaderNodeObject<PropertyNode>;
+export const alphaT: ShaderNodeObject<PropertyNode>;
+export const anisotropy: ShaderNodeObject<PropertyNode>;
+export const anisotropyT: ShaderNodeObject<PropertyNode>;
+export const anisotropyB: ShaderNodeObject<PropertyNode>;
+export const specularColor: ShaderNodeObject<PropertyNode>;
+export const specularF90: ShaderNodeObject<PropertyNode>;
+export const shininess: ShaderNodeObject<PropertyNode>;
+export const output: ShaderNodeObject<PropertyNode>;
+export const dashSize: ShaderNodeObject<PropertyNode>;
+export const gapSize: ShaderNodeObject<PropertyNode>;
+export const pointWidth: ShaderNodeObject<PropertyNode>;
+export const ior: ShaderNodeObject<PropertyNode>;
+export const transmission: ShaderNodeObject<PropertyNode>;
+export const thickness: ShaderNodeObject<PropertyNode>;
+export const attenuationDistance: ShaderNodeObject<PropertyNode>;
+export const attenuationColor: ShaderNodeObject<PropertyNode>;
+export const dispersion: ShaderNodeObject<PropertyNode>;

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

@@ -0,0 +1,17 @@
+import Node from "./Node.js";
+
+export default class StackNode extends Node {
+    isStackNode: true;
+    nodes: Node[];
+    outputNode: Node | null;
+
+    constructor();
+
+    add(node: Node): this;
+
+    if(boolNode: Node, method: () => void): this;
+
+    elseIf(node: Node, method: () => void): this;
+
+    else(node: Node, method: () => void): this;
+}

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

@@ -0,0 +1,8 @@
+import Node from "./Node.js";
+declare class StructTypeNode extends Node {
+    types: string[];
+    readonly isStructTypeNode: true;
+    constructor(types: string[]);
+    getMemberTypes(): string[];
+}
+export default StructTypeNode;

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

@@ -0,0 +1,10 @@
+import Node from "./Node.js";
+import NodeBuilder from "./NodeBuilder.js";
+
+export default class TempNode extends Node {
+    isTempNode: true;
+
+    constructor(type: string | null);
+
+    hasDependencies(builder: NodeBuilder): boolean;
+}

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

@@ -0,0 +1,7 @@
+export default class UniformGroup {
+    name: string;
+
+    readonly isUniformGroup: true;
+
+    constructor(name: string);
+}

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

@@ -0,0 +1,21 @@
+import Node from "./Node.js";
+
+export default class UniformGroupNode extends Node {
+    name: string;
+    version: number;
+
+    shared: boolean;
+
+    readonly isUniformGroup: true;
+
+    constructor(name: string, shared?: boolean);
+
+    set needsUpdate(value: boolean);
+}
+
+export const uniformGroup: (name: string) => UniformGroupNode;
+export const sharedUniformGroup: (name: string) => UniformGroupNode;
+
+export const frameGroup: UniformGroupNode;
+export const renderGroup: UniformGroupNode;
+export const objectGroup: UniformGroupNode;

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

@@ -0,0 +1,23 @@
+import { NodeUpdateType } from "./constants.js";
+import InputNode from "./InputNode.js";
+import Node from "./Node.js";
+import NodeBuilder from "./NodeBuilder.js";
+import NodeFrame from "./NodeFrame.js";
+import UniformGroupNode from "./UniformGroupNode.js";
+declare class UniformNode<TValue> extends InputNode<TValue> {
+    readonly isUniformNode: true;
+    name: string;
+    groupNode: UniformGroupNode;
+    constructor(value: TValue, nodeType?: string | null);
+    label(name: string): this;
+    setGroup(group: UniformGroupNode): this;
+    getGroup(): UniformGroupNode;
+    getUniformHash(builder: NodeBuilder): string;
+    onUpdate(callback: (frame: NodeFrame, self: this) => TValue | undefined, updateType: NodeUpdateType): this;
+    generate(builder: NodeBuilder, output: string | null): string;
+}
+export default UniformNode;
+export declare const uniform: <TValue>(
+    arg1: InputNode<TValue> | TValue,
+    arg2?: Node | string,
+) => import("../shadernode/ShaderNode.js").ShaderNodeObject<UniformNode<TValue>>;

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

@@ -0,0 +1,28 @@
+import { OperatorNodeOp } from "../math/OperatorNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from "./Node.js";
+
+export default class VarNode extends Node {
+    node: Node;
+    name: string | null;
+
+    readonly isVarNode: true;
+
+    constructor(node: Node, name?: string | null);
+
+    op(op: OperatorNodeOp, ...params: Node[]): this;
+    assign(...params: Node[]): this;
+    add(...params: Node[]): this;
+    sub(...params: Node[]): this;
+    mul(...params: Node[]): this;
+    div(...params: Node[]): this;
+}
+
+export const temp: (node: NodeRepresentation, name?: string | null) => ShaderNodeObject<VarNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        temp: typeof temp;
+        toVar: typeof temp;
+    }
+}

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

@@ -0,0 +1,21 @@
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from "./Node.js";
+import NodeBuilder from "./NodeBuilder.js";
+import NodeVarying from "./NodeVarying.js";
+
+export default class VaryingNode extends Node {
+    node: Node;
+    name: string | null;
+
+    constructor(node: Node, name?: string | null);
+
+    setupVarying(builder: NodeBuilder): NodeVarying;
+}
+
+export const varying: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VaryingNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        varying: typeof varying;
+    }
+}

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

@@ -0,0 +1,27 @@
+export declare const NodeShaderStage: {
+    readonly VERTEX: "vertex";
+    readonly FRAGMENT: "fragment";
+};
+export declare const NodeUpdateType: {
+    readonly NONE: "none";
+    readonly FRAME: "frame";
+    readonly RENDER: "render";
+    readonly OBJECT: "object";
+};
+export declare const NodeType: {
+    readonly BOOLEAN: "bool";
+    readonly INTEGER: "int";
+    readonly FLOAT: "float";
+    readonly VECTOR2: "vec2";
+    readonly VECTOR3: "vec3";
+    readonly VECTOR4: "vec4";
+    readonly MATRIX2: "mat2";
+    readonly MATRIX3: "mat3";
+    readonly MATRIX4: "mat4";
+};
+export type NodeShaderStage = "vertex" | "fragment" | "compute";
+export type NodeUpdateType = "none" | "frame" | "render" | "object";
+export declare const defaultShaderStages: NodeShaderStage[];
+export declare const defaultBuildStages: string[];
+export declare const shaderStages: NodeShaderStage[];
+export declare const vectorComponents: string[];

package/three/src/nodes/display/AfterImageNode.d.ts

@@ -0,0 +1,25 @@
+import TextureNode from "../accessors/TextureNode.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import UniformNode from "../core/UniformNode.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class AfterImageNode extends TempNode {
+    textureNode: TextureNode;
+    textureNodeOld: Node;
+    damp: UniformNode<number>;
+
+    constructor(textureNode: Node, damp?: number);
+
+    getTextureNode(): TextureNode;
+
+    setSize(width: number, height: number): void;
+}
+
+export const afterImage: (node: Node, damp?: number) => ShaderNodeObject<AfterImageNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        afterImage: typeof afterImage;
+    }
+}

package/three/src/nodes/display/AnamorphicNode.d.ts

@@ -0,0 +1,31 @@
+import { Vector2 } from "../../math/Vector2.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class AnamorphicNode extends TempNode {
+    textureNode: Node;
+    thresholdNode: Node;
+    scaleNode: Node;
+    samples: number;
+    resolution: Vector2;
+
+    constructor(textureNode: Node, thresholdNode: Node, scaleNode: Node, samples: number);
+
+    getTextureNode(): Node;
+
+    setSize(width: number, height: number): void;
+}
+
+export const anamorphic: (
+    node: Node,
+    threshold?: NodeRepresentation,
+    scale?: NodeRepresentation,
+    samples?: NodeRepresentation,
+) => ShaderNodeObject<AnamorphicNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        anamorphic: typeof anamorphic;
+    }
+}