hai_core 0.7.0

Core implementation of Hai game engine, and general 2D rendering library using WebGPU as well.
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
64
65
66
67
68
69
70
71
72
73

use std::sync::Arc;

use glam::Vec3;
use hai_pal::sync::RwLock;

use crate::traits::{FocusablePayload, Node};

use super::constants::{VIEWPORT_HEIGHT, VIEWPORT_WIDTH};
use super::walk::walk_nodes_bottom_top;

pub struct HitTestResult {
    pub target: Arc<RwLock<dyn Node>>,
    pub parent_ids: Vec<u32>,
}

impl PartialEq for HitTestResult {
    fn eq(&self, other: &Self) -> bool {
        self.target.read().base().id() == other.target.read().base().id()
    }
}

pub fn hit_test<'a>(
    root_node: &Arc<RwLock<dyn Node>>,
    global_logical_x: f32,
    global_logical_y: f32,
    upload_payload: &FocusablePayload,
) -> Option<HitTestResult> {
    let root_node = root_node.read();
    let mut focused_node = None;

    walk_nodes_bottom_top(
        &*root_node,
        &mut |child, _, parent_ids| {
            let child_ref = child.read();

            let p = child_ref
                .base()
                .global_transform()
                .inverse()
                .transform_point3(Vec3::new(
                    global_logical_x / VIEWPORT_WIDTH,
                    global_logical_y / VIEWPORT_HEIGHT,
                    1.0,
                ));

            let local_logical_x = p.x * VIEWPORT_WIDTH;
            let local_logical_y = p.y * VIEWPORT_HEIGHT;

            let hit = match child_ref.as_focusable() {
                Some(focusable) => {
                    // check if pointer is over the node
                    let hit = focusable.contains(local_logical_x, local_logical_y, upload_payload);

                    if hit {
                        focused_node = Some(HitTestResult {
                            target: child.clone(),
                            parent_ids: parent_ids.to_vec(),
                        });
                    }

                    hit
                }
                None => false,
            };

            hit
        },
        &[],
        true,
    );

    focused_node
}