bevy_rectray 0.5.0

A minimal 2d layout system for bevy.
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

use bevy::{
    ecs::component::Component,
    prelude::{Reflect, ReflectComponent, ReflectDefault, ReflectDeserialize, ReflectSerialize},
};
use serde::{Deserialize, Serialize};

use crate::Anchor;
/// Anchor and direction for a tooltip like object.
///
/// * `T` means [`Anchor::TOP_CENTER`] then go up.
/// * `TL` means [`Anchor::TOP_LEFT`] then go bottom left.
/// * `LT` means [`Anchor::TOP_LEFT`] then go top right.
#[derive(Debug, Clone, Copy, Default, Reflect, Serialize, Deserialize)]
#[reflect(Default, Serialize, Deserialize)]
#[repr(u8)]
pub enum AnchorDirection {
    #[default]
    B,
    L,
    T,
    R,
    BL,
    LB,
    BR,
    RB,
    TL,
    LT,
    TR,
    RT,
}

impl AnchorDirection {
    pub fn to_parent_anchor(self) -> Anchor {
        match self {
            AnchorDirection::B => Anchor::BOTTOM_CENTER,
            AnchorDirection::L => Anchor::CENTER_LEFT,
            AnchorDirection::T => Anchor::TOP_CENTER,
            AnchorDirection::R => Anchor::CENTER_RIGHT,
            AnchorDirection::BL => Anchor::BOTTOM_RIGHT,
            AnchorDirection::LB => Anchor::TOP_LEFT,
            AnchorDirection::BR => Anchor::BOTTOM_LEFT,
            AnchorDirection::RB => Anchor::TOP_RIGHT,
            AnchorDirection::TL => Anchor::TOP_RIGHT,
            AnchorDirection::LT => Anchor::BOTTOM_LEFT,
            AnchorDirection::TR => Anchor::TOP_LEFT,
            AnchorDirection::RT => Anchor::BOTTOM_RIGHT,
        }
    }

    pub fn to_anchor(self) -> Anchor {
        match self {
            AnchorDirection::B => Anchor::TOP_CENTER,
            AnchorDirection::L => Anchor::CENTER_RIGHT,
            AnchorDirection::T => Anchor::BOTTOM_CENTER,
            AnchorDirection::R => Anchor::CENTER_LEFT,
            AnchorDirection::BL => Anchor::TOP_RIGHT,
            AnchorDirection::LB => Anchor::TOP_RIGHT,
            AnchorDirection::BR => Anchor::TOP_LEFT,
            AnchorDirection::RB => Anchor::TOP_LEFT,
            AnchorDirection::TL => Anchor::BOTTOM_RIGHT,
            AnchorDirection::LT => Anchor::BOTTOM_RIGHT,
            AnchorDirection::TR => Anchor::BOTTOM_LEFT,
            AnchorDirection::RT => Anchor::BOTTOM_LEFT,
        }
    }
}

/// Determines how an object reacts if out of frame.
#[derive(Debug, Clone, Default, Reflect, Serialize, Deserialize, Component)]
#[reflect(Serialize, Deserialize, Component)]
pub enum OutOfFrameBehavior {
    /// Do nothing.
    #[default]
    None,
    /// If out of frame, nudge the rectangle into the frame.
    ///
    /// # Note
    ///
    /// Only works if the parent's global rotation is `0`,
    /// since we work on local transform.
    Nudge,
    /// Changes the combination of `anchor` and `parent_anchor` until in screen,
    /// if all choices failed, use `Transform2d`.
    AnchorSwap {
        choices: [AnchorDirection; 4],
        len: u8,
    },
}

impl OutOfFrameBehavior {
    pub const fn anchor_swap(directions: &[AnchorDirection]) -> Self {
        let mut arr = [AnchorDirection::B; 4];
        let mut i = 0;
        while i < 4 && i < directions.len() {
            arr[i] = directions[i];
            i += 1;
        }
        OutOfFrameBehavior::AnchorSwap {
            choices: arr,
            len: i as u8,
        }
    }

    pub fn iter_anchor_swaps(&self) -> &[AnchorDirection] {
        match self {
            OutOfFrameBehavior::AnchorSwap { choices, len } => &choices[0..*len as usize],
            _ => &[],
        }
    }
}