@nativescript/canvas-three 2.0.0-webgpu.3 → 2.0.0-webgpu.31

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

@@ -0,0 +1,183 @@
+import { Camera } from '../../cameras/Camera.js';
+import { ColorSpace, ShadowMapType, ToneMapping } from '../../constants.js';
+import { BufferAttribute } from '../../core/BufferAttribute.js';
+import { BufferGeometry, GeometryGroup } from '../../core/BufferGeometry.js';
+import { Object3D } from '../../core/Object3D.js';
+import { RenderTarget } from '../../core/RenderTarget.js';
+import { Material } from '../../materials/Material.js';
+import { Box2 } from '../../math/Box2.js';
+import { Color } from '../../math/Color.js';
+import { Plane } from '../../math/Plane.js';
+import { Vector2 } from '../../math/Vector2.js';
+import { Vector4 } from '../../math/Vector4.js';
+import { ComputeNode, LightsNode, MRTNode } from '../../nodes/Nodes.js';
+import { Scene } from '../../scenes/Scene.js';
+import { FramebufferTexture } from '../../textures/FramebufferTexture.js';
+import { Texture } from '../../textures/Texture.js';
+import Animation from './Animation.js';
+import Attributes from './Attributes.js';
+import Backend from './Backend.js';
+import Background from './Background.js';
+import Bindings from './Bindings.js';
+import Color4 from './Color4.js';
+import Geometries from './Geometries.js';
+import Info from './Info.js';
+import Nodes from './nodes/Nodes.js';
+import Pipelines from './Pipelines.js';
+import QuadMesh from './QuadMesh.js';
+import RenderBundle from './RenderBundle.js';
+import RenderBundles from './RenderBundles.js';
+import RenderContext from './RenderContext.js';
+import RenderContexts from './RenderContexts.js';
+import RenderList, { Bundle, RenderItem } from './RenderList.js';
+import RenderLists from './RenderLists.js';
+import RenderObjects from './RenderObjects.js';
+import Textures from './Textures.js';
+export interface RendererParameters {
+	logarithmicDepthBuffer?: boolean | undefined;
+	alpha?: boolean | undefined;
+	antialias?: boolean | undefined;
+	samples?: number | undefined;
+}
+declare class Renderer {
+	readonly isRenderer: true;
+	domElement: HTMLCanvasElement;
+	backend: Backend;
+	samples: number;
+	autoClear: boolean;
+	autoClearColor: boolean;
+	autoClearDepth: boolean;
+	autoClearStencil: boolean;
+	alpha: boolean;
+	logarithmicDepthBuffer: boolean;
+	outputColorSpace: ColorSpace;
+	toneMapping: ToneMapping;
+	toneMappingExposure: number;
+	sortObjects: boolean;
+	depth: boolean;
+	stencil: boolean;
+	clippingPlanes: readonly Plane[];
+	info: Info;
+	_pixelRatio: number;
+	_width: number;
+	_height: number;
+	_viewport: Vector4;
+	_scissor: Vector4;
+	_scissorTest: boolean;
+	_attributes: Attributes | null;
+	_geometries: Geometries | null;
+	_nodes: Nodes | null;
+	_animation: Animation | null;
+	_bindings: Bindings | null;
+	_objects: RenderObjects | null;
+	_pipelines: Pipelines | null;
+	_bundles: RenderBundles | null;
+	_renderLists: RenderLists | null;
+	_renderContexts: RenderContexts | null;
+	_textures: Textures | null;
+	_background: Background | null;
+	_quad: QuadMesh;
+	_currentRenderContext: RenderContext | null;
+	_opaqueSort: ((a: RenderItem, b: RenderItem) => number) | null;
+	_transparentSort: ((a: RenderItem, b: RenderItem) => number) | null;
+	_frameBufferTarget: RenderTarget | null;
+	_clearColor: Color4;
+	_clearDepth: number;
+	_clearStencil: number;
+	_renderTarget: RenderTarget | null;
+	_activeCubeFace: number;
+	_activeMipmapLevel: number;
+	_mrt: MRTNode | null;
+	_renderObjectFunction: ((object: Object3D, scene: Scene, camera: Camera, geometry: BufferGeometry, material: Material, group: GeometryGroup, lightsNode: LightsNode) => void) | null;
+	_currentRenderObjectFunction: ((object: Object3D, scene: Scene, camera: Camera, geometry: BufferGeometry, material: Material, group: GeometryGroup, lightsNode: LightsNode) => void) | null;
+	_currentRenderBundle: RenderBundle | null;
+	_handleObjectFunction: (object: Object3D, material: Material, scene: Scene, camera: Camera, lightsNode: LightsNode, group: GeometryGroup, passId?: string) => void;
+	_initialized: boolean;
+	_initPromise: Promise<void> | null;
+	_compilationPromises: Promise<void>[] | null;
+	transparent: boolean;
+	opaque: boolean;
+	shadowMap: {
+		enabled: boolean;
+		type: ShadowMapType | null;
+	};
+	xr: {
+		enabled: boolean;
+	};
+	debug: {
+		checkShaderErrors: boolean;
+		onShaderError: ((gl: WebGL2RenderingContext, programGPU: WebGLProgram, glVertexShader: WebGLShader, glFragmentShader: WebGLShader) => void) | null;
+	};
+	localClippingEnabled?: boolean | undefined;
+	constructor(backend: Backend, parameters?: RendererParameters);
+	init(): Promise<void>;
+	get coordinateSystem(): import('../../constants.js').CoordinateSystem;
+	compileAsync(scene: Scene, camera: Camera, targetScene?: Scene | null): Promise<void>;
+	renderAsync(scene: Scene, camera: Camera): Promise<void>;
+	setMRT(mrt: MRTNode | null): this;
+	getMRT(): MRTNode | null;
+	_renderBundle(bundle: Bundle, sceneRef: Scene, lightsNode: LightsNode): void;
+	render(scene: Scene, camera: Camera): Promise<void> | undefined;
+	_getFrameBufferTarget(): RenderTarget<Texture> | null;
+	_renderScene(scene: Scene, camera: Camera, useFrameBufferTarget?: boolean): RenderContext;
+	getMaxAnisotropy(): number;
+	getActiveCubeFace(): number;
+	getActiveMipmapLevel(): number;
+	setAnimationLoop(callback: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null): Promise<void>;
+	getArrayBufferAsync(attribute: BufferAttribute): Promise<ArrayBuffer>;
+	getContext(): void;
+	getPixelRatio(): number;
+	getDrawingBufferSize(target: Vector2): Vector2;
+	getSize(target: Vector2): Vector2;
+	setPixelRatio(value?: number): void;
+	setDrawingBufferSize(width: number, height: number, pixelRatio: number): void;
+	setSize(width: number, height: number, updateStyle?: boolean): void;
+	setOpaqueSort(method: ((a: RenderItem, b: RenderItem) => number) | null): void;
+	setTransparentSort(method: ((a: RenderItem, b: RenderItem) => number) | null): void;
+	getScissor(target: Vector4): Vector4;
+	setScissor(x: Vector4): void;
+	setScissor(x: number, y: number, width: number, height: number): void;
+	getScissorTest(): boolean;
+	setScissorTest(boolean: boolean): void;
+	getViewport(target: Vector4): Vector4;
+	setViewport(x: Vector4): void;
+	setViewport(x: number, y: number, width: number, height: number, minDepth?: number, maxDepth?: number): void;
+	getClearColor(target: Color4): Color4;
+	setClearColor(color: Color, alpha?: number): void;
+	getClearAlpha(): number;
+	setClearAlpha(alpha: number): void;
+	getClearDepth(): number;
+	setClearDepth(depth: number): void;
+	getClearStencil(): number;
+	setClearStencil(stencil: number): void;
+	isOccluded(object: Object3D): boolean | null;
+	clear(color?: boolean, depth?: boolean, stencil?: boolean): Promise<void> | undefined;
+	clearColor(): Promise<void> | undefined;
+	clearDepth(): Promise<void> | undefined;
+	clearStencil(): Promise<void> | undefined;
+	clearAsync(color?: boolean, depth?: boolean, stencil?: boolean): Promise<void>;
+	clearColorAsync(): Promise<void>;
+	clearDepthAsync(): Promise<void>;
+	clearStencilAsync(): Promise<void>;
+	get currentColorSpace(): ColorSpace;
+	dispose(): void;
+	setRenderTarget(renderTarget: RenderTarget | null, activeCubeFace?: number, activeMipmapLevel?: number): void;
+	getRenderTarget(): RenderTarget<Texture> | null;
+	setRenderObjectFunction(renderObjectFunction: ((object: Object3D, scene: Scene, camera: Camera, geometry: BufferGeometry, material: Material, group: GeometryGroup, lightsNode: LightsNode) => void) | null): void;
+	getRenderObjectFunction(): ((object: Object3D, scene: Scene, camera: Camera, geometry: BufferGeometry, material: Material, group: GeometryGroup, lightsNode: LightsNode) => void) | null;
+	computeAsync(computeNodes: ComputeNode | ComputeNode[]): Promise<void>;
+	hasFeatureAsync(name: string): Promise<void>;
+	hasFeature(name: string): false | void;
+	copyFramebufferToTexture(framebufferTexture: FramebufferTexture): void;
+	copyTextureToTexture(srcTexture: Texture, dstTexture: Texture, srcRegion?: Box2 | null, dstPosition?: Vector2 | null, level?: number): void;
+	readRenderTargetPixelsAsync(renderTarget: RenderTarget, x: number, y: number, width: number, height: number, index?: number): Promise<import('../../core/BufferAttribute.js').TypedArray>;
+	_projectObject(object: Object3D, camera: Camera, groupOrder: number, renderList: RenderList): void;
+	_renderBundles(bundles: Bundle[], sceneRef: Scene, lightsNode: LightsNode): void;
+	_renderObjects(renderList: RenderItem[], camera: Camera, scene: Scene, lightsNode: LightsNode): void;
+	renderObject(object: Object3D, scene: Scene, camera: Camera, geometry: BufferGeometry, material: Material, group: GeometryGroup, lightsNode: LightsNode): void;
+	_renderObjectDirect(object: Object3D, material: Material, scene: Scene, camera: Camera, lightsNode: LightsNode, group: GeometryGroup, passId?: string): void;
+	_createObjectPipeline(object: Object3D, material: Material, scene: Scene, camera: Camera, lightsNode: LightsNode, group: GeometryGroup, passId?: string): void;
+	get compute(): (computeNodes: ComputeNode | ComputeNode[]) => Promise<void>;
+	get compile(): (scene: Scene, camera: Camera, targetScene?: Scene | null) => Promise<void>;
+}
+export default Renderer;

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

