CollisionListener

Custom collision handling.

Custom collision handling can be implemented by using the on_collision function on a node. Under the hood, this function adds a LambdaCollisionListener component to that node. This component inherits from the CollisionListener component, which is the base component for all collision listeners. You can create your own component, inherit from CollisionListener, add it to a node, and this component will receive collision callbacks from that node.

Note

To receive collision callbacks, the body should have an active RigidBody or CharacterController component.

Note

MotionType Static is the cheapest motionType for a body to receive callbacks, but it has its limitations. See MotionType.

This component is provided by the engine.physics_core module, which is included in the engine.core module.

Example:

require engine.core

let node = create_node(NodeData())
add_component(node, new RigidBody())
on_collision(node) @(collision) {
    print("Collision detected")
}

See also Physics Simulation in a Main Loop

Structures

Collision

Collision event

Fields:

• nodeId : NodeId - the other body that collides with the receiver body

• normal : float3 - normal of the collision on the other node (world space)

• penetration : float - penetration depth

• impulse : float - collision impulse, use for impact measurement

• positions : array<float3> - positions of the collision (world space, not empty)

Classes

CollisionListener : Component

Base component for all collision callback handlers. When added to a node with an active RigidBody component, it starts receiving collision callbacks for it.

You can create a custom component, inherit it from CollisionListener, override methods, and receive callbacks to yourself

However, if you want a quick collision handling, consider using on_collision function.

Usage example:

class CustomCollisionListener : CollisionListener {
    def override on_initialize() {
        super.on_initialize()
        // ...
    }

    def override on_collision(c: Collision) {
        // Collision started
        ...
    }

    def override on_collision_stay(c: Collision) {
        // Collision stays
        ...
    }

    def override on_collision_exit(otherNode: NodeId) {
        // Collision finished
        ...
    }
}

// ...
add_component(node, new CustomCollisionListener())

Note

CharacterController generates collision events only with rigid bodies. To collide with other CharacterController-s, it must have an active RigidBody component.

CollisionListener.on_collision(collision: Collision)

Called when the body collides with another another node with a RigidBody component collides with this node.

The callback is called for every new collision.

Arguments:

• collision : Collision

CollisionListener.on_collision_stay(collision: Collision)

Registers a callback that is called when another node with a RigidBody component collides with this node.

The callback is called for every collisions that stays between frames.

Arguments:

• collision : Collision

CollisionListener.on_collision_exit(otherNode: NodeId)

Registers a callback that is called when another node with a RigidBody component collides with this node.

The callback is called for every finished collisions.

Arguments:

• otherNode : NodeId

LambdaCollisionListener : CollisionListener

Collision handler that calls lambdas as custom handlers.

Don’t use this component directly, instead use on_collision function and others.

Usage example:

on_collision(node) @(collision) {
    print("Collision started between {node} and {collision.node}")
}
on_collision_stay(node) @(collision) {
    print("Collision stays between {node} and {collision.node}")
}
on_collision_exit(node) @(otherNode) {
    print("Collision finished between {node} and {otherNode}")
}

LambdaCollisionListener.on_collision(collision: Collision)

Called when you use on_collision on a node. See on_collision

Arguments:

• collision : Collision

LambdaCollisionListener.on_collision_stay(collision: Collision)

Called when you use on_collision_stay on a node. See on_collision_stay

Arguments:

• collision : Collision

LambdaCollisionListener.on_collision_exit(node: NodeId)

Called when you use on_collision_exit on a node. See on_collision_exit

Arguments:

• node : NodeId

LambdaCollisionListener.addOnCollisionListener(callback: lambda<(collision:Collision):void>)

Adds a callback for on_collision event.

Arguments:

• callback : lambda<(collision: Collision ):void>

LambdaCollisionListener.addOnCollisionStayListener(callback: lambda<(collision:Collision):void>)

Adds a callback for on_collision_stay event.

Arguments:

• callback : lambda<(collision: Collision ):void>

LambdaCollisionListener.addOnCollisionExitListener(callback: lambda<(otherNode:NodeId):void>)

Adds a callback for on_collision_exit event.

Arguments:

• callback : lambda<(otherNode: NodeId ):void>