Struct Ray 

pub struct Ray { /* private fields */ }

A point in the world and the direction it looks.

Camera::ray_through builds one from a pixel; hit it against whatever shapes a game keeps to see what that pixel points at.

Implementations

impl Ray

pub fn new(origin: Vec3, direction: Vec3) -> Self

A ray from origin along direction, which is kept one unit long so that every hit is a distance in meters.

pub const fn origin(&self) -> Vec3

Ray origin.

pub const fn direction(&self) -> Vec3

The direction it points, one unit long.

pub fn at(&self, t: f32) -> Vec3

The point t meters along the ray.

Examples found in repository

examples/sound-lab.rs (line 504)

    fn handle_drag(&mut self, ctx: &mut TickContext<'_, SoundCheck>) {
        // Read before the check below for the UI's own claim on the
        // pointer, so a release over it still frees a source a drag moved
        // there.
        if ctx.released(Button::Select) {
            self.dragging = None;
        }
        if ctx.ui_wants_pointer() {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());

        if ctx.pressed(Button::Select) {
            self.dragging = self.sources.iter().position(|source| {
                ray.hit_sphere(source.position, SOURCE_PICK_RADIUS)
                    .is_some()
            });
        }

        let Some(index) = self.dragging else {
            return;
        };
        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let hit = ray.at(distance);
        let dropped =
            Vec2::new(hit.x, hit.z).clamp(Vec2::splat(-PLAY_BOUND), Vec2::splat(PLAY_BOUND));
        self.sources[index].position = Vec3::new(dropped.x, SOURCE_HEIGHT, dropped.y);
    }

examples/isometric-board.rs (line 440)

    fn handle_click(&mut self, ctx: &mut TickContext<'_, Board>) {
        if ctx.ui_wants_pointer() || !ctx.pressed(Button::Select) {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());
        let (lift, half) = unit_geometry(self.turn);

        if self.current().target.is_none() {
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                self.selected = !self.selected;
                return;
            }
        }
        if !self.selected {
            return;
        }

        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let Some(tile) = tile_at(ray.at(distance)) else {
            return;
        };
        if tile == self.current().tile || tile == self.other().tile {
            return;
        }

        let destination = tile_center(tile) + Vec3::Y * lift;
        let heading = destination.x - self.current().position.x;
        let current = self.current_mut();
        if heading.abs() > f32::EPSILON {
            current.facing_right = heading > 0.0;
        }
        current.target = Some(destination);
        self.selected = false;
        ctx.play(Sound::Click);
    }

    /// Cursor target, `None` while the UI has the pointer.
    fn hovered(&self, ctx: &FrameContext<'_, Board>) -> Hover {
        if ctx.ui_wants_pointer() {
            return Hover::None;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());

        if self.current().target.is_none() {
            let (_, half) = unit_geometry(self.turn);
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                return Hover::CurrentUnit;
            }
        }
        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return Hover::None;
        };
        match tile_at(ray.at(distance)) {
            Some(tile) => Hover::Tile(tile),
            None => Hover::None,
        }
    }

pub fn hit_plane(&self, plane: Plane) -> Option<f32>

Distance in meters along the ray to plane; None where the ray is parallel to it or points away from it.

Examples found in repository

examples/sound-lab.rs (lines 498-501)

    fn handle_drag(&mut self, ctx: &mut TickContext<'_, SoundCheck>) {
        // Read before the check below for the UI's own claim on the
        // pointer, so a release over it still frees a source a drag moved
        // there.
        if ctx.released(Button::Select) {
            self.dragging = None;
        }
        if ctx.ui_wants_pointer() {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());

        if ctx.pressed(Button::Select) {
            self.dragging = self.sources.iter().position(|source| {
                ray.hit_sphere(source.position, SOURCE_PICK_RADIUS)
                    .is_some()
            });
        }

        let Some(index) = self.dragging else {
            return;
        };
        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let hit = ray.at(distance);
        let dropped =
            Vec2::new(hit.x, hit.z).clamp(Vec2::splat(-PLAY_BOUND), Vec2::splat(PLAY_BOUND));
        self.sources[index].position = Vec3::new(dropped.x, SOURCE_HEIGHT, dropped.y);
    }

