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

package/three/src/nodes/utils/RemapNode.d.ts

@@ -1,36 +1,24 @@
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class RemapNode extends Node {
-    node: Node;
-    inLowNode: Node;
-    inHighNode: Node;
-    outLowNode: Node;
-    outHighNode: Node;
+	node: Node;
+	inLowNode: Node;
+	inHighNode: Node;
+	outLowNode: Node;
+	outHighNode: Node;
 
-    doClamp: boolean;
+	doClamp: boolean;
 
-    constructor(node: Node, inLowNode: Node, inHighNode: Node, outLowNode?: Node, outHighNode?: Node);
+	constructor(node: Node, inLowNode: Node, inHighNode: Node, outLowNode?: Node, outHighNode?: Node);
 }
 
-export const remap: (
-    node: Node,
-    inLowNode: NodeRepresentation,
-    inHighNode: NodeRepresentation,
-    outLowNode?: NodeRepresentation,
-    outHighNode?: NodeRepresentation,
-) => ShaderNodeObject<RemapNode>;
-export const remapClamp: (
-    node: Node,
-    inLowNode: NodeRepresentation,
-    inHighNode: NodeRepresentation,
-    outLowNode?: NodeRepresentation,
-    outHighNode?: NodeRepresentation,
-) => ShaderNodeObject<RemapNode>;
+export const remap: (node: Node, inLowNode: NodeRepresentation, inHighNode: NodeRepresentation, outLowNode?: NodeRepresentation, outHighNode?: NodeRepresentation) => ShaderNodeObject<RemapNode>;
+export const remapClamp: (node: Node, inLowNode: NodeRepresentation, inHighNode: NodeRepresentation, outLowNode?: NodeRepresentation, outHighNode?: NodeRepresentation) => ShaderNodeObject<RemapNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        remap: typeof remap;
-        remapClamp: typeof remapClamp;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		remap: typeof remap;
+		remapClamp: typeof remapClamp;
+	}
 }

package/three/src/nodes/utils/RotateNode.d.ts

@@ -1,21 +1,18 @@
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class RotateNode extends TempNode {
-    positionNode: Node;
-    rotationNode: Node;
+	positionNode: Node;
+	rotationNode: Node;
 
-    constructor(positionNode: Node, rotationNode: Node);
+	constructor(positionNode: Node, rotationNode: Node);
 }
 
-export const rotate: (
-    positionNode: NodeRepresentation,
-    rotationNode: NodeRepresentation,
-) => ShaderNodeObject<RotateNode>;
+export const rotate: (positionNode: NodeRepresentation, rotationNode: NodeRepresentation) => ShaderNodeObject<RotateNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        rotate: typeof rotate;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		rotate: typeof rotate;
+	}
 }

package/three/src/nodes/utils/RotateUVNode.d.ts

@@ -1,19 +1,19 @@
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class RotateUVNode extends TempNode {
-    uvNode: Node;
-    rotationNode: Node;
-    centerNode: Node;
+	uvNode: Node;
+	rotationNode: Node;
+	centerNode: Node;
 
-    constructor(uvNode: Node, rotationNode: Node, centerNode?: Node);
+	constructor(uvNode: Node, rotationNode: Node, centerNode?: Node);
 }
 
 export const rotateUV: (uvNode: Node, rotationNode: Node, centerNode?: Node) => ShaderNodeObject<RotateUVNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        rotateUV: typeof rotateUV;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		rotateUV: typeof rotateUV;
+	}
 }

package/three/src/nodes/utils/SplitNode.d.ts

@@ -1,15 +1,15 @@
-import Node from "../core/Node.js";
-import { SwizzleOption } from "../shadernode/ShaderNode.js";
+import Node from '../core/Node.js';
+import { SwizzleOption } from '../shadernode/ShaderNode.js';
 
 /** swizzle node */
 export default class SplitNode extends Node {
-    node: Node;
-    components: string;
+	node: Node;
+	components: string;
 
-    /**
-     * @param node the input node
-     * @param components swizzle like string, default = "x"
-     */
-    constructor(node: Node, components?: SwizzleOption);
-    getVectorLength(): number;
+	/**
+	 * @param node the input node
+	 * @param components swizzle like string, default = "x"
+	 */
+	constructor(node: Node, components?: SwizzleOption);
+	getVectorLength(): number;
 }

