Engine API Reference - v2.6.1
    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 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 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 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');

    • 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