|
|
@@ -11698,6 +11698,8 @@ declare module "babylonjs/Materials/Textures/rawTexture" {
|
|
|
import { Scene } from "babylonjs/scene";
|
|
|
import { Texture } from "babylonjs/Materials/Textures/texture";
|
|
|
import "babylonjs/Engines/Extensions/engine.rawTexture";
|
|
|
+ import { Nullable } from "babylonjs/types";
|
|
|
+ import { ThinEngine } from "babylonjs/Engines/thinEngine";
|
|
|
/**
|
|
|
* Raw texture can help creating a texture directly from an array of data.
|
|
|
* This can be super useful if you either get the data from an uncompressed source or
|
|
|
@@ -11717,7 +11719,7 @@ declare module "babylonjs/Materials/Textures/rawTexture" {
|
|
|
* @param width define the width of the texture
|
|
|
* @param height define the height of the texture
|
|
|
* @param format define the format of the data (RGB, RGBA... Engine.TEXTUREFORMAT_xxx)
|
|
|
- * @param scene define the scene the texture belongs to
|
|
|
+ * @param sceneOrEngine defines the scene or engine the texture will belong to
|
|
|
* @param generateMipMaps define whether mip maps should be generated or not
|
|
|
* @param invertY define if the data should be flipped on Y when uploaded to the GPU
|
|
|
* @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
|
|
|
@@ -11727,7 +11729,7 @@ declare module "babylonjs/Materials/Textures/rawTexture" {
|
|
|
/**
|
|
|
* Define the format of the data (RGB, RGBA... Engine.TEXTUREFORMAT_xxx)
|
|
|
*/
|
|
|
- format: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number);
|
|
|
+ format: number, sceneOrEngine: Nullable<Scene | ThinEngine>, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number);
|
|
|
/**
|
|
|
* Updates the texture underlying data.
|
|
|
* @param data Define the new data of the texture
|
|
|
@@ -11738,76 +11740,76 @@ declare module "babylonjs/Materials/Textures/rawTexture" {
|
|
|
* @param data Define the texture data
|
|
|
* @param width Define the width of the texture
|
|
|
* @param height Define the height of the texture
|
|
|
- * @param scene Define the scene the texture belongs to
|
|
|
+ * @param sceneOrEngine defines the scene or engine the texture will belong to
|
|
|
* @param generateMipMaps Define whether or not to create mip maps for the texture
|
|
|
* @param invertY define if the data should be flipped on Y when uploaded to the GPU
|
|
|
* @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
|
|
|
* @returns the luminance texture
|
|
|
*/
|
|
|
- static CreateLuminanceTexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
|
|
|
+ static CreateLuminanceTexture(data: ArrayBufferView, width: number, height: number, sceneOrEngine: Nullable<Scene | ThinEngine>, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
|
|
|
/**
|
|
|
* Creates a luminance alpha texture from some data.
|
|
|
* @param data Define the texture data
|
|
|
* @param width Define the width of the texture
|
|
|
* @param height Define the height of the texture
|
|
|
- * @param scene Define the scene the texture belongs to
|
|
|
+ * @param sceneOrEngine defines the scene or engine the texture will belong to
|
|
|
* @param generateMipMaps Define whether or not to create mip maps for the texture
|
|
|
* @param invertY define if the data should be flipped on Y when uploaded to the GPU
|
|
|
* @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
|
|
|
* @returns the luminance alpha texture
|
|
|
*/
|
|
|
- static CreateLuminanceAlphaTexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
|
|
|
+ static CreateLuminanceAlphaTexture(data: ArrayBufferView, width: number, height: number, sceneOrEngine: Nullable<Scene | ThinEngine>, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
|
|
|
/**
|
|
|
* Creates an alpha texture from some data.
|
|
|
* @param data Define the texture data
|
|
|
* @param width Define the width of the texture
|
|
|
* @param height Define the height of the texture
|
|
|
- * @param scene Define the scene the texture belongs to
|
|
|
+ * @param sceneOrEngine defines the scene or engine the texture will belong to
|
|
|
* @param generateMipMaps Define whether or not to create mip maps for the texture
|
|
|
* @param invertY define if the data should be flipped on Y when uploaded to the GPU
|
|
|
* @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
|
|
|
* @returns the alpha texture
|
|
|
*/
|
|
|
- static CreateAlphaTexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
|
|
|
+ static CreateAlphaTexture(data: ArrayBufferView, width: number, height: number, sceneOrEngine: Nullable<Scene | ThinEngine>, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
|
|
|
/**
|
|
|
* Creates a RGB texture from some data.
|
|
|
* @param data Define the texture data
|
|
|
* @param width Define the width of the texture
|
|
|
* @param height Define the height of the texture
|
|
|
- * @param scene Define the scene the texture belongs to
|
|
|
+ * @param sceneOrEngine defines the scene or engine the texture will belong to
|
|
|
* @param generateMipMaps Define whether or not to create mip maps for the texture
|
|
|
* @param invertY define if the data should be flipped on Y when uploaded to the GPU
|
|
|
* @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
|
|
|
* @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
|
|
|
* @returns the RGB alpha texture
|
|
|
*/
|
|
|
- static CreateRGBTexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number): RawTexture;
|
|
|
+ static CreateRGBTexture(data: ArrayBufferView, width: number, height: number, sceneOrEngine: Nullable<Scene | ThinEngine>, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number): RawTexture;
|
|
|
/**
|
|
|
* Creates a RGBA texture from some data.
|
|
|
* @param data Define the texture data
|
|
|
* @param width Define the width of the texture
|
|
|
* @param height Define the height of the texture
|
|
|
- * @param scene Define the scene the texture belongs to
|
|
|
+ * @param sceneOrEngine defines the scene or engine the texture will belong to
|
|
|
* @param generateMipMaps Define whether or not to create mip maps for the texture
|
|
|
* @param invertY define if the data should be flipped on Y when uploaded to the GPU
|
|
|
* @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
|
|
|
* @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
|
|
|
* @returns the RGBA texture
|
|
|
*/
|
|
|
- static CreateRGBATexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number): RawTexture;
|
|
|
+ static CreateRGBATexture(data: ArrayBufferView, width: number, height: number, sceneOrEngine: Nullable<Scene | ThinEngine>, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number): RawTexture;
|
|
|
/**
|
|
|
* Creates a R texture from some data.
|
|
|
* @param data Define the texture data
|
|
|
* @param width Define the width of the texture
|
|
|
* @param height Define the height of the texture
|
|
|
- * @param scene Define the scene the texture belongs to
|
|
|
+ * @param sceneOrEngine defines the scene or engine the texture will belong to
|
|
|
* @param generateMipMaps Define whether or not to create mip maps for the texture
|
|
|
* @param invertY define if the data should be flipped on Y when uploaded to the GPU
|
|
|
* @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
|
|
|
* @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
|
|
|
* @returns the R texture
|
|
|
*/
|
|
|
- static CreateRTexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number): RawTexture;
|
|
|
+ static CreateRTexture(data: ArrayBufferView, width: number, height: number, sceneOrEngine: Nullable<Scene | ThinEngine>, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number): RawTexture;
|
|
|
}
|
|
|
}
|
|
|
declare module "babylonjs/Materials/Textures/Procedurals/proceduralTextureSceneComponent" {
|
|
|
@@ -12099,12 +12101,13 @@ declare module "babylonjs/Particles/baseParticleSystem" {
|
|
|
import { ImageProcessingConfiguration, ImageProcessingConfigurationDefines } from "babylonjs/Materials/imageProcessingConfiguration";
|
|
|
import { ProceduralTexture } from "babylonjs/Materials/Textures/Procedurals/proceduralTexture";
|
|
|
import { RawTexture } from "babylonjs/Materials/Textures/rawTexture";
|
|
|
- import { Scene } from "babylonjs/scene";
|
|
|
import { ColorGradient, FactorGradient, Color3Gradient, IValueGradient } from "babylonjs/Misc/gradients";
|
|
|
import { BoxParticleEmitter, IParticleEmitterType, PointParticleEmitter, HemisphericParticleEmitter, SphereParticleEmitter, SphereDirectedParticleEmitter, CylinderParticleEmitter, CylinderDirectedParticleEmitter, ConeParticleEmitter } from "babylonjs/Particles/EmitterTypes/index";
|
|
|
import { Texture } from "babylonjs/Materials/Textures/texture";
|
|
|
import { Color4 } from "babylonjs/Maths/math.color";
|
|
|
+ import { ThinEngine } from "babylonjs/Engines/thinEngine";
|
|
|
import { Animation } from "babylonjs/Animations/animation";
|
|
|
+ import { Scene } from "babylonjs/scene";
|
|
|
/**
|
|
|
* This represents the base class for particle system in Babylon.
|
|
|
* Particles are often small sprites used to simulate hard-to-reproduce phenomena like fire, smoke, water, or abstract visual effects like magic glitter and faery dust.
|
|
|
@@ -12336,7 +12339,7 @@ declare module "babylonjs/Particles/baseParticleSystem" {
|
|
|
* Get hosting scene
|
|
|
* @returns the scene
|
|
|
*/
|
|
|
- getScene(): Scene;
|
|
|
+ getScene(): Nullable<Scene>;
|
|
|
/**
|
|
|
* You can use gravity if you want to give an orientation to your particles.
|
|
|
*/
|
|
|
@@ -12487,7 +12490,11 @@ declare module "babylonjs/Particles/baseParticleSystem" {
|
|
|
/**
|
|
|
* The scene the particle system belongs to.
|
|
|
*/
|
|
|
- protected _scene: Scene;
|
|
|
+ protected _scene: Nullable<Scene>;
|
|
|
+ /**
|
|
|
+ * The engine the particle system belongs to.
|
|
|
+ */
|
|
|
+ protected _engine: ThinEngine;
|
|
|
/**
|
|
|
* Local cache of defines for image processing.
|
|
|
*/
|
|
|
@@ -12495,17 +12502,17 @@ declare module "babylonjs/Particles/baseParticleSystem" {
|
|
|
/**
|
|
|
* Default configuration related to image processing available in the standard Material.
|
|
|
*/
|
|
|
- protected _imageProcessingConfiguration: ImageProcessingConfiguration;
|
|
|
+ protected _imageProcessingConfiguration: Nullable<ImageProcessingConfiguration>;
|
|
|
/**
|
|
|
* Gets the image processing configuration used either in this material.
|
|
|
*/
|
|
|
- get imageProcessingConfiguration(): ImageProcessingConfiguration;
|
|
|
+ get imageProcessingConfiguration(): Nullable<ImageProcessingConfiguration>;
|
|
|
/**
|
|
|
* Sets the Default image processing configuration used either in the this material.
|
|
|
*
|
|
|
* If sets to null, the scene one is in use.
|
|
|
*/
|
|
|
- set imageProcessingConfiguration(value: ImageProcessingConfiguration);
|
|
|
+ set imageProcessingConfiguration(value: Nullable<ImageProcessingConfiguration>);
|
|
|
/**
|
|
|
* Attaches a new image processing configuration to the Standard Material.
|
|
|
* @param configuration
|
|
|
@@ -12588,6 +12595,7 @@ declare module "babylonjs/Particles/baseParticleSystem" {
|
|
|
}
|
|
|
}
|
|
|
declare module "babylonjs/Particles/subEmitter" {
|
|
|
+ import { ThinEngine } from "babylonjs/Engines/thinEngine";
|
|
|
import { Scene } from "babylonjs/scene";
|
|
|
import { ParticleSystem } from "babylonjs/Particles/particleSystem";
|
|
|
/**
|
|
|
@@ -12644,15 +12652,15 @@ declare module "babylonjs/Particles/subEmitter" {
|
|
|
*/
|
|
|
serialize(): any;
|
|
|
/** @hidden */
|
|
|
- static _ParseParticleSystem(system: any, scene: Scene, rootUrl: string): ParticleSystem;
|
|
|
+ static _ParseParticleSystem(system: any, sceneOrEngine: Scene | ThinEngine, rootUrl: string): ParticleSystem;
|
|
|
/**
|
|
|
* Creates a new SubEmitter from a serialized JSON version
|
|
|
* @param serializationObject defines the JSON object to read from
|
|
|
- * @param scene defines the hosting scene
|
|
|
+ * @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, scene: Scene, rootUrl: string): SubEmitter;
|
|
|
+ static Parse(serializationObject: any, sceneOrEngine: Scene | ThinEngine, rootUrl: string): SubEmitter;
|
|
|
/** Release associated resources */
|
|
|
dispose(): void;
|
|
|
}
|
|
|
@@ -12698,7 +12706,7 @@ declare module "babylonjs/Particles/particleSystem" {
|
|
|
import { Observable } from "babylonjs/Misc/observable";
|
|
|
import { Vector3, Matrix } from "babylonjs/Maths/math.vector";
|
|
|
import { Effect } from "babylonjs/Materials/effect";
|
|
|
- import { Scene, IDisposable } from "babylonjs/scene";
|
|
|
+ import { IDisposable } from "babylonjs/scene";
|
|
|
import { IParticleSystem } from "babylonjs/Particles/IParticleSystem";
|
|
|
import { BaseParticleSystem } from "babylonjs/Particles/baseParticleSystem";
|
|
|
import { Particle } from "babylonjs/Particles/particle";
|
|
|
@@ -12707,6 +12715,8 @@ declare module "babylonjs/Particles/particleSystem" {
|
|
|
import "babylonjs/Shaders/particles.fragment";
|
|
|
import "babylonjs/Shaders/particles.vertex";
|
|
|
import { Color4, Color3 } from "babylonjs/Maths/math.color";
|
|
|
+ import { ThinEngine } from "babylonjs/Engines/thinEngine";
|
|
|
+ import { Scene } from "babylonjs/scene";
|
|
|
/**
|
|
|
* This represents a particle system in Babylon.
|
|
|
* Particles are often small sprites used to simulate hard-to-reproduce phenomena like fire, smoke, water, or abstract visual effects like magic glitter and faery dust.
|
|
|
@@ -12796,6 +12806,8 @@ declare module "babylonjs/Particles/particleSystem" {
|
|
|
private readonly _rawTextureWidth;
|
|
|
private _rampGradientsTexture;
|
|
|
private _useRampGradients;
|
|
|
+ /** Gets or sets a matrix to use to compute projection */
|
|
|
+ defaultProjectionMatrix: Matrix;
|
|
|
/** Gets or sets a boolean indicating that ramp gradients must be used
|
|
|
* @see https://doc.babylonjs.com/babylon101/particles#ramp-gradients
|
|
|
*/
|
|
|
@@ -12867,12 +12879,12 @@ declare module "babylonjs/Particles/particleSystem" {
|
|
|
* Particles are often small sprites used to simulate hard-to-reproduce phenomena like fire, smoke, water, or abstract visual effects like magic glitter and faery dust.
|
|
|
* @param name The name of the particle system
|
|
|
* @param capacity The max number of particles alive at the same time
|
|
|
- * @param scene The scene the particle system belongs to
|
|
|
+ * @param sceneOrEngine The scene the particle system belongs to or the engine to use if no scene
|
|
|
* @param customEffect a custom effect used to change the way particles are rendered by default
|
|
|
* @param isAnimationSheetEnabled Must be true if using a spritesheet to animate the particles texture
|
|
|
* @param epsilon Offset used to render the particles
|
|
|
*/
|
|
|
- constructor(name: string, capacity: number, scene: Scene, customEffect?: Nullable<Effect>, isAnimationSheetEnabled?: boolean, epsilon?: number);
|
|
|
+ constructor(name: string, capacity: number, sceneOrEngine: Scene | ThinEngine, customEffect?: Nullable<Effect>, isAnimationSheetEnabled?: boolean, epsilon?: number);
|
|
|
private _addFactorGradient;
|
|
|
private _removeFactorGradient;
|
|
|
/**
|
|
|
@@ -13162,16 +13174,16 @@ declare module "babylonjs/Particles/particleSystem" {
|
|
|
/** @hidden */
|
|
|
static _Serialize(serializationObject: any, particleSystem: IParticleSystem, serializeTexture: boolean): void;
|
|
|
/** @hidden */
|
|
|
- static _Parse(parsedParticleSystem: any, particleSystem: IParticleSystem, scene: Scene, rootUrl: string): void;
|
|
|
+ static _Parse(parsedParticleSystem: any, particleSystem: IParticleSystem, sceneOrEngine: Scene | ThinEngine, rootUrl: string): void;
|
|
|
/**
|
|
|
* Parses a JSON object to create a particle system.
|
|
|
* @param parsedParticleSystem The JSON object to parse
|
|
|
- * @param scene The scene to create the particle system in
|
|
|
+ * @param sceneOrEngine The scene or the engine to create the particle system in
|
|
|
* @param rootUrl The root url to use to load external dependencies like texture
|
|
|
* @param doNotStart Ignore the preventAutoStart attribute and does not start
|
|
|
* @returns the Parsed particle system
|
|
|
*/
|
|
|
- static Parse(parsedParticleSystem: any, scene: Scene, rootUrl: string, doNotStart?: boolean): ParticleSystem;
|
|
|
+ static Parse(parsedParticleSystem: any, sceneOrEngine: Scene | ThinEngine, rootUrl: string, doNotStart?: boolean): ParticleSystem;
|
|
|
}
|
|
|
}
|
|
|
declare module "babylonjs/Particles/particle" {
|
|
|
@@ -13326,7 +13338,8 @@ declare module "babylonjs/Particles/EmitterTypes/IParticleEmitterType" {
|
|
|
import { Vector3, Matrix } from "babylonjs/Maths/math.vector";
|
|
|
import { Effect } from "babylonjs/Materials/effect";
|
|
|
import { Particle } from "babylonjs/Particles/particle";
|
|
|
- import { Scene } from "babylonjs/scene";
|
|
|
+ import { Nullable } from "babylonjs/types";
|
|
|
+ import { Scene } from "babylonjs/scene";
|
|
|
/**
|
|
|
* Particle emitter represents a volume emitting particles.
|
|
|
* This is the responsibility of the implementation to define the volume shape like cone/sphere/box.
|
|
|
@@ -13378,7 +13391,7 @@ declare module "babylonjs/Particles/EmitterTypes/IParticleEmitterType" {
|
|
|
* @param serializationObject defines the JSON object
|
|
|
* @param scene defines the hosting scene
|
|
|
*/
|
|
|
- parse(serializationObject: any, scene: Scene): void;
|
|
|
+ parse(serializationObject: any, scene: Nullable<Scene>): void;
|
|
|
}
|
|
|
}
|
|
|
declare module "babylonjs/Particles/EmitterTypes/boxParticleEmitter" {
|
|
|
@@ -14191,7 +14204,7 @@ declare module "babylonjs/Particles/EmitterTypes/meshParticleEmitter" {
|
|
|
* @param serializationObject defines the JSON object
|
|
|
* @param scene defines the hosting scene
|
|
|
*/
|
|
|
- parse(serializationObject: any, scene: Scene): void;
|
|
|
+ parse(serializationObject: any, scene: Nullable<Scene>): void;
|
|
|
}
|
|
|
}
|
|
|
declare module "babylonjs/Particles/EmitterTypes/index" {
|
|
|
@@ -14207,17 +14220,16 @@ declare module "babylonjs/Particles/EmitterTypes/index" {
|
|
|
}
|
|
|
declare module "babylonjs/Particles/IParticleSystem" {
|
|
|
import { Nullable } from "babylonjs/types";
|
|
|
- import { Vector2, Vector3 } from "babylonjs/Maths/math.vector";
|
|
|
+ import { Vector2, Vector3, Matrix } from "babylonjs/Maths/math.vector";
|
|
|
import { Color3, Color4 } from "babylonjs/Maths/math.color";
|
|
|
- import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
|
|
|
import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
|
|
|
- import { Texture } from "babylonjs/Materials/Textures/texture";
|
|
|
import { BoxParticleEmitter, IParticleEmitterType, PointParticleEmitter, HemisphericParticleEmitter, SphereParticleEmitter, SphereDirectedParticleEmitter, CylinderParticleEmitter, ConeParticleEmitter } from "babylonjs/Particles/EmitterTypes/index";
|
|
|
import { Scene } from "babylonjs/scene";
|
|
|
import { ColorGradient, FactorGradient, Color3Gradient } from "babylonjs/Misc/gradients";
|
|
|
import { Effect } from "babylonjs/Materials/effect";
|
|
|
import { Observable } from "babylonjs/Misc/observable";
|
|
|
import { Animation } from "babylonjs/Animations/animation";
|
|
|
+ import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
|
|
|
/**
|
|
|
* Interface representing a particle system in Babylon.js.
|
|
|
* This groups the common functionalities that needs to be implemented in order to create a particle system.
|
|
|
@@ -14263,7 +14275,7 @@ declare module "babylonjs/Particles/IParticleSystem" {
|
|
|
/**
|
|
|
* The texture used to render each particle. (this can be a spritesheet)
|
|
|
*/
|
|
|
- particleTexture: Nullable<Texture>;
|
|
|
+ particleTexture: Nullable<BaseTexture>;
|
|
|
/**
|
|
|
* Blend mode use to render the particle, it can be either ParticleSystem.BLENDMODE_ONEONE, ParticleSystem.BLENDMODE_STANDARD or ParticleSystem.BLENDMODE_ADD.
|
|
|
*/
|
|
|
@@ -14430,6 +14442,8 @@ declare module "babylonjs/Particles/IParticleSystem" {
|
|
|
isLocal: boolean;
|
|
|
/** Snippet ID if the particle system was created from the snippet server */
|
|
|
snippetId: string;
|
|
|
+ /** Gets or sets a matrix to use to compute projection */
|
|
|
+ defaultProjectionMatrix: Matrix;
|
|
|
/**
|
|
|
* Gets the maximum number of particles active at the same time.
|
|
|
* @returns The max number of active particles.
|
|
|
@@ -14842,7 +14856,7 @@ declare module "babylonjs/Particles/IParticleSystem" {
|
|
|
* Get hosting scene
|
|
|
* @returns the scene
|
|
|
*/
|
|
|
- getScene(): Scene;
|
|
|
+ getScene(): Nullable<Scene>;
|
|
|
}
|
|
|
}
|
|
|
declare module "babylonjs/Meshes/transformNode" {
|
|
|
@@ -35032,8 +35046,8 @@ declare module "babylonjs/Materials/Textures/baseTexture" {
|
|
|
* Define the current state of the loading sequence when in delayed load mode.
|
|
|
*/
|
|
|
delayLoadState: number;
|
|
|
- private _scene;
|
|
|
- private _engine;
|
|
|
+ protected _scene: Nullable<Scene>;
|
|
|
+ protected _engine: Nullable<ThinEngine>;
|
|
|
/** @hidden */
|
|
|
_texture: Nullable<InternalTexture>;
|
|
|
private _uid;
|
|
|
@@ -48580,10 +48594,12 @@ declare module "babylonjs/XR/webXRSessionManager" {
|
|
|
}
|
|
|
}
|
|
|
declare module "babylonjs/XR/webXRCamera" {
|
|
|
+ import { Vector3 } from "babylonjs/Maths/math.vector";
|
|
|
import { Scene } from "babylonjs/scene";
|
|
|
import { Camera } from "babylonjs/Cameras/camera";
|
|
|
import { FreeCamera } from "babylonjs/Cameras/freeCamera";
|
|
|
import { WebXRSessionManager } from "babylonjs/XR/webXRSessionManager";
|
|
|
+ import { Observable } from "babylonjs/Misc/observable";
|
|
|
/**
|
|
|
* WebXR Camera which holds the views for the xrSession
|
|
|
* @see https://doc.babylonjs.com/how_to/webxr_camera
|
|
|
@@ -48596,6 +48612,14 @@ declare module "babylonjs/XR/webXRCamera" {
|
|
|
private _xrInvPositionCache;
|
|
|
private _xrInvQuaternionCache;
|
|
|
/**
|
|
|
+ * Observable raised before camera teleportation
|
|
|
+ */
|
|
|
+ onBeforeCameraTeleport: Observable<Vector3>;
|
|
|
+ /**
|
|
|
+ * Observable raised after camera teleportation
|
|
|
+ */
|
|
|
+ onAfterCameraTeleport: Observable<Vector3>;
|
|
|
+ /**
|
|
|
* Should position compensation execute on first frame.
|
|
|
* This is used when copying the position from a native (non XR) camera
|
|
|
*/
|
|
|
@@ -70569,13 +70593,16 @@ declare module "babylonjs/Particles/gpuParticleSystem" {
|
|
|
import { Nullable } from "babylonjs/types";
|
|
|
import { Color3Gradient, IValueGradient } from "babylonjs/Misc/gradients";
|
|
|
import { Observable } from "babylonjs/Misc/observable";
|
|
|
+ import { Matrix } from "babylonjs/Maths/math.vector";
|
|
|
import { Color4, Color3 } from "babylonjs/Maths/math.color";
|
|
|
import { IParticleSystem } from "babylonjs/Particles/IParticleSystem";
|
|
|
import { BaseParticleSystem } from "babylonjs/Particles/baseParticleSystem";
|
|
|
- import { Scene, IDisposable } from "babylonjs/scene";
|
|
|
+ import { IDisposable } from "babylonjs/scene";
|
|
|
import { Effect } from "babylonjs/Materials/effect";
|
|
|
import { RawTexture } from "babylonjs/Materials/Textures/rawTexture";
|
|
|
import { IAnimatable } from "babylonjs/Animations/animatable.interface";
|
|
|
+ import { ThinEngine } from "babylonjs/Engines/thinEngine";
|
|
|
+ import { Scene } from "babylonjs/scene";
|
|
|
import "babylonjs/Shaders/gpuUpdateParticles.fragment";
|
|
|
import "babylonjs/Shaders/gpuUpdateParticles.vertex";
|
|
|
import "babylonjs/Shaders/gpuRenderParticles.fragment";
|
|
|
@@ -70604,7 +70631,6 @@ declare module "babylonjs/Particles/gpuParticleSystem" {
|
|
|
private _targetIndex;
|
|
|
private _sourceBuffer;
|
|
|
private _targetBuffer;
|
|
|
- private _engine;
|
|
|
private _currentRenderId;
|
|
|
private _started;
|
|
|
private _stopped;
|
|
|
@@ -70645,6 +70671,8 @@ declare module "babylonjs/Particles/gpuParticleSystem" {
|
|
|
* Specifies if the particles are updated in emitter local space or world space.
|
|
|
*/
|
|
|
isLocal: boolean;
|
|
|
+ /** Gets or sets a matrix to use to compute projection */
|
|
|
+ defaultProjectionMatrix: Matrix;
|
|
|
/**
|
|
|
* Is this system ready to be used/rendered
|
|
|
* @return true if the system is ready
|
|
|
@@ -70901,14 +70929,14 @@ declare module "babylonjs/Particles/gpuParticleSystem" {
|
|
|
* Particles are often small sprites used to simulate hard-to-reproduce phenomena like fire, smoke, water, or abstract visual effects like magic glitter and faery dust.
|
|
|
* @param name The name of the particle system
|
|
|
* @param options The options used to create the system
|
|
|
- * @param scene The scene the particle system belongs to
|
|
|
+ * @param sceneOrEngine The scene the particle system belongs to or the engine to use if no scene
|
|
|
* @param isAnimationSheetEnabled Must be true if using a spritesheet to animate the particles texture
|
|
|
* @param customEffect a custom effect used to change the way particles are rendered by default
|
|
|
*/
|
|
|
constructor(name: string, options: Partial<{
|
|
|
capacity: number;
|
|
|
randomTextureSize: number;
|
|
|
- }>, scene: Scene, isAnimationSheetEnabled?: boolean, customEffect?: Nullable<Effect>);
|
|
|
+ }>, sceneOrEngine: Scene | ThinEngine, isAnimationSheetEnabled?: boolean, customEffect?: Nullable<Effect>);
|
|
|
protected _reset(): void;
|
|
|
private _createUpdateVAO;
|
|
|
private _createRenderVAO;
|
|
|
@@ -70976,12 +71004,12 @@ declare module "babylonjs/Particles/gpuParticleSystem" {
|
|
|
/**
|
|
|
* Parses a JSON object to create a GPU particle system.
|
|
|
* @param parsedParticleSystem The JSON object to parse
|
|
|
- * @param scene The scene to create the particle system in
|
|
|
+ * @param sceneOrEngine The scene or the engine to create the particle system in
|
|
|
* @param rootUrl The root url to use to load external dependencies like texture
|
|
|
* @param doNotStart Ignore the preventAutoStart attribute and does not start
|
|
|
* @returns the parsed GPU particle system
|
|
|
*/
|
|
|
- static Parse(parsedParticleSystem: any, scene: Scene, rootUrl: string, doNotStart?: boolean): GPUParticleSystem;
|
|
|
+ static Parse(parsedParticleSystem: any, sceneOrEngine: Scene | ThinEngine, rootUrl: string, doNotStart?: boolean): GPUParticleSystem;
|
|
|
}
|
|
|
}
|
|
|
declare module "babylonjs/Particles/particleSystemSet" {
|
|
|
@@ -90358,7 +90386,7 @@ declare module BABYLON {
|
|
|
* @param width define the width of the texture
|
|
|
* @param height define the height of the texture
|
|
|
* @param format define the format of the data (RGB, RGBA... Engine.TEXTUREFORMAT_xxx)
|
|
|
- * @param scene define the scene the texture belongs to
|
|
|
+ * @param sceneOrEngine defines the scene or engine the texture will belong to
|
|
|
* @param generateMipMaps define whether mip maps should be generated or not
|
|
|
* @param invertY define if the data should be flipped on Y when uploaded to the GPU
|
|
|
* @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
|
|
|
@@ -90368,7 +90396,7 @@ declare module BABYLON {
|
|
|
/**
|
|
|
* Define the format of the data (RGB, RGBA... Engine.TEXTUREFORMAT_xxx)
|
|
|
*/
|
|
|
- format: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number);
|
|
|
+ format: number, sceneOrEngine: Nullable<Scene | ThinEngine>, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number);
|
|
|
/**
|
|
|
* Updates the texture underlying data.
|
|
|
* @param data Define the new data of the texture
|
|
|
@@ -90379,76 +90407,76 @@ declare module BABYLON {
|
|
|
* @param data Define the texture data
|
|
|
* @param width Define the width of the texture
|
|
|
* @param height Define the height of the texture
|
|
|
- * @param scene Define the scene the texture belongs to
|
|
|
+ * @param sceneOrEngine defines the scene or engine the texture will belong to
|
|
|
* @param generateMipMaps Define whether or not to create mip maps for the texture
|
|
|
* @param invertY define if the data should be flipped on Y when uploaded to the GPU
|
|
|
* @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
|
|
|
* @returns the luminance texture
|
|
|
*/
|
|
|
- static CreateLuminanceTexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
|
|
|
+ static CreateLuminanceTexture(data: ArrayBufferView, width: number, height: number, sceneOrEngine: Nullable<Scene | ThinEngine>, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
|
|
|
/**
|
|
|
* Creates a luminance alpha texture from some data.
|
|
|
* @param data Define the texture data
|
|
|
* @param width Define the width of the texture
|
|
|
* @param height Define the height of the texture
|
|
|
- * @param scene Define the scene the texture belongs to
|
|
|
+ * @param sceneOrEngine defines the scene or engine the texture will belong to
|
|
|
* @param generateMipMaps Define whether or not to create mip maps for the texture
|
|
|
* @param invertY define if the data should be flipped on Y when uploaded to the GPU
|
|
|
* @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
|
|
|
* @returns the luminance alpha texture
|
|
|
*/
|
|
|
- static CreateLuminanceAlphaTexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
|
|
|
+ static CreateLuminanceAlphaTexture(data: ArrayBufferView, width: number, height: number, sceneOrEngine: Nullable<Scene | ThinEngine>, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
|
|
|
/**
|
|
|
* Creates an alpha texture from some data.
|
|
|
* @param data Define the texture data
|
|
|
* @param width Define the width of the texture
|
|
|
* @param height Define the height of the texture
|
|
|
- * @param scene Define the scene the texture belongs to
|
|
|
+ * @param sceneOrEngine defines the scene or engine the texture will belong to
|
|
|
* @param generateMipMaps Define whether or not to create mip maps for the texture
|
|
|
* @param invertY define if the data should be flipped on Y when uploaded to the GPU
|
|
|
* @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
|
|
|
* @returns the alpha texture
|
|
|
*/
|
|
|
- static CreateAlphaTexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
|
|
|
+ static CreateAlphaTexture(data: ArrayBufferView, width: number, height: number, sceneOrEngine: Nullable<Scene | ThinEngine>, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number): RawTexture;
|
|
|
/**
|
|
|
* Creates a RGB texture from some data.
|
|
|
* @param data Define the texture data
|
|
|
* @param width Define the width of the texture
|
|
|
* @param height Define the height of the texture
|
|
|
- * @param scene Define the scene the texture belongs to
|
|
|
+ * @param sceneOrEngine defines the scene or engine the texture will belong to
|
|
|
* @param generateMipMaps Define whether or not to create mip maps for the texture
|
|
|
* @param invertY define if the data should be flipped on Y when uploaded to the GPU
|
|
|
* @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
|
|
|
* @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
|
|
|
* @returns the RGB alpha texture
|
|
|
*/
|
|
|
- static CreateRGBTexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number): RawTexture;
|
|
|
+ static CreateRGBTexture(data: ArrayBufferView, width: number, height: number, sceneOrEngine: Nullable<Scene | ThinEngine>, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number): RawTexture;
|
|
|
/**
|
|
|
* Creates a RGBA texture from some data.
|
|
|
* @param data Define the texture data
|
|
|
* @param width Define the width of the texture
|
|
|
* @param height Define the height of the texture
|
|
|
- * @param scene Define the scene the texture belongs to
|
|
|
+ * @param sceneOrEngine defines the scene or engine the texture will belong to
|
|
|
* @param generateMipMaps Define whether or not to create mip maps for the texture
|
|
|
* @param invertY define if the data should be flipped on Y when uploaded to the GPU
|
|
|
* @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
|
|
|
* @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
|
|
|
* @returns the RGBA texture
|
|
|
*/
|
|
|
- static CreateRGBATexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number): RawTexture;
|
|
|
+ static CreateRGBATexture(data: ArrayBufferView, width: number, height: number, sceneOrEngine: Nullable<Scene | ThinEngine>, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number): RawTexture;
|
|
|
/**
|
|
|
* Creates a R texture from some data.
|
|
|
* @param data Define the texture data
|
|
|
* @param width Define the width of the texture
|
|
|
* @param height Define the height of the texture
|
|
|
- * @param scene Define the scene the texture belongs to
|
|
|
+ * @param sceneOrEngine defines the scene or engine the texture will belong to
|
|
|
* @param generateMipMaps Define whether or not to create mip maps for the texture
|
|
|
* @param invertY define if the data should be flipped on Y when uploaded to the GPU
|
|
|
* @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
|
|
|
* @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
|
|
|
* @returns the R texture
|
|
|
*/
|
|
|
- static CreateRTexture(data: ArrayBufferView, width: number, height: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number): RawTexture;
|
|
|
+ static CreateRTexture(data: ArrayBufferView, width: number, height: number, sceneOrEngine: Nullable<Scene | ThinEngine>, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: number, type?: number): RawTexture;
|
|
|
}
|
|
|
}
|
|
|
declare module BABYLON {
|
|
|
@@ -90946,7 +90974,7 @@ declare module BABYLON {
|
|
|
* Get hosting scene
|
|
|
* @returns the scene
|
|
|
*/
|
|
|
- getScene(): Scene;
|
|
|
+ getScene(): Nullable<Scene>;
|
|
|
/**
|
|
|
* You can use gravity if you want to give an orientation to your particles.
|
|
|
*/
|
|
|
@@ -91097,7 +91125,11 @@ declare module BABYLON {
|
|
|
/**
|
|
|
* The scene the particle system belongs to.
|
|
|
*/
|
|
|
- protected _scene: Scene;
|
|
|
+ protected _scene: Nullable<Scene>;
|
|
|
+ /**
|
|
|
+ * The engine the particle system belongs to.
|
|
|
+ */
|
|
|
+ protected _engine: ThinEngine;
|
|
|
/**
|
|
|
* Local cache of defines for image processing.
|
|
|
*/
|
|
|
@@ -91105,17 +91137,17 @@ declare module BABYLON {
|
|
|
/**
|
|
|
* Default configuration related to image processing available in the standard Material.
|
|
|
*/
|
|
|
- protected _imageProcessingConfiguration: ImageProcessingConfiguration;
|
|
|
+ protected _imageProcessingConfiguration: Nullable<ImageProcessingConfiguration>;
|
|
|
/**
|
|
|
* Gets the image processing configuration used either in this material.
|
|
|
*/
|
|
|
- get imageProcessingConfiguration(): ImageProcessingConfiguration;
|
|
|
+ get imageProcessingConfiguration(): Nullable<ImageProcessingConfiguration>;
|
|
|
/**
|
|
|
* Sets the Default image processing configuration used either in the this material.
|
|
|
*
|
|
|
* If sets to null, the scene one is in use.
|
|
|
*/
|
|
|
- set imageProcessingConfiguration(value: ImageProcessingConfiguration);
|
|
|
+ set imageProcessingConfiguration(value: Nullable<ImageProcessingConfiguration>);
|
|
|
/**
|
|
|
* Attaches a new image processing configuration to the Standard Material.
|
|
|
* @param configuration
|
|
|
@@ -91252,15 +91284,15 @@ declare module BABYLON {
|
|
|
*/
|
|
|
serialize(): any;
|
|
|
/** @hidden */
|
|
|
- static _ParseParticleSystem(system: any, scene: Scene, rootUrl: string): ParticleSystem;
|
|
|
+ static _ParseParticleSystem(system: any, sceneOrEngine: Scene | ThinEngine, rootUrl: string): ParticleSystem;
|
|
|
/**
|
|
|
* Creates a new SubEmitter from a serialized JSON version
|
|
|
* @param serializationObject defines the JSON object to read from
|
|
|
- * @param scene defines the hosting scene
|
|
|
+ * @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, scene: Scene, rootUrl: string): SubEmitter;
|
|
|
+ static Parse(serializationObject: any, sceneOrEngine: Scene | ThinEngine, rootUrl: string): SubEmitter;
|
|
|
/** Release associated resources */
|
|
|
dispose(): void;
|
|
|
}
|
|
|
@@ -91383,6 +91415,8 @@ declare module BABYLON {
|
|
|
private readonly _rawTextureWidth;
|
|
|
private _rampGradientsTexture;
|
|
|
private _useRampGradients;
|
|
|
+ /** Gets or sets a matrix to use to compute projection */
|
|
|
+ defaultProjectionMatrix: Matrix;
|
|
|
/** Gets or sets a boolean indicating that ramp gradients must be used
|
|
|
* @see https://doc.babylonjs.com/babylon101/particles#ramp-gradients
|
|
|
*/
|
|
|
@@ -91454,12 +91488,12 @@ declare module BABYLON {
|
|
|
* Particles are often small sprites used to simulate hard-to-reproduce phenomena like fire, smoke, water, or abstract visual effects like magic glitter and faery dust.
|
|
|
* @param name The name of the particle system
|
|
|
* @param capacity The max number of particles alive at the same time
|
|
|
- * @param scene The scene the particle system belongs to
|
|
|
+ * @param sceneOrEngine The scene the particle system belongs to or the engine to use if no scene
|
|
|
* @param customEffect a custom effect used to change the way particles are rendered by default
|
|
|
* @param isAnimationSheetEnabled Must be true if using a spritesheet to animate the particles texture
|
|
|
* @param epsilon Offset used to render the particles
|
|
|
*/
|
|
|
- constructor(name: string, capacity: number, scene: Scene, customEffect?: Nullable<Effect>, isAnimationSheetEnabled?: boolean, epsilon?: number);
|
|
|
+ constructor(name: string, capacity: number, sceneOrEngine: Scene | ThinEngine, customEffect?: Nullable<Effect>, isAnimationSheetEnabled?: boolean, epsilon?: number);
|
|
|
private _addFactorGradient;
|
|
|
private _removeFactorGradient;
|
|
|
/**
|
|
|
@@ -91749,16 +91783,16 @@ declare module BABYLON {
|
|
|
/** @hidden */
|
|
|
static _Serialize(serializationObject: any, particleSystem: IParticleSystem, serializeTexture: boolean): void;
|
|
|
/** @hidden */
|
|
|
- static _Parse(parsedParticleSystem: any, particleSystem: IParticleSystem, scene: Scene, rootUrl: string): void;
|
|
|
+ static _Parse(parsedParticleSystem: any, particleSystem: IParticleSystem, sceneOrEngine: Scene | ThinEngine, rootUrl: string): void;
|
|
|
/**
|
|
|
* Parses a JSON object to create a particle system.
|
|
|
* @param parsedParticleSystem The JSON object to parse
|
|
|
- * @param scene The scene to create the particle system in
|
|
|
+ * @param sceneOrEngine The scene or the engine to create the particle system in
|
|
|
* @param rootUrl The root url to use to load external dependencies like texture
|
|
|
* @param doNotStart Ignore the preventAutoStart attribute and does not start
|
|
|
* @returns the Parsed particle system
|
|
|
*/
|
|
|
- static Parse(parsedParticleSystem: any, scene: Scene, rootUrl: string, doNotStart?: boolean): ParticleSystem;
|
|
|
+ static Parse(parsedParticleSystem: any, sceneOrEngine: Scene | ThinEngine, rootUrl: string, doNotStart?: boolean): ParticleSystem;
|
|
|
}
|
|
|
}
|
|
|
declare module BABYLON {
|
|
|
@@ -91955,7 +91989,7 @@ declare module BABYLON {
|
|
|
* @param serializationObject defines the JSON object
|
|
|
* @param scene defines the hosting scene
|
|
|
*/
|
|
|
- parse(serializationObject: any, scene: Scene): void;
|
|
|
+ parse(serializationObject: any, scene: Nullable<Scene>): void;
|
|
|
}
|
|
|
}
|
|
|
declare module BABYLON {
|
|
|
@@ -92732,7 +92766,7 @@ declare module BABYLON {
|
|
|
* @param serializationObject defines the JSON object
|
|
|
* @param scene defines the hosting scene
|
|
|
*/
|
|
|
- parse(serializationObject: any, scene: Scene): void;
|
|
|
+ parse(serializationObject: any, scene: Nullable<Scene>): void;
|
|
|
}
|
|
|
}
|
|
|
declare module BABYLON {
|
|
|
@@ -92781,7 +92815,7 @@ declare module BABYLON {
|
|
|
/**
|
|
|
* The texture used to render each particle. (this can be a spritesheet)
|
|
|
*/
|
|
|
- particleTexture: Nullable<Texture>;
|
|
|
+ particleTexture: Nullable<BaseTexture>;
|
|
|
/**
|
|
|
* Blend mode use to render the particle, it can be either ParticleSystem.BLENDMODE_ONEONE, ParticleSystem.BLENDMODE_STANDARD or ParticleSystem.BLENDMODE_ADD.
|
|
|
*/
|
|
|
@@ -92948,6 +92982,8 @@ declare module BABYLON {
|
|
|
isLocal: boolean;
|
|
|
/** Snippet ID if the particle system was created from the snippet server */
|
|
|
snippetId: string;
|
|
|
+ /** Gets or sets a matrix to use to compute projection */
|
|
|
+ defaultProjectionMatrix: Matrix;
|
|
|
/**
|
|
|
* Gets the maximum number of particles active at the same time.
|
|
|
* @returns The max number of active particles.
|
|
|
@@ -93360,7 +93396,7 @@ declare module BABYLON {
|
|
|
* Get hosting scene
|
|
|
* @returns the scene
|
|
|
*/
|
|
|
- getScene(): Scene;
|
|
|
+ getScene(): Nullable<Scene>;
|
|
|
}
|
|
|
}
|
|
|
declare module BABYLON {
|
|
|
@@ -112721,8 +112757,8 @@ declare module BABYLON {
|
|
|
* Define the current state of the loading sequence when in delayed load mode.
|
|
|
*/
|
|
|
delayLoadState: number;
|
|
|
- private _scene;
|
|
|
- private _engine;
|
|
|
+ protected _scene: Nullable<Scene>;
|
|
|
+ protected _engine: Nullable<ThinEngine>;
|
|
|
/** @hidden */
|
|
|
_texture: Nullable<InternalTexture>;
|
|
|
private _uid;
|
|
|
@@ -125719,6 +125755,14 @@ declare module BABYLON {
|
|
|
private _xrInvPositionCache;
|
|
|
private _xrInvQuaternionCache;
|
|
|
/**
|
|
|
+ * Observable raised before camera teleportation
|
|
|
+ */
|
|
|
+ onBeforeCameraTeleport: Observable<Vector3>;
|
|
|
+ /**
|
|
|
+ * Observable raised after camera teleportation
|
|
|
+ */
|
|
|
+ onAfterCameraTeleport: Observable<Vector3>;
|
|
|
+ /**
|
|
|
* Should position compensation execute on first frame.
|
|
|
* This is used when copying the position from a native (non XR) camera
|
|
|
*/
|
|
|
@@ -145941,7 +145985,6 @@ declare module BABYLON {
|
|
|
private _targetIndex;
|
|
|
private _sourceBuffer;
|
|
|
private _targetBuffer;
|
|
|
- private _engine;
|
|
|
private _currentRenderId;
|
|
|
private _started;
|
|
|
private _stopped;
|
|
|
@@ -145982,6 +146025,8 @@ declare module BABYLON {
|
|
|
* Specifies if the particles are updated in emitter local space or world space.
|
|
|
*/
|
|
|
isLocal: boolean;
|
|
|
+ /** Gets or sets a matrix to use to compute projection */
|
|
|
+ defaultProjectionMatrix: Matrix;
|
|
|
/**
|
|
|
* Is this system ready to be used/rendered
|
|
|
* @return true if the system is ready
|
|
|
@@ -146238,14 +146283,14 @@ declare module BABYLON {
|
|
|
* Particles are often small sprites used to simulate hard-to-reproduce phenomena like fire, smoke, water, or abstract visual effects like magic glitter and faery dust.
|
|
|
* @param name The name of the particle system
|
|
|
* @param options The options used to create the system
|
|
|
- * @param scene The scene the particle system belongs to
|
|
|
+ * @param sceneOrEngine The scene the particle system belongs to or the engine to use if no scene
|
|
|
* @param isAnimationSheetEnabled Must be true if using a spritesheet to animate the particles texture
|
|
|
* @param customEffect a custom effect used to change the way particles are rendered by default
|
|
|
*/
|
|
|
constructor(name: string, options: Partial<{
|
|
|
capacity: number;
|
|
|
randomTextureSize: number;
|
|
|
- }>, scene: Scene, isAnimationSheetEnabled?: boolean, customEffect?: Nullable<Effect>);
|
|
|
+ }>, sceneOrEngine: Scene | ThinEngine, isAnimationSheetEnabled?: boolean, customEffect?: Nullable<Effect>);
|
|
|
protected _reset(): void;
|
|
|
private _createUpdateVAO;
|
|
|
private _createRenderVAO;
|
|
|
@@ -146313,12 +146358,12 @@ declare module BABYLON {
|
|
|
/**
|
|
|
* Parses a JSON object to create a GPU particle system.
|
|
|
* @param parsedParticleSystem The JSON object to parse
|
|
|
- * @param scene The scene to create the particle system in
|
|
|
+ * @param sceneOrEngine The scene or the engine to create the particle system in
|
|
|
* @param rootUrl The root url to use to load external dependencies like texture
|
|
|
* @param doNotStart Ignore the preventAutoStart attribute and does not start
|
|
|
* @returns the parsed GPU particle system
|
|
|
*/
|
|
|
- static Parse(parsedParticleSystem: any, scene: Scene, rootUrl: string, doNotStart?: boolean): GPUParticleSystem;
|
|
|
+ static Parse(parsedParticleSystem: any, sceneOrEngine: Scene | ThinEngine, rootUrl: string, doNotStart?: boolean): GPUParticleSystem;
|
|
|
}
|
|
|
}
|
|
|
declare module BABYLON {
|
David `Deltakosh` Catuhe