API
Options
All
  • Public
  • Public/Protected
  • All
Menu

Class PhysicsBody

PhysicsBody is useful for creating a physics body that can be used in a physics engine. It allows the user to set the mass and velocity of the body, which can then be used to calculate the motion of the body in the physics engine.

Hierarchy

  • PhysicsBody

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

  • Constructs a new physics body for the given node.

    Parameters

    • transformNode: TransformNode

      The Transform Node to construct the physics body for. For better performance, it is advised that this node does not have a parent.

    • motionType: PhysicsMotionType

      The motion type of the physics body. The options are:

      • PhysicsMotionType.STATIC - Static bodies are not moving and unaffected by forces or collisions. They are good for level boundaries or terrain.
      • PhysicsMotionType.DYNAMIC - Dynamic bodies are fully simulated. They can move and collide with other objects.
      • PhysicsMotionType.ANIMATED - They behave like dynamic bodies, but they won't be affected by other bodies, but still push other bodies out of the way.
    • startsAsleep: boolean

      Whether the physics body should start in a sleeping state (not a guarantee). Defaults to false.

    • scene: Scene

      The scene containing the physics engine.

      This code is useful for creating a physics body for a given Transform Node in a scene. It checks the version of the physics engine and the physics plugin, and initializes the body accordingly. It also sets the node's rotation quaternion if it is not already set. Finally, it adds the body to the physics engine.

    Returns PhysicsBody

Properties

_pluginDataSearch playground for _pluginData

_pluginData: any

V2 Physics plugin private data for single Transform

_pluginDataInstancesSearch playground for _pluginDataInstances

_pluginDataInstances: any[]

V2 Physics plugin private data for instances

disablePreStepSearch playground for disablePreStep

disablePreStep: boolean

Disable pre-step that consists in updating Physics Body from Transform Node Translation/Orientation. True by default for maximum performance.

startAsleepSearch playground for startAsleep

startAsleep: boolean

Physics engine will try to make this body sleeping and not active

transformNodeSearch playground for transformNode

transformNode: TransformNode

The transform node associated with this Physics Body

Accessors

numInstances

  • get numInstances(): number

  • This returns the number of internal instances of the physics body

    Returns number

shape

  • Retrieves the physics shape associated with this object.

    Returns Nullable<PhysicsShape>

    The physics shape associated with this object, or undefined if no shape is associated.

    This method is useful for retrieving the physics shape associated with this object, which can be used to apply physical forces to the object or to detect collisions.

  • Sets the shape of the physics body.

    Parameters

    • shape: Nullable<PhysicsShape>

      The shape of the physics body.

      This method is useful for setting the shape of the physics body, which is necessary for the physics engine to accurately simulate the body's behavior. The shape is used to calculate the body's mass, inertia, and other properties.

    Returns void

Methods

addConstraintSearch playground for addConstraint

  • Adds a constraint to the physics engine.

    Parameters

    • childBody: PhysicsBody

      The body to which the constraint will be applied.

    • constraint: PhysicsConstraint

      The constraint to be applied.

    • Optional instanceIndex: number

      If this body is instanced, the index of the instance to which the constraint will be applied. If not specified, no constraint will be applied.

    • Optional childInstanceIndex: number

      If the child body is instanced, the index of the instance to which the constraint will be applied. If not specified, no constraint will be applied.

    Returns void

applyForceSearch playground for applyForce

  • applyForce(force: Vector3, location: Vector3, instanceIndex?: number): void

  • Applies a force to the physics object.

    Parameters

    • force: Vector3

      The force vector.

    • location: Vector3

      The location of the force.

    • Optional instanceIndex: number

      For a instanced body, the instance to where the force should be applied. If not specified, the force is applied to all instances.

      This method is useful for applying a force to a physics object, which can be used to simulate physical forces such as gravity, collisions, and explosions. This can be used to create realistic physics simulations in a game or other application.

    Returns void

