Interface BodyComponent

Derived from ColliderComponent, attaching this to a SceneObject turns it into a dynamic rigid-body that is automatically moved by the physics simulation in response to gravity, collisions, and other forces.

Example

// @input Physics.BodyComponent bodyComponent

// Add instant impulse force upward
script.bodyComponent.addForce(new vec3(0, 500, 0), Physics.ForceMode.Impulse);

// Add instant impulse torque to rotate the object
script.bodyComponent.addTorque(new vec3(0, 0, Math.PI * -25), Physics.ForceMode.Impulse);

// Every frame, add upward force over time, relative to the object rotation
// This is similar to a rocket boosting the object upward
script.createEvent("UpdateEvent").bind(function() {
    script.bodyComponent.addRelativeForce(new vec3(0, 2000, 0), Physics.ForceMode.Force);
});
interface BodyComponent {
    angularDamping: number;
    angularVelocity: vec3;
    damping: number;
    debugDrawEnabled: boolean;
    density: number;
    dynamic: boolean;
    enabled: boolean;
    filter: Filter;
    fitVisual: boolean;
    forceCompound: boolean;
    intangible: boolean;
    mass: number;
    matter: Matter;
    onCollisionEnter: event1<CollisionEnterEventArgs, void>;
    onCollisionExit: event1<CollisionExitEventArgs, void>;
    onCollisionStay: event1<CollisionStayEventArgs, void>;
    onOverlapEnter: event1<OverlapEnterEventArgs, void>;
    onOverlapExit: event1<OverlapExitEventArgs, void>;
    onOverlapStay: event1<OverlapStayEventArgs, void>;
    overlapFilter: Filter;
    rotateSmoothFactor: number;
    sceneObject: SceneObject;
    shape: Shape;
    smooth: boolean;
    translateSmoothFactor: number;
    uniqueIdentifier: string;
    velocity: vec3;
    worldSettings: Physics.WorldSettingsAsset;
    addForce(force: vec3, mode: ForceMode): void;
    addForceAt(force: vec3, offset: vec3, mode: ForceMode): void;
    addPointConstraint(target: ColliderComponent, position: vec3): ConstraintComponent;
    addRelativeForce(force: vec3, mode: ForceMode): void;
    addRelativeForceAt(force: vec3, position: vec3, mode: ForceMode): void;
    addRelativeTorque(torque: vec3, mode: ForceMode): void;
    addTorque(torque: vec3, mode: ForceMode): void;
    clearMotion(): void;
    destroy(): void;
    getSceneObject(): SceneObject;
    getTransform(): Transform;
    getTypeName(): string;
    isOfType(type: string): boolean;
    isSame(other: ScriptObject): boolean;
    removeConstraint(constraint: ConstraintComponent): void;
}

Hierarchy (view full)

Properties

angularDamping angularVelocity damping debugDrawEnabled density dynamic enabled filter fitVisual forceCompound intangible mass matter onCollisionEnter onCollisionExit onCollisionStay onOverlapEnter onOverlapExit onOverlapStay overlapFilter rotateSmoothFactor sceneObject shape smooth translateSmoothFactor uniqueIdentifier velocity worldSettings

Methods

addForce addForceAt addPointConstraint addRelativeForce addRelativeForceAt addRelativeTorque addTorque clearMotion destroy getSceneObject getTransform getTypeName isOfType isSame removeConstraint

Properties

angularDamping

angularDamping: number

Damping applied to angular velocity, in the range 0.0 (no damping) to 1.0 (maximum damping).

angularVelocity

angularVelocity: vec3

Angular velocity, expressed as an axis of rotation scaled by angular speed (radians/s).

damping

damping: number

Damping applied to linear velocity, in the range 0.0 (no damping) to 1.0 (maximum damping). This produces an effect similar to drag in that it causes the object to slow down over time. It is not however physically accurate, and it doesn't take into account surface area or mass.

debugDrawEnabled

debugDrawEnabled: boolean

Toggle collider wire rendering for visualizing collider geometry shape and where it is placed.

density

density: number

Density (kg/L) of the object, used to derive mass from volume. If modified, mass changes according to shape and scale.

dynamic

dynamic: boolean

If enabled, the body is dynamically simulated, such that it responds to forces and collisions. Otherwise, it acts as a static collider, functionally equivalent to Physics.ColliderComponent.

enabled

enabled: boolean

If disabled, the Component will stop enacting its behavior.

filter

filter: Filter