package/three/src/nodes/utils/SpriteSheetUVNode.d.ts

@@ -1,16 +1,12 @@
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class SpriteSheetUVNode extends Node {
-    countNode: Node;
-    uvNode: Node;
-    frameNode: Node;
+	countNode: Node;
+	uvNode: Node;
+	frameNode: Node;
 
-    constructor(countNode: Node, uvNode?: Node, frameNode?: Node);
+	constructor(countNode: Node, uvNode?: Node, frameNode?: Node);
 }
 
-export const spritesheetUV: (
-    countNode: NodeRepresentation,
-    uvNode?: NodeRepresentation,
-    frameNode?: NodeRepresentation,
-) => ShaderNodeObject<SpriteSheetUVNode>;
+export const spritesheetUV: (countNode: NodeRepresentation, uvNode?: NodeRepresentation, frameNode?: NodeRepresentation) => ShaderNodeObject<SpriteSheetUVNode>;

package/three/src/nodes/utils/StoargeArrayElementNode.d.ts

@@ -1,25 +1,22 @@
-import StorageBufferNode from "../accessors/StorageBufferNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
-import ArrayElementNode from "./ArrayElementNode.js";
+import StorageBufferNode from '../accessors/StorageBufferNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import ArrayElementNode from './ArrayElementNode.js';
 
 export default class StorageArrayElementNode extends ArrayElementNode {
-    node: StorageBufferNode;
+	node: StorageBufferNode;
 
-    readonly isStorageArrayElementNode: true;
+	readonly isStorageArrayElementNode: true;
 
-    constructor(storageBufferNode: StorageBufferNode, indexNode: Node);
+	constructor(storageBufferNode: StorageBufferNode, indexNode: Node);
 
-    get storageBufferNode(): StorageBufferNode;
-    set storageBufferNode(value: StorageBufferNode);
+	get storageBufferNode(): StorageBufferNode;
+	set storageBufferNode(value: StorageBufferNode);
 }
 
-export const storageElement: (
-    storageBufferNode: NodeRepresentation,
-    indexNode: NodeRepresentation,
-) => ShaderNodeObject<StorageArrayElementNode>;
+export const storageElement: (storageBufferNode: NodeRepresentation, indexNode: NodeRepresentation) => ShaderNodeObject<StorageArrayElementNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        storageElement: typeof storageElement;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		storageElement: typeof storageElement;
+	}
 }

package/three/src/nodes/utils/TimerNode.d.ts

@@ -1,22 +1,18 @@
-import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import UniformNode from '../core/UniformNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
-export type TimerNodeScope =
-    | typeof TimerNode.LOCAL
-    | typeof TimerNode.GLOBAL
-    | typeof TimerNode.DELTA
-    | typeof TimerNode.FRAME;
+export type TimerNodeScope = typeof TimerNode.LOCAL | typeof TimerNode.GLOBAL | typeof TimerNode.DELTA | typeof TimerNode.FRAME;
 
 export default class TimerNode extends UniformNode<number> {
-    static LOCAL: "local";
-    static GLOBAL: "global";
-    static DELTA: "delta";
-    static FRAME: "frame";
+	static LOCAL: 'local';
+	static GLOBAL: 'global';
+	static DELTA: 'delta';
+	static FRAME: 'frame';
 
-    scope: TimerNodeScope;
-    scale: number;
+	scope: TimerNodeScope;
+	scale: number;
 
-    constructor(scope?: TimerNodeScope, scale?: number, value?: number);
+	constructor(scope?: TimerNodeScope, scale?: number, value?: number);
 }
 
 export const timerLocal: (timeScale?: number, value?: number) => ShaderNodeObject<TimerNode>;

