@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Particles/solidParticleSystem.d.ts

@@ -0,0 +1,534 @@
+/**
+ * The SPS is a single updatable mesh. The solid particles are simply separate parts or faces fo this big mesh.
+ *As it is just a mesh, the SPS has all the same properties than any other BJS mesh : not more, not less. It can be scaled, rotated, translated, enlighted, textured, moved, etc.
+
+ * The SPS is also a particle system. It provides some methods to manage the particles.
+ * However it is behavior agnostic. This means it has no emitter, no particle physics, no particle recycler. You have to implement your own behavior.
+ *
+ * Full documentation here : https://doc.babylonjs.com/how_to/Solid_Particle_System
+ */
+export class SolidParticleSystem {
+    /**
+     * Creates a SPS (Solid Particle System) object.
+     * @param name (String) is the SPS name, this will be the underlying mesh name.
+     * @param scene (Scene) is the scene in which the SPS is added.
+     * @param options defines the options of the sps e.g.
+     * * updatable (optional boolean, default true) : if the SPS must be updatable or immutable.
+     * * isPickable (optional boolean, default false) : if the solid particles must be pickable.
+     * * enableDepthSort (optional boolean, default false) : if the solid particles must be sorted in the geometry according to their distance to the camera.
+     * * useModelMaterial (optional boolean, default false) : if the model materials must be used to create the SPS multimaterial. This enables the multimaterial supports of the SPS.
+     * * enableMultiMaterial (optional boolean, default false) : if the solid particles can be given different materials.
+     * * expandable (optional boolean, default false) : if particles can still be added after the initial SPS mesh creation.
+     * * particleIntersection (optional boolean, default false) : if the solid particle intersections must be computed.
+     * * boundingSphereOnly (optional boolean, default false) : if the particle intersection must be computed only with the bounding sphere (no bounding box computation, so faster).
+     * * bSphereRadiusFactor (optional float, default 1.0) : a number to multiply the bounding sphere radius by in order to reduce it for instance.
+     * * computeBoundingBox (optional boolean, default false): if the bounding box of the entire SPS will be computed (for occlusion detection, for example). If it is false, the bounding box will be the bounding box of the first particle.
+     * * autoFixFaceOrientation (optional boolean, default false): if the particle face orientations will be flipped for transformations that change orientation (scale (-1, 1, 1), for example)
+     * @param options.updatable
+     * @param options.isPickable
+     * @param options.enableDepthSort
+     * @param options.particleIntersection
+     * @param options.boundingSphereOnly
+     * @param options.bSphereRadiusFactor
+     * @param options.expandable
+     * @param options.useModelMaterial
+     * @param options.enableMultiMaterial
+     * @param options.computeBoundingBox
+     * @param options.autoFixFaceOrientation
+     * @example bSphereRadiusFactor = 1.0 / Math.sqrt(3.0) => the bounding sphere exactly matches a spherical mesh.
+     */
+    constructor(name: any, scene: any, options: any);
+    /**
+     *  The SPS array of Solid Particle objects. Just access each particle as with any classic array.
+     *  Example : var p = SPS.particles[i];
+     */
+    particles: any[];
+    /**
+     * The SPS total number of particles. Read only. Use SPS.counter instead if you need to set your own value.
+     */
+    nbParticles: number;
+    /**
+     * If the particles must ever face the camera (default false). Useful for planar particles.
+     */
+    billboard: boolean;
+    /**
+     * Recompute normals when adding a shape
+     */
+    recomputeNormals: boolean;
+    /**
+     * This a counter ofr your own usage. It's not set by any SPS functions.
+     */
+    counter: number;
+    /**
+     * This empty object is intended to store some SPS specific or temporary values in order to lower the Garbage Collector activity.
+     * Please read : https://doc.babylonjs.com/how_to/Solid_Particle_System#garbage-collector-concerns
+     */
+    vars: {};
+    /**
+     * If the particle intersection must be computed only with the bounding sphere (no bounding box computation, so faster). (Internal use only)
+     * @internal
+     */
+    _bSphereOnly: any;
+    /**
+     * A number to multiply the bounding sphere radius by in order to reduce it for instance. (Internal use only)
+     * @internal
+     */
+    _bSphereRadiusFactor: any;
+    _positions: any[];
+    _indices: any[];
+    _normals: any[];
+    _colors: any[];
+    _uvs: any[];
+    _index: number;
+    _updatable: any;
+    _pickable: any;
+    _isVisibilityBoxLocked: boolean;
+    _alwaysVisible: boolean;
+    _depthSort: any;
+    _expandable: any;
+    _shapeCounter: number;
+    _copy: SolidParticle;
+    _color: Color4;
+    _computeParticleColor: boolean;
+    _computeParticleTexture: boolean;
+    _computeParticleRotation: boolean;
+    _computeParticleVertex: boolean;
+    _computeBoundingBox: any;
+    _autoFixFaceOrientation: any;
+    _depthSortParticles: boolean;
+    _mustUnrotateFixedNormals: boolean;
+    _particlesIntersect: any;
+    _needs32Bits: boolean;
+    _isNotBuilt: boolean;
+    _lastParticleId: number;
+    _idxOfId: any[];
+    _multimaterialEnabled: any;
+    _useModelMaterial: any;
+    _depthSortFunction: (p1: any, p2: any) => number;
+    _materialSortFunction: (p1: any, p2: any) => number;
+    _autoUpdateSubMeshes: boolean;
+    _recomputeInvisibles: boolean;
+    name: any;
+    _scene: any;
+    _camera: any;
+    pickedBySubMesh: never[][] | undefined;
+    pickedParticles: never[] | undefined;
+    depthSortedParticles: any[] | undefined;
+    _multimaterial: MultiMaterial | undefined;
+    _materials: any[] | undefined;
+    _materialIndexesById: {} | undefined;
+    _tmpVertex: SolidParticleVertex;
+    /**
+     * Builds the SPS underlying mesh. Returns a standard Mesh.
+     * If no model shape was added to the SPS, the returned mesh is just a single triangular plane.
+     * @returns the created mesh
+     */
+    buildMesh(): Mesh;
+    _indices32: Uint32Array | Uint16Array | null | undefined;
+    _positions32: Float32Array | null | undefined;
+    _uvs32: Float32Array | null | undefined;
+    _colors32: Float32Array | null | undefined;
+    mesh: Mesh | undefined;
+    _normals32: Float32Array | null | undefined;
+    _fixedNormal32: Float32Array | null | undefined;
+    /**
+     * Digests the mesh and generates as many solid particles in the system as wanted. Returns the SPS.
+     * These particles will have the same geometry than the mesh parts and will be positioned at the same localisation than the mesh original places.
+     * Thus the particles generated from `digest()` have their property `position` set yet.
+     * @param mesh ( Mesh ) is the mesh to be digested
+     * @param options {facetNb} (optional integer, default 1) is the number of mesh facets per particle, this parameter is overridden by the parameter `number` if any
+     * {delta} (optional integer, default 0) is the random extra number of facets per particle , each particle will have between `facetNb` and `facetNb + delta` facets
+     * {number} (optional positive integer) is the wanted number of particles : each particle is built with `mesh_total_facets / number` facets
+     * {storage} (optional existing array) is an array where the particles will be stored for a further use instead of being inserted in the SPS.
+     * @param options.facetNb
+     * @param options.number
+     * @param options.delta
+     * @param options.storage
+     * @returns the current SPS
+     */
+    digest(mesh: any, options: facetNb): SolidParticleSystem;
+    /**
+     * Unrotate the fixed normals in case the mesh was built with pre-rotated particles, ex : use of positionFunction in addShape()
+     * @internal
+     */
+    _unrotateFixedNormals(): void;
+    /**
+     * Resets the temporary working copy particle
+     * @internal
+     */
+    _resetCopy(): void;
+    /**
+     * Inserts the shape model geometry in the global SPS mesh by updating the positions, indices, normals, colors, uvs arrays
+     * @param p the current index in the positions array to be updated
+     * @param ind the current index in the indices array
+     * @param shape a Vector3 array, the shape geometry
+     * @param positions the positions array to be updated
+     * @param meshInd the shape indices array
+     * @param indices the indices array to be updated
+     * @param meshUV the shape uv array
+     * @param uvs the uv array to be updated
+     * @param meshCol the shape color array
+     * @param colors the color array to be updated
+     * @param meshNor the shape normals array
+     * @param normals the normals array to be updated
+     * @param idx the particle index
+     * @param idxInShape the particle index in its shape
+     * @param options the addShape() method  passed options
+     * @param model
+     * @model the particle model
+     * @internal
+     */
+    _meshBuilder(p: any, ind: any, shape: any, positions: any, meshInd: any, indices: any, meshUV: any, uvs: any, meshCol: any, colors: any, meshNor: any, normals: any, idx: any, idxInShape: any, options: any, model: any): SolidParticle;
+    /**
+     * Returns a shape Vector3 array from positions float array
+     * @param positions float array
+     * @returns a vector3 array
+     * @internal
+     */
+    _posToShape(positions: any): Vector3[];
+    /**
+     * Returns a shapeUV array from a float uvs (array deep copy)
+     * @param uvs as a float array
+     * @returns a shapeUV array
+     * @internal
+     */
+    _uvsToShapeUV(uvs: any): any[];
+    /**
+     * Adds a new particle object in the particles array
+     * @param idx particle index in particles array
+     * @param id particle id
+     * @param idxpos positionIndex : the starting index of the particle vertices in the SPS "positions" array
+     * @param idxind indiceIndex : he starting index of the particle indices in the SPS "indices" array
+     * @param model particle ModelShape object
+     * @param shapeId model shape identifier
+     * @param idxInShape index of the particle in the current model
+     * @param bInfo model bounding info object
+     * @param storage target storage array, if any
+     * @internal
+     */
+    _addParticle(idx: any, id: any, idxpos: any, idxind: any, model: any, shapeId: any, idxInShape: any, bInfo?: null, storage?: null): SolidParticle;
+    /**
+     * Adds some particles to the SPS from the model shape. Returns the shape id.
+     * Please read the doc : https://doc.babylonjs.com/how_to/Solid_Particle_System#create-an-immutable-sps
+     * @param mesh is any Mesh object that will be used as a model for the solid particles.
+     * @param nb (positive integer) the number of particles to be created from this model
+     * @param options {positionFunction} is an optional javascript function to called for each particle on SPS creation.
+     * {vertexFunction} is an optional javascript function to called for each vertex of each particle on SPS creation
+     * {storage} (optional existing array) is an array where the particles will be stored for a further use instead of being inserted in the SPS.
+     * @param options.positionFunction
+     * @param options.vertexFunction
+     * @param options.storage
+     * @returns the number of shapes in the system
+     */
+    addShape(mesh: any, nb: any, options: positionFunction): number;
+    /**
+     * Rebuilds a particle back to its just built status : if needed, recomputes the custom positions and vertices
+     * @internal
+     */
+    _rebuildParticle(particle: any, reset?: boolean): void;
+    /**
+     * Rebuilds the whole mesh and updates the VBO : custom positions and vertices are recomputed if needed.
+     * @param reset boolean, default false : if the particles must be reset at position and rotation zero, scaling 1, color white, initial UVs and not parented.
+     * @returns the SPS.
+     */
+    rebuildMesh(reset?: boolean): SolidParticleSystem;
+    /** Removes the particles from the start-th to the end-th included from an expandable SPS (required).
+     *  Returns an array with the removed particles.
+     *  If the number of particles to remove is lower than zero or greater than the global remaining particle number, then an empty array is returned.
+     *  The SPS can't be empty so at least one particle needs to remain in place.
+     *  Under the hood, the VertexData array, so the VBO buffer, is recreated each call.
+     * @param start index of the first particle to remove
+     * @param end index of the last particle to remove (included)
+     * @returns an array populated with the removed particles
+     */
+    removeParticles(start: any, end: any): any[];
+    /**
+     * Inserts some pre-created particles in the solid particle system so that they can be managed by setParticles().
+     * @param solidParticleArray an array populated with Solid Particles objects
+     * @returns the SPS
+     */
+    insertParticlesFromArray(solidParticleArray: any): SolidParticleSystem;
+    /**
+     * Creates a new particle and modifies the SPS mesh geometry :
+     * - calls _meshBuilder() to increase the SPS mesh geometry step by step
+     * - calls _addParticle() to populate the particle array
+     * factorized code from addShape() and insertParticlesFromArray()
+     * @param idx particle index in the particles array
+     * @param i particle index in its shape
+     * @param modelShape particle ModelShape object
+     * @param shape shape vertex array
+     * @param meshInd shape indices array
+     * @param meshUV shape uv array
+     * @param meshCol shape color array
+     * @param meshNor shape normals array
+     * @param bbInfo shape bounding info
+     * @param storage target particle storage
+     * @param options
+     * @options addShape() passed options
+     * @internal
+     */
+    _insertNewParticle(idx: any, i: any, modelShape: any, shape: any, meshInd: any, meshUV: any, meshCol: any, meshNor: any, bbInfo: any, storage: any, options: any): SolidParticle | null;
+    /**
+     *  Sets all the particles : this method actually really updates the mesh according to the particle positions, rotations, colors, textures, etc.
+     *  This method calls `updateParticle()` for each particle of the SPS.
+     *  For an animated SPS, it is usually called within the render loop.
+     * This methods does nothing if called on a non updatable or not yet built SPS. Example : buildMesh() not called after having added or removed particles from an expandable SPS.
+     * @param start The particle index in the particle array where to start to compute the particle property values _(default 0)_
+     * @param end The particle index in the particle array where to stop to compute the particle property values _(default nbParticle - 1)_
+     * @param update If the mesh must be finally updated on this call after all the particle computations _(default true)_
+     * @returns the SPS.
+     */
+    setParticles(start?: number, end?: number, update?: boolean): SolidParticleSystem;
+    /**
+     * Disposes the SPS.
+     */
+    dispose(): void;
+    _materialIndexes: any[] | null | undefined;
+    _indicesByMaterial: number[] | null | undefined;
+    /** Returns an object {idx: number faceId: number} for the picked particle from the passed pickingInfo object.
+     * idx is the particle index in the SPS
+     * faceId is the picked face index counted within this particle.
+     * Returns null if the pickInfo can't identify a picked particle.
+     * @param pickingInfo (PickingInfo object)
+     * @returns {idx: number, faceId: number} or null
+     */
+    pickedParticle(pickingInfo: any): idx;
+    /**
+     * Returns a SolidParticle object from its identifier : particle.id
+     * @param id (integer) the particle Id
+     * @returns the searched particle or null if not found in the SPS.
+     */
+    getParticleById(id: any): any;
+    /**
+     * Returns a new array populated with the particles having the passed shapeId.
+     * @param shapeId (integer) the shape identifier
+     * @returns a new solid particle array
+     */
+    getParticlesByShapeId(shapeId: any): any[];
+    /**
+     * Populates the passed array "ref" with the particles having the passed shapeId.
+     * @param shapeId the shape identifier
+     * @returns the SPS
+     * @param ref
+     */
+    getParticlesByShapeIdToRef(shapeId: any, ref: any): SolidParticleSystem;
+    /**
+     * Computes the required SubMeshes according the materials assigned to the particles.
+     * @returns the solid particle system.
+     * Does nothing if called before the SPS mesh is built.
+     */
+    computeSubMeshes(): SolidParticleSystem;
+    /**
+     * Sorts the solid particles by material when MultiMaterial is enabled.
+     * Updates the indices32 array.
+     * Updates the indicesByMaterial array.
+     * Updates the mesh indices array.
+     * @returns the SPS
+     * @internal
+     */
+    _sortParticlesByMaterial(): SolidParticleSystem;
+    /**
+     * Sets the material indexes by id materialIndexesById[id] = materialIndex
+     * @internal
+     */
+    _setMaterialIndexesById(): void;
+    /**
+     * Returns an array with unique values of Materials from the passed array
+     * @param array the material array to be checked and filtered
+     * @internal
+     */
+    _filterUniqueMaterialId(array: any): any;
+    /**
+     * Sets a new Standard Material as _defaultMaterial if not already set.
+     * @internal
+     */
+    _setDefaultMaterial(): StandardMaterial;
+    _defaultMaterial: StandardMaterial | undefined;
+    /**
+     * Visibility helper : Recomputes the visible size according to the mesh bounding box
+     * doc : https://doc.babylonjs.com/how_to/Solid_Particle_System#sps-visibility
+     * @returns the SPS.
+     */
+    refreshVisibleSize(): SolidParticleSystem;
+    /**
+     * Visibility helper : Sets the size of a visibility box, this sets the underlying mesh bounding box.
+     * @param size the size (float) of the visibility box
+     * note : this doesn't lock the SPS mesh bounding box.
+     * doc : https://doc.babylonjs.com/how_to/Solid_Particle_System#sps-visibility
+     */
+    setVisibilityBox(size: any): void;
+    /**
+     * Sets the SPS as always visible or not
+     * doc : https://doc.babylonjs.com/how_to/Solid_Particle_System#sps-visibility
+     */
+    set isAlwaysVisible(arg: boolean);
+    /**
+     * Gets whether the SPS as always visible or not
+     * doc : https://doc.babylonjs.com/how_to/Solid_Particle_System#sps-visibility
+     */
+    get isAlwaysVisible(): boolean;
+    /**
+     * Sets the SPS visibility box as locked or not. This enables/disables the underlying mesh bounding box updates.
+     * doc : https://doc.babylonjs.com/how_to/Solid_Particle_System#sps-visibility
+     */
+    set isVisibilityBoxLocked(arg: boolean);
+    /**
+     * Gets if the SPS visibility box as locked or not. This enables/disables the underlying mesh bounding box updates.
+     * doc : https://doc.babylonjs.com/how_to/Solid_Particle_System#sps-visibility
+     */
+    get isVisibilityBoxLocked(): boolean;
+    /**
+     * Tells to `setParticles()` to compute the particle rotations or not.
+     * Default value : true. The SPS is faster when it's set to false.
+     * Note : the particle rotations aren't stored values, so setting `computeParticleRotation` to false will prevents the particle to rotate.
+     */
+    set computeParticleRotation(arg: boolean);
+    /**
+     * Gets if `setParticles()` computes the particle rotations or not.
+     * Default value : true. The SPS is faster when it's set to false.
+     * Note : the particle rotations aren't stored values, so setting `computeParticleRotation` to false will prevents the particle to rotate.
+     */
+    get computeParticleRotation(): boolean;
+    /**
+     * Tells to `setParticles()` to compute the particle colors or not.
+     * Default value : true. The SPS is faster when it's set to false.
+     * Note : the particle colors are stored values, so setting `computeParticleColor` to false will keep yet the last colors set.
+     */
+    set computeParticleColor(arg: boolean);
+    /**
+     * Gets if `setParticles()` computes the particle colors or not.
+     * Default value : true. The SPS is faster when it's set to false.
+     * Note : the particle colors are stored values, so setting `computeParticleColor` to false will keep yet the last colors set.
+     */
+    get computeParticleColor(): boolean;
+    set computeParticleTexture(arg: boolean);
+    /**
+     * Gets if `setParticles()` computes the particle textures or not.
+     * Default value : true. The SPS is faster when it's set to false.
+     * Note : the particle textures are stored values, so setting `computeParticleTexture` to false will keep yet the last colors set.
+     */
+    get computeParticleTexture(): boolean;
+    /**
+     * Tells to `setParticles()` to call the vertex function for each vertex of each particle, or not.
+     * Default value : false. The SPS is faster when it's set to false.
+     * Note : the particle custom vertex positions aren't stored values.
+     */
+    set computeParticleVertex(arg: boolean);
+    /**
+     * Gets if `setParticles()` calls the vertex function for each vertex of each particle, or not.
+     * Default value : false. The SPS is faster when it's set to false.
+     * Note : the particle custom vertex positions aren't stored values.
+     */
+    get computeParticleVertex(): boolean;
+    /**
+     * Tells to `setParticles()` to compute or not the mesh bounding box when computing the particle positions.
+     */
+    set computeBoundingBox(arg: any);
+    /**
+     * Gets if `setParticles()` computes or not the mesh bounding box when computing the particle positions.
+     */
+    get computeBoundingBox(): any;
+    /**
+     * Tells to `setParticles()` to sort or not the distance between each particle and the camera.
+     * Skipped when `enableDepthSort` is set to `false` (default) at construction time.
+     * Default : `true`
+     */
+    set depthSortParticles(arg: boolean);
+    /**
+     * Gets if `setParticles()` sorts or not the distance between each particle and the camera.
+     * Skipped when `enableDepthSort` is set to `false` (default) at construction time.
+     * Default : `true`
+     */
+    get depthSortParticles(): boolean;
+    /**
+     * Gets if the SPS is created as expandable at construction time.
+     * Default : `false`
+     */
+    get expandable(): any;
+    /**
+     * Gets if the SPS supports the Multi Materials
+     */
+    get multimaterialEnabled(): any;
+    /**
+     * Gets if the SPS uses the model materials for its own multimaterial.
+     */
+    get useModelMaterial(): any;
+    /**
+     * The SPS used material array.
+     */
+    get materials(): any[] | undefined;
+    /**
+     * Sets the SPS MultiMaterial from the passed materials.
+     * Note : the passed array is internally copied and not used then by reference.
+     * @param materials an array of material objects. This array indexes are the materialIndex values of the particles.
+     */
+    setMultiMaterial(materials: any): void;
+    set multimaterial(arg: MultiMaterial | undefined);
+    /**
+     * The SPS computed multimaterial object
+     */
+    get multimaterial(): MultiMaterial | undefined;
+    set autoUpdateSubMeshes(arg: boolean);
+    /**
+     * If the subMeshes must be updated on the next call to setParticles()
+     */
+    get autoUpdateSubMeshes(): boolean;
+    /**
+     * This function does nothing. It may be overwritten to set all the particle first values.
+     * The SPS doesn't call this function, you may have to call it by your own.
+     * doc : https://doc.babylonjs.com/how_to/Solid_Particle_System#particle-management
+     */
+    initParticles(): void;
+    /**
+     * This function does nothing. It may be overwritten to recycle a particle.
+     * The SPS doesn't call this function, you may have to call it by your own.
+     * doc : https://doc.babylonjs.com/how_to/Solid_Particle_System#particle-management
+     * @param particle The particle to recycle
+     * @returns the recycled particle
+     */
+    recycleParticle(particle: any): any;
+    /**
+     * Updates a particle : this function should  be overwritten by the user.
+     * It is called on each particle by `setParticles()`. This is the place to code each particle behavior.
+     * doc : https://doc.babylonjs.com/how_to/Solid_Particle_System#particle-management
+     * @example : just set a particle position or velocity and recycle conditions
+     * @param particle The particle to update
+     * @returns the updated particle
+     */
+    updateParticle(particle: any): any;
+    /**
+     * Updates a vertex of a particle : it can be overwritten by the user.
+     * This will be called on each vertex particle by `setParticles()` if `computeParticleVertex` is set to true only.
+     * @param particle the current particle
+     * @param vertex the current vertex of the current particle : a SolidParticleVertex object
+     * @param pt the index of the current vertex in the particle shape
+     * doc : https://doc.babylonjs.com/how_to/Solid_Particle_System#update-each-particle-shape
+     * @example : just set a vertex particle position or color
+     * @returns the sps
+     */
+    updateParticleVertex(particle: any, vertex: any, pt: any): SolidParticleSystem;
+    /**
+     * This will be called before any other treatment by `setParticles()` and will be passed three parameters.
+     * This does nothing and may be overwritten by the user.
+     * @param start the particle index in the particle array where to stop to iterate, same than the value passed to setParticle()
+     * @param stop the particle index in the particle array where to stop to iterate, same than the value passed to setParticle()
+     * @param update the boolean update value actually passed to setParticles()
+     */
+    beforeUpdateParticles(start: any, stop: any, update: any): void;
+    /**
+     * This will be called  by `setParticles()` after all the other treatments and just before the actual mesh update.
+     * This will be passed three parameters.
+     * This does nothing and may be overwritten by the user.
+     * @param start the particle index in the particle array where to stop to iterate, same than the value passed to setParticle()
+     * @param stop the particle index in the particle array where to stop to iterate, same than the value passed to setParticle()
+     * @param update the boolean update value actually passed to setParticles()
+     */
+    afterUpdateParticles(start: any, stop: any, update: any): void;
+}
+import { SolidParticle } from "./solidParticle.js";
+import { Color4 } from "../Maths/math.color.js";
+import { MultiMaterial } from "../Materials/multiMaterial.js";
+import { SolidParticleVertex } from "./solidParticle.js";
+import { Mesh } from "../Meshes/mesh.js";
+import { Vector3 } from "../Maths/math.vector.js";
+import { StandardMaterial } from "../Materials/standardMaterial.js";

