/**
 * Represents a BabylonJS indice array which can be either Uint16 (if used with less  than Uint16 vertices)  or Uint32
 */
export type GeometryIndiceArray = Uint16Array | Uint32Array;
/**
 * Represents a geometry that can be sent to BabylonJS
 */
export interface GeometryArrays {
    /**
     * Positions (x,y,z).
     */
    readonly positions: Float32Array;
    /**
     * Uvs (u,v)
     */
    readonly uvs: Float32Array;
    /**
     * Indices. Describes triangles by referencing items in {@link positions}.
     */
    readonly indices: GeometryIndiceArray;
}
/**
 * Represent an offset into a Geometry array that indicates the position of a mesh or sub-mesh
 */
export interface GeometryArrayOffset {
    readonly indices: number;
    readonly positions: number;
}
/**
 * Represents a block of reusable geometry memory.
 * It is expensive to allocate memory for geometry arrays (vertices, normals, indices) for each mesh.
 * By using this class we can allocate a large block of memory and then allocate smaller slices from this block
 * to write geometry data to. For example during mesh merging.
 */
export declare class GeometryBuffer {
    private static readonly _memoryBlockOptions;
    private readonly _verticesBlock;
    private readonly _normalsBlock;
    private readonly _uint32IndiceBlock;
    /**
     * Total size in bytes of geometry memory.
     */
    get byteLength(): number;
    /**
     * Updates the maximum length of the geometry buffer to accommodate the given primitive count and indice count.
     * If the given counts are greater than the current maximum lengths, then the maximum size will be updated.
     *
     * @param primitiveCount - The desired primitive count.
     * @param indiceCount - The desired indice count.
     * @returns This  {@link GeometryBuffer} instance.
     */
    maximizeLength(primitiveCount: number, indiceCount: number): GeometryBuffer;
    /**
     * Allocate a block of geometry arrays ({@link GeometryArrays}). Only one allocation at a time may exist
     * Therefore next call to this method will invalidate contents of previous {@link GeometryArrays} instances.
     * @param primitiveCount Number of primitives to allocate.
     * @param indiceCount Number of indices to allocate.
     */
    malloc(primitiveCount: number, indiceCount: number): GeometryArrays;
    /**
     * Frees the memory used by the geometry buffer.
     */
    free(): void;
    private indiceBlock;
}
//# sourceMappingURL=GeometryBuffer.d.ts.map