geng 0.17.2

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
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

use super::*;

pub struct Vec2Slider<'a> {
    pub position: &'a mut Aabb2<f32>,
    pub sense: &'a mut geng::ui::Sense,
    pub hover_at: &'a mut Option<vec2<f32>>,
    pub animation: &'a mut f32,
    pub change: RefCell<&'a mut Option<vec2<f32>>>,
    pub value: vec2<f32>,
}

impl<'a> Vec2Slider<'a> {
    pub fn new(cx: &'a geng::ui::Controller, value: vec2<f32>) -> Self {
        Self {
            position: cx.get_state_with(|| Aabb2::point(vec2::ZERO)),
            sense: cx.get_state(),
            animation: cx.get_state(),
            hover_at: cx.get_state(),
            change: RefCell::new(cx.get_state()),
            value,
        }
    }

    pub fn get_change(&self) -> Option<vec2<f32>> {
        self.change.borrow_mut().take()
    }
}

impl geng::ui::Widget for Vec2Slider<'_> {
    fn calc_constraints(
        &mut self,
        _children: &geng::ui::ConstraintsContext,
    ) -> geng::ui::Constraints {
        geng::ui::Constraints {
            min_size: vec2(100.0, 100.0),
            flex: vec2(0.0, 0.0),
        }
    }
    // If using Sense helper this method must be added
    fn sense(&mut self) -> Option<&mut geng::ui::Sense> {
        Some(self.sense)
    }
    fn update(&mut self, delta_time: f64) {
        let delta_time = delta_time as f32 * 10.0;
        if self.sense.is_hovered() || self.sense.is_captured() {
            *self.animation += delta_time;
        } else {
            *self.animation -= delta_time;
        }
        *self.animation = self.animation.clamp(0.0, 1.0);
    }
    fn draw(&mut self, cx: &mut geng::ui::DrawContext) {
        *self.position = cx.position.map(|x| x as f32); // Update hidden state to remember our widget's position

        cx.draw2d.draw2d(
            cx.framebuffer,
            &geng::PixelPerfectCamera,
            &draw2d::Ellipse {
                transform: mat3::translate(self.position.center())
                    * mat3::scale(self.position.size() / 2.0),
                cut: 0.0,
                color: cx.theme.usable_color,
            },
        );
        cx.draw2d.draw2d(
            cx.framebuffer,
            &geng::PixelPerfectCamera,
            &draw2d::Ellipse::circle(
                self.position.center() + self.position.size() * self.value / 2.0,
                5.0 + *self.animation * 5.0,
                cx.theme.hover_color,
            ),
        );
    }
    fn handle_event(&mut self, event: &geng::Event) {
        // Use helper to determine if we should process interactions
        if let geng::Event::CursorMove { position } = event {
            *self.hover_at = Some(
                ((position.map(|x| x as f32) - self.position.center())
                    / (self.position.size() / 2.0))
                    .clamp_len(..=1.0),
            );
        }
        if self.sense.is_captured() {
            if let geng::Event::MousePress { .. } | geng::Event::CursorMove { .. } = event {
                if let Some(new_value) = *self.hover_at {
                    **self.change.borrow_mut() = Some(new_value);
                }
            }
        }
    }
}