# componentsAtPoint method

An iterable of descendant components intersecting the given point. The
`point`

is in the local coordinate space.

More precisely, imagine a ray originating at a certain point (x, y) on the screen, and extending perpendicularly to the screen's surface into your game's world. The purpose of this method is to find all components that intersect with this ray, in the order from those that are closest to the user to those that are farthest.

The return value is an Iterable of components. If the `nestedPoints`

parameter is given, then it will also report the points of intersection
for each component in its local coordinate space. Specifically, the last
element in the list is the point in the coordinate space of the returned
component, the element before the last is in that component's parent's
coordinate space, and so on. The `nestedPoints`

list must be growable and
modifiable.

The default implementation relies on the CoordinateTransform interface to translate from the parent's coordinate system into the local one. Make sure that your component implements this interface if it alters the coordinate system when rendering.

If your component overrides renderTree, then it almost certainly needs to override this method as well, so that this method can find all rendered components wherever they are.

## Implementation

```
Iterable<Component> componentsAtPoint(
Vector2 point, [
List<Vector2>? nestedPoints,
]) {
return componentsAtLocation<Vector2>(
point,
nestedPoints,
(transform, point) => transform.parentToLocal(point),
(component, point) => component.containsLocalPoint(point),
);
}
```