nightshade 0.57.0

A cross-platform data-oriented game engine.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

//! Ray casts against the picking collider set. The rapier ray and the collider
//! traversal live here; the picking domain keeps only the screen-space math.

use crate::ecs::picking::queries::{PickingOptions, PickingRay, PickingResult};
use crate::ecs::world::{Vec2, World};

pub fn pick_entities_trimesh(
    world: &World,
    screen_pos: Vec2,
    options: PickingOptions,
) -> Vec<PickingResult> {
    use rapier3d::prelude::*;

    let ray = match PickingRay::from_screen_position(world, screen_pos) {
        Some(ray) => ray,
        None => return Vec::new(),
    };

    let rapier_ray = rapier3d::parry::query::Ray::new(
        point![ray.origin.x, ray.origin.y, ray.origin.z],
        vector![ray.direction.x, ray.direction.y, ray.direction.z],
    );

    let mut results = Vec::new();
    let picking_world =
        world.plugin_resource::<crate::plugins::physics::picking::resources::PickingWorld>();

    for (handle, collider) in picking_world.collider_set.iter() {
        let entity = match picking_world.get_entity(handle) {
            Some(e) => e,
            None => continue,
        };

        if options.ignore_invisible
            && let Some(visible) = world.get::<crate::ecs::primitives::Visibility>(entity)
            && !visible.visible
        {
            continue;
        }

        if let Some(toi) =
            collider
                .shape()
                .cast_ray(collider.position(), &rapier_ray, options.max_distance, true)
        {
            let world_position = ray.origin + ray.direction * toi;
            results.push(PickingResult {
                entity,
                distance: toi,
                world_position,
            });
        }
    }

    results.sort_by(|a, b| a.distance.partial_cmp(&b.distance).unwrap());
    results
}

pub fn pick_closest_entity_trimesh(world: &World, screen_pos: Vec2) -> Option<PickingResult> {
    pick_entities_trimesh(world, screen_pos, PickingOptions::default())
        .into_iter()
        .next()
}