Class RapierPhysics

constructor

• new RapierPhysics(): RapierPhysics

• Returns RapierPhysics

debugRenderColliders

debugRenderRaycasts

gravity

• get gravity(): Vec3

• Returns Vec3

• set gravity(value): void

• Parameters

  • value: Vec3

  Returns void

isUpdating

• get isUpdating(): boolean

• Returns boolean

world

• get world(): undefined | World

• Get access to the rapier world

  Returns undefined | World

addBoxCollider

• addBoxCollider(collider, size): Promise<void>

• Parameters

  • collider: ICollider
  • size: Vector3

  Returns Promise<void>

addCapsuleCollider

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

• Parameters

  • collider: ICollider
  • height: number
  • radius: number

  Returns Promise<void>

addFixedJoint

• addFixedJoint(body1, body2): void

• Parameters

  • body1: IRigidbody
  • body2: IRigidbody

  Returns void

addForce

• addForce(rigidbody, force, wakeup): void

• Parameters

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

  Returns void

addHingeJoint

• addHingeJoint(body1, body2, anchor, axis): 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;
    }

    • x: number

    • y: number

    • z: number

  • axis: {
        x: number;
        y: number;
        z: number;
    }

    • x: number

    • y: number

    • z: number

  Returns void

addImpulse

• addImpulse(rigidbody, force, wakeup): void

• Parameters

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

  Returns void

addMeshCollider

• addMeshCollider(collider, mesh, convex, scale): Promise<void>

• Parameters

  • collider: ICollider
  • mesh: Mesh<BufferGeometry<NormalBufferAttributes>, Material | Material[], Object3DEventMap>
  • convex: boolean
  • scale: Vector3

  Returns Promise<void>

addSphereCollider

• addSphereCollider(collider): Promise<void>

• Parameters

  • collider: ICollider

  Returns Promise<void>

applyImpulse

• applyImpulse(rb, vec, wakeup): void

• Parameters

  • rb: IRigidbody
  • vec: Vec3
  • wakeup: boolean

  Returns void

clearCaches

• clearCaches(): void

• clear all possibly cached data (e.g. mesh data when creating scaled mesh colliders)

  Returns void

getAngularVelocity

• getAngularVelocity(rb): null | Vec3

• Parameters

  • rb: IRigidbody

  Returns null | Vec3

getBody

• getBody(obj): any

• Get the rapier body for a Needle component

  Parameters

  • obj: ICollider | IRigidbody

  Returns any

getComponent

• getComponent(rapierObject): null | IComponent

• Get the Needle Engine component for a rapier object

  Parameters

  • rapierObject: object

  Returns null | IComponent

getLinearVelocity

• getLinearVelocity(comp): null | Vec3

• Returns the linear velocity of a rigidbody or the rigidbody of a collider

  Parameters

  • comp: ICollider | IRigidbody

  Returns null | Vec3

initialize

• initialize(context): Promise<boolean>

• Parameters

  • context: Context

  Returns Promise<boolean>

isSleeping

• isSleeping(rb): undefined | boolean

• Parameters

  • rb: IRigidbody

  Returns undefined | boolean

postStep

• postStep(): void

• Returns void

raycast

• raycast(origin?, direction?, options?): null | {
      collider: ICollider;
      point: Vector3;
  }

• 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 options

    • OptionalfilterGroups?: number

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

      Return false to ignore this collider

      • • (c): boolean

        • Parameters

          • c: ICollider

          Returns boolean

    • 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
      Copy

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

raycastAndGetNormal

• raycastAndGetNormal(origin?, direction?, options?): null | {
      collider: ICollider;
      normal: Vector3;
      point: Vector3;
  }

• raycast that also gets the normal vector. If you don't need it use raycast()

  Parameters

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

    • OptionalfilterGroups?: number

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

      Return false to ignore this collider

      • • (c): boolean

        • Parameters

          • c: ICollider

          Returns boolean

    • 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
      Copy

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

removeBody

• removeBody(obj): void

• Parameters

  • obj: IComponent

  Returns void

resetForces

• resetForces(rb, wakeup): void

• Parameters

  • rb: IRigidbody
  • wakeup: boolean

  Returns void

resetTorques

• resetTorques(rb, wakeup): void

• Parameters

  • rb: IRigidbody
  • wakeup: boolean

  Returns void

setAngularVelocity

• setAngularVelocity(rb, vec, wakeup): void

• Parameters

  • rb: IRigidbody
  • vec: Vec3
  • wakeup: boolean

  Returns void

setLinearVelocity

• setLinearVelocity(rb, vec, wakeup): void

• Parameters

  • rb: IRigidbody
  • vec: Vec3
  • wakeup: boolean

  Returns void

sphereOverlap

• sphereOverlap(point, radius): 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?): void

• Parameters

  • Optionaldt: number

  Returns void

updateBody

• updateBody(comp, translation, rotation): void

• Parameters

  • comp: ICollider | IRigidbody
  • translation: boolean
  • rotation: boolean

  Returns void

updatePhysicsMaterial

• updatePhysicsMaterial(col): void

• Parameters

  • col: ICollider

  Returns void

updateProperties

• updateProperties(obj): void

• Parameters

  • obj: ICollider | IRigidbody

  Returns void

wakeup

• wakeup(rb): void

• Parameters

  • rb: IRigidbody

  Returns void