package/three/src/nodes/utils/TriplanarTexturesNode.d.ts

@@ -1,42 +1,25 @@
-import TextureNode from "../accessors/TextureNode.js";
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import TextureNode from '../accessors/TextureNode.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class TriplanarTexturesNode extends Node {
-    textureXNode: TextureNode;
-    textureYNode: TextureNode | null;
-    textureZNode: TextureNode | null;
+	textureXNode: TextureNode;
+	textureYNode: TextureNode | null;
+	textureZNode: TextureNode | null;
 
-    scaleNode: ShaderNodeObject<Node>;
+	scaleNode: ShaderNodeObject<Node>;
 
-    positionNode: ShaderNodeObject<Node>;
-    normalNode: ShaderNodeObject<Node>;
+	positionNode: ShaderNodeObject<Node>;
+	normalNode: ShaderNodeObject<Node>;
 
-    constructor(
-        textureXNode: Node,
-        textureYNode?: TextureNode | null,
-        textureZNode?: TextureNode | null,
-        scaleNode?: ShaderNodeObject<Node>,
-        positionNode?: ShaderNodeObject<Node>,
-        normalNode?: ShaderNodeObject<Node>,
-    );
+	constructor(textureXNode: Node, textureYNode?: TextureNode | null, textureZNode?: TextureNode | null, scaleNode?: ShaderNodeObject<Node>, positionNode?: ShaderNodeObject<Node>, normalNode?: ShaderNodeObject<Node>);
 }
 
-export const triplanarTextures: (
-    textureXNode: NodeRepresentation,
-    textureYNode?: NodeRepresentation,
-    textureZNode?: NodeRepresentation,
-    scaleNode?: NodeRepresentation,
-    positionNode?: NodeRepresentation,
-    normalNode?: NodeRepresentation,
-) => ShaderNodeObject<TriplanarTexturesNode>;
-export const triplanarTexture: (
-    texture: NodeRepresentation,
-    ...params: NodeRepresentation[]
-) => ShaderNodeObject<TriplanarTexturesNode>;
+export const triplanarTextures: (textureXNode: NodeRepresentation, textureYNode?: NodeRepresentation, textureZNode?: NodeRepresentation, scaleNode?: NodeRepresentation, positionNode?: NodeRepresentation, normalNode?: NodeRepresentation) => ShaderNodeObject<TriplanarTexturesNode>;
+export const triplanarTexture: (texture: NodeRepresentation, ...params: NodeRepresentation[]) => ShaderNodeObject<TriplanarTexturesNode>;
 
-declare module "../shadernode/ShaderNode.js" {
-    interface NodeElements {
-        triplanarTexture: typeof triplanarTexture;
-    }
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		triplanarTexture: typeof triplanarTexture;
+	}
 }

package/three/src/objects/BatchedMesh.d.ts

@@ -1,11 +1,11 @@
-import { Camera } from "../cameras/Camera.js";
-import { BufferGeometry } from "../core/BufferGeometry.js";
-import { Material } from "../materials/Material.js";
-import { Box3 } from "../math/Box3.js";
-import { Color } from "../math/Color.js";
-import { Matrix4 } from "../math/Matrix4.js";
-import { Sphere } from "../math/Sphere.js";
-import { Mesh } from "./Mesh.js";
+import { Camera } from '../cameras/Camera.js';
+import { BufferGeometry } from '../core/BufferGeometry.js';
+import { Material } from '../materials/Material.js';
+import { Box3 } from '../math/Box3.js';
+import { Color } from '../math/Color.js';
+import { Matrix4 } from '../math/Matrix4.js';
+import { Sphere } from '../math/Sphere.js';
+import { Mesh } from './Mesh.js';
 
 /**
  * A special version of {@link Mesh} with multi draw batch rendering support. Use {@link BatchedMesh} if you have to
@@ -45,153 +45,149 @@ import { Mesh } from "./Mesh.js";
  * @also Example: {@link https://threejs.org/examples/#webgl_mesh_batch WebGL / mesh / batch}
  */
 declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