examples/isometric-board.rs (lines 434-437)

    fn handle_click(&mut self, ctx: &mut TickContext<'_, Board>) {
        if ctx.ui_wants_pointer() || !ctx.pressed(Button::Select) {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());
        let (lift, half) = unit_geometry(self.turn);

        if self.current().target.is_none() {
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                self.selected = !self.selected;
                return;
            }
        }
        if !self.selected {
            return;
        }

        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let Some(tile) = tile_at(ray.at(distance)) else {
            return;
        };
        if tile == self.current().tile || tile == self.other().tile {
            return;
        }

        let destination = tile_center(tile) + Vec3::Y * lift;
        let heading = destination.x - self.current().position.x;
        let current = self.current_mut();
        if heading.abs() > f32::EPSILON {
            current.facing_right = heading > 0.0;
        }
        current.target = Some(destination);
        self.selected = false;
        ctx.play(Sound::Click);
    }

    /// Cursor target, `None` while the UI has the pointer.
    fn hovered(&self, ctx: &FrameContext<'_, Board>) -> Hover {
        if ctx.ui_wants_pointer() {
            return Hover::None;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());

        if self.current().target.is_none() {
            let (_, half) = unit_geometry(self.turn);
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                return Hover::CurrentUnit;
            }
        }
        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return Hover::None;
        };
        match tile_at(ray.at(distance)) {
            Some(tile) => Hover::Tile(tile),
            None => Hover::None,
        }
    }

pub fn hit_sphere(&self, center: Vec3, radius: f32) -> Option<f32>

Distance in meters along the ray to the sphere of radius meters around center; None where the ray never intersects it.

A ray that starts within one returns where it leaves.

Examples found in repository

examples/sound-lab.rs (line 490)

    fn handle_drag(&mut self, ctx: &mut TickContext<'_, SoundCheck>) {
        // Read before the check below for the UI's own claim on the
        // pointer, so a release over it still frees a source a drag moved
        // there.
        if ctx.released(Button::Select) {
            self.dragging = None;
        }
        if ctx.ui_wants_pointer() {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());

        if ctx.pressed(Button::Select) {
            self.dragging = self.sources.iter().position(|source| {
                ray.hit_sphere(source.position, SOURCE_PICK_RADIUS)
                    .is_some()
            });
        }

        let Some(index) = self.dragging else {
            return;
        };
        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let hit = ray.at(distance);
        let dropped =
            Vec2::new(hit.x, hit.z).clamp(Vec2::splat(-PLAY_BOUND), Vec2::splat(PLAY_BOUND));
        self.sources[index].position = Vec3::new(dropped.x, SOURCE_HEIGHT, dropped.y);
    }

pub fn hit_aabb(&self, min: Vec3, max: Vec3) -> Option<f32>

Distance in meters along the ray to the bounds between min and max; None where the ray never intersects them.

A ray that starts within them returns where it leaves.

Examples found in repository

examples/ui-fonts.rs (line 223)

fn hit_station(ray: Ray) -> Option<StationKind> {
    StationKind::ALL
        .into_iter()
        .filter_map(|station| {
            let (min, max) = station.aabb();
            ray.hit_aabb(min, max).map(|distance| (distance, station))
        })
        .min_by(|(a, _), (b, _)| a.total_cmp(b))
        .map(|(_, station)| station)
}

examples/isometric-board.rs (line 425)

    fn handle_click(&mut self, ctx: &mut TickContext<'_, Board>) {
        if ctx.ui_wants_pointer() || !ctx.pressed(Button::Select) {
            return;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());
        let (lift, half) = unit_geometry(self.turn);

        if self.current().target.is_none() {
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                self.selected = !self.selected;
                return;
            }
        }
        if !self.selected {
            return;
        }

        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return;
        };
        let Some(tile) = tile_at(ray.at(distance)) else {
            return;
        };
        if tile == self.current().tile || tile == self.other().tile {
            return;
        }

        let destination = tile_center(tile) + Vec3::Y * lift;
        let heading = destination.x - self.current().position.x;
        let current = self.current_mut();
        if heading.abs() > f32::EPSILON {
            current.facing_right = heading > 0.0;
        }
        current.target = Some(destination);
        self.selected = false;
        ctx.play(Sound::Click);
    }

    /// Cursor target, `None` while the UI has the pointer.
    fn hovered(&self, ctx: &FrameContext<'_, Board>) -> Hover {
        if ctx.ui_wants_pointer() {
            return Hover::None;
        }
        let ray = ctx
            .last_camera()
            .ray_through(ctx.pointer(), ctx.window_size());

        if self.current().target.is_none() {
            let (_, half) = unit_geometry(self.turn);
            let center = self.current().position;
            if ray.hit_aabb(center - half, center + half).is_some() {
                return Hover::CurrentUnit;
            }
        }
        let Some(distance) = ray.hit_plane(ray::Plane {
            point: Vec3::ZERO,
            normal: Vec3::Y,
        }) else {
            return Hover::None;
        };
        match tile_at(ray.at(distance)) {
            Some(tile) => Hover::Tile(tile),
            None => Hover::None,
        }
    }

Trait Implementations

impl Clone for Ray

fn clone(&self) -> Ray

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Ray

impl Debug for Ray

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Ray

fn eq(&self, other: &Ray) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Ray