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

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

@@ -0,0 +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';
+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;
+}
+export default ClippingContext;

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

@@ -0,0 +1,10 @@
+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;
+}
+export default Color4;

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

@@ -0,0 +1,8 @@
+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);
+}
+export default ComputePipeline;

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

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

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

@@ -0,0 +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';
+declare class CubeRenderTarget extends WebGLCubeRenderTarget {
+	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

@@ -0,0 +1,30 @@
+declare class DataMap<
+	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;
+}
+export default DataMap;

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

@@ -0,0 +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';
+interface GeometryData {
+	initialized?: boolean | undefined;
+}
+declare class Geometries extends DataMap<{
+	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;
+}
+export default Geometries;

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

@@ -0,0 +1,34 @@
+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;
+}
+export default Info;

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

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

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

@@ -0,0 +1,53 @@
+import ComputeNode from '../../nodes/gpgpu/ComputeNode.js';
+import Backend from './Backend.js';
+import Binding from './Binding.js';
+import Bindings from './Bindings.js';
+import ComputePipeline from './ComputePipeline.js';
+import DataMap from './DataMap.js';
+import Nodes from './nodes/Nodes.js';
+import Pipeline from './Pipeline.js';
+import ProgrammableStage from './ProgrammableStage.js';
+import RenderObject from './RenderObject.js';
+import RenderPipeline from './RenderPipeline.js';
+interface ComputeNodeData {
+	version: number;
+	pipeline: ComputePipeline;
+}
+interface RenderObjectData {
+	pipeline: RenderPipeline;
+}
+declare class Pipelines extends DataMap<{
+	computeNode: {
+		key: ComputeNode;
+		value: ComputeNodeData;
+	};
+	renderObject: {
+		key: RenderObject;
+		value: RenderObjectData;
+	};
+}> {
+	backend: Backend;
+	nodes: Nodes;
+	bindings: Bindings | null;
+	caches: Map<string, Pipeline>;
+	programs: {
+		vertex: Map<string, ProgrammableStage>;
+		fragment: Map<string, ProgrammableStage>;
+		compute: Map<string, ProgrammableStage>;
+	};
+	constructor(backend: Backend, nodes: Nodes);
+	getForCompute(computeNode: ComputeNode, bindings: Binding[]): ComputePipeline;
+	getForRender(renderObject: RenderObject, promises?: Promise<void>[] | null): RenderPipeline;
+	delete(object: ComputeNode | RenderObject): never;
+	dispose(): void;
+	updateForRender(renderObject: RenderObject): void;
+	_getComputePipeline(computeNode: ComputeNode, stageCompute: ProgrammableStage, cacheKey: string, bindings: Binding[]): ComputePipeline;
+	_getRenderPipeline(renderObject: RenderObject, stageVertex: ProgrammableStage, stageFragment: ProgrammableStage, cacheKey: string, promises: Promise<void>[] | null): RenderPipeline;
+	_getComputeCacheKey(computeNode: ComputeNode, stageCompute: ProgrammableStage): string;
+	_getRenderCacheKey(renderObject: RenderObject, stageVertex: ProgrammableStage, stageFragment: ProgrammableStage): string;
+	_releasePipeline(pipeline: Pipeline): void;
+	_releaseProgram(program: ProgrammableStage): void;
+	_needsComputeUpdate(computeNode: ComputeNode): boolean;
+	_needsRenderUpdate(renderObject: RenderObject): true | void;
+}
+export default Pipelines;

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

@@ -0,0 +1,21 @@
+import { Node } from '../../nodes/Nodes.js';
+import Renderer from './Renderer.js';
+
+declare class PostProcessing {
+	renderer: Renderer;
+	outputNode: Node;
+
+	outputColorTransform: boolean;
+
+	needsUpdate: boolean;
+
+	constructor(renderer: Renderer, outputNode?: Node);
+
+	render(): void;
+
+	update(): void;
+
+	renderAsync(): Promise<void>;
+}
+
+export default PostProcessing;

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

