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

package/three/src/renderers/common/Animation.d.ts

@@ -1,13 +1,13 @@
-import Info from "./Info.js";
-import Nodes from "./nodes/Nodes.js";
+import Info from './Info.js';
+import Nodes from './nodes/Nodes.js';
 declare class Animation {
-    nodes: Nodes;
-    info: Info;
-    animationLoop: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null;
-    requestId: number | null;
-    constructor(nodes: Nodes, info: Info);
-    _init(): void;
-    dispose(): void;
-    setAnimationLoop(callback: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null): void;
+	nodes: Nodes;
+	info: Info;
+	animationLoop: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null;
+	requestId: number | null;
+	constructor(nodes: Nodes, info: Info);
+	_init(): void;
+	dispose(): void;
+	setAnimationLoop(callback: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null): void;
 }
 export default Animation;

package/three/src/renderers/common/Attributes.d.ts

@@ -1,22 +1,22 @@
-import { BufferAttribute } from "../../core/BufferAttribute.js";
-import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
-import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
-import Backend from "./Backend.js";
-import { AttributeType } from "./Constants.js";
-import DataMap from "./DataMap.js";
+import { BufferAttribute } from '../../core/BufferAttribute.js';
+import { InterleavedBuffer } from '../../core/InterleavedBuffer.js';
+import { InterleavedBufferAttribute } from '../../core/InterleavedBufferAttribute.js';
+import Backend from './Backend.js';
+import { AttributeType } from './Constants.js';
+import DataMap from './DataMap.js';
 interface Data {
-    version?: number | undefined;
+	version?: number | undefined;
 }
 declare class Attributes extends DataMap<{
-    attribute: {
-        key: BufferAttribute | InterleavedBufferAttribute;
-        value: Data;
-    };
+	attribute: {
+		key: BufferAttribute | InterleavedBufferAttribute;
+		value: Data;
+	};
 }> {
-    backend: Backend;
-    constructor(backend: Backend);
-    delete(attribute: BufferAttribute | InterleavedBufferAttribute): Data;
-    update(attribute: BufferAttribute | InterleavedBufferAttribute, type: AttributeType): void;
-    _getBufferAttribute(attribute: BufferAttribute | InterleavedBufferAttribute): BufferAttribute | InterleavedBuffer;
+	backend: Backend;
+	constructor(backend: Backend);
+	delete(attribute: BufferAttribute | InterleavedBufferAttribute): Data;
+	update(attribute: BufferAttribute | InterleavedBufferAttribute, type: AttributeType): void;
+	_getBufferAttribute(attribute: BufferAttribute | InterleavedBufferAttribute): BufferAttribute | InterleavedBuffer;
 }
 export default Attributes;

package/three/src/renderers/common/Backend.d.ts

@@ -1,19 +1,19 @@
-import { CoordinateSystem } from "../../constants.js";
-import Renderer from "./Renderer.js";
+import { CoordinateSystem } from '../../constants.js';
+import Renderer from './Renderer.js';
 
 export interface BackendParameters {
-    canvas?: HTMLCanvasElement | undefined;
+	canvas?: HTMLCanvasElement | undefined;
 }
 
 export default abstract class Backend {
-    renderer: Renderer | null;
-    domElement: HTMLCanvasElement | null;
+	renderer: Renderer | null;
+	domElement: HTMLCanvasElement | null;
 
-    constructor(parameters?: BackendParameters);
+	constructor(parameters?: BackendParameters);
 
-    init(renderer: Renderer): void;
+	init(renderer: Renderer): void;
 
-    abstract get coordinateSystem(): CoordinateSystem;
+	abstract get coordinateSystem(): CoordinateSystem;
 
-    getDomElement(): HTMLCanvasElement;
+	getDomElement(): HTMLCanvasElement;
 }

package/three/src/renderers/common/Background.d.ts