@@ -0,0 +1,27 @@
+import { Texture } from '../../textures/Texture.js';
+import Binding from './Binding.js';
+
+declare class SampledTexture extends Binding {
+	id: number;
+	texture: Texture | null;
+	version: number;
+	store: boolean;
+	readonly isSampledTexture: true;
+	constructor(name: string, texture: Texture | null);
+	get needsBindingsUpdate(): boolean;
+	update(): boolean;
+}
+
+declare class SampledArrayTexture extends SampledTexture {
+	readonly isSampledArrayTexture: true;
+}
+
+declare class Sampled3DTexture extends SampledTexture {
+	readonly isSampled3DTexture: true;
+}
+
+declare class SampledCubeTexture extends SampledTexture {
+	readonly isSampledCubeTexture: true;
+}
+
+export { Sampled3DTexture, SampledArrayTexture, SampledCubeTexture, SampledTexture };

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

@@ -0,0 +1,11 @@
+import TextureNode from '../../nodes/accessors/TextureNode.js';
+import Binding from './Binding.js';
+
+declare class Sampler extends Binding {
+	texture: TextureNode | null;
+	version: number;
+	readonly isSampler: true;
+	constructor(name: string, texture: TextureNode | null);
+}
+
+export default Sampler;

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

@@ -0,0 +1,7 @@
+import { BufferAttribute, TypedArray } from '../../core/BufferAttribute.js';
+
+export default class StorageBufferAttribute extends BufferAttribute {
+	readonly isStorageBufferAttribute: true;
+
+	constructor(array: TypedArray, itemSize: number);
+}

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

