Class RapierPhysics

Implements

Constructors

constructor

Properties

debugRenderColliders

debugRenderColliders: boolean = false

Enable to render collider shapes

debugRenderRaycasts

debugRenderRaycasts: boolean = false

Enable to visualize raycasts in the scene with gizmos

enabled

enabled: boolean = false

Enables or disables the physics engine

Accessors

gravity

  • get gravity(): Vec3

    Sets the gravity vector for the physics simulation

    Returns Vec3

  • set gravity(value: Vec3): void

    Sets the gravity vector for the physics simulation

    Parameters

    • value: Vec3

    Returns void

isInitialized

  • get isInitialized(): boolean

    Indicates whether the physics engine has been initialized

    Returns boolean

isUpdating

  • get isUpdating(): boolean

    Indicates whether the physics engine is currently updating

    Returns boolean

world

  • get world(): undefined | World

    Get access to the rapier world

    Returns undefined | World

Methods

addBoxCollider

addCapsuleCollider

  • addCapsuleCollider(
        collider: ICollider,
        height: number,
        radius: number,
    ): Promise<void>

    Adds a capsule collider to the physics world

    Parameters

    • collider: ICollider

      The collider component to add

    • height: number

      The height of the capsule

    • radius: number

      The radius of the capsule

    Returns Promise<void>

addFixedJoint

addForce

  • addForce(rigidbody: IRigidbody, force: Vec3, wakeup: boolean): void

    Adds a continuous force to a rigidbody

    Parameters

    • rigidbody: IRigidbody
    • force: Vec3
    • wakeup: boolean

      Whether to wake up the rigidbody

    Returns void

addHingeJoint

  • addHingeJoint(
        body1: IRigidbody,
        body2: IRigidbody,
        anchor: { x: number; y: number; z: number },
        axis: { x: number; y: number; z: number },
    ): void

    The joint prevents any relative movement between two rigid-bodies, except for relative rotations along one axis. This is typically used to simulate wheels, fans, etc. They are characterized by one local anchor as well as one local axis on each rigid-body.

    Parameters

    • body1: IRigidbody
    • body2: IRigidbody
    • anchor: { x: number; y: number; z: number }
    • axis: { x: number; y: number; z: number }

    Returns void

addImpulse

  • addImpulse(rigidbody: IRigidbody, force: Vec3, wakeup: boolean): void

    Parameters

    Returns void

addMeshCollider

  • addMeshCollider(
        collider: ICollider,
        mesh: Mesh,
        convex: boolean,
        extraScale?: Vector3,
    ): Promise<void>

    Adds a mesh collider to the physics world

    Parameters

    • collider: ICollider

      The collider component to add

    • mesh: Mesh

      The mesh to use for collision

    • convex: boolean

      Whether the collision mesh should be treated as convex

    • OptionalextraScale: Vector3

    Returns Promise<void>

addSphereCollider

applyImpulse

  • applyImpulse(rb: IRigidbody, vec: Vec3, wakeup: boolean): void

    Applies an instantaneous impulse to a rigidbody

    Parameters

    • rb: IRigidbody

      The rigidbody to apply impulse to

    • vec: Vec3

      The impulse vector to apply

    • wakeup: boolean

      Whether to wake up the rigidbody

    Returns void

clearCaches

  • clearCaches(): void

    Clears all cached data (e.g., mesh data when creating scaled mesh colliders)

    Returns void

getAngularVelocity

  • getAngularVelocity(rb: IRigidbody): null | Vec3

    Gets the angular velocity of a rigidbody

    Parameters

    • rb: IRigidbody

      The rigidbody to get angular velocity from

    Returns null | Vec3

    The angular velocity vector or null if not available

getBody

getComponent

getLinearVelocity

initialize

isSleeping

  • isSleeping(rb: IRigidbody): undefined | boolean

    Checks if a rigidbody is currently sleeping

    Parameters

    Returns undefined | boolean

    Whether the rigidbody is sleeping or undefined if cannot be determined

postStep

raycast

  • raycast(
        origin?: Vec3 | Vec2,
        direction?: Vec3,
        options?: {
            filterGroups?: number;
            filterPredicate?: (c: ICollider) => boolean;
            maxDistance?: number;
            queryFilterFlags?: QueryFilterFlags;
            solid?: boolean;
            useIgnoreRaycastLayer?: boolean;
        },
    ): null
    | { collider: ICollider; point: Vector3 }

    Performs a fast raycast against physics colliders

    Parameters

    • Optionalorigin: Vec3 | Vec2

      Ray origin in screen or worldspace

    • Optionaldirection: Vec3

      Ray direction in worldspace

    • Optionaloptions: {
          filterGroups?: number;
          filterPredicate?: (c: ICollider) => boolean;
          maxDistance?: number;
          queryFilterFlags?: QueryFilterFlags;
          solid?: boolean;
          useIgnoreRaycastLayer?: boolean;
      }

      Additional raycast configuration options

      • OptionalfilterGroups?: number
      • OptionalfilterPredicate?: (c: ICollider) => boolean

        Return false to ignore this collider

      • OptionalmaxDistance?: number
      • OptionalqueryFilterFlags?: QueryFilterFlags
      • Optionalsolid?: boolean

        True if you want to also hit objects when the raycast starts from inside a collider

      • OptionaluseIgnoreRaycastLayer?: boolean

        When enabled the hit object's layer will be tested. If layer 2 is enabled the object will be ignored (Layer 2 == IgnoreRaycast) If not set the raycast will ignore objects in the IgnoreRaycast layer (default: true)

        Default

        undefined

    Returns null | { collider: ICollider; point: Vector3 }

    Raycast result containing hit point and collider, or null if no hit

