bevy_picking_state_machine 0.4.0

A global state machine for working with `bevy_picking`.
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use crate::{GlobalPickingState, PickingStateMachine};
use bevy::{ecs::entity::Entity, input::mouse::MouseButton, math::Vec2};

/// A picking transition event.
#[derive(Debug, Clone, Copy)]
pub enum PickingTransition {
    Pressed {
        entity: Entity,
        button: MouseButton,
    },
    Released {
        entity: Entity,
        button: MouseButton,
        down: Vec2,
        time: f32,
        outside: bool,
    },
    HoverEnter {
        entity: Entity,
    },
    HoverExit {
        entity: Entity,
    },
    Cancelled {
        entity: Entity,
        button: MouseButton,
        down: Vec2,
        time: f32,
    },
}

impl PickingTransition {
    pub fn entity(&self) -> Entity {
        match *self {
            PickingTransition::Pressed { entity, .. } => entity,
            PickingTransition::Released { entity, .. } => entity,
            PickingTransition::HoverEnter { entity } => entity,
            PickingTransition::HoverExit { entity } => entity,
            PickingTransition::Cancelled { entity, .. } => entity,
        }
    }
}

impl PickingStateMachine {
    pub(crate) fn queue_transitions(&mut self, now: f32) {
        use GlobalPickingState::*;
        self.transitions.clear();
        let time = self.press.map(|x| now - x.time).unwrap_or(0.0);
        let button = self.press.map(|x| x.button).unwrap_or(MouseButton::Left);
        let down = self.press.map(|x| x.position).unwrap_or(Vec2::ZERO);
        match (self.previous, self.current) {
            (None, None) => (),
            (None, Hover { entity }) => {
                self.transitions
                    .push(PickingTransition::HoverEnter { entity });
            }
            (None, Pressed { entity }) => {
                self.transitions
                    .push(PickingTransition::Pressed { entity, button });
            }
            (Hover { entity }, None) => {
                self.transitions
                    .push(PickingTransition::HoverExit { entity });
            }
            (Hover { entity: e1 }, Hover { entity: e2 }) => {
                if e1 != e2 {
                    self.transitions
                        .push(PickingTransition::HoverExit { entity: e1 });
                    self.transitions
                        .push(PickingTransition::HoverEnter { entity: e2 });
                }
            }
            (Hover { entity: e1 }, Pressed { entity: e2 }) => {
                if e1 == e2 {
                    self.transitions
                        .push(PickingTransition::Pressed { entity: e1, button });
                } else {
                    self.transitions
                        .push(PickingTransition::HoverExit { entity: e1 });
                    self.transitions
                        .push(PickingTransition::HoverEnter { entity: e2 });
                    self.transitions
                        .push(PickingTransition::Pressed { entity: e2, button });
                }
            }
            (Pressed { entity }, None) => {
                if self.is_post_cancellation_state {
                    self.transitions.push(PickingTransition::Cancelled {
                        entity,
                        down,
                        time,
                        button,
                    });
                } else {
                    self.transitions.push(PickingTransition::Released {
                        entity,
                        button,
                        down,
                        time,
                        outside: true,
                    });
                    self.transitions
                        .push(PickingTransition::HoverExit { entity });
                }
            }
            (Pressed { entity: e1 }, Hover { entity: e2 }) => {
                if e1 == e2 {
                    self.transitions.push(PickingTransition::Released {
                        entity: e1,
                        button,
                        down,
                        time,
                        outside: false,
                    });
                } else {
                    self.transitions.push(PickingTransition::Released {
                        entity: e1,
                        button,
                        down,
                        time,
                        outside: true,
                    });
                    self.transitions
                        .push(PickingTransition::HoverExit { entity: e1 });
                    self.transitions
                        .push(PickingTransition::HoverEnter { entity: e2 });
                }
            }
            (Pressed { entity: e1 }, Pressed { entity: e2 }) => {
                // Both of these situations should be forbidden, but just in case.
                if e1 != e2 || self.current_btn_just_pressed {
                    self.transitions.push(PickingTransition::Released {
                        entity: e1,
                        button,
                        down,
                        time,
                        outside: true,
                    });
                    self.transitions
                        .push(PickingTransition::HoverExit { entity: e1 });
                    self.transitions
                        .push(PickingTransition::HoverEnter { entity: e2 });
                    self.transitions
                        .push(PickingTransition::Pressed { entity: e2, button });
                }
            }
        }
    }
}