@@ -0,0 +1,8 @@
+import { TypedArray } from '../../core/BufferAttribute.js';
+import { InstancedBufferAttribute } from '../../core/InstancedBufferAttribute.js';
+
+export default class StorageInstancedBufferAttribute extends InstancedBufferAttribute {
+	readonly isStorageInstancedBufferAttribute: true;
+
+	constructor(array: TypedArray | number, itemSize: number);
+}

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

@@ -0,0 +1,5 @@
+import { Texture } from '../../textures/Texture.js';
+
+export default class StorageTexture extends Texture {
+	constructor(width?: number, height?: number);
+}

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

@@ -0,0 +1,67 @@
+import { RenderTarget } from '../../core/RenderTarget.js';
+import { Vector3 } from '../../math/Vector3.js';
+import { DepthTexture } from '../../textures/DepthTexture.js';
+import { Texture } from '../../textures/Texture.js';
+import Backend from './Backend.js';
+import DataMap from './DataMap.js';
+import Info from './Info.js';
+import Renderer from './Renderer.js';
+type SizeVector3Unitialized = Vector3 & {
+	width?: number;
+	height?: number;
+	depth?: number;
+};
+type SizeVector3 = Vector3 & {
+	width: number;
+	height: number;
+	depth: number;
+};
+interface RenderTargetData {
+	depthTextureMips?: {
+		[activeMipmapLevel: number]: DepthTexture;
+	};
+	width?: number;
+	height?: number;
+	textures?: Texture[];
+	depthTexture?: DepthTexture;
+	depth?: boolean;
+	stencil?: boolean;
+	renderTarget?: RenderTarget;
+	sampleCount?: number;
+	initialized?: boolean;
+}
+interface TextureData {
+	initialized?: boolean;
+	version?: number;
+	isDefaultTexture?: boolean;
+}
+interface TextureOptions {
+	width?: number;
+	height?: number;
+	depth?: number;
+	needsMipmaps?: boolean;
+	levels?: number;
+}
+declare class Textures extends DataMap<{
+	renderTarget: {
+		key: RenderTarget;
+		value: RenderTargetData;
+	};
+	texture: {
+		key: Texture;
+		value: TextureData;
+	};
+}> {
+	renderer: Renderer;
+	backend: Backend;
+	info: Info;
+	constructor(renderer: Renderer, backend: Backend, info: Info);
+	updateRenderTarget(renderTarget: RenderTarget, activeMipmapLevel?: number): void;
+	updateTexture(texture: Texture, options?: TextureOptions): void;
+	getSize(texture: Texture, target?: SizeVector3Unitialized): SizeVector3;
+	getMipLevels(texture: Texture, width: number, height: number): number;
+	needsMipmaps(texture: Texture): boolean;
+	isEnvironmentTexture(texture: Texture): boolean;
+	_destroyTexture(texture: Texture): void;
+}
+export default Textures;

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