raycastAndGetNormal

  • raycastAndGetNormal(
        origin?: Vec3 | Vec2,
        direction?: Vec3,
        options?: {
            filterGroups?: number;
            filterPredicate?: (c: ICollider) => boolean;
            maxDistance?: number;
            queryFilterFlags?: QueryFilterFlags;
            solid?: boolean;
            useIgnoreRaycastLayer?: boolean;
        },
    ): null
    | { collider: ICollider; normal: Vector3; point: Vector3 }

    Performs a raycast that also returns the normal vector at the hit point

    Parameters

    • Optionalorigin: Vec3 | Vec2

      Ray origin in screen or worldspace

    • Optionaldirection: Vec3

      Ray direction in worldspace

    • Optionaloptions: {
          filterGroups?: number;
          filterPredicate?: (c: ICollider) => boolean;
          maxDistance?: number;
          queryFilterFlags?: QueryFilterFlags;
          solid?: boolean;
          useIgnoreRaycastLayer?: boolean;
      }

      Additional raycast configuration options

      • OptionalfilterGroups?: number
      • OptionalfilterPredicate?: (c: ICollider) => boolean

        Return false to ignore this collider

      • OptionalmaxDistance?: number
      • OptionalqueryFilterFlags?: QueryFilterFlags
      • Optionalsolid?: boolean

        True if you want to also hit objects when the raycast starts from inside a collider

      • OptionaluseIgnoreRaycastLayer?: boolean

        When enabled the hit object's layer will be tested. If layer 2 is enabled the object will be ignored (Layer 2 == IgnoreRaycast) If not set the raycast will ignore objects in the IgnoreRaycast layer (default: true)

        Default

        undefined

    Returns null | { collider: ICollider; normal: Vector3; point: Vector3 }

    Raycast result containing hit point, normal, and collider, or null if no hit

removeBody

resetForces

  • resetForces(rb: IRigidbody, wakeup: boolean): void

    Resets all forces acting on a rigidbody

    Parameters

    • rb: IRigidbody

      The rigidbody to reset forces on

    • wakeup: boolean

      Whether to wake up the rigidbody

    Returns void

resetTorques

  • resetTorques(rb: IRigidbody, wakeup: boolean): void

    Resets all torques acting on a rigidbody

    Parameters

    • rb: IRigidbody

      The rigidbody to reset torques on

    • wakeup: boolean

      Whether to wake up the rigidbody

    Returns void

setAngularVelocity

  • setAngularVelocity(rb: IRigidbody, vec: Vec3, wakeup: boolean): void

    Sets the angular velocity of a rigidbody

    Parameters

    • rb: IRigidbody

      The rigidbody to set angular velocity for

    • vec: Vec3

      The angular velocity vector to set

    • wakeup: boolean

      Whether to wake up the rigidbody

    Returns void

setLinearVelocity

  • setLinearVelocity(rb: IRigidbody, vec: Vec3, wakeup: boolean): void

    Sets the linear velocity of a rigidbody

    Parameters

    • rb: IRigidbody

      The rigidbody to set linear velocity for

    • vec: Vec3

      The linear velocity vector to set

    • wakeup: boolean

      Whether to wake up the rigidbody

    Returns void

sphereOverlap

  • sphereOverlap(point: Vector3, radius: number): SphereOverlapResult[]

    Precice sphere overlap detection using rapier against colliders

    Parameters

    • point: Vector3

      center of the sphere in worldspace

    • radius: number

      radius of the sphere

    Returns SphereOverlapResult[]

    array of colliders that overlap with the sphere. Note: they currently only contain the collider and the gameobject

step

  • step(dt?: number): void

    Advances physics simulation by the given time step

    Parameters

    • Optionaldt: number

    Returns void

updateBody

  • updateBody(
        comp: ICollider | IRigidbody,
        translation: boolean,
        rotation: boolean,
    ): void

    Updates the position and/or rotation of a physics body

    Parameters

    • comp: ICollider | IRigidbody

      The collider or rigidbody component to update

    • translation: boolean

      Whether to update the position

    • rotation: boolean

      Whether to update the rotation

    Returns void

updatePhysicsMaterial

updateProperties

wakeup

Settings

Member Visibility

On This Page

Constructors
Properties
Accessors
Methods