@babylonjs/core 5.38.0 → 5.40.0

package/Particles/solidParticleSystem.d.ts

@@ -1,7 +1,11 @@
-import type { Nullable } from "../types";
+import type { Nullable, IndicesArray } from "../types";
+import { Vector3 } from "../Maths/math.vector";
+import { Color4 } from "../Maths/math.color";
 import { Mesh } from "../Meshes/mesh";
 import type { Scene, IDisposable } from "../scene";
-import { DepthSortedParticle, SolidParticle, SolidParticleVertex } from "./solidParticle";
+import { DepthSortedParticle, SolidParticle, ModelShape, SolidParticleVertex } from "./solidParticle";
+import type { TargetCamera } from "../Cameras/targetCamera";
+import { BoundingInfo } from "../Culling/boundingInfo";
 import type { Material } from "../Materials/material";
 import { MultiMaterial } from "../Materials/multiMaterial";
 import type { PickingInfo } from "../Collisions/pickingInfo";
@@ -94,55 +98,55 @@ export declare class SolidParticleSystem implements IDisposable {
      * @internal
      */
     _bSphereRadiusFactor: number;
-    private _scene;
-    private _positions;
-    private _indices;
-    private _normals;
-    private _colors;
-    private _uvs;
-    private _indices32;
-    private _positions32;
-    private _normals32;
-    private _fixedNormal32;
-    private _colors32;
-    private _uvs32;
-    private _index;
-    private _updatable;
-    private _pickable;
-    private _isVisibilityBoxLocked;
-    private _alwaysVisible;
-    private _depthSort;
-    private _expandable;
-    private _shapeCounter;
-    private _copy;
-    private _color;
-    private _computeParticleColor;
-    private _computeParticleTexture;
-    private _computeParticleRotation;
-    private _computeParticleVertex;
-    private _computeBoundingBox;
-    private _autoFixFaceOrientation;
-    private _depthSortParticles;
-    private _camera;
-    private _mustUnrotateFixedNormals;
-    private _particlesIntersect;
-    private _needs32Bits;
-    private _isNotBuilt;
-    private _lastParticleId;
-    private _idxOfId;
-    private _multimaterialEnabled;
-    private _useModelMaterial;
-    private _indicesByMaterial;
-    private _materialIndexes;
-    private _depthSortFunction;
-    private _materialSortFunction;
-    private _materials;
-    private _multimaterial;
-    private _materialIndexesById;
-    private _defaultMaterial;
-    private _autoUpdateSubMeshes;
-    private _tmpVertex;
-    private _recomputeInvisibles;
+    protected _scene: Scene;
+    protected _positions: number[];
+    protected _indices: number[];
+    protected _normals: number[];
+    protected _colors: number[];
+    protected _uvs: number[];
+    protected _indices32: IndicesArray;
+    protected _positions32: Float32Array;
+    protected _normals32: Float32Array;
+    protected _fixedNormal32: Float32Array;
+    protected _colors32: Float32Array;
+    protected _uvs32: Float32Array;
+    protected _index: number;
+    protected _updatable: boolean;
+    protected _pickable: boolean;
+    protected _isVisibilityBoxLocked: boolean;
+    protected _alwaysVisible: boolean;
+    protected _depthSort: boolean;
+    protected _expandable: boolean;
+    protected _shapeCounter: number;
+    protected _copy: SolidParticle;
+    protected _color: Color4;
+    protected _computeParticleColor: boolean;
+    protected _computeParticleTexture: boolean;
+    protected _computeParticleRotation: boolean;
+    protected _computeParticleVertex: boolean;
+    protected _computeBoundingBox: boolean;
+    protected _autoFixFaceOrientation: boolean;
+    protected _depthSortParticles: boolean;
+    protected _camera: TargetCamera;
+    protected _mustUnrotateFixedNormals: boolean;
+    protected _particlesIntersect: boolean;
+    protected _needs32Bits: boolean;
+    protected _isNotBuilt: boolean;
+    protected _lastParticleId: number;
+    protected _idxOfId: number[];
+    protected _multimaterialEnabled: boolean;
+    protected _useModelMaterial: boolean;
+    protected _indicesByMaterial: number[];
+    protected _materialIndexes: number[];
+    protected _depthSortFunction: (p1: DepthSortedParticle, p2: DepthSortedParticle) => number;
+    protected _materialSortFunction: (p1: DepthSortedParticle, p2: DepthSortedParticle) => number;
+    protected _materials: Material[];
+    protected _multimaterial: MultiMaterial;
+    protected _materialIndexesById: any;
+    protected _defaultMaterial: Material;
+    protected _autoUpdateSubMeshes: boolean;
+    protected _tmpVertex: SolidParticleVertex;
+    protected _recomputeInvisibles: boolean;
     /**
      * Creates a SPS (Solid Particle System) object.
      * @param name (String) is the SPS name, this will be the underlying mesh name.
@@ -216,12 +220,12 @@ export declare class SolidParticleSystem implements IDisposable {
      * Unrotate the fixed normals in case the mesh was built with pre-rotated particles, ex : use of positionFunction in addShape()
      * @internal
      */
-    private _unrotateFixedNormals;
+    protected _unrotateFixedNormals(): void;
     /**
      * Resets the temporary working copy particle
      * @internal
      */
-    private _resetCopy;
+    protected _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
@@ -243,21 +247,21 @@ export declare class SolidParticleSystem implements IDisposable {
      * @model the particle model
      * @internal
      */
-    private _meshBuilder;
+    protected _meshBuilder(p: number, ind: number, shape: Vector3[], positions: number[], meshInd: IndicesArray, indices: number[], meshUV: number[] | Float32Array, uvs: number[], meshCol: number[] | Float32Array, colors: number[], meshNor: number[] | Float32Array, normals: number[], idx: number, idxInShape: number, options: any, model: ModelShape): SolidParticle;
     /**
      * Returns a shape Vector3 array from positions float array
      * @param positions float array
      * @returns a vector3 array
      * @internal
      */
-    private _posToShape;
+    protected _posToShape(positions: number[] | Float32Array): Vector3[];
     /**
      * Returns a shapeUV array from a float uvs (array deep copy)
      * @param uvs as a float array
      * @returns a shapeUV array
      * @internal
      */
-    private _uvsToShapeUV;
+    protected _uvsToShapeUV(uvs: number[] | Float32Array): number[];
     /**
      * Adds a new particle object in the particles array
      * @param idx particle index in particles array
@@ -271,7 +275,7 @@ export declare class SolidParticleSystem implements IDisposable {
      * @param storage target storage array, if any
      * @internal
      */
-    private _addParticle;
+    protected _addParticle(idx: number, id: number, idxpos: number, idxind: number, model: ModelShape, shapeId: number, idxInShape: number, bInfo?: Nullable<BoundingInfo>, storage?: Nullable<[]>): SolidParticle;
     /**
      * Adds some particles to the SPS from the model shape. Returns the shape id.
      * Please read the doc : https://doc.babylonjs.com/features/featuresDeepDive/particles/solid_particle_system/immutable_sps
@@ -294,7 +298,7 @@ export declare class SolidParticleSystem implements IDisposable {
      * Rebuilds a particle back to its just built status : if needed, recomputes the custom positions and vertices
      * @internal
      */
-    private _rebuildParticle;
+    protected _rebuildParticle(particle: SolidParticle, 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.
@@ -336,7 +340,7 @@ export declare class SolidParticleSystem implements IDisposable {
      * @options addShape() passed options
      * @internal
      */
-    private _insertNewParticle;
+    protected _insertNewParticle(idx: number, i: number, modelShape: ModelShape, shape: Vector3[], meshInd: IndicesArray, meshUV: number[] | Float32Array, meshCol: number[] | Float32Array, meshNor: number[] | Float32Array, bbInfo: Nullable<BoundingInfo>, storage: Nullable<[]>, options: any): Nullable<SolidParticle>;
     /**
      *  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.
@@ -396,23 +400,23 @@ export declare class SolidParticleSystem implements IDisposable {
      * @returns the SPS
      * @internal
      */
-    private _sortParticlesByMaterial;
+    protected _sortParticlesByMaterial(): SolidParticleSystem;
     /**
      * Sets the material indexes by id materialIndexesById[id] = materialIndex
      * @internal
      */
-    private _setMaterialIndexesById;
+    protected _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
      */
-    private _filterUniqueMaterialId;
+    protected _filterUniqueMaterialId(array: Material[]): Material[];
     /**
      * Sets a new Standard Material as _defaultMaterial if not already set.
      * @internal
      */
-    private _setDefaultMaterial;
+    protected _setDefaultMaterial(): Material;
     /**
      * Visibility helper : Recomputes the visible size according to the mesh bounding box
      * doc : https://doc.babylonjs.com/features/featuresDeepDive/particles/solid_particle_system/sps_visibility