@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.
461 lines (460 loc) • 16.1 kB
TypeScript
import type { Nullable } from "../types.js";
import { Vector3 } from "../Maths/math.vector.js";
import type { Mesh } from "../Meshes/mesh.js";
import type { Scene } from "../scene.js";
import type { PhysicsImpostor } from "./v1/physicsImpostor.js";
import type { PhysicsBody } from "./v2/physicsBody.js";
/**
* A helper for physics simulations
* @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine#further-functionality-of-the-impostor-class
*/
export declare class PhysicsHelper {
private _scene;
private _physicsEngine;
private _hitData;
/**
* Initializes the Physics helper
* @param scene Babylon.js scene
*/
constructor(scene: Scene);
/**
* Applies a radial explosion impulse
* @param origin the origin of the explosion
* @param radiusOrEventOptions the radius or the options of radial explosion
* @param strength the explosion strength
* @param falloff possible options: Constant & Linear. Defaults to Constant
* @returns A physics radial explosion event, or null
*/
applyRadialExplosionImpulse(origin: Vector3, radiusOrEventOptions: number | PhysicsRadialExplosionEventOptions, strength?: number, falloff?: PhysicsRadialImpulseFalloff): Nullable<PhysicsRadialExplosionEvent>;
/**
* Applies a radial explosion force
* @param origin the origin of the explosion
* @param radiusOrEventOptions the radius or the options of radial explosion
* @param strength the explosion strength
* @param falloff possible options: Constant & Linear. Defaults to Constant
* @returns A physics radial explosion event, or null
*/
applyRadialExplosionForce(origin: Vector3, radiusOrEventOptions: number | PhysicsRadialExplosionEventOptions, strength?: number, falloff?: PhysicsRadialImpulseFalloff): Nullable<PhysicsRadialExplosionEvent>;
private _applicationForBodies;
/**
* Creates a gravitational field
* @param origin the origin of the gravitational field
* @param radiusOrEventOptions the radius or the options of radial gravitational field
* @param strength the gravitational field strength
* @param falloff possible options: Constant & Linear. Defaults to Constant
* @returns A physics gravitational field event, or null
*/
gravitationalField(origin: Vector3, radiusOrEventOptions: number | PhysicsRadialExplosionEventOptions, strength?: number, falloff?: PhysicsRadialImpulseFalloff): Nullable<PhysicsGravitationalFieldEvent>;
/**
* Creates a physics updraft event
* @param origin the origin of the updraft
* @param radiusOrEventOptions the radius or the options of the updraft
* @param strength the strength of the updraft
* @param height the height of the updraft
* @param updraftMode possible options: Center & Perpendicular. Defaults to Center
* @returns A physics updraft event, or null
*/
updraft(origin: Vector3, radiusOrEventOptions: number | PhysicsUpdraftEventOptions, strength?: number, height?: number, updraftMode?: PhysicsUpdraftMode): Nullable<PhysicsUpdraftEvent>;
/**
* Creates a physics vortex event
* @param origin the of the vortex
* @param radiusOrEventOptions the radius or the options of the vortex
* @param strength the strength of the vortex
* @param height the height of the vortex
* @returns a Physics vortex event, or null
* A physics vortex event or null
*/
vortex(origin: Vector3, radiusOrEventOptions: number | PhysicsVortexEventOptions, strength?: number, height?: number): Nullable<PhysicsVortexEvent>;
private _copyPhysicsHitData;
}
/**
* Represents a physics radial explosion event
*/
declare class PhysicsRadialExplosionEvent {
private _scene;
private _options;
private _sphere;
private _dataFetched;
/**
* Initializes a radial explosion event
* @param _scene BabylonJS scene
* @param _options The options for the vortex event
*/
constructor(_scene: Scene, _options: PhysicsRadialExplosionEventOptions);
/**
* Returns the data related to the radial explosion event (sphere).
* @returns The radial explosion event data
*/
getData(): PhysicsRadialExplosionEventData;
private _getHitData;
/**
* Returns the force and contact point of the body or false, if the body is not affected by the force/impulse.
* @param body A physics body where the transform node is an AbstractMesh
* @param origin the origin of the explosion
* @param data the data of the hit
* @param instanceIndex the instance index of the body
* @returns if there was a hit
*/
getBodyHitData(body: PhysicsBody, origin: Vector3, data: PhysicsHitData, instanceIndex?: number): boolean;
/**
* Returns the force and contact point of the impostor or false, if the impostor is not affected by the force/impulse.
* @param impostor A physics imposter
* @param origin the origin of the explosion
* @param data the data of the hit
* @returns A physics force and contact point, or null
*/
getImpostorHitData(impostor: PhysicsImpostor, origin: Vector3, data: PhysicsHitData): boolean;
/**
* Triggers affected impostors callbacks
* @param affectedImpostorsWithData defines the list of affected impostors (including associated data)
*/
triggerAffectedImpostorsCallback(affectedImpostorsWithData: Array<PhysicsAffectedImpostorWithData>): void;
/**
* Triggers affected bodies callbacks
* @param affectedBodiesWithData defines the list of affected bodies (including associated data)
*/
triggerAffectedBodiesCallback(affectedBodiesWithData: Array<PhysicsAffectedBodyWithData>): void;
/**
* Disposes the sphere.
* @param force Specifies if the sphere should be disposed by force
*/
dispose(force?: boolean): void;
/*** Helpers ***/
private _prepareSphere;
private _intersectsWithSphere;
}
/**
* Represents a gravitational field event
*/
declare class PhysicsGravitationalFieldEvent {
private _physicsHelper;
private _scene;
private _origin;
private _options;
private _tickCallback;
private _sphere;
private _dataFetched;
/**
* Initializes the physics gravitational field event
* @param _physicsHelper A physics helper
* @param _scene BabylonJS scene
* @param _origin The origin position of the gravitational field event
* @param _options The options for the vortex event
*/
constructor(_physicsHelper: PhysicsHelper, _scene: Scene, _origin: Vector3, _options: PhysicsRadialExplosionEventOptions);
/**
* Returns the data related to the gravitational field event (sphere).
* @returns A gravitational field event
*/
getData(): PhysicsGravitationalFieldEventData;
/**
* Enables the gravitational field.
*/
enable(): void;
/**
* Disables the gravitational field.
*/
disable(): void;
/**
* Disposes the sphere.
* @param force The force to dispose from the gravitational field event
*/
dispose(force?: boolean): void;
private _tick;
}
/**
* Represents a physics updraft event
*/
declare class PhysicsUpdraftEvent {
private _scene;
private _origin;
private _options;
private _physicsEngine;
private _originTop;
private _originDirection;
private _tickCallback;
private _cylinder;
private _cylinderPosition;
private _dataFetched;
private static _HitData;
/**
* Initializes the physics updraft event
* @param _scene BabylonJS scene
* @param _origin The origin position of the updraft
* @param _options The options for the updraft event
*/
constructor(_scene: Scene, _origin: Vector3, _options: PhysicsUpdraftEventOptions);
/**
* Returns the data related to the updraft event (cylinder).
* @returns A physics updraft event
*/
getData(): PhysicsUpdraftEventData;
/**
* Enables the updraft.
*/
enable(): void;
/**
* Disables the updraft.
*/
disable(): void;
/**
* Disposes the cylinder.
* @param force Specifies if the updraft should be disposed by force
*/
dispose(force?: boolean): void;
private _getHitData;
private _getBodyHitData;
private _getImpostorHitData;
private _tick;
/*** Helpers ***/
private _prepareCylinder;
private _intersectsWithCylinder;
}
/**
* Represents a physics vortex event
*/
declare class PhysicsVortexEvent {
private _scene;
private _origin;
private _options;
private _physicsEngine;
private _originTop;
private _tickCallback;
private _cylinder;
private _cylinderPosition;
private _dataFetched;
private static _OriginOnPlane;
private static _HitData;
/**
* Initializes the physics vortex event
* @param _scene The BabylonJS scene
* @param _origin The origin position of the vortex
* @param _options The options for the vortex event
*/
constructor(_scene: Scene, _origin: Vector3, _options: PhysicsVortexEventOptions);
/**
* Returns the data related to the vortex event (cylinder).
* @returns The physics vortex event data
*/
getData(): PhysicsVortexEventData;
/**
* Enables the vortex.
*/
enable(): void;
/**
* Disables the cortex.
*/
disable(): void;
/**
* Disposes the sphere.
* @param force
*/
dispose(force?: boolean): void;
private _getHitData;
private _getBodyHitData;
private _getImpostorHitData;
private _tick;
/*** Helpers ***/
private _prepareCylinder;
private _intersectsWithCylinder;
}
/**
* Options fot the radial explosion event
* @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine#further-functionality-of-the-impostor-class
*/
export declare class PhysicsRadialExplosionEventOptions {
/**
* The radius of the sphere for the radial explosion.
*/
radius: number;
/**
* The strength of the explosion.
*/
strength: number;
/**
* The strength of the force in correspondence to the distance of the affected object
*/
falloff: PhysicsRadialImpulseFalloff;
/**
* Sphere options for the radial explosion.
*/
sphere: {
segments: number;
diameter: number;
};
/**
* Sphere options for the radial explosion.
*/
affectedImpostorsCallback: (affectedImpostorsWithData: Array<PhysicsAffectedImpostorWithData>) => void;
/**
* Sphere options for the radial explosion.
*/
affectedBodiesCallback: (affectedBodiesWithData: Array<PhysicsAffectedBodyWithData>) => void;
}
/**
* Options fot the updraft event
* @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine#further-functionality-of-the-impostor-class
*/
export declare class PhysicsUpdraftEventOptions {
/**
* The radius of the cylinder for the vortex
*/
radius: number;
/**
* The strength of the updraft.
*/
strength: number;
/**
* The height of the cylinder for the updraft.
*/
height: number;
/**
* The mode for the updraft.
*/
updraftMode: PhysicsUpdraftMode;
}
/**
* Options fot the vortex event
* @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine#further-functionality-of-the-impostor-class
*/
export declare class PhysicsVortexEventOptions {
/**
* The radius of the cylinder for the vortex
*/
radius: number;
/**
* The strength of the vortex.
*/
strength: number;
/**
* The height of the cylinder for the vortex.
*/
height: number;
/**
* At which distance, relative to the radius the centripetal forces should kick in? Range: 0-1
*/
centripetalForceThreshold: number;
/**
* This multiplier determines with how much force the objects will be pushed sideways/around the vortex, when below the threshold.
*/
centripetalForceMultiplier: number;
/**
* This multiplier determines with how much force the objects will be pushed sideways/around the vortex, when above the threshold.
*/
centrifugalForceMultiplier: number;
/**
* This multiplier determines with how much force the objects will be pushed upwards, when in the vortex.
*/
updraftForceMultiplier: number;
}
/**
* The strength of the force in correspondence to the distance of the affected object
* @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine#further-functionality-of-the-impostor-class
*/
export declare enum PhysicsRadialImpulseFalloff {
/** Defines that impulse is constant in strength across it's whole radius */
Constant = 0,
/** Defines that impulse gets weaker if it's further from the origin */
Linear = 1
}
/**
* The strength of the force in correspondence to the distance of the affected object
* @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine#further-functionality-of-the-impostor-class
*/
export declare enum PhysicsUpdraftMode {
/** Defines that the upstream forces will pull towards the top center of the cylinder */
Center = 0,
/** Defines that once a impostor is inside the cylinder, it will shoot out perpendicular from the ground of the cylinder */
Perpendicular = 1
}
/**
* Interface for a physics hit data
* @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine#further-functionality-of-the-impostor-class
*/
export interface PhysicsHitData {
/**
* The force applied at the contact point
*/
force: Vector3;
/**
* The contact point
*/
contactPoint: Vector3;
/**
* The distance from the origin to the contact point
*/
distanceFromOrigin: number;
/**
* For an instanced physics body (mesh with thin instances), the index of the thin instance the hit applies to
*/
instanceIndex?: number;
}
/**
* Interface for radial explosion event data
* @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine#further-functionality-of-the-impostor-class
*/
export interface PhysicsRadialExplosionEventData {
/**
* A sphere used for the radial explosion event
*/
sphere: Mesh;
}
/**
* Interface for gravitational field event data
* @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine#further-functionality-of-the-impostor-class
*/
export interface PhysicsGravitationalFieldEventData {
/**
* A sphere mesh used for the gravitational field event
*/
sphere: Mesh;
}
/**
* Interface for updraft event data
* @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine#further-functionality-of-the-impostor-class
*/
export interface PhysicsUpdraftEventData {
/**
* A cylinder used for the updraft event
*/
cylinder?: Mesh;
}
/**
* Interface for vortex event data
* @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine#further-functionality-of-the-impostor-class
*/
export interface PhysicsVortexEventData {
/**
* A cylinder used for the vortex event
*/
cylinder: Mesh;
}
/**
* Interface for an affected physics impostor
* @see https://doc.babylonjs.com/features/featuresDeepDive/physics/usingPhysicsEngine#further-functionality-of-the-impostor-class
*/
export interface PhysicsAffectedImpostorWithData {
/**
* The impostor affected by the effect
*/
impostor: PhysicsImpostor;
/**
* The data about the hit/force from the explosion
*/
hitData: PhysicsHitData;
}
/**
* Interface for an affected physics body
* @see
*/
export interface PhysicsAffectedBodyWithData {
/**
* The impostor affected by the effect
*/
body: PhysicsBody;
/**
* The data about the hit/force from the explosion
*/
hitData: PhysicsHitData;
}
export {};