@@ -0,0 +1,45 @@
+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';
+declare class Uniform<TValue> {
+	name: string;
+	value: TValue;
+	boundary: number;
+	itemSize: number;
+	offset: number;
+	constructor(name: string, value: TValue);
+	setValue(value: TValue): void;
+	getValue(): TValue;
+}
+declare class NumberUniform extends Uniform<number> {
+	readonly isNumberUniform: true;
+	constructor(name: string, value?: number);
+}
+declare class Vector2Uniform extends Uniform<Vector2> {
+	readonly isVector2Uniform: true;
+	constructor(name: string, value?: Vector2);
+}
+declare class Vector3Uniform extends Uniform<Vector3> {
+	readonly isVector3Uniform: true;
+	constructor(name: string, value?: Vector3);
+}
+declare class Vector4Uniform extends Uniform<Vector4> {
+	readonly isVector4Uniform: true;
+	constructor(name: string, value?: Vector4);
+}
+declare class ColorUniform extends Uniform<Color> {
+	readonly isColorUniform: true;
+	constructor(name: string, value?: Color);
+}
+declare class Matrix3Uniform extends Uniform<Matrix3> {
+	readonly isMatrix3Uniform: true;
+	constructor(name: string, value?: Matrix3);
+}
+declare class Matrix4Uniform extends Uniform<Matrix4> {
+	readonly isMatrix4Uniform: true;
+	constructor(name: string, value?: Matrix4);
+}
+export { ColorUniform, Matrix3Uniform, Matrix4Uniform, NumberUniform, Vector2Uniform, Vector3Uniform, Vector4Uniform };

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