@@ -0,0 +1,10 @@
+import NodeAttribute from '../../nodes/core/NodeAttribute.js';
+declare class ProgrammableStage {
+	id: number;
+	code: string;
+	stage: 'compute' | 'vertex' | 'fragment';
+	attributes: NodeAttribute[] | null;
+	usedTimes: number;
+	constructor(code: string, type: 'compute' | 'vertex' | 'fragment', transforms?: null, attributes?: NodeAttribute[] | null);
+}
+export default ProgrammableStage;

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

@@ -0,0 +1,14 @@
+import { OrthographicCamera } from '../../cameras/OrthographicCamera.js';
+import { Material } from '../../materials/Material.js';
+import { Mesh } from '../../objects/Mesh.js';
+import Renderer from './Renderer.js';
+
+export default class QuadMesh extends Mesh {
+	camera: OrthographicCamera;
+
+	constructor(material?: Material | null);
+
+	renderAsync(renderer: Renderer): Promise<void>;
+
+	render(renderer: Renderer): void;
+}

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

@@ -0,0 +1,9 @@
+import { Camera } from '../../cameras/Camera.js';
+import { Object3D } from '../../core/Object3D.js';
+declare class RenderBundle {
+	scene: Object3D;
+	camera: Camera;
+	constructor(scene: Object3D, camera: Camera);
+	clone(): RenderBundle & this;
+}
+export default RenderBundle;

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

@@ -0,0 +1,11 @@
+import { Camera } from '../../cameras/Camera.js';
+import { Object3D } from '../../core/Object3D.js';
+import ChainMap from './ChainMap.js';
+import RenderBundle from './RenderBundle.js';
+declare class RenderBundles {
+	lists: ChainMap<readonly [Object3D, Camera], RenderBundle>;
+	constructor();
+	get(scene: Object3D, camera: Camera): RenderBundle;
+	dispose(): void;
+}
+export default RenderBundles;

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

@@ -0,0 +1,41 @@
+import { RenderTarget } from '../../core/RenderTarget.js';
+import { Vector4 } from '../../math/Vector4.js';
+import { DepthTexture } from '../../textures/DepthTexture.js';
+import { Texture } from '../../textures/Texture.js';
+import ClippingContext from './ClippingContext.js';
+declare class RenderContext {
+	id: number;
+	color: boolean;
+	clearColor: boolean;
+	clearColorValue: {
+		r: number;
+		g: number;
+		b: number;
+		a: number;
+	};
+	depth: boolean;
+	clearDepth: boolean;
+	clearDepthValue: number;
+	stencil: boolean;
+	clearStencil: boolean;
+	clearStencilValue: number;
+	viewport: boolean;
+	viewportValue: Vector4;
+	scissor: boolean;
+	scissorValue: Vector4;
+	textures: Texture[] | null;
+	depthTexture: DepthTexture | null;
+	activeCubeFace: number;
+	sampleCount: number;
+	width: number;
+	height: number;
+	readonly isRenderContext: true;
+	clippingContext?: ClippingContext | undefined;
+	depthClearValue?: number | undefined;
+	stencilClearValue?: number | undefined;
+	renderTarget?: RenderTarget | undefined;
+	activeMipmapLevel?: number | undefined;
+	occlusionQueryCount?: number | undefined;
+	constructor();
+}
+export default RenderContext;

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

@@ -0,0 +1,15 @@
+import { Camera } from '../../cameras/Camera.js';
+import { RenderTarget } from '../../core/RenderTarget.js';
+import { Scene } from '../../scenes/Scene.js';
+import ChainMap from './ChainMap.js';
+import RenderContext from './RenderContext.js';
+declare class RenderContexts {
+	chainMaps: {
+		[attachmentState: string]: ChainMap<readonly [Scene, Camera], RenderContext> | undefined;
+	};
+	constructor();
+	get(scene: Scene, camera: Camera, renderTarget?: RenderTarget | null): RenderContext;
+	getChainMap(attachmentState: string): ChainMap<readonly [Scene, Camera], RenderContext>;
+	dispose(): void;
+}
+export default RenderContexts;

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