@@ -1,23 +1,23 @@
-import { Mesh } from "../../objects/Mesh.js";
-import { Scene } from "../../scenes/Scene.js";
-import DataMap from "./DataMap.js";
-import Nodes from "./nodes/Nodes.js";
-import RenderContext from "./RenderContext.js";
-import Renderer from "./Renderer.js";
-import RenderList from "./RenderList.js";
+import { Mesh } from '../../objects/Mesh.js';
+import { Scene } from '../../scenes/Scene.js';
+import DataMap from './DataMap.js';
+import Nodes from './nodes/Nodes.js';
+import RenderContext from './RenderContext.js';
+import Renderer from './Renderer.js';
+import RenderList from './RenderList.js';
 interface SceneData {
-    backgroundMesh?: Mesh;
-    backgroundCacheKey: string;
+	backgroundMesh?: Mesh;
+	backgroundCacheKey: string;
 }
 declare class Background extends DataMap<{
-    scene: {
-        key: Scene;
-        value: SceneData;
-    };
+	scene: {
+		key: Scene;
+		value: SceneData;
+	};
 }> {
-    renderer: Renderer;
-    nodes: Nodes;
-    constructor(renderer: Renderer, nodes: Nodes);
-    update(scene: Scene, renderList: RenderList, renderContext: RenderContext): void;
+	renderer: Renderer;
+	nodes: Nodes;
+	constructor(renderer: Renderer, nodes: Nodes);
+	update(scene: Scene, renderList: RenderList, renderContext: RenderContext): void;
 }
 export default Background;

package/three/src/renderers/common/BindGroup.d.ts

@@ -1,9 +1,9 @@
-import Binding from "./Binding.js";
-import NodeUniformsGroup from "./nodes/NodeUniformsGroup.js";
+import Binding from './Binding.js';
+import NodeUniformsGroup from './nodes/NodeUniformsGroup.js';
 declare class BindGroup {
-    name: string;
-    bindings: NodeUniformsGroup[] | Binding[];
-    id: number;
-    constructor(name?: string, bindings?: NodeUniformsGroup[]);
+	name: string;
+	bindings: NodeUniformsGroup[] | Binding[];
+	id: number;
+	constructor(name?: string, bindings?: NodeUniformsGroup[]);
 }
 export default BindGroup;

package/three/src/renderers/common/Binding.d.ts

@@ -1,8 +1,8 @@
 declare class Binding {
-    name: string;
-    visibility: number;
-    constructor(name?: string);
-    setVisibility(visibility: number): void;
-    clone(): Binding & this;
+	name: string;
+	visibility: number;
+	constructor(name?: string);
+	setVisibility(visibility: number): void;
+	clone(): Binding & this;
 }
 export default Binding;

package/three/src/renderers/common/Bindings.d.ts

@@ -1,42 +1,35 @@
-import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
-import Attributes from "./Attributes.js";
-import Backend from "./Backend.js";
-import BindGroup from "./BindGroup.js";
-import DataMap from "./DataMap.js";
-import Info from "./Info.js";
-import Nodes from "./nodes/Nodes.js";
-import Pipelines from "./Pipelines.js";
-import RenderObject from "./RenderObject.js";
-import Textures from "./Textures.js";
+import ComputeNode from '../../nodes/gpgpu/ComputeNode.js';
+import Attributes from './Attributes.js';
+import Backend from './Backend.js';
+import BindGroup from './BindGroup.js';
+import DataMap from './DataMap.js';
+import Info from './Info.js';
+import Nodes from './nodes/Nodes.js';
+import Pipelines from './Pipelines.js';
+import RenderObject from './RenderObject.js';
+import Textures from './Textures.js';
 interface BindGroupData {
-    bindGroup?: BindGroup | undefined;
+	bindGroup?: BindGroup | undefined;
 }
 declare class Bindings extends DataMap<{
-    bindGroup: {
-        key: BindGroup;
-        value: BindGroupData;
-    };
+	bindGroup: {
+		key: BindGroup;
+		value: BindGroupData;
+	};
 }> {
-    backend: Backend;
-    textures: Textures;
-    pipelines: Pipelines;
-    attributes: Attributes;
-    nodes: Nodes;
-    info: Info;
-    constructor(
-        backend: Backend,
-        nodes: Nodes,
-        textures: Textures,
-        attributes: Attributes,
-        pipelines: Pipelines,
-        info: Info,
-    );
-    getForRender(renderObject: RenderObject): BindGroup[];
-    getForCompute(computeNode: ComputeNode): BindGroup[];
-    updateForCompute(computeNode: ComputeNode): void;
-    updateForRender(renderObject: RenderObject): void;
-    _updateBindings(object: ComputeNode | RenderObject, bindings: BindGroup[]): void;
-    _init(bindGroup: BindGroup): void;
-    _update(object: ComputeNode | RenderObject, bindGroup: BindGroup, bindings: BindGroup[]): void;
+	backend: Backend;
+	textures: Textures;
+	pipelines: Pipelines;
+	attributes: Attributes;
+	nodes: Nodes;
+	info: Info;
+	constructor(backend: Backend, nodes: Nodes, textures: Textures, attributes: Attributes, pipelines: Pipelines, info: Info);
+	getForRender(renderObject: RenderObject): BindGroup[];
+	getForCompute(computeNode: ComputeNode): BindGroup[];
+	updateForCompute(computeNode: ComputeNode): void;
+	updateForRender(renderObject: RenderObject): void;
+	_updateBindings(object: ComputeNode | RenderObject, bindings: BindGroup[]): void;
+	_init(bindGroup: BindGroup): void;
+	_update(object: ComputeNode | RenderObject, bindGroup: BindGroup, bindings: BindGroup[]): void;
 }
 export default Bindings;