package/dist/types/node_modules/@babylonjs/core/Particles/subEmitter.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Type of sub emitter
+ */
+export const SubEmitterType: any;
+/**
+ * Sub emitter class used to emit particles from an existing particle
+ */
+export class SubEmitter {
+    /**
+     * @internal
+     */
+    static _ParseParticleSystem(system: any, sceneOrEngine: any, rootUrl: any, doNotStart?: boolean): void;
+    /**
+     * Creates a new SubEmitter from a serialized JSON version
+     * @param serializationObject defines the JSON object to read from
+     * @param sceneOrEngine defines the hosting scene or the hosting engine
+     * @param rootUrl defines the rootUrl for data loading
+     * @returns a new SubEmitter
+     */
+    static Parse(serializationObject: any, sceneOrEngine: any, rootUrl: any): SubEmitter;
+    /**
+     * Creates a sub emitter
+     * @param particleSystem the particle system to be used by the sub emitter
+     */
+    constructor(particleSystem: any);
+    particleSystem: any;
+    /**
+     * Type of the submitter (Default: END)
+     */
+    type: any;
+    /**
+     * If the particle should inherit the direction from the particle it's attached to. (+Y will face the direction the particle is moving) (Default: false)
+     * Note: This only is supported when using an emitter of type Mesh
+     */
+    inheritDirection: boolean;
+    /**
+     * How much of the attached particles speed should be added to the sub emitted particle (default: 0)
+     */
+    inheritedVelocityAmount: number;
+    /**
+     * Clones the sub emitter
+     * @returns the cloned sub emitter
+     */
+    clone(): SubEmitter;
+    /**
+     * Serialize current object to a JSON object
+     * @param serializeTexture defines if the texture must be serialized as well
+     * @returns the serialized object
+     */
+    serialize(serializeTexture?: boolean): {
+        type: any;
+        inheritDirection: boolean;
+        inheritedVelocityAmount: number;
+        particleSystem: any;
+    };
+    /** Release associated resources */
+    dispose(): void;
+}