-    /**
-     * This bounding box encloses all instances of the {@link BatchedMesh}. Can be calculated with
-     * {@link .computeBoundingBox()}.
-     * @default null
-     */
-    boundingBox: Box3 | null;
-
-    /**
-     * This bounding sphere encloses all instances of the {@link BatchedMesh}. Can be calculated with
-     * {@link .computeBoundingSphere()}.
-     * @default null
-     */
-    boundingSphere: Sphere | null;
-
-    customSort: ((this: this, list: Array<{ start: number; count: number; z: number }>, camera: Camera) => void) | null;
-
-    /**
-     * If true then the individual objects within the {@link BatchedMesh} are frustum culled.
-     * @default true
-     */
-    perObjectFrustumCulled: boolean;
-
-    /**
-     * If true then the individual objects within the {@link BatchedMesh} are sorted to improve overdraw-related
-     * artifacts. If the material is marked as "transparent" objects are rendered back to front and if not then they are
-     * rendered front to back.
-     * @default true
-     */
-    sortObjects: boolean;
-
-    /**
-     * The maximum number of individual geometries that can be stored in the {@link BatchedMesh}. Read only.
-     */
-    get maxInstanceCount(): number;
-
-    /**
-     * Read-only flag to check if a given object is of type {@link BatchedMesh}.
-     */
-    readonly isBatchedMesh: true;
-
-    /**
-     * @param maxInstanceCount the max number of individual geometries planned to be added.
-     * @param maxVertexCount the max number of vertices to be used by all geometries.
-     * @param maxIndexCount the max number of indices to be used by all geometries.
-     * @param material an instance of {@link Material}. Default is a new {@link MeshBasicMaterial}.
-     */
-    constructor(maxInstanceCount: number, maxVertexCount: number, maxIndexCount?: number, material?: Material);
-
-    /**
-     * Computes the bounding box, updating {@link .boundingBox} attribute.
-     * Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
-     */
-    computeBoundingBox(): void;
-
-    /**
-     * Computes the bounding sphere, updating {@link .boundingSphere} attribute.
-     * Bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
-     */
-    computeBoundingSphere(): void;
-
-    /**
-     * Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer
-     * used in your app.
-     */
-    dispose(): this;
-
-    /**
-     * Takes a sort a function that is run before render. The function takes a list of instances to sort and a camera.
-     * The objects in the list include a "z" field to perform a depth-ordered sort with.
-     */
-    setCustomSort(
-        sortFunction:
-            | ((this: this, list: Array<{ start: number; count: number; z: number }>, camera: Camera) => void)
-            | null,
-    ): this;
-
-    /**
-     * Get the color of the defined geometry.
-     * @param instanceId The id of an instance to get the color of.
-     * @param target The target object to copy the color in to.
-     */
-    getColorAt(instanceId: number, target: Color): void;
-
-    /**
-     * Get the local transformation matrix of the defined instance.
-     * @param instanceId The id of an instance to get the matrix of.
-     * @param target This 4x4 matrix will be set to the local transformation matrix of the defined instance.
-     */
-    getMatrixAt(instanceId: number, target: Matrix4): Matrix4;
-
-    /**
-     * Get whether the given instance is marked as "visible" or not.
-     * @param instanceId The id of an instance to get the visibility state of.
-     */
-    getVisibleAt(instanceId: number): boolean;
-
-    /**
-     * Sets the given color to the defined geometry instance.
-     * @param instanceId The id of the instance to set the color of.
-     * @param color The color to set the instance to.
-     */
-    setColorAt(instanceId: number, color: Color): void;
-
-    /**
-     * Sets the given local transformation matrix to the defined instance.
-     * @param instanceId The id of an instance to set the matrix of.
-     * @param matrix A 4x4 matrix representing the local transformation of a single instance.
-     */
-    setMatrixAt(instanceId: number, matrix: Matrix4): this;
-
-    /**
-     * Sets the visibility of the instance at the given index.
-     * @param instanceId The id of the instance to set the visibility of.
-     * @param visible A boolean value indicating the visibility state.
-     */
-    setVisibleAt(instanceId: number, visible: boolean): this;
-
-    /**
-     * Adds the given geometry to the {@link BatchedMesh} and returns the associated index referring to it.
-     * @param geometry The geometry to add into the {@link BatchedMesh}.
-     * @param reservedVertexRange Optional parameter specifying the amount of vertex buffer space to reserve for the
-     * added geometry. This is necessary if it is planned to set a new geometry at this index at a later time that is
-     * larger than the original geometry. Defaults to the length of the given geometry vertex buffer.
-     * @param reservedIndexRange Optional parameter specifying the amount of index buffer space to reserve for the added
-     * geometry. This is necessary if it is planned to set a new geometry at this index at a later time that is larger
-     * than the original geometry. Defaults to the length of the given geometry index buffer.
-     */
-    addGeometry(geometry: BufferGeometry, reservedVertexRange?: number, reservedIndexRange?: number): number;
-
-    /**
-     * Adds a new instance to the {@link BatchedMesh} using the geometry of the given geometryId and returns a new id
-     * referring to the new instance to be used by other functions.
-     * @param geometryId The id of a previously added geometry via "addGeometry" to add into the {@link BatchedMesh} to
-     * render.
-     */
-    addInstance(geometryId: number): number;
-
-    /**
-     * Replaces the geometry at `geometryId` with the provided geometry. Throws an error if there is not enough space
-     * reserved for geometry. Calling this will change all instances that are rendering that geometry.
-     * @param geometryId Which geometry id to replace with this geometry.
-     * @param geometry The geometry to substitute at the given geometry id.
-     */
-    setGeometryAt(geometryId: number, geometry: BufferGeometry): number;
-
-    getBoundingBoxAt(geometryId: number, target: Box3): Box3 | null;
-    getBoundingSphereAt(geometryId: number, target: Sphere): Sphere | null;
+	/**
+	 * This bounding box encloses all instances of the {@link BatchedMesh}. Can be calculated with
+	 * {@link .computeBoundingBox()}.
+	 * @default null
+	 */
+	boundingBox: Box3 | null;
+
+	/**
+	 * This bounding sphere encloses all instances of the {@link BatchedMesh}. Can be calculated with
+	 * {@link .computeBoundingSphere()}.
+	 * @default null
+	 */
+	boundingSphere: Sphere | null;
+
+	customSort: ((this: this, list: Array<{ start: number; count: number; z: number }>, camera: Camera) => void) | null;
+
+	/**
+	 * If true then the individual objects within the {@link BatchedMesh} are frustum culled.
+	 * @default true
+	 */
+	perObjectFrustumCulled: boolean;
+
+	/**
+	 * If true then the individual objects within the {@link BatchedMesh} are sorted to improve overdraw-related
+	 * artifacts. If the material is marked as "transparent" objects are rendered back to front and if not then they are
+	 * rendered front to back.
+	 * @default true
+	 */
+	sortObjects: boolean;
+
+	/**
+	 * The maximum number of individual geometries that can be stored in the {@link BatchedMesh}. Read only.
+	 */
+	get maxInstanceCount(): number;
+
+	/**
+	 * Read-only flag to check if a given object is of type {@link BatchedMesh}.
+	 */
+	readonly isBatchedMesh: true;
+
+	/**
+	 * @param maxInstanceCount the max number of individual geometries planned to be added.
+	 * @param maxVertexCount the max number of vertices to be used by all geometries.
+	 * @param maxIndexCount the max number of indices to be used by all geometries.
+	 * @param material an instance of {@link Material}. Default is a new {@link MeshBasicMaterial}.
+	 */
+	constructor(maxInstanceCount: number, maxVertexCount: number, maxIndexCount?: number, material?: Material);
+
+	/**
+	 * Computes the bounding box, updating {@link .boundingBox} attribute.
+	 * Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+	 */
+	computeBoundingBox(): void;
+
+	/**
+	 * Computes the bounding sphere, updating {@link .boundingSphere} attribute.
+	 * Bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+	 */
+	computeBoundingSphere(): void;
+
+	/**
+	 * Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer
+	 * used in your app.
+	 */
+	dispose(): this;
+
+	/**
+	 * Takes a sort a function that is run before render. The function takes a list of instances to sort and a camera.
+	 * The objects in the list include a "z" field to perform a depth-ordered sort with.
+	 */
+	setCustomSort(sortFunction: ((this: this, list: Array<{ start: number; count: number; z: number }>, camera: Camera) => void) | null): this;
+
+	/**
+	 * Get the color of the defined geometry.
+	 * @param instanceId The id of an instance to get the color of.
+	 * @param target The target object to copy the color in to.
+	 */
+	getColorAt(instanceId: number, target: Color): void;
+
+	/**
+	 * Get the local transformation matrix of the defined instance.
+	 * @param instanceId The id of an instance to get the matrix of.
+	 * @param target This 4x4 matrix will be set to the local transformation matrix of the defined instance.
+	 */
+	getMatrixAt(instanceId: number, target: Matrix4): Matrix4;
+
+	/**
+	 * Get whether the given instance is marked as "visible" or not.
+	 * @param instanceId The id of an instance to get the visibility state of.
+	 */
+	getVisibleAt(instanceId: number): boolean;
+
+	/**
+	 * Sets the given color to the defined geometry instance.
+	 * @param instanceId The id of the instance to set the color of.
+	 * @param color The color to set the instance to.
+	 */
+	setColorAt(instanceId: number, color: Color): void;
+
+	/**
+	 * Sets the given local transformation matrix to the defined instance.
+	 * @param instanceId The id of an instance to set the matrix of.
+	 * @param matrix A 4x4 matrix representing the local transformation of a single instance.
+	 */
+	setMatrixAt(instanceId: number, matrix: Matrix4): this;
+
+	/**
+	 * Sets the visibility of the instance at the given index.
+	 * @param instanceId The id of the instance to set the visibility of.
+	 * @param visible A boolean value indicating the visibility state.
+	 */
+	setVisibleAt(instanceId: number, visible: boolean): this;
+
+	/**
+	 * Adds the given geometry to the {@link BatchedMesh} and returns the associated index referring to it.
+	 * @param geometry The geometry to add into the {@link BatchedMesh}.
+	 * @param reservedVertexRange Optional parameter specifying the amount of vertex buffer space to reserve for the
+	 * added geometry. This is necessary if it is planned to set a new geometry at this index at a later time that is
+	 * larger than the original geometry. Defaults to the length of the given geometry vertex buffer.
+	 * @param reservedIndexRange Optional parameter specifying the amount of index buffer space to reserve for the added
+	 * geometry. This is necessary if it is planned to set a new geometry at this index at a later time that is larger
+	 * than the original geometry. Defaults to the length of the given geometry index buffer.
+	 */
+	addGeometry(geometry: BufferGeometry, reservedVertexRange?: number, reservedIndexRange?: number): number;
+
+	/**
+	 * Adds a new instance to the {@link BatchedMesh} using the geometry of the given geometryId and returns a new id
+	 * referring to the new instance to be used by other functions.
+	 * @param geometryId The id of a previously added geometry via "addGeometry" to add into the {@link BatchedMesh} to
+	 * render.
+	 */
+	addInstance(geometryId: number): number;
+
+	/**
+	 * Replaces the geometry at `geometryId` with the provided geometry. Throws an error if there is not enough space
+	 * reserved for geometry. Calling this will change all instances that are rendering that geometry.
+	 * @param geometryId Which geometry id to replace with this geometry.
+	 * @param geometry The geometry to substitute at the given geometry id.
+	 */
+	setGeometryAt(geometryId: number, geometry: BufferGeometry): number;
+
+	getBoundingBoxAt(geometryId: number, target: Box3): Box3 | null;
+	getBoundingSphereAt(geometryId: number, target: Sphere): Sphere | null;
 }
 
 export { BatchedMesh };