@@ -0,0 +1,42 @@
+import { Camera } from '../../cameras/Camera.js';
+import { BufferGeometry, GeometryGroup } from '../../core/BufferGeometry.js';
+import { Object3D } from '../../core/Object3D.js';
+import { Light } from '../../lights/Light.js';
+import { Material } from '../../materials/Material.js';
+import { LightsNode } from '../../nodes/Nodes.js';
+export interface Bundle {
+	object: Object3D;
+	camera: Camera;
+	renderList: RenderList;
+}
+export interface RenderItem {
+	id: number | null;
+	object: Object3D | null;
+	geometry: BufferGeometry | null;
+	material: Material | null;
+	groupOrder: number | null;
+	renderOrder: number | null;
+	z: number | null;
+	group: GeometryGroup | null;
+}
+declare class RenderList {
+	renderItems: RenderItem[];
+	renderItemsIndex: number;
+	opaque: RenderItem[];
+	transparent: RenderItem[];
+	bundles: Bundle[];
+	lightsNode: LightsNode;
+	lightsArray: Light[];
+	occlusionQueryCount: number;
+	constructor();
+	begin(): this;
+	getNextRenderItem(object: Object3D, geometry: BufferGeometry, material: Material, groupOrder: number, z: number, group: GeometryGroup | null): RenderItem;
+	push(object: Object3D, geometry: BufferGeometry, material: Material, groupOrder: number, z: number, group: GeometryGroup | null): void;
+	unshift(object: Object3D, geometry: BufferGeometry, material: Material, groupOrder: number, z: number, group: GeometryGroup | null): void;
+	pushBundle(group: Bundle): void;
+	pushLight(light: Light): void;
+	getLightsNode(): LightsNode;
+	sort(customOpaqueSort: ((a: RenderItem, b: RenderItem) => number) | null, customTransparentSort: ((a: RenderItem, b: RenderItem) => number) | null): void;
+	finish(): void;
+}
+export default RenderList;

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

@@ -0,0 +1,11 @@
+import { Camera } from '../../cameras/Camera.js';
+import { Object3D } from '../../core/Object3D.js';
+import ChainMap from './ChainMap.js';
+import RenderList from './RenderList.js';
+declare class RenderLists {
+	lists: ChainMap<readonly [Object3D, Camera], RenderList>;
+	constructor();
+	get(scene: Object3D, camera: Camera): RenderList;
+	dispose(): void;
+}
+export default RenderLists;

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

