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

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

@@ -1,143 +1,133 @@
-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";
+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;
+	code: string;
 }
 
 export interface NodeData {
-    vertex: { [key: string]: unknown };
-    fragment: { [key: string]: unknown };
-    compute: { [key: string]: unknown };
+	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;
+	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

@@ -1,52 +1,49 @@
-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";
+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;
+	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;
+	vertex?: ShaderStageNodeData | undefined;
+	fragment?: ShaderStageNodeData | undefined;
+	compute?: ShaderStageNodeData | undefined;
+	any?: ShaderStageNodeData | undefined;
 }
 interface BufferAttributeData {
-    node: BufferAttributeNode;
+	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;
+	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

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

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

@@ -1,34 +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";
+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;
+	time: number;
+	deltaTime: number;
 
-    frameId: number;
-    renderId: number;
+	frameId: number;
+	renderId: number;
 
-    startTime: number | null;
+	startTime: number | null;
 
-    frameMap: WeakMap<Node, number>;
-    frameBeforeMap: WeakMap<Node, number>;
-    renderMap: WeakMap<Node, number>;
-    renderBeforeMap: WeakMap<Node, number>;
+	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;
+	renderer: Renderer | null;
+	material: Material | null;
+	camera: Camera | null;
+	object: Object3D | null;
+	scene: Scene | null;
 
-    constructor();
+	constructor();
 
-    updateBeforeNode(node: Node): void;
+	updateBeforeNode(node: Node): void;
 
-    updateNode(node: Node): void;
-    update(): void;
+	updateNode(node: Node): void;
+	update(): void;
 }

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

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

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

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

@@ -1,17 +1,17 @@
-import Node from "./Node.js";
-import NodeBuilder from "./NodeBuilder.js";
+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;
+	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

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

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

@@ -1,14 +1,14 @@
-import UniformNode from "./UniformNode.js";
+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;
+	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

@@ -1,21 +1,18 @@
-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";
+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;
+	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;
+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

@@ -1,7 +1,7 @@
 declare class NodeVar {
-    readonly isNodeVar: true;
-    name: string;
-    type: string | null;
-    constructor(name: string, type: string | null);
+	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

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

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

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

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

@@ -1,13 +1,13 @@
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import Node from "./Node.js";
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import Node from './Node.js';
 
 export default class PropertyNode extends Node {
-    name: string | null;
-    varying: boolean;
+	name: string | null;
+	varying: boolean;
 
-    readonly isPropertyNode: true;
+	readonly isPropertyNode: true;
 
-    constructor(nodeType?: string | null, name?: string | null, varying?: boolean);
+	constructor(nodeType?: string | null, name?: string | null, varying?: boolean);
 }
 
 export const property: (type?: string | null, name?: string | null) => ShaderNodeObject<PropertyNode>;