@@ -0,0 +1,6 @@
+import Buffer from './Buffer.js';
+declare class UniformBuffer extends Buffer {
+	readonly isUniformBuffer: true;
+	constructor(name?: string, buffer?: null);
+}
+export default UniformBuffer;

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

@@ -0,0 +1,23 @@
+import { ColorNodeUniform, Matrix3NodeUniform, Matrix4NodeUniform, NodeUniformGPU, NumberNodeUniform, Vector2NodeUniform, Vector3NodeUniform, Vector4NodeUniform } from './nodes/NodeUniform.js';
+import UniformBuffer from './UniformBuffer.js';
+declare class UniformsGroup extends UniformBuffer {
+	readonly isUniformsGroup: true;
+	_values: number[] | null;
+	uniforms: NodeUniformGPU[];
+	constructor(name?: string);
+	addUniform(uniform: NodeUniformGPU): this;
+	removeUniform(uniform: NodeUniformGPU): this;
+	get values(): number[];
+	get buffer(): Float32Array;
+	get byteLength(): number;
+	update(): boolean;
+	updateByType(uniform: NodeUniformGPU): boolean | undefined;
+	updateNumber(uniform: NumberNodeUniform): boolean;
+	updateVector2(uniform: Vector2NodeUniform): boolean;
+	updateVector3(uniform: Vector3NodeUniform): boolean;
+	updateVector4(uniform: Vector4NodeUniform): boolean;
+	updateColor(uniform: ColorNodeUniform): boolean;
+	updateMatrix3(uniform: Matrix3NodeUniform): boolean;
+	updateMatrix4(uniform: Matrix4NodeUniform): boolean;
+}
+export default UniformsGroup;

package/three/src/renderers/common/extras/PMREMGenerator.d.ts

@@ -0,0 +1,9 @@
+import { RenderTarget } from '../../../core/RenderTarget.js';
+import { Scene } from '../../../scenes/Scene.js';
+import Renderer from '../Renderer.js';
+
+export default class PMREMGenerator {
+	constructor(renderer: Renderer);
+
+	fromScene(scene: Scene, sigma?: number, near?: number, far?: number): RenderTarget;
+}

package/three/src/renderers/common/nodes/NodeBuilderState.d.ts

@@ -0,0 +1,19 @@
+import Node from '../../../nodes/core/Node.js';
+import NodeAttribute from '../../../nodes/core/NodeAttribute.js';
+import BindGroup from '../BindGroup.js';
+declare class NodeBuilderState {
+	vertexShader: string | null;
+	fragmentShader: string | null;
+	computeShader: string | null;
+	transforms: never[];
+	nodeAttributes: NodeAttribute[];
+	bindings: BindGroup[];
+	updateNodes: Node[];
+	updateBeforeNodes: Node[];
+	updateAfterNodes: Node[];
+	instanceBindGroups: boolean;
+	usedTimes: number;
+	constructor(vertexShader: string | null, fragmentShader: string | null, computeShader: string | null, nodeAttributes: NodeAttribute[], bindings: BindGroup[], updateNodes: Node[], updateBeforeNodes: Node[], updateAfterNodes: Node[], instanceBindGroups?: boolean, transforms?: never[]);
+	createBindings(): BindGroup[];
+}
+export default NodeBuilderState;

package/three/src/renderers/common/nodes/NodeSampledTexture.d.ts

@@ -0,0 +1,24 @@
+import TextureNode from '../../../nodes/accessors/TextureNode.js';
+import UniformGroupNode from '../../../nodes/core/UniformGroupNode.js';
+import { SampledTexture } from '../SampledTexture.js';
+
+type GPUStorageTextureAccess = 'read-only' | 'read-write' | 'write-only';
+
+declare class NodeSampledTexture extends SampledTexture {
+	textureNode: TextureNode | undefined;
+	groupNode: UniformGroupNode;
+	access: 'read-write' | 'read-only' | 'write-only';
+	constructor(name: string, textureNode: TextureNode | undefined, groupNode: UniformGroupNode, access: GPUStorageTextureAccess | null);
+	get needsBindingsUpdate(): boolean;
+	update(): boolean;
+}
+
+declare class NodeSampledCubeTexture extends NodeSampledTexture {
+	readonly isSampledCubeTexture: true;
+}
+
+declare class NodeSampledTexture3D extends NodeSampledTexture {
+	readonly isSampledTexture3D = true;
+}
+
+export { NodeSampledCubeTexture, NodeSampledTexture, NodeSampledTexture3D };

