@needle-tools/engine
Version:
Needle Engine is a web-based runtime for 3D apps. It runs on your machine for development with great integrations into editors like Unity or Blender - and can be deployed onto any device! It is flexible, extensible and networking and XR are built-in.
141 lines (140 loc) • 5.82 kB
TypeScript
import { BatchedMesh, BufferGeometry, Material, Matrix4, Mesh, Object3D } from "three";
import { Context } from "../engine/engine_setup.js";
import type { Renderer } from "./Renderer.js";
declare class InstancingSetupArgs {
rend: Renderer;
foundMeshes: number;
useMatrixWorldAutoUpdate: boolean;
}
/**
* Handles instancing for Needle Engine.
*/
export declare class InstancingHandler {
static readonly instance: InstancingHandler;
/** This is the initial instance count when creating a new instancing structure.
* Override this and the number of max instances that you expect for a given object.
* The larger the value the more objects can be added without having to resize but it will also consume more memory.
* (The instancing mesh renderer will grow x2 if the max instance count is reached)
* @default 4
* @returns The initial instance count
* */
static getStartInstanceCount: (_obj: Object3D) => number;
objs: InstancedMeshRenderer[];
setup(renderer: Renderer, obj: Object3D, context: Context, handlesArray: InstanceHandle[] | null, args: InstancingSetupArgs, level?: number): InstanceHandle[] | null;
private tryCreateOrAddInstance;
private autoUpdateInstanceMatrix;
}
/**
* The instance handle is used to interface with the mesh that is rendered using instancing.
*/
export declare class InstanceHandle {
static readonly all: InstanceHandle[];
/** The name of the object */
get name(): string;
get isActive(): boolean;
get vertexCount(): number;
get maxVertexCount(): number;
get reservedVertexCount(): number;
get indexCount(): number;
get maxIndexCount(): number;
get reservedIndexCount(): number;
/** The object that is being instanced */
readonly object: Mesh;
/** The instancer/BatchedMesh that is rendering this object*/
readonly renderer: InstancedMeshRenderer;
/** @internal */
__instanceIndex: number;
/** @internal */
__reservedVertexRange: number;
/** @internal */
__reservedIndexRange: number;
__geometryIndex: number;
/** The mesh information of the object - this tries to also calculate the LOD info */
readonly meshInformation: MeshInformation;
constructor(originalObject: Mesh, instancer: InstancedMeshRenderer);
/** Calculates the mesh information again
* @returns true if the vertex count or index count has changed
*/
updateMeshInformation(): boolean;
/** Updates the matrix from the rendered object. Will also call updateWorldMatrix internally */
updateInstanceMatrix(updateChildren?: boolean, updateMatrix?: boolean): void;
/** Updates the matrix of the instance */
setMatrix(matrix: Matrix4): void;
/** Can be used to change the geometry of this instance */
setGeometry(geo: BufferGeometry): boolean;
/** Adds this object to the instancing renderer (effectively activating instancing) */
add(): void;
/** Removes this object from the instancing renderer
* @param delete_ If true, the instance handle will be removed from the global list
*/
remove(delete_: boolean): void;
}
declare class InstancedMeshRenderer {
/** The three instanced mesh
* @link https://threejs.org/docs/#api/en/objects/InstancedMesh
*/
get batchedMesh(): BatchedMesh;
get visible(): boolean;
set visible(val: boolean);
get castShadow(): boolean;
set castShadow(val: boolean);
set receiveShadow(val: boolean);
/** If true, the instancer is allowed to grow when the max instance count is reached */
allowResize: boolean;
/** The name of the instancer */
name: string;
/** The added geometry */
readonly geometry: BufferGeometry;
/** The material used for the instanced mesh */
readonly material: Material;
/** The current number of instances */
get count(): number;
/** Update the bounding box and sphere of the instanced mesh
* @param box If true, update the bounding box
* @param sphere If true, update the bounding sphere
*/
updateBounds(box?: boolean, sphere?: boolean): void;
private _context;
private _batchedMesh;
private _handles;
private readonly _geometryIds;
private _maxInstanceCount;
private _currentInstanceCount;
private _currentVertexCount;
private _currentIndexCount;
private _maxVertexCount;
private _maxIndexCount;
private static nullMatrix;
/** Check if the geometry can be added to this instancer
* @param geometry The geometry to check
* @param material The material of the geometry
* @returns true if the geometry can be added
*/
canAdd(geometry: BufferGeometry, material: Material): boolean;
private _needUpdateBounds;
private _debugMaterial;
constructor(name: string, geo: BufferGeometry, material: Material, initialMaxCount: number, context: Context);
dispose(): void;
addInstance(obj: Mesh): InstanceHandle | null;
add(handle: InstanceHandle): boolean;
remove(handle: InstanceHandle, delete_: boolean): void;
updateInstance(mat: Matrix4, index: number): void;
updateGeometry(geo: BufferGeometry, geometryIndex: number): boolean;
private onBeforeRender;
private onAfterRender;
private validateGeometry;
private markNeedsUpdate;
/**
* @param geo The geometry to add (if none is provided it means the geometry is already added and just updated)
*/
private mustGrow;
private grow;
private tryEstimateVertexCountSize;
private addGeometry;
private removeGeometry;
}
declare type MeshInformation = {
vertexCount: number;
indexCount: number;
};
export {};