applyImpulseSearch playground for applyImpulse

  • applyImpulse(impulse: Vector3, location: Vector3, instanceIndex?: number): void

  • Applies an impulse to the physics object.

    Parameters

    • impulse: Vector3

      The impulse vector.

    • location: Vector3

      The location of the impulse.

    • Optional instanceIndex: number

      For a instanced body, the instance to where the impulse should be applied. If not specified, the impulse is applied to all instances.

      This method is useful for applying an impulse to a physics object, which can be used to simulate physical forces such as gravity, collisions, and explosions. This can be used to create realistic physics simulations in a game or other application.

    Returns void

cloneSearch playground for clone

  • Clone the PhysicsBody to a new body and assign it to the transformNode parameter

    Parameters

    • transformNode: TransformNode

      transformNode that will be used for the cloned PhysicsBody

    Returns PhysicsBody

    the newly cloned PhysicsBody

computeMassPropertiesSearch playground for computeMassProperties

  • Computes the mass properties of the physics object, based on the set of physics shapes this body uses. This method is useful for computing the initial mass properties of a physics object, such as its mass, inertia, and center of mass; these values are important for accurately simulating the physics of the object in the physics engine, and computing values based on the shape will provide you with reasonable intial values, which you can then customize.

    Parameters

    • Optional instanceIndex: number

    Returns PhysicsMassProperties

disposeSearch playground for dispose

  • dispose(): void

  • Disposes the body from the physics engine.

    This method is useful for cleaning up the physics engine when a body is no longer needed. Disposing the body will free up resources and prevent memory leaks.

    Returns void

getAngularDampingSearch playground for getAngularDamping

  • getAngularDamping(instanceIndex?: number): number

  • Gets the angular damping of the physics body.

    Parameters

    • Optional instanceIndex: number

    Returns number

    The angular damping of the physics body.

    This method is useful for getting the angular damping of the physics body, which is the rate of reduction of the angular velocity over time. This is important for simulating realistic physics behavior in a game.

getAngularVelocitySearch playground for getAngularVelocity

  • getAngularVelocity(instanceIndex?: number): Vector3

  • Gets the angular velocity of the physics body as a new vector3.

    Parameters

    • Optional instanceIndex: number

    Returns Vector3

    The angular velocity of the physics body.

    This method is useful for getting the angular velocity of a physics body, which can be used to determine the body's rotational speed. This information can be used to create realistic physics simulations.

getAngularVelocityToRefSearch playground for getAngularVelocityToRef

  • getAngularVelocityToRef(angVel: Vector3, instanceIndex?: number): void

  • Gets the angular velocity of the physics body and stores it in the given vector3.

    Parameters

    • angVel: Vector3

      The vector3 to store the angular velocity in.

      This method is useful for getting the angular velocity of a physics body, which can be used to determine the body's rotational speed. This information can be used to create realistic physics simulations.

    • Optional instanceIndex: number

    Returns void

getClassNameSearch playground for getClassName

  • getClassName(): string

  • Returns the string "PhysicsBody".

    Returns string

    "PhysicsBody"

getCollisionEndedObservableSearch playground for getCollisionEndedObservable

  • Returns an observable that will be notified when the body has finished colliding with another body

    Returns Observable<IBasePhysicsCollisionEvent>

getCollisionObservableSearch playground for getCollisionObservable

  • Returns an observable that will be notified for when a collision starts or continues for this PhysicsBody

    Returns Observable<IPhysicsCollisionEvent>

    Observable

getEventMaskSearch playground for getEventMask

  • getEventMask(instanceIndex?: number): number

  • Gets the event mask of the physics engine.

    Parameters

    • Optional instanceIndex: number

    Returns number

    The event mask of the physics engine.

    This method is useful for getting the event mask of the physics engine, which is used to determine which events the engine will respond to. This is important for ensuring that the engine is responding to the correct events and not wasting resources on unnecessary events.