package/three/src/renderers/common/nodes/NodeSampler.d.ts

@@ -0,0 +1,12 @@
+import TextureNode from '../../../nodes/accessors/TextureNode.js';
+import UniformGroupNode from '../../../nodes/core/UniformGroupNode.js';
+import Sampler from '../Sampler.js';
+
+declare class NodeSampler extends Sampler {
+	textureNode: TextureNode | undefined;
+	groupNode: UniformGroupNode;
+	constructor(name: string, textureNode: TextureNode | undefined, groupNode: UniformGroupNode);
+	update(): void;
+}
+
+export default NodeSampler;

package/three/src/renderers/common/nodes/NodeUniform.d.ts

@@ -0,0 +1,45 @@
+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 NodeUniform from '../../../nodes/core/NodeUniform.js';
+import { ColorUniform, Matrix3Uniform, Matrix4Uniform, NumberUniform, Vector2Uniform, Vector3Uniform, Vector4Uniform } from '../Uniform.js';
+declare class NumberNodeUniform extends NumberUniform {
+	nodeUniform: NodeUniform<number>;
+	constructor(nodeUniform: NodeUniform<number>);
+	getValue(): number;
+}
+declare class Vector2NodeUniform extends Vector2Uniform {
+	nodeUniform: NodeUniform<Vector2>;
+	constructor(nodeUniform: NodeUniform<Vector2>);
+	getValue(): Vector2;
+}
+declare class Vector3NodeUniform extends Vector3Uniform {
+	nodeUniform: NodeUniform<Vector3>;
+	constructor(nodeUniform: NodeUniform<Vector3>);
+	getValue(): Vector3;
+}
+declare class Vector4NodeUniform extends Vector4Uniform {
+	nodeUniform: NodeUniform<Vector4>;
+	constructor(nodeUniform: NodeUniform<Vector4>);
+	getValue(): Vector4;
+}
+declare class ColorNodeUniform extends ColorUniform {
+	nodeUniform: NodeUniform<Color>;
+	constructor(nodeUniform: NodeUniform<Color>);
+	getValue(): Color;
+}
+declare class Matrix3NodeUniform extends Matrix3Uniform {
+	nodeUniform: NodeUniform<Matrix3>;
+	constructor(nodeUniform: NodeUniform<Matrix3>);
+	getValue(): Matrix3;
+}
+declare class Matrix4NodeUniform extends Matrix4Uniform {
+	nodeUniform: NodeUniform<Matrix4>;
+	constructor(nodeUniform: NodeUniform<Matrix4>);
+	getValue(): Matrix4;
+}
+export { ColorNodeUniform, Matrix3NodeUniform, Matrix4NodeUniform, NumberNodeUniform, Vector2NodeUniform, Vector3NodeUniform, Vector4NodeUniform };
+export type NodeUniformGPU = NumberNodeUniform | Vector2NodeUniform | Vector3NodeUniform | Vector4NodeUniform | ColorNodeUniform | Matrix3NodeUniform | Matrix4NodeUniform;

package/three/src/renderers/common/nodes/NodeUniformsGroup.d.ts

@@ -0,0 +1,10 @@
+import { UniformGroupNode, UniformNode } from '../../../nodes/Nodes.js';
+import UniformsGroup from '../UniformsGroup.js';
+declare class NodeUniformsGroup extends UniformsGroup {
+	id: number;
+	groupNode: UniformGroupNode;
+	readonly isNodeUniformsGroup: true;
+	constructor(name: string, groupNode: UniformGroupNode);
+	getNodes(): UniformNode<unknown>[];
+}
+export default NodeUniformsGroup;

package/three/src/renderers/common/nodes/Nodes.d.ts