package/three/src/renderers/common/Buffer.d.ts

@@ -1,11 +1,11 @@
-import Binding from "./Binding.js";
+import Binding from './Binding.js';
 declare class Buffer extends Binding {
-    readonly isBuffer: true;
-    bytesPerElement: number;
-    _buffer: Float32Array | null;
-    constructor(name?: string, buffer?: Float32Array | null);
-    get byteLength(): number;
-    get buffer(): Float32Array | null;
-    update(): boolean;
+	readonly isBuffer: true;
+	bytesPerElement: number;
+	_buffer: Float32Array | null;
+	constructor(name?: string, buffer?: Float32Array | null);
+	get byteLength(): number;
+	get buffer(): Float32Array | null;
+	update(): boolean;
 }
 export default Buffer;

package/three/src/renderers/common/ChainMap.d.ts

@@ -1,9 +1,9 @@
 type RecursiveWeakMap<K extends readonly object[], V> = WeakMap<K[number], V | RecursiveWeakMap<K, V>>;
 export default class ChainMap<K extends readonly object[], V> {
-    weakMap: RecursiveWeakMap<K, V>;
-    constructor();
-    get(keys: K): V | undefined;
-    set(keys: K, value: V): V;
-    delete(keys: K): boolean;
+	weakMap: RecursiveWeakMap<K, V>;
+	constructor();
+	get(keys: K): V | undefined;
+	set(keys: K, value: V): V;
+	delete(keys: K): boolean;
 }
 export {};

package/three/src/renderers/common/ClippingContext.d.ts

@@ -1,23 +1,23 @@
-import { Camera } from "../../cameras/Camera.js";
-import { Material } from "../../materials/Material.js";
-import { Matrix3 } from "../../math/Matrix3.js";
-import { Matrix4 } from "../../math/Matrix4.js";
-import { Plane } from "../../math/Plane.js";
-import { Vector4 } from "../../math/Vector4.js";
-import Renderer from "./Renderer.js";
+import { Camera } from '../../cameras/Camera.js';
+import { Material } from '../../materials/Material.js';
+import { Matrix3 } from '../../math/Matrix3.js';
+import { Matrix4 } from '../../math/Matrix4.js';
+import { Plane } from '../../math/Plane.js';
+import { Vector4 } from '../../math/Vector4.js';
+import Renderer from './Renderer.js';
 declare class ClippingContext {
-    version: number;
-    globalClippingCount: number;
-    localClippingCount: number;
-    localClippingEnabled: boolean | undefined;
-    localClipIntersection: boolean;
-    planes: Vector4[];
-    parentVersion: number;
-    viewNormalMatrix: Matrix3;
-    viewMatrix?: Matrix4 | undefined;
-    constructor();
-    projectPlanes(source: readonly Plane[], offset: number): void;
-    updateGlobal(renderer: Renderer, camera: Camera): void;
-    update(parent: ClippingContext, material: Material): void;
+	version: number;
+	globalClippingCount: number;
+	localClippingCount: number;
+	localClippingEnabled: boolean | undefined;
+	localClipIntersection: boolean;
+	planes: Vector4[];
+	parentVersion: number;
+	viewNormalMatrix: Matrix3;
+	viewMatrix?: Matrix4 | undefined;
+	constructor();
+	projectPlanes(source: readonly Plane[], offset: number): void;
+	updateGlobal(renderer: Renderer, camera: Camera): void;
+	update(parent: ClippingContext, material: Material): void;
 }
 export default ClippingContext;

package/three/src/renderers/common/Color4.d.ts

@@ -1,10 +1,10 @@
-import { Color, ColorRepresentation } from "../../math/Color.js";
+import { Color, ColorRepresentation } from '../../math/Color.js';
 declare class Color4 extends Color {
-    a: number;
-    constructor(color?: ColorRepresentation);
-    constructor(r: number, g: number, b: number, a?: number);
-    set(...args: [color: ColorRepresentation] | [r: number, g: number, b: number, a?: number]): this;
-    copy(color: Color): this;
-    clone(): this;
+	a: number;
+	constructor(color?: ColorRepresentation);
+	constructor(r: number, g: number, b: number, a?: number);
+	set(...args: [color: ColorRepresentation] | [r: number, g: number, b: number, a?: number]): this;
+	copy(color: Color): this;
+	clone(): this;
 }
 export default Color4;