getGeometrySearch playground for getGeometry

  • getGeometry(): {}

  • Retrieves the geometry of the body from the physics plugin.

    Returns {}

    The geometry of the body.

    This method is useful for retrieving the geometry of the body from the physics plugin, which can be used for various physics calculations.

    getGravityFactorSearch playground for getGravityFactor

    • getGravityFactor(instanceIndex?: number): number

    • Gets the gravity factor of the physics body

      Parameters

      • Optional instanceIndex: number

        the instance of the body to get, if undefined the value of first instance will be returned

      Returns number

      the gravity factor

    getLinearDampingSearch playground for getLinearDamping

    • getLinearDamping(instanceIndex?: number): number

    • Gets the linear damping of the physics body.

      Parameters

      • Optional instanceIndex: number

      Returns number

      The linear damping of the physics body.

      This method is useful for retrieving the linear damping of the physics body, which is the amount of resistance the body has to linear motion. This is useful for simulating realistic physics behavior in a game.

    getLinearVelocitySearch playground for getLinearVelocity

    • getLinearVelocity(instanceIndex?: number): Vector3

    • Gets the linear velocity of the physics body as a new vector3.

      Parameters

      • Optional instanceIndex: number

      Returns Vector3

      The linear velocity of the physics body.

      This method is useful for getting the linear velocity of a physics body in a physics engine. This can be used to determine the speed and direction of the body, which can be used to calculate the motion of the body.

    getLinearVelocityToRefSearch playground for getLinearVelocityToRef

    • getLinearVelocityToRef(linVel: Vector3, instanceIndex?: number): void

    • Gets the linear velocity of the physics body and stores it in the given vector3.

      Parameters

      • linVel: Vector3

        The vector3 to store the linear velocity in.

        This method is useful for getting the linear velocity of a physics body in a physics engine. This can be used to determine the speed and direction of the body, which can be used to calculate the motion of the body.

      • Optional instanceIndex: number

      Returns void

    getMassPropertiesSearch playground for getMassProperties

    • Retrieves the mass properties of the object.

      Parameters

      • Optional instanceIndex: number

      Returns PhysicsMassProperties

      The mass properties of the object.

      This method is useful for physics simulations, as it allows the user to retrieve the mass properties of the object, such as its mass, center of mass, and moment of inertia. This information is necessary for accurate physics simulations.

    getMotionTypeSearch playground for getMotionType

    • Gets the motion type of the physics body. Can be STATIC, DYNAMIC, or ANIMATED.

      Parameters

      • Optional instanceIndex: number

      Returns PhysicsMotionType

    getObjectCenterWorldSearch playground for getObjectCenterWorld

    • getObjectCenterWorld(instanceIndex?: number): Vector3

    • Parameters

      • Optional instanceIndex: number

      Returns Vector3

    getObjectCenterWorldToRefSearch playground for getObjectCenterWorldToRef

    • getObjectCenterWorldToRef(ref: Vector3, instanceIndex?: number): Vector3

    • Parameters

      • ref: Vector3
      • Optional instanceIndex: number

      Returns Vector3

    iterateOverAllInstancesSearch playground for iterateOverAllInstances

    • iterateOverAllInstances(callback: ((body: PhysicsBody, instanceIndex?: number) => void)): void

    • Executes a callback on the body or all of the instances of a body

      Parameters

      • callback: ((body: PhysicsBody, instanceIndex?: number) => void)

        the callback to execute

          • Parameters

            Returns void

      Returns void

    setAngularDampingSearch playground for setAngularDamping

    • setAngularDamping(damping: number, instanceIndex?: number): void

    • Sets the angular damping of the physics body.

      Parameters

      • damping: number

        The angular damping of the body.

        This method is useful for controlling the angular velocity of a physics body. By setting the damping, the body's angular velocity will be reduced over time, simulating the effect of friction. This can be used to create realistic physical behavior in a physics engine.

      • Optional instanceIndex: number

      Returns void

    setAngularVelocitySearch playground for setAngularVelocity

    • setAngularVelocity(angVel: Vector3, instanceIndex?: number): void

    • Sets the angular velocity of the physics object.

      Parameters

      • angVel: Vector3

        The angular velocity to set.

        This method is useful for setting the angular velocity of a physics object, which is necessary for simulating realistic physics behavior. The angular velocity is used to determine the rate of rotation of the object, which is important for simulating realistic motion.

      • Optional instanceIndex: number

      Returns void

    setCollisionCallbackEnabledSearch playground for setCollisionCallbackEnabled

    • setCollisionCallbackEnabled(enabled: boolean): void

    • Enable or disable collision callback for this PhysicsBody.

      Parameters

      • enabled: boolean

        true if PhysicsBody's collision will rise a collision event and notifies the observable

      Returns void

    setCollisionEndedCallbackEnabledSearch playground for setCollisionEndedCallbackEnabled

    • setCollisionEndedCallbackEnabled(enabled: boolean): void

    • Parameters

      • enabled: boolean

      Returns void

    setEventMaskSearch playground for setEventMask

    • setEventMask(eventMask: number, instanceIndex?: number): void

    • Sets the event mask for the physics engine.

      Parameters

      • eventMask: number

        A bitmask that determines which events will be sent to the physics engine.

        This method is useful for setting the event mask for the physics engine, which determines which events will be sent to the physics engine. This allows the user to control which events the physics engine will respond to.

      • Optional instanceIndex: number

      Returns void

    setGravityFactorSearch playground for setGravityFactor

    • setGravityFactor(factor: number, instanceIndex?: number): void

    • Sets the gravity factor of the physics body

      Parameters

      • factor: number

        the gravity factor to set

      • Optional instanceIndex: number

        the instance of the body to set, if undefined all instances will be set

      Returns void

    setLinearDampingSearch playground for setLinearDamping

    • setLinearDamping(damping: number, instanceIndex?: number): void

    • Sets the linear damping of the physics body.

      Parameters

      • damping: number

        The linear damping value.

        This method is useful for controlling the linear damping of the physics body, which is the rate at which the body's velocity decreases over time. This is useful for simulating the effects of air resistance or other forms of friction.

      • Optional instanceIndex: number

      Returns void

    setLinearVelocitySearch playground for setLinearVelocity

    • setLinearVelocity(linVel: Vector3, instanceIndex?: number): void

    • Sets the linear velocity of the physics object.

      Parameters

      • linVel: Vector3

        The linear velocity to set.

        This method is useful for setting the linear velocity of a physics object, which is necessary for simulating realistic physics in a game engine. By setting the linear velocity, the physics object will move in the direction and speed specified by the vector. This allows for realistic physics simulations, such as simulating the motion of a ball rolling down a hill.

      • Optional instanceIndex: number

      Returns void

    setMassPropertiesSearch playground for setMassProperties

    • Sets the mass properties of the physics object.

      Parameters

      • massProps: PhysicsMassProperties

        The mass properties to set.

      • Optional instanceIndex: number

        The index of the instance to set the mass properties for. If not defined, the mass properties will be set for all instances.

        This method is useful for setting the mass properties of a physics object, such as its mass, inertia, and center of mass. This is important for accurately simulating the physics of the object in the physics engine.

      Returns void

    setMotionTypeSearch playground for setMotionType

    • Sets the motion type of the physics body. Can be STATIC, DYNAMIC, or ANIMATED.

      Parameters

      Returns void

    setTargetTransformSearch playground for setTargetTransform

    • setTargetTransform(position: Vector3, rotation: Quaternion, instanceIndex?: number): void

    • Set the target transformation (position and rotation) of the body, such that the body will set its velocity to reach that target

      Parameters

      • position: Vector3

        The target position

      • rotation: Quaternion

        The target rotation

      • Optional instanceIndex: number

        The index of the instance in an instanced body

      Returns void

    syncWithBoneSearch playground for syncWithBone

    • Sync with a bone

      Parameters

      • bone: Bone

        The bone that the impostor will be synced to.

      • boneMesh: AbstractMesh

        The mesh that the bone is influencing.

      • jointPivot: Vector3

        The pivot of the joint / bone in local space.

      • Optional distToJoint: number

        Optional distance from the impostor to the joint.

      • Optional adjustRotation: Quaternion

        Optional quaternion for adjusting the local rotation of the bone.

      • Optional boneAxis: Vector3

        Optional vector3 axis the bone is aligned with

      Returns void

    updateBodyInstancesSearch playground for updateBodyInstances

    • updateBodyInstances(): void

    • If a physics body is connected to an instanced node, update the number physic instances to match the number of node instances.

      Returns void

    Legend

    • Constructor
    • Property
    • Method
    • Accessor
    • Inherited constructor
    • Inherited property
    • Inherited method
    • Property
    • Method
    • Static method

    Settings

    Theme