@combeenation/3d-viewer 0.0.1-types

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

@@ -0,0 +1,235 @@
+/** Defines the 4 color options */
+export const PointColor: any;
+/**
+ * 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 class PointsCloudSystem {
+    /**
+     * 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
+     * @param options.updatable
+     */
+    constructor(name: any, pointSize: any, scene: any, options: any);
+    /**
+     *  The PCS array of cloud point objects. Just access each particle as with any classic array.
+     *  Example : var p = SPS.particles[i];
+     */
+    particles: any[];
+    /**
+     * 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;
+    /**
+     * This empty object is intended to store some PCS specific or temporary values in order to lower the Garbage Collector activity.
+     * Please read :
+     */
+    vars: {};
+    _promises: any[];
+    _positions: any[];
+    _indices: any[];
+    _normals: any[];
+    _colors: any[];
+    _uvs: any[];
+    _updatable: any;
+    _isVisibilityBoxLocked: boolean;
+    _alwaysVisible: boolean;
+    _groups: any[];
+    _groupCounter: number;
+    _computeParticleColor: boolean;
+    _computeParticleTexture: boolean;
+    _computeParticleRotation: boolean;
+    _computeBoundingBox: boolean;
+    _isReady: boolean;
+    name: any;
+    _size: any;
+    _scene: any;
+    /**
+     * Gets the particle positions computed by the Point Cloud System
+     */
+    get positions(): Float32Array | null | undefined;
+    /**
+     * Gets the particle colors computed by the Point Cloud System
+     */
+    get colors(): Float32Array | null | undefined;
+    /**
+     * Gets the particle uvs computed by the Point Cloud System
+     */
+    get uvs(): Float32Array | null | undefined;
+    /**
+     * 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: any): Promise<any>;
+    /**
+     * @internal
+     */
+    _buildMesh(material: any): Promise<any>;
+    _positions32: Float32Array | null | undefined;
+    _uvs32: Float32Array | null | undefined;
+    _colors32: Float32Array | null | undefined;
+    mesh: Mesh | undefined;
+    _addParticle(idx: any, group: any, groupId: any, idxInGroup: any): CloudPoint;
+    _randomUnitVector(particle: any): void;
+    _getColorIndicesForCoord(pointsGroup: any, x: any, y: any, width: any): Color4;
+    _setPointsColorOrUV(mesh: any, pointsGroup: any, isVolume: any, colorFromTexture: any, hasTexture: any, color: any, range: any): void;
+    _colorFromTexture(mesh: any, pointsGroup: any, isVolume: any): void;
+    _calculateDensity(nbPoints: any, positions: any, indices: any): any[];
+    /**
+     * 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: any, pointFunction?: (particle: any) => void): 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: any, nb: any, colorWith: any, color: any, range: any): 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: any, nb: any, colorWith: any, color: any, range: any): 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;
+    _indices32: any;
+    /**
+     * 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: any): void;
+    /**
+     * Sets the PCS as always visible or not
+     * doc :
+     */
+    set isAlwaysVisible(arg: boolean);
+    /**
+     * Gets whether the PCS is always visible or not
+     * doc :
+     */
+    get isAlwaysVisible(): 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(arg: any);
+    /**
+     * 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(arg: 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;
+    set computeParticleTexture(arg: 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(arg: 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: 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 :
+     * @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;
+    /**
+     * 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: 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 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: any, stop: any, update: any): void;
+}
+import { Mesh } from "../Meshes/mesh.js";
+import { CloudPoint } from "./cloudPoint.js";
+import { Color4 } from "@babylonjs/core/Maths/math.color.js";

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

@@ -0,0 +1,266 @@
+/**
+ * Represents one particle of a solid particle system.
+ */
+export class SolidParticle {
+    /**
+     * Creates a Solid Particle object.
+     * Don't create particles manually, use instead the Solid Particle System internal tools like _addParticle()
+     * @param particleIndex (integer) is the particle index in the Solid Particle System pool.
+     * @param particleId (integer) is the particle identifier. Unless some particles are removed from the SPS, it's the same value than the particle idx.
+     * @param positionIndex (integer) is the starting index of the particle vertices in the SPS "positions" array.
+     * @param indiceIndex (integer) is the starting index of the particle indices in the SPS "indices" array.
+     * @param model (ModelShape) is a reference to the model shape on what the particle is designed.
+     * @param shapeId (integer) is the model shape identifier in the SPS.
+     * @param idxInShape (integer) is the index of the particle in the current model (ex: the 10th box of addShape(box, 30))
+     * @param sps defines the sps it is associated to
+     * @param modelBoundingInfo is the reference to the model BoundingInfo used for intersection computations.
+     * @param materialIndex is the particle material identifier (integer) when the MultiMaterials are enabled in the SPS.
+     */
+    constructor(particleIndex: any, particleId: any, positionIndex: any, indiceIndex: any, model: any, shapeId: any, idxInShape: any, sps: any, modelBoundingInfo?: null, materialIndex?: null);
+    /**
+     * particle global index
+     */
+    idx: any;
+    /**
+     * particle identifier
+     */
+    id: any;
+    /**
+     * The color of the particle
+     */
+    color: Color4;
+    /**
+     * The world space position of the particle.
+     */
+    position: Vector3;
+    /**
+     * The world space rotation of the particle. (Not use if rotationQuaternion is set)
+     */
+    rotation: Vector3;
+    /**
+     * The scaling of the particle.
+     */
+    scaling: Vector3;
+    /**
+     * The uvs of the particle.
+     */
+    uvs: Vector4;
+    /**
+     * The current speed of the particle.
+     */
+    velocity: Vector3;
+    /**
+     * The pivot point in the particle local space.
+     */
+    pivot: Vector3;
+    /**
+     * Must the particle be translated from its pivot point in its local space ?
+     * In this case, the pivot point is set at the origin of the particle local space and the particle is translated.
+     * Default : false
+     */
+    translateFromPivot: boolean;
+    /**
+     * Is the particle active or not ?
+     */
+    alive: boolean;
+    /**
+     * Is the particle visible or not ?
+     */
+    isVisible: boolean;
+    /**
+     * Index of this particle in the global "positions" array (Internal use)
+     * @internal
+     */
+    _pos: any;
+    /**
+     * @internal Index of this particle in the global "indices" array (Internal use)
+     */
+    _ind: any;
+    /**
+     * ModelShape id of this particle
+     */
+    shapeId: any;
+    /**
+     * Index of the particle in its shape id
+     */
+    idxInShape: any;
+    /**
+     * @internal Still set as invisible in order to skip useless computations (Internal use)
+     */
+    _stillInvisible: boolean;
+    /**
+     * @internal Last computed particle rotation matrix
+     */
+    _rotationMatrix: number[];
+    /**
+     * Parent particle Id, if any.
+     * Default null.
+     */
+    parentId: any;
+    /**
+     * The particle material identifier (integer) when MultiMaterials are enabled in the SPS.
+     */
+    materialIndex: any;
+    /**
+     * Custom object or properties.
+     */
+    props: any;
+    /**
+     * The culling strategy to use to check whether the solid particle must be culled or not when using isInFrustum().
+     * The possible values are :
+     * - AbstractMesh.CULLINGSTRATEGY_STANDARD
+     * - AbstractMesh.CULLINGSTRATEGY_BOUNDINGSPHERE_ONLY
+     * - AbstractMesh.CULLINGSTRATEGY_OPTIMISTIC_INCLUSION
+     * - AbstractMesh.CULLINGSTRATEGY_OPTIMISTIC_INCLUSION_THEN_BSPHERE_ONLY
+     * The default value for solid particles is AbstractMesh.CULLINGSTRATEGY_BOUNDINGSPHERE_ONLY
+     * Please read each static variable documentation in the class AbstractMesh to get details about the culling process.
+     * */
+    cullingStrategy: number;
+    /**
+     * @internal Internal global position in the SPS.
+     */
+    _globalPosition: Vector3;
+    _model: any;
+    _sps: any;
+    _modelBoundingInfo: any;
+    _boundingInfo: BoundingInfo | undefined;
+    /**
+     * Particle BoundingInfo object
+     * @returns a BoundingInfo
+     */
+    getBoundingInfo(): BoundingInfo | undefined;
+    /**
+     * Returns true if there is already a bounding info
+     */
+    get hasBoundingInfo(): boolean;
+    /**
+     * Copies the particle property values into the existing target : position, rotation, scaling, uvs, colors, pivot, parent, visibility, alive
+     * @param target the particle target
+     * @returns the current particle
+     */
+    copyToRef(target: any): SolidParticle;
+    /**
+     * Legacy support, changed scale to scaling
+     */
+    set scale(arg: Vector3);
+    /**
+     * Legacy support, changed scale to scaling
+     */
+    get scale(): Vector3;
+    /**
+     * Legacy support, changed quaternion to rotationQuaternion
+     */
+    set quaternion(arg: any);
+    /**
+     * Legacy support, changed quaternion to rotationQuaternion
+     */
+    get quaternion(): any;
+    rotationQuaternion: any;
+    /**
+     * Returns a boolean. True if the particle intersects another particle or another mesh, else false.
+     * The intersection is computed on the particle bounding sphere and Axis Aligned Bounding Box (AABB)
+     * @param target is the object (solid particle or mesh) what the intersection is computed against.
+     * @returns true if it intersects
+     */
+    intersectsMesh(target: any): boolean;
+    /**
+     * Returns `true` if the solid particle is within the frustum defined by the passed array of planes.
+     * A particle is in the frustum if its bounding box intersects the frustum
+     * @param frustumPlanes defines the frustum to test
+     * @returns true if the particle is in the frustum planes
+     */
+    isInFrustum(frustumPlanes: any): boolean;
+    /**
+     * get the rotation matrix of the particle
+     * @internal
+     */
+    getRotationMatrix(m: any): void;
+}
+/**
+ * Represents the shape of the model used by one particle of a solid particle system.
+ * SPS internal tool, don't use it manually.
+ */
+export class ModelShape {
+    /**
+     * Creates a ModelShape object. This is an internal simplified reference to a mesh used as for a model to replicate particles from by the SPS.
+     * SPS internal tool, don't use it manually.
+     * @internal
+     */
+    constructor(id: any, shape: any, indices: any, normals: any, colors: any, shapeUV: any, posFunction: any, vtxFunction: any, material: any);
+    /**
+     * length of the shape in the model indices array (internal use)
+     * @internal
+     */
+    _indicesLength: any;
+    shapeId: any;
+    _shape: any;
+    _indices: any;
+    _shapeUV: any;
+    _shapeColors: any;
+    _normals: any;
+    _positionFunction: any;
+    _vertexFunction: any;
+    _material: any;
+    set shapeID(arg: any);
+    /**
+     * Get or set the shapeId
+     * @deprecated Please use shapeId instead
+     */
+    get shapeID(): any;
+}
+/**
+ * Represents a Depth Sorted Particle in the solid particle system.
+ * @internal
+ */
+export class DepthSortedParticle {
+    /**
+     * Creates a new sorted particle
+     * @param idx
+     * @param ind
+     * @param indLength
+     * @param materialIndex
+     */
+    constructor(idx: any, ind: any, indLength: any, materialIndex: any);
+    /**
+     * Particle index
+     */
+    idx: any;
+    /**
+     * Index of the particle in the "indices" array
+     */
+    ind: any;
+    /**
+     * Length of the particle shape in the "indices" array
+     */
+    indicesLength: any;
+    /**
+     * Squared distance from the particle to the camera
+     */
+    sqDistance: number;
+    /**
+     * Material index when used with MultiMaterials
+     */
+    materialIndex: any;
+}
+/**
+ * Represents a solid particle vertex
+ */
+export class SolidParticleVertex {
+    position: Vector3;
+    color: Color4;
+    uv: Vector2;
+    set x(arg: number);
+    /** Vertex x coordinate */
+    get x(): number;
+    set y(arg: number);
+    /** Vertex y coordinate */
+    get y(): number;
+    set z(arg: number);
+    /** Vertex z coordinate */
+    get z(): number;
+}
+import { Color4 } from "../Maths/math.color.js";
+import { Vector3 } from "../Maths/math.vector.js";
+import { Vector4 } from "../Maths/math.vector.js";
+import { BoundingInfo } from "../Culling/boundingInfo.js";
+import { Vector2 } from "../Maths/math.vector.js";