@@ -0,0 +1,98 @@
+import { Camera } from '../../../cameras/Camera.js';
+import { Object3D } from '../../../core/Object3D.js';
+import { Material } from '../../../materials/Material.js';
+import { Color } from '../../../math/Color.js';
+import { ComputeNode, LightsNode, Node, NodeBuilder, NodeFrame, ShaderNodeObject, UniformGroupNode } from '../../../nodes/Nodes.js';
+import { Fog } from '../../../scenes/Fog.js';
+import { FogExp2 } from '../../../scenes/FogExp2.js';
+import { Scene } from '../../../scenes/Scene.js';
+import { CubeTexture } from '../../../textures/CubeTexture.js';
+import { Texture } from '../../../textures/Texture.js';
+import Backend from '../Backend.js';
+import ChainMap from '../ChainMap.js';
+import DataMap from '../DataMap.js';
+import Renderer from '../Renderer.js';
+import RenderObject from '../RenderObject.js';
+import NodeBuilderState from './NodeBuilderState.js';
+import NodeUniformsGroup from './NodeUniformsGroup.js';
+interface NodeUniformsGroupData {
+	renderId?: number | undefined;
+	frameId?: number | undefined;
+}
+interface RenderObjectData {
+	nodeBuilderState?: NodeBuilderState | undefined;
+}
+interface ComputeNodeData {
+	nodeBuilderState?: NodeBuilderState | undefined;
+}
+interface SceneData {
+	background?: Color | Texture | CubeTexture | undefined;
+	backgroundNode?: Node | undefined;
+	fog?: Fog | FogExp2 | undefined;
+	fogNode?: Node | undefined;
+	environment?: Texture | undefined;
+	environmentNode?: Node | undefined;
+}
+declare class Nodes extends DataMap<{
+	nodeUniformsGroup: {
+		key: NodeUniformsGroup;
+		value: NodeUniformsGroupData;
+	};
+	renderObject: {
+		key: RenderObject;
+		value: RenderObjectData;
+	};
+	computeNode: {
+		key: ComputeNode;
+		value: ComputeNodeData;
+	};
+	scene: {
+		key: Scene;
+		value: SceneData;
+	};
+}> {
+	renderer: Renderer;
+	backend: Backend;
+	nodeFrame: NodeFrame;
+	nodeBuilderCache: Map<string, NodeBuilderState>;
+	callHashCache: ChainMap<
+		readonly [Scene, LightsNode],
+		{
+			callId: number;
+			cacheKey: string;
+		}
+	>;
+	groupsData: ChainMap<
+		readonly [UniformGroupNode, NodeUniformsGroup],
+		{
+			version?: number;
+		}
+	>;
+	constructor(renderer: Renderer, backend: Backend);
+	updateGroup(nodeUniformsGroup: NodeUniformsGroup): boolean;
+	getForRenderCacheKey(renderObject: RenderObject): string;
+	getForRender(renderObject: RenderObject): NodeBuilderState;
+	delete(object: NodeUniformsGroup | RenderObject | ComputeNode | Scene): SceneData | RenderObjectData | NodeUniformsGroupData | ComputeNodeData;
+	getForCompute(computeNode: ComputeNode): NodeBuilderState;
+	_createNodeBuilderState(nodeBuilder: NodeBuilder): NodeBuilderState;
+	getEnvironmentNode(scene: Scene): Node | null;
+	getBackgroundNode(scene: Scene): Node | null;
+	getFogNode(scene: Scene): Node | null;
+	getCacheKey(scene: Scene, lightsNode: LightsNode): string;
+	updateScene(scene: Scene): void;
+	get isToneMappingState(): boolean;
+	updateBackground(scene: Scene): void;
+	updateFog(scene: Scene): void;
+	updateEnvironment(scene: Scene): void;
+	getNodeFrame(renderer?: Renderer, scene?: Scene | null, object?: Object3D | null, camera?: Camera | null, material?: Material | null): NodeFrame;
+	getNodeFrameForRender(renderObject: RenderObject): NodeFrame;
+	getOutputCacheKey(): string;
+	hasOutputChange(outputTarget: Texture): boolean;
+	getOutputNode(outputTexture: Texture): ShaderNodeObject<Node>;
+	updateBefore(renderObject: RenderObject): void;
+	updateAfter(renderObject: RenderObject): void;
+	updateForCompute(computeNode: ComputeNode): void;
+	updateForRender(renderObject: RenderObject): void;
+	dispose(): void;
+}
+export default Nodes;