@babylonjs/core
Version:
Getting started? Play directly with the Babylon.js API using our [playground](https://playground.babylonjs.com/). It also contains a lot of samples to learn how to use it.
254 lines (252 loc) • 11.7 kB
TypeScript
import { Color4 } from "../Maths/math.js";
import { Mesh } from "../Meshes/mesh.js";
import type { Scene, IDisposable } from "../scene.js";
import { CloudPoint } from "./cloudPoint.js";
import type { Material } from "../Materials/material.js";
/** Defines the 4 color options */
export declare enum PointColor {
/** color value */
Color = 2,
/** uv value */
UV = 1,
/** random value */
Random = 0,
/** stated value */
Stated = 3
}
/**
* The PointCloudSystem (PCS) is a single updatable mesh. The points corresponding to the vertices of this big mesh.
* As it is just a mesh, the PointCloudSystem has all the same properties as any other BJS mesh : not more, not less. It can be scaled, rotated, translated, enlighted, textured, moved, etc.
* The PointCloudSystem is also a particle system, with each point being a particle. 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 : TO BE ENTERED
*/
export declare class PointsCloudSystem implements IDisposable {
/**
* The PCS array of cloud point objects. Just access each particle as with any classic array.
* Example : var p = SPS.particles[i];
*/
particles: CloudPoint[];
/**
* The PCS total number of particles. Read only. Use PCS.counter instead if you need to set your own value.
*/
nbParticles: number;
/**
* This a counter for your own usage. It's not set by any SPS functions.
*/
counter: number;
/**
* The PCS name. This name is also given to the underlying mesh.
*/
name: string;
/**
* The PCS mesh. It's a standard BJS Mesh, so all the methods from the Mesh class are available.
*/
mesh?: Mesh;
/**
* This empty object is intended to store some PCS specific or temporary values in order to lower the Garbage Collector activity.
* Please read :
*/
vars: any;
/**
* @internal
*/
_size: number;
private _scene;
private _promises;
private _positions;
private _indices;
private _normals;
private _colors;
private _uvs;
private _indices32;
private _positions32;
private _colors32;
private _uvs32;
private _updatable;
private _isVisibilityBoxLocked;
private _alwaysVisible;
private _groups;
private _groupCounter;
private _computeParticleColor;
private _computeParticleTexture;
private _computeParticleRotation;
private _computeBoundingBox;
private _isReady;
/**
* Gets the particle positions computed by the Point Cloud System
*/
get positions(): Float32Array;
/**
* Gets the particle colors computed by the Point Cloud System
*/
get colors(): Float32Array;
/**
* Gets the particle uvs computed by the Point Cloud System
*/
get uvs(): Float32Array;
/**
* Creates a PCS (Points Cloud System) object
* @param name (String) is the PCS name, this will be the underlying mesh name
* @param pointSize (number) is the size for each point. Has no effect on a WebGPU engine.
* @param scene (Scene) is the scene in which the PCS is added
* @param options defines the options of the PCS e.g.
* * updatable (optional boolean, default true) : if the PCS must be updatable or immutable
*/
constructor(name: string, pointSize: number, scene: Scene, options?: {
updatable?: boolean;
});
/**
* Builds the PCS underlying mesh. Returns a standard Mesh.
* If no points were added to the PCS, the returned mesh is just a single point.
* @param material The material to use to render the mesh. If not provided, will create a default one
* @returns a promise for the created mesh
*/
buildMeshAsync(material?: Material): Promise<Mesh>;
private _buildMeshAsync;
private _addParticle;
private _randomUnitVector;
private _getColorIndicesForCoord;
private _setPointsColorOrUV;
private _colorFromTexture;
private _calculateDensity;
/**
* Adds points to the PCS in random positions within a unit sphere
* @param nb (positive integer) the number of particles to be created from this model
* @param pointFunction is an optional javascript function to be called for each particle on PCS creation
* @returns the number of groups in the system
*/
addPoints(nb: number, pointFunction?: any): number;
/**
* Adds points to the PCS from the surface of the model shape
* @param mesh is any Mesh object that will be used as a surface model for the points
* @param nb (positive integer) the number of particles to be created from this model
* @param colorWith determines whether a point is colored using color (default), uv, random, stated or none (invisible)
* @param color (color4) to be used when colorWith is stated or color (number) when used to specify texture position
* @param range (number from 0 to 1) to determine the variation in shape and tone for a stated color
* @returns the number of groups in the system
*/
addSurfacePoints(mesh: Mesh, nb: number, colorWith?: number, color?: Color4 | number, range?: number): number;
/**
* Adds points to the PCS inside the model shape
* @param mesh is any Mesh object that will be used as a surface model for the points
* @param nb (positive integer) the number of particles to be created from this model
* @param colorWith determines whether a point is colored using color (default), uv, random, stated or none (invisible)
* @param color (color4) to be used when colorWith is stated or color (number) when used to specify texture position
* @param range (number from 0 to 1) to determine the variation in shape and tone for a stated color
* @returns the number of groups in the system
*/
addVolumePoints(mesh: Mesh, nb: number, colorWith?: number, color?: Color4 | number, range?: number): number;
/**
* 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.
* @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 PCS.
*/
setParticles(start?: number, end?: number, update?: boolean): PointsCloudSystem;
/**
* Disposes the PCS.
*/
dispose(): void;
/**
* Visibility helper : Recomputes the visible size according to the mesh bounding box
* doc :
* @returns the PCS.
*/
refreshVisibleSize(): PointsCloudSystem;
/**
* 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 PCS mesh bounding box.
* doc :
*/
setVisibilityBox(size: number): void;
/**
* Gets whether the PCS is always visible or not
* doc :
*/
get isAlwaysVisible(): boolean;
/**
* Sets the PCS as always visible or not
* doc :
*/
set isAlwaysVisible(val: boolean);
/**
* Tells to `setParticles()` to compute the particle rotations or not
* Default value : false. The PCS is faster when it's set to false
* Note : particle rotations are only applied to parent particles
* Note : the particle rotations aren't stored values, so setting `computeParticleRotation` to false will prevents the particle to rotate
*/
set computeParticleRotation(val: boolean);
/**
* Tells to `setParticles()` to compute the particle colors or not.
* Default value : true. The PCS 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(val: boolean);
set computeParticleTexture(val: boolean);
/**
* Gets if `setParticles()` computes the particle colors or not.
* Default value : false. The PCS 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;
/**
* Gets if `setParticles()` computes the particle textures or not.
* Default value : false. The PCS 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 compute or not the mesh bounding box when computing the particle positions.
*/
set computeBoundingBox(val: boolean);
/**
* Gets if `setParticles()` computes or not the mesh bounding box when computing the particle positions.
*/
get computeBoundingBox(): boolean;
/**
* This function does nothing. It may be overwritten to set all the particle first values.
* The PCS doesn't call this function, you may have to call it by your own.
* doc :
*/
initParticles(): void;
/**
* This function does nothing. It may be overwritten to recycle a particle
* The PCS doesn't call this function, you can to call it
* doc :
* @param particle The particle to recycle
* @returns the recycled particle
*/
recycleParticle(particle: CloudPoint): CloudPoint;
/**
* 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 :
* @example : just set a particle position or velocity and recycle conditions
* @param particle The particle to update
* @returns the updated particle
*/
updateParticle(particle: CloudPoint): CloudPoint;
/**
* 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 start 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?: number, stop?: number, update?: boolean): 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 start 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?: number, stop?: number, update?: boolean): void;
}