import type { Nullable, DeepImmutableObject } from "../types"; import { VertexBuffer, Buffer } from "../Buffers/buffer"; import { Matrix } from "../Maths/math.vector"; declare module "./mesh" { interface Mesh { /** * Gets or sets a boolean defining if we want picking to pick thin instances as well */ thinInstanceEnablePicking: boolean; /** * Indicates that a buffer created as static should be recreated if the buffer is updated (by calling thinInstanceSetMatrixAt or thinInstanceSetAttributeAt, for eg.) * If this flag is false (the default behavior), a buffer created as "static" won't show any update done to it, and will stay the same as it was created. * Note however that recreating a buffer each time there's a change will have some performance cost, that's why it is set to false by default. * You should set this flag to true only if your static buffers should change infrequently. If they change frequently, you should create your buffers as "dynamic" instead. */ thinInstanceAllowAutomaticStaticBufferRecreation: boolean; /** * Creates a new thin instance * @param matrix the matrix or array of matrices (position, rotation, scale) of the thin instance(s) to create * @param refresh true to refresh the underlying gpu buffer (default: true). If you do multiple calls to this method in a row, set refresh to true only for the last call to save performance * @returns the thin instance index number. If you pass an array of matrices, other instance indexes are index+1, index+2, etc */ thinInstanceAdd(matrix: DeepImmutableObject | Array>, refresh?: boolean): number; /** * Adds the transformation (matrix) of the current mesh as a thin instance * @param refresh true to refresh the underlying gpu buffer (default: true). If you do multiple calls to this method in a row, set refresh to true only for the last call to save performance * @returns the thin instance index number */ thinInstanceAddSelf(refresh?: boolean): number; /** * Registers a custom attribute to be used with thin instances * @param kind name of the attribute * @param stride size in floats of the attribute */ thinInstanceRegisterAttribute(kind: string, stride: number): void; /** * Sets the matrix of a thin instance * @param index index of the thin instance * @param matrix matrix to set * @param refresh true to refresh the underlying gpu buffer (default: true). If you do multiple calls to this method in a row, set refresh to true only for the last call to save performance */ thinInstanceSetMatrixAt(index: number, matrix: DeepImmutableObject, refresh?: boolean): void; /** * Sets the value of a custom attribute for a thin instance * @param kind name of the attribute * @param index index of the thin instance * @param value value to set * @param refresh true to refresh the underlying gpu buffer (default: true). If you do multiple calls to this method in a row, set refresh to true only for the last call to save performance */ thinInstanceSetAttributeAt(kind: string, index: number, value: Array, refresh?: boolean): void; /** * Gets / sets the number of thin instances to display. Note that you can't set a number higher than what the underlying buffer can handle. */ thinInstanceCount: number; /** * Sets a buffer to be used with thin instances. This method is a faster way to setup multiple instances than calling thinInstanceAdd repeatedly * @param kind name of the attribute. Use "matrix" to setup the buffer of matrices * @param buffer buffer to set * @param stride size in floats of each value of the buffer * @param staticBuffer indicates that the buffer is static, so that you won't change it after it is set (better performances - true by default) */ thinInstanceSetBuffer(kind: string, buffer: Nullable, stride?: number, staticBuffer?: boolean): void; /** * Gets the list of world matrices * @returns an array containing all the world matrices from the thin instances */ thinInstanceGetWorldMatrices(): Matrix[]; /** * Synchronize the gpu buffers with a thin instance buffer. Call this method if you update later on the buffers passed to thinInstanceSetBuffer * @param kind name of the attribute to update. Use "matrix" to update the buffer of matrices */ thinInstanceBufferUpdated(kind: string): void; /** * Applies a partial update to a buffer directly on the GPU * Note that the buffer located on the CPU is NOT updated! It's up to you to update it (or not) with the same data you pass to this method * @param kind name of the attribute to update. Use "matrix" to update the buffer of matrices * @param data the data to set in the GPU buffer * @param offset the offset in the GPU buffer where to update the data */ thinInstancePartialBufferUpdate(kind: string, data: Float32Array, offset: number): void; /** * Refreshes the bounding info, taking into account all the thin instances defined * @param forceRefreshParentInfo true to force recomputing the mesh bounding info and use it to compute the aggregated bounding info * @param applySkeleton defines whether to apply the skeleton before computing the bounding info * @param applyMorph defines whether to apply the morph target before computing the bounding info */ thinInstanceRefreshBoundingInfo(forceRefreshParentInfo?: boolean, applySkeleton?: boolean, applyMorph?: boolean): void; /** @internal */ _thinInstanceInitializeUserStorage(): void; /** @internal */ _thinInstanceUpdateBufferSize(kind: string, numInstances?: number): void; /** @internal */ _thinInstanceCreateMatrixBuffer(kind: string, buffer: Nullable, staticBuffer: boolean): Buffer; /** @internal */ _thinInstanceRecreateBuffer(kind: string, staticBuffer?: boolean): void; /** @internal */ _userThinInstanceBuffersStorage: { data: { [key: string]: Float32Array; }; sizes: { [key: string]: number; }; vertexBuffers: { [key: string]: Nullable; }; strides: { [key: string]: number; }; }; } }