package/three/src/renderers/common/ComputePipeline.d.ts

@@ -1,8 +1,8 @@
-import Pipeline from "./Pipeline.js";
-import ProgrammableStage from "./ProgrammableStage.js";
+import Pipeline from './Pipeline.js';
+import ProgrammableStage from './ProgrammableStage.js';
 declare class ComputePipeline extends Pipeline {
-    computeProgram: ProgrammableStage;
-    readonly isComputePipeline: true;
-    constructor(cacheKey: string, computeProgram: ProgrammableStage);
+	computeProgram: ProgrammableStage;
+	readonly isComputePipeline: true;
+	constructor(cacheKey: string, computeProgram: ProgrammableStage);
 }
 export default ComputePipeline;

package/three/src/renderers/common/Constants.d.ts

@@ -1,7 +1,7 @@
 export declare const AttributeType: {
-    readonly VERTEX: 1;
-    readonly INDEX: 2;
-    readonly STORAGE: 4;
+	readonly VERTEX: 1;
+	readonly INDEX: 2;
+	readonly STORAGE: 4;
 };
 export type AttributeType = (typeof AttributeType)[keyof typeof AttributeType];
 export declare const GPU_CHUNK_BYTES = 16;

package/three/src/renderers/common/CubeRenderTarget.d.ts

@@ -1,10 +1,10 @@
-import { RenderTargetOptions } from "../../core/RenderTarget.js";
-import { WebGLCubeRenderTarget } from "../../renderers/WebGLCubeRenderTarget.js";
-import { Texture } from "../../textures/Texture.js";
-import { WebGLRenderer } from "../WebGLRenderer.js";
+import { RenderTargetOptions } from '../../core/RenderTarget.js';
+import { WebGLCubeRenderTarget } from '../../renderers/WebGLCubeRenderTarget.js';
+import { Texture } from '../../textures/Texture.js';
+import { WebGLRenderer } from '../WebGLRenderer.js';
 declare class CubeRenderTarget extends WebGLCubeRenderTarget {
-    readonly isCubeRenderTarget: true;
-    constructor(size?: number, options?: RenderTargetOptions);
-    fromEquirectangularTexture(renderer: WebGLRenderer, texture: Texture): this;
+	readonly isCubeRenderTarget: true;
+	constructor(size?: number, options?: RenderTargetOptions);
+	fromEquirectangularTexture(renderer: WebGLRenderer, texture: Texture): this;
 }
 export default CubeRenderTarget;

package/three/src/renderers/common/DataMap.d.ts

@@ -1,20 +1,30 @@
 declare class DataMap<
-    M extends {
-        [key: string]: {
-            key: object;
-            value: unknown;
-        };
-    },
+	M extends {
+		[key: string]: {
+			key: object;
+			value: unknown;
+		};
+	}
 > {
-    data: WeakMap<M[keyof M]["key"], M[keyof M]["value"]>;
-    constructor();
-    get<K extends M[keyof M]["key"]>(object: K): Extract<M[keyof M], {
-        key: K;
-    }>["value"];
-    delete<K extends M[keyof M]["key"]>(object: K): Extract<M[keyof M], {
-        key: K;
-    }>["value"];
-    has(object: M[keyof M]["key"]): boolean;
-    dispose(): void;
+	data: WeakMap<M[keyof M]['key'], M[keyof M]['value']>;
+	constructor();
+	get<K extends M[keyof M]['key']>(
+		object: K
+	): Extract<
+		M[keyof M],
+		{
+			key: K;
+		}
+	>['value'];
+	delete<K extends M[keyof M]['key']>(
+		object: K
+	): Extract<
+		M[keyof M],
+		{
+			key: K;
+		}
+	>['value'];
+	has(object: M[keyof M]['key']): boolean;
+	dispose(): void;
 }
 export default DataMap;

package/three/src/renderers/common/Geometries.d.ts

