Engine API Reference
    Preparing search index...

    Class CollisionComponent

    The CollisionComponent enables an Entity to act as a collision volume. Use it on its own to define a trigger volume. Or use it in conjunction with a RigidBodyComponent to make a collision volume that can be simulated using the physics engine.

    When an entity is configured as a trigger volume, if an entity with a dynamic or kinematic body enters or leaves that trigger volume, both entities will receive trigger events.

    You should never need to use the CollisionComponent constructor directly. To add an CollisionComponent to an Entity, use Entity#addComponent:

    const entity = pc.Entity();
    entity.addComponent('collision'); // This defaults to 1x1x1 box-shaped trigger volume

    To create a 0.5 radius dynamic rigid body sphere:

    const entity = pc.Entity();
    entity.addComponent('collision', {
        type: 'sphere'
    });
    entity.addComponent('rigidbody', {
        type: 'dynamic'
    });

    Once the CollisionComponent is added to the entity, you can access it via the collision property:

    entity.collision.type = 'cylinder'; // Set the collision volume to a cylinder

    console.log(entity.collision.type); // Get the collision volume type and print it

    Relevant Engine API examples:

    Hierarchy (View Summary)

    Index

    Properties

    entity system

    Accessors

    angularOffset asset axis checkVertexDuplicates convexHull enabled halfExtents height linearOffset model radius renderAsset type

    Methods

    fire getShapePosition getShapeRotation hasEvent off on once

    Events

    EVENT_COLLISIONEND EVENT_COLLISIONSTART EVENT_CONTACT EVENT_TRIGGERENTER EVENT_TRIGGERLEAVE

    Properties

    entity: Entity

    The Entity that this Component is attached to.

    system: ComponentSystem

    The ComponentSystem used to create this Component.

    Accessors

    • get angularOffset(): Quat

      Gets the rotational offset of the collision shape from the Entity rotation in local space.

      Returns Quat

    • set angularOffset(arg: Quat): void

      Sets the rotational offset of the collision shape from the Entity rotation in local space. Defaults to identity.

      Parameters

      Returns void

    • get asset(): null | number | Asset

      Gets the asset or asset id for the model of the mesh collision volume.

      Returns null | number | Asset

    • set asset(arg: null | number | Asset): void

      Sets the asset or asset id for the model of the mesh collision volume. Defaults to null.

      Parameters

      • arg: null | number | Asset

      Returns void

    • get axis(): number

      Gets the local space axis with which the capsule, cylinder or cone-shaped collision volume's length is aligned.

      Returns number

    • set axis(arg: number): void

      Sets the local space axis with which the capsule, cylinder or cone-shaped collision volume's length is aligned. 0 for X, 1 for Y and 2 for Z. Defaults to 1 (Y-axis).

      Parameters

      • arg: number

      Returns void

    • get checkVertexDuplicates(): boolean

      Gets whether checking for duplicate vertices should be enabled when creating collision meshes.

      Returns boolean

    • set checkVertexDuplicates(arg: boolean): void

      Sets whether checking for duplicate vertices should be enabled when creating collision meshes.

      Parameters

      • arg: boolean

      Returns void

    • get convexHull(): boolean

      Gets whether the collision mesh should be treated as a convex hull.

      Returns boolean

    • set convexHull(arg: boolean): void

      Sets whether the collision mesh should be treated as a convex hull. When false, the mesh can only be used with a static body. When true, the mesh can be used with a static, dynamic or kinematic body. Defaults to false.

      Parameters

      • arg: boolean

      Returns void

    • get enabled(): boolean

      Gets the enabled state of the component.

      Returns boolean

    • set enabled(arg: boolean): void

      Sets the enabled state of the component.

      Parameters

      • arg: boolean

      Returns void

    • get halfExtents(): Vec3

      Gets the half-extents of the box-shaped collision volume in the x, y and z axes.

      Returns Vec3

    • set halfExtents(arg: Vec3): void

      Sets the half-extents of the box-shaped collision volume in the x, y and z axes. Defaults to [0.5, 0.5, 0.5].

      Parameters

      Returns void

    • get height(): number

      Gets the total height of the capsule, cylinder or cone-shaped collision volume from tip to tip.

      Returns number

    • set height(arg: number): void

      Sets the total height of the capsule, cylinder or cone-shaped collision volume from tip to tip. Defaults to 2.

      Parameters

      • arg: number

      Returns void

    • get linearOffset(): Vec3

      Gets the positional offset of the collision shape from the Entity position along the local axes.

      Returns Vec3

    • set linearOffset(arg: Vec3): void

      Sets the positional offset of the collision shape from the Entity position along the local axes. Defaults to [0, 0, 0].

      Parameters

      Returns void

    • get model(): null | Model

      Gets the model that is added to the scene graph for the mesh collision volume.

      Returns null | Model

    • set model(arg: null | Model): void

      Sets the model that is added to the scene graph for the mesh collision volume.

      Parameters

      Returns void

    • get radius(): number

      Gets the radius of the sphere, capsule, cylinder or cone-shaped collision volumes.

      Returns number

    • set radius(arg: number): void

      Sets the radius of the sphere, capsule, cylinder or cone-shaped collision volumes. Defaults to 0.5.

      Parameters

      • arg: number

      Returns void

    • get renderAsset(): null | number | Asset

      Gets the render asset id of the mesh collision volume.

      Returns null | number | Asset

    • set renderAsset(arg: null | number | Asset): void

      Sets the render asset or asset id of the mesh collision volume. Defaults to null. If not set then the asset property will be checked instead.

      Parameters

      • arg: null | number | Asset

      Returns void

    • get type(): string

      Gets the type of the collision volume.

      Returns string

    • set type(arg: string): void

      Sets the type of the collision volume. Can be:

      • "box": A box-shaped collision volume.
      • "capsule": A capsule-shaped collision volume.
      • "compound": A compound shape. Any descendant entities with a collision component of type box, capsule, cone, cylinder or sphere will be combined into a single, rigid shape.
      • "cone": A cone-shaped collision volume.
      • "cylinder": A cylinder-shaped collision volume.
      • "mesh": A collision volume that uses a model asset as its shape.
      • "sphere": A sphere-shaped collision volume.

      Defaults to "box".

      Parameters

      • arg: string

      Returns void

    Methods

    • Fire an event, all additional arguments are passed on to the event listener.

      Parameters

      • name: string

        Name of event to fire.

      • Optionalarg1: any

        First argument that is passed to the event handler.

      • Optionalarg2: any

        Second argument that is passed to the event handler.

      • Optionalarg3: any

        Third argument that is passed to the event handler.

      • Optionalarg4: any

        Fourth argument that is passed to the event handler.

      • Optionalarg5: any

        Fifth argument that is passed to the event handler.

      • Optionalarg6: any

        Sixth argument that is passed to the event handler.

      • Optionalarg7: any

        Seventh argument that is passed to the event handler.

      • Optionalarg8: any

        Eighth argument that is passed to the event handler.

      Returns EventHandler

      Self for chaining.

      obj.fire('test', 'This is the message');

    • Returns the world position for the collision shape, taking into account of any offsets.

      Returns Vec3

      The world position for the collision shape.

    • Returns the world rotation for the collision shape, taking into account of any offsets.

      Returns Quat

      The world rotation for the collision.

    • Test if there are any handlers bound to an event name.

      Parameters

      • name: string

        The name of the event to test.

      Returns boolean

      True if the object has handlers bound to the specified event name.

      obj.on('test', () => {}); // bind an event to 'test'
      obj.hasEvent('test'); // returns true
      obj.hasEvent('hello'); // returns false

    • Detach an event handler from an event. If callback is not provided then all callbacks are unbound from the event, if scope is not provided then all events with the callback will be unbound.

      Parameters

      • Optionalname: string

        Name of the event to unbind.

      • Optionalcallback: HandleEventCallback

        Function to be unbound.

      • Optionalscope: any

        Scope that was used as the this when the event is fired.

      Returns EventHandler

      Self for chaining.

      const handler = () => {};
      obj.on('test', handler);

      obj.off(); // Removes all events
      obj.off('test'); // Removes all events called 'test'
      obj.off('test', handler); // Removes all handler functions, called 'test'
      obj.off('test', handler, this); // Removes all handler functions, called 'test' with scope this

    • Attach an event handler to an event.

      Parameters

      • name: string

        Name of the event to bind the callback to.

      • callback: HandleEventCallback

        Function that is called when event is fired. Note the callback is limited to 8 arguments.

      • Optionalscope: any = ...

        Object to use as 'this' when the event is fired, defaults to current this.

      Returns EventHandle

      Can be used for removing event in the future.

      obj.on('test', (a, b) => {
          console.log(a + b);
      });
      obj.fire('test', 1, 2); // prints 3 to the console

      const evt = obj.on('test', (a, b) => {
          console.log(a + b);
      });
      // some time later
      evt.off();

    • Attach an event handler to an event. This handler will be removed after being fired once.

      Parameters

      • name: string

        Name of the event to bind the callback to.

      • callback: HandleEventCallback

        Function that is called when event is fired. Note the callback is limited to 8 arguments.

      • Optionalscope: any = ...

        Object to use as 'this' when the event is fired, defaults to current this.

      Returns EventHandle

      • can be used for removing event in the future.
      obj.once('test', (a, b) => {
          console.log(a + b);
      });
      obj.fire('test', 1, 2); // prints 3 to the console
      obj.fire('test', 1, 2); // not going to get handled

    Events

    EVENT_COLLISIONEND: string = 'collisionend'

    Fired when two rigid bodies stop touching. The handler is passed an Entity that represents the other rigid body involved in the collision.

    entity.collision.on('collisionend', (other) => {
        console.log(`${entity.name} stopped touching ${other.name}`);
    });
    EVENT_COLLISIONSTART: string = 'collisionstart'

    Fired when two rigid bodies start touching. The handler is passed the ContactResult object which contains details of the contact between the two rigid bodies.

    entity.collision.on('collisionstart', (result) => {
       console.log(`${entity.name} started touching ${result.other.name}`);
    });
    EVENT_CONTACT: string = 'contact'

    Fired when a contact occurs between two rigid bodies. The handler is passed a ContactResult object which contains details of the contact between the two rigid bodies.

    entity.collision.on('contact', (result) => {
       console.log(`Contact between ${entity.name} and ${result.other.name}`);
    });
    EVENT_TRIGGERENTER: string = 'triggerenter'

    Fired when a rigid body enters a trigger volume. The handler is passed an Entity representing the rigid body that entered this collision volume.

    entity.collision.on('triggerenter', (other) => {
        console.log(`${other.name} entered trigger volume ${entity.name}`);
    });
    EVENT_TRIGGERLEAVE: string = 'triggerleave'

    Fired when a rigid body exits a trigger volume. The handler is passed an Entity representing the rigid body that exited this collision volume.

    entity.collision.on('triggerleave', (other) => {
        console.log(`${other.name} exited trigger volume ${entity.name}`);
    });

    Settings

    Member Visibility

    On This Page

    Properties
    Accessors
    Methods
    Events