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

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

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

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

@@ -1,9 +1,9 @@
-import InputNode from "./InputNode.js";
-import NodeBuilder from "./NodeBuilder.js";
+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);
+	isConstNode: true;
+	constructor(value: Value, nodeType?: string | null);
 
-    generateConst(builder: NodeBuilder): string;
+	generateConst(builder: NodeBuilder): string;
 }

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

@@ -1,21 +1,21 @@
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import Node from "./Node.js";
-import { NodeBuilderContext } from "./NodeBuilder.js";
+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;
+	isContextNode: true;
+	node: Node;
+	context: NodeBuilderContext;
 
-    constructor(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;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		context: typeof context;
+		label: typeof label;
+	}
 }

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

@@ -1,18 +1,18 @@
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import Node from "./Node.js";
+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;
+	scope: IndexNodeScope;
 
-    readonly isInstanceNode: true;
+	readonly isInstanceNode: true;
 
-    constructor(scope: IndexNodeScope);
+	constructor(scope: IndexNodeScope);
 
-    static VERTEX: "vertex";
-    static INSTANCE: "instance";
-    static DRAW: "draw";
+	static VERTEX: 'vertex';
+	static INSTANCE: 'instance';
+	static DRAW: 'draw';
 }
 
 export const vertexIndex: ShaderNodeObject<IndexNode>;

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

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

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

@@ -1,46 +1,46 @@
-import Node from "./Node.js";
-import NodeBuilder from "./NodeBuilder.js";
-import StackNode from "./StackNode.js";
+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;
+	directDiffuse: Node;
+	directSpecular: Node;
+	indirectDiffuse: Node;
+	indirectSpecular: Node;
 }
 
 export interface LightingModelDirectInput {
-    lightDirection: Node;
-    lightColor: Node;
-    reflectedLight: LightingModelReflectedLight;
+	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;
+	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;
+	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;
+	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,17 +1,17 @@
-import { Node } from "../Nodes.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import OutputStructNode from "./OutputStructNode.js";
+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 };
+	outputNodes: { [name: string]: Node };
 
-    readonly isMRTNode: true;
+	readonly isMRTNode: true;
 
-    constructor(outputNodes: { [name: string]: Node });
+	constructor(outputNodes: { [name: string]: Node });
 
-    getNode(name: string): Node;
+	getNode(name: string): Node;
 
-    merge(mrtNode: MRTNode): ShaderNodeObject<MRTNode>;
+	merge(mrtNode: MRTNode): ShaderNodeObject<MRTNode>;
 }
 
 export default MRTNode;

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

@@ -1,114 +1,117 @@
-import { EventDispatcher } from "../../core/EventDispatcher.js";
-import { NodeUpdateType } from "./constants.js";
-import NodeBuilder from "./NodeBuilder.js";
-import NodeFrame from "./NodeFrame.js";
+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;
-    };
+	textures: {
+		[key: string]: unknown;
+	};
+	images: {
+		[key: string]: unknown;
+	};
+	nodes: {
+		[key: string]: NodeJSONIntermediateOutputData;
+	};
 }
 interface NodeJSONMetadata {
-    version: number;
-    type: "Node";
-    generator: "Node.toJSON";
+	version: number;
+	type: 'Node';
+	generator: 'Node.toJSON';
 }
 interface NodeJSONInputNodes {
-    [property: string]:
-        | string[]
-        | {
-            [index: string]: string | undefined;
-        }
-        | string
-        | undefined;
+	[property: string]:
+		| string[]
+		| {
+				[index: string]: string | undefined;
+		  }
+		| string
+		| undefined;
 }
 export interface NodeJSONInputData {
-    inputNodes?: NodeJSONInputNodes | undefined;
-    meta: {
-        textures: {
-            [key: string]: unknown;
-        };
-        nodes: {
-            [key: string]: Node;
-        };
-    };
+	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[];
+	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[];
+	uuid: string;
+	type: string | undefined;
+	metadata?: NodeJSONMetadata;
+	inputNodes?: NodeJSONInputNodes | undefined;
+	textures?: unknown[];
+	images?: unknown[];
+	nodes?: NodeJSONOutputData[];
 }
 declare class Node extends EventDispatcher<{
-    dispose: {};
+	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;
+	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 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

@@ -1,9 +1,9 @@
-import Node from "./Node.js";
+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);
+	readonly isNodeAttribute: true;
+	name: string;
+	type: string | null;
+	node: Node | null;
+	constructor(name: string, type: string | null, node?: Node | null);
 }
 export default NodeAttribute;