Collision filter to use for this collider.

fitVisual

fitVisual: boolean

If enabled, the collider shape extends to fit the visual mesh, if any. Only applicable for Box and Sphere shapes.

forceCompound

forceCompound: boolean

Nested collider/body components may be merged into compound shapes. By default, this occurs only for dynamic bodies and not for static colliders. If forceCompound is set, this occurs for static colliders as well.

intangible

intangible: boolean

If enabled, the collider doesn't interact with the world but may still be detected with ray casts and intersection events.

mass

mass: number

Mass (kg) of the object. If modified from this field, mass is constant irrespective of shape and scale.

matter

matter: Matter

The matter used by the collider to define its physical substance, such as friction and bounciness.

ReadonlyonCollisionEnter

onCollisionEnter: event1<CollisionEnterEventArgs, void>

Signals when objects initially collide.

ReadonlyonCollisionExit

onCollisionExit: event1<CollisionExitEventArgs, void>

Signals when objects stop colliding.

ReadonlyonCollisionStay

onCollisionStay: event1<CollisionStayEventArgs, void>

Signals every frame while objects continue to collide.

ReadonlyonOverlapEnter

onOverlapEnter: event1<OverlapEnterEventArgs, void>

Signals when colliders first overlap.

ReadonlyonOverlapExit

onOverlapExit: event1<OverlapExitEventArgs, void>

Signals when colliders stop overlapping.

ReadonlyonOverlapStay

onOverlapStay: event1<OverlapStayEventArgs, void>

Signals every frame while colliders continue to overlap.

overlapFilter

overlapFilter: Filter

Collision filter used for overlap events.

rotateSmoothFactor

rotateSmoothFactor: number

Smoothing spring factor, for rotation.

ReadonlysceneObject

sceneObject: SceneObject

shape

shape: Shape

The Shape object used for collision.

smooth

smooth: boolean

Smooth transform changes using a dampened spring. Useful to reduce motion noise. This only applies to the simulation and changes from outside the simulation. The scene object's transform is not affected. It has no effect for dynamic bodies.

translateSmoothFactor

translateSmoothFactor: number

Smoothing spring factor, for translation. This controls the restitution strength of the spring, so low values are smoother but lag more.

ReadonlyuniqueIdentifier

uniqueIdentifier: string

velocity

velocity: vec3

Linear velocity (cm/s).

worldSettings

worldSettings: Physics.WorldSettingsAsset

The WorldSettingsAsset used by the collider to define the physics simulation settings.

Methods

addForce

  • addForce(force, mode): void

  • Apply linear force at the object's center-of-mass.

    Parameters

    Returns void

addForceAt

  • addForceAt(force, offset, mode): void

  • Apply force at a point offset from the object's origin, effectively generating torque.

    Parameters

    Returns void

addPointConstraint

  • addPointConstraint(target, position): ConstraintComponent

  • Add a point constraint between this body and the given collider, at the given position. target is optional. If null, it is statically constrained to the world. This is a convenience function that creates a child SceneObject with a ConstraintComponent, and sets its type, target, and constraint parameters. To fully remove the constraint, its SceneObject must be removed - not the component. Call removeConstraint() to do this.

    Parameters

    Returns ConstraintComponent

addRelativeForce

  • addRelativeForce(force, mode): void

  • Relative to local rotation, apply linear force at the object's center-of-mass.

    Parameters

    Returns void

addRelativeForceAt

  • addRelativeForceAt(force, position, mode): void

  • Relative to local rotation, apply force at a point offset from the object's origin, effectively generating torque.

    Parameters

    Returns void

addRelativeTorque

  • addRelativeTorque(torque, mode): void

  • Relative to local rotation, apply torque (angular force).

    Parameters

    Returns void

addTorque

  • addTorque(torque, mode): void

  • Apply torque (angular force).

    Parameters

    Returns void

clearMotion

destroy

getSceneObject

getTransform

getTypeName

isOfType

  • isOfType(type): boolean

  • Returns true if the object matches or derives from the passed in type.

    Parameters

    • type: string

    Returns boolean

isSame

  • isSame(other): boolean

  • Returns true if this object is the same as other. Useful for checking if two references point to the same thing.

    Parameters

    Returns boolean

removeConstraint

  • removeConstraint(constraint): void

  • Removes a constraint that was added with one of the add*Constraint() functions.

    Parameters

    Returns void

Settings

Member Visibility

On This Page

Properties
Methods