@@ -0,0 +1,61 @@
+import { Camera } from '../../cameras/Camera.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 { Object3D } from '../../core/Object3D.js';
+import { Material } from '../../materials/Material.js';
+import { LightsNode } from '../../nodes/Nodes.js';
+import { Scene } from '../../scenes/Scene.js';
+import BindGroup from './BindGroup.js';
+import ClippingContext from './ClippingContext.js';
+import Geometries from './Geometries.js';
+import NodeBuilderState from './nodes/NodeBuilderState.js';
+import Nodes from './nodes/Nodes.js';
+import RenderContext from './RenderContext.js';
+import Renderer from './Renderer.js';
+import RenderPipeline from './RenderPipeline.js';
+export default class RenderObject {
+	_nodes: Nodes;
+	_geometries: Geometries;
+	id: number;
+	renderer: Renderer;
+	object: Object3D;
+	material: Material;
+	scene: Scene;
+	camera: Camera;
+	lightsNode: LightsNode;
+	context: RenderContext;
+	geometry: BufferGeometry;
+	version: number;
+	drawRange: {
+		start: number;
+		count: number;
+	} | null;
+	attributes: Array<BufferAttribute | InterleavedBufferAttribute> | null;
+	pipeline: RenderPipeline | null;
+	vertexBuffers: Array<BufferAttribute | InterleavedBuffer> | null;
+	clippingContext: ClippingContext;
+	clippingContextVersion: number;
+	initialNodesCacheKey: string;
+	initialCacheKey: string;
+	_nodeBuilderState: NodeBuilderState | null;
+	_bindings: BindGroup[] | null;
+	onDispose: (() => void) | null;
+	readonly isRenderObject: true;
+	onMaterialDispose: () => void;
+	constructor(nodes: Nodes, geometries: Geometries, renderer: Renderer, object: Object3D, material: Material, scene: Scene, camera: Camera, lightsNode: LightsNode, renderContext: RenderContext);
+	updateClipping(parent: ClippingContext): void;
+	get clippingNeedsUpdate(): boolean;
+	getNodeBuilderState(): NodeBuilderState;
+	getBindings(): BindGroup[];
+	getIndex(): BufferAttribute | null;
+	getChainArray(): readonly [Object3D<import('../../core/Object3D.js').Object3DEventMap>, Material, RenderContext, LightsNode];
+	getAttributes(): (InterleavedBufferAttribute | BufferAttribute)[];
+	getVertexBuffers(): (InterleavedBuffer | BufferAttribute)[] | null;
+	getMaterialCacheKey(): string;
+	get needsUpdate(): boolean;
+	getDynamicCacheKey(): string;
+	getCacheKey(): string;
+	dispose(): void;
+}

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

@@ -0,0 +1,31 @@
+import { Camera } from '../../cameras/Camera.js';
+import { Object3D } from '../../core/Object3D.js';
+import { Material } from '../../materials/Material.js';
+import LightsNode from '../../nodes/lighting/LightsNode.js';
+import { Scene } from '../../scenes/Scene.js';
+import Bindings from './Bindings.js';
+import ChainMap from './ChainMap.js';
+import Geometries from './Geometries.js';
+import Info from './Info.js';
+import Nodes from './nodes/Nodes.js';
+import Pipelines from './Pipelines.js';
+import RenderContext from './RenderContext.js';
+import Renderer from './Renderer.js';
+import RenderObject from './RenderObject.js';
+declare class RenderObjects {
+	renderer: Renderer;
+	nodes: Nodes;
+	geometries: Geometries;
+	pipelines: Pipelines;
+	bindings: Bindings;
+	info: Info;
+	chainMaps: {
+		[passId: string]: ChainMap<readonly [Object3D, Material, RenderContext, LightsNode], RenderObject>;
+	};
+	constructor(renderer: Renderer, nodes: Nodes, geometries: Geometries, pipelines: Pipelines, bindings: Bindings, info: Info);
+	get(object: Object3D, material: Material, scene: Scene, camera: Camera, lightsNode: LightsNode, renderContext: RenderContext, passId: string | undefined): RenderObject;
+	getChainMap(passId?: string): ChainMap<readonly [Object3D<import('../../core/Object3D.js').Object3DEventMap>, Material, RenderContext, LightsNode], RenderObject>;
+	dispose(): void;
+	createRenderObject(nodes: Nodes, geometries: Geometries, renderer: Renderer, object: Object3D, material: Material, scene: Scene, camera: Camera, lightsNode: LightsNode, renderContext: RenderContext, passId: string | undefined): RenderObject;
+}
+export default RenderObjects;

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

@@ -0,0 +1,8 @@
+import Pipeline from './Pipeline.js';
+import ProgrammableStage from './ProgrammableStage.js';
+declare class RenderPipeline extends Pipeline {
+	vertexProgram: ProgrammableStage;
+	fragmentProgram: ProgrammableStage;
+	constructor(cacheKey: string, vertexProgram: ProgrammableStage, fragmentProgram: ProgrammableStage);
+}
+export default RenderPipeline;