package/dist/types/node_modules/@babylonjs/core/Particles/webgl2ParticleSystem.d.ts

@@ -0,0 +1,36 @@
+/** @internal */
+export class WebGL2ParticleSystem {
+    constructor(parent: any, engine: any);
+    _renderVAO: any[];
+    _updateVAO: any[];
+    alignDataInBuffer: boolean;
+    _parent: any;
+    _engine: any;
+    _updateEffectOptions: {
+        attributes: string[];
+        uniformsNames: string[];
+        uniformBuffersNames: never[];
+        samplers: string[];
+        defines: string;
+        fallbacks: null;
+        onCompiled: null;
+        onError: null;
+        indexParameters: null;
+        maxSimultaneousLights: number;
+        transformFeedbackVaryings: never[];
+    };
+    isUpdateBufferCreated(): boolean;
+    isUpdateBufferReady(): boolean;
+    createUpdateBuffer(defines: any): UniformBufferEffectCommonAccessor;
+    _updateEffect: Effect | undefined;
+    createVertexBuffers(updateBuffer: any, renderVertexBuffers: any): void;
+    createParticleBuffer(data: any): any;
+    bindDrawBuffers(index: any): void;
+    preUpdateParticleBuffer(): void;
+    updateParticleBuffer(index: any, targetBuffer: any, currentActiveCount: any): void;
+    releaseBuffers(): void;
+    releaseVertexBuffers(): void;
+    _createUpdateVAO(source: any): any;
+}
+import { UniformBufferEffectCommonAccessor } from "../Materials/uniformBufferEffectCommonAccessor.js";
+import { Effect } from "../Materials/effect.js";

package/dist/types/node_modules/@babylonjs/core/Physics/IPhysicsEngine.d.ts

@@ -0,0 +1 @@
+export {};