@@ -1,31 +1,31 @@
-import { BufferAttribute } from "../../core/BufferAttribute.js";
-import { BufferGeometry } from "../../core/BufferGeometry.js";
-import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
-import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
-import Attributes from "./Attributes.js";
-import { AttributeType } from "./Constants.js";
-import DataMap from "./DataMap.js";
-import Info from "./Info.js";
-import RenderObject from "./RenderObject.js";
+import { BufferAttribute } from '../../core/BufferAttribute.js';
+import { BufferGeometry } from '../../core/BufferGeometry.js';
+import { InterleavedBuffer } from '../../core/InterleavedBuffer.js';
+import { InterleavedBufferAttribute } from '../../core/InterleavedBufferAttribute.js';
+import Attributes from './Attributes.js';
+import { AttributeType } from './Constants.js';
+import DataMap from './DataMap.js';
+import Info from './Info.js';
+import RenderObject from './RenderObject.js';
 interface GeometryData {
-    initialized?: boolean | undefined;
+	initialized?: boolean | undefined;
 }
 declare class Geometries extends DataMap<{
-    geometry: {
-        key: BufferGeometry;
-        value: GeometryData;
-    };
+	geometry: {
+		key: BufferGeometry;
+		value: GeometryData;
+	};
 }> {
-    attributes: Attributes;
-    info: Info;
-    wireframes: WeakMap<BufferGeometry, BufferAttribute>;
-    attributeCall: WeakMap<BufferAttribute | InterleavedBufferAttribute | InterleavedBuffer, number>;
-    constructor(attributes: Attributes, info: Info);
-    has(renderObject: RenderObject | BufferGeometry): boolean;
-    updateForRender(renderObject: RenderObject): void;
-    initGeometry(renderObject: RenderObject): void;
-    updateAttributes(renderObject: RenderObject): void;
-    updateAttribute(attribute: BufferAttribute | InterleavedBufferAttribute, type: AttributeType): void;
-    getIndex(renderObject: RenderObject): BufferAttribute | null;
+	attributes: Attributes;
+	info: Info;
+	wireframes: WeakMap<BufferGeometry, BufferAttribute>;
+	attributeCall: WeakMap<BufferAttribute | InterleavedBufferAttribute | InterleavedBuffer, number>;
+	constructor(attributes: Attributes, info: Info);
+	has(renderObject: RenderObject | BufferGeometry): boolean;
+	updateForRender(renderObject: RenderObject): void;
+	initGeometry(renderObject: RenderObject): void;
+	updateAttributes(renderObject: RenderObject): void;
+	updateAttribute(attribute: BufferAttribute | InterleavedBufferAttribute, type: AttributeType): void;
+	getIndex(renderObject: RenderObject): BufferAttribute | null;
 }
 export default Geometries;

package/three/src/renderers/common/Info.d.ts

@@ -1,34 +1,34 @@
-import { Object3D } from "../../core/Object3D.js";
+import { Object3D } from '../../core/Object3D.js';
 declare class Info {
-    autoReset: boolean;
-    frame: number;
-    calls: number;
-    render: {
-        calls: number;
-        frameCalls: number;
-        drawCalls: number;
-        triangles: number;
-        points: number;
-        lines: number;
-        timestamp: number;
-        previousFrameCalls: number;
-        timestampCalls: number;
-    };
-    compute: {
-        calls: number;
-        frameCalls: number;
-        timestamp: number;
-        previousFrameCalls: number;
-        timestampCalls: number;
-    };
-    memory: {
-        geometries: number;
-        textures: number;
-    };
-    constructor();
-    update(object: Object3D, count: number, instanceCount: number): void;
-    updateTimestamp(type: "render" | "compute", time: number): void;
-    reset(): void;
-    dispose(): void;
+	autoReset: boolean;
+	frame: number;
+	calls: number;
+	render: {
+		calls: number;
+		frameCalls: number;
+		drawCalls: number;
+		triangles: number;
+		points: number;
+		lines: number;
+		timestamp: number;
+		previousFrameCalls: number;
+		timestampCalls: number;
+	};
+	compute: {
+		calls: number;
+		frameCalls: number;
+		timestamp: number;
+		previousFrameCalls: number;
+		timestampCalls: number;
+	};
+	memory: {
+		geometries: number;
+		textures: number;
+	};
+	constructor();
+	update(object: Object3D, count: number, instanceCount: number): void;
+	updateTimestamp(type: 'render' | 'compute', time: number): void;
+	reset(): void;
+	dispose(): void;
 }
 export default Info;

package/three/src/renderers/common/Pipeline.d.ts

@@ -1,6 +1,6 @@
 declare class Pipeline {
-    cacheKey: string;
-    usedTimes: number;
-    constructor(cacheKey: string);
+	cacheKey: string;
+	usedTimes: number;
+	constructor(cacheKey: string);
 }
 export default Pipeline;