Class RapierPhysics

Implements

  • IPhysicsEngine

Constructors

constructor

Accessors

gravity isUpdating world

Methods

addBoxCollider addCapsuleCollider addFixedJoint addForce addHingeJoint addImpulse addMeshCollider addSphereCollider applyImpulse clearCaches getAngularVelocity getBody getComponent getLinearVelocity initialize isSleeping postStep raycast raycastAndGetNormal removeBody resetForces resetTorques setAngularVelocity setLinearVelocity sphereOverlap step updateBody updatePhysicsMaterial updateProperties wakeup

Constructors

constructor

Accessors

gravity

  • get gravity(): Vec3

  • Returns Vec3

  • set gravity(value): void

  • Parameters

    • value: Vec3

    Returns void

isUpdating

  • get isUpdating(): boolean

  • Returns boolean

world

  • get world(): any

  • Get access to the rapier world

    Returns any

Methods

addBoxCollider

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

  • Parameters

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

  • Returns void

getAngularVelocity

  • getAngularVelocity(rb): Vec3

  • Parameters

    • rb: IRigidbody

    Returns Vec3

getBody

  • getBody(obj): any

  • Get the rapier body for a Needle component

    Parameters

    • obj: ICollider | IRigidbody

    Returns any

getComponent

  • getComponent(rapierObject): IComponent

  • Get the Needle Engine component for a rapier object

    Parameters

    • rapierObject: object

    Returns IComponent

getLinearVelocity

  • getLinearVelocity(comp): Vec3

  • Parameters

    • comp: ICollider | IRigidbody

    Returns Vec3

initialize

  • initialize(context): Promise<boolean>

  • Parameters

    Returns Promise<boolean>

isSleeping

  • isSleeping(rb): any

  • Parameters

    • rb: IRigidbody

    Returns any

postStep

  • postStep(): void

  • Returns void

raycast

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

  • Parameters

    • Optional origin: Vec3 | Vec2
    • Optional direction: Vec3
    • Optional options: {
          filterGroups?: number;
          filterPredicate?: ((c) => boolean);
          maxDistance?: number;
          queryFilterFlags?: QueryFilterFlags;
          solid?: boolean;
      }
      • Optional filterGroups?: number
      • Optional filterPredicate?: ((c) => boolean)

        Return false to ignore this collider

          • (c): boolean

          • Parameters

            • c: ICollider

            Returns boolean

      • Optional maxDistance?: number
      • Optional queryFilterFlags?: QueryFilterFlags
      • Optional solid?: boolean

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

    Returns {
        collider: ICollider;
        point: Vector3;
    }

raycastAndGetNormal

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

  • Parameters

    • Optional origin: Vec3 | Vec2
    • Optional direction: Vec3
    • Optional options: {
          filterGroups?: number;
          filterPredicate?: ((c) => boolean);
          maxDistance?: number;
          queryFilterFlags?: QueryFilterFlags;
          solid?: boolean;
      }
      • Optional filterGroups?: number
      • Optional filterPredicate?: ((c) => boolean)

        Return false to ignore this collider

          • (c): boolean

          • Parameters

            • c: ICollider

            Returns boolean

      • Optional maxDistance?: number
      • Optional queryFilterFlags?: QueryFilterFlags
      • Optional solid?: boolean

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

    Returns {
        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

    • Optional dt: 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

Settings

Member Visibility

Theme

On This Page

constructorgravityisUpdatingworldaddBoxCollideraddCapsuleCollideraddFixedJointaddForceaddHingeJointaddImpulseaddMeshCollideraddSphereColliderapplyImpulseclearCachesgetAngularVelocitygetBodygetComponentgetLinearVelocityinitializeisSleepingpostStepraycastraycastAndGetNormalremoveBodyresetForcesresetTorquessetAngularVelocitysetLinearVelocitysphereOverlapstepupdateBodyupdatePhysicsMaterialupdatePropertieswakeup

Generated using TypeDoc