bevy_mod_transform2d 0.3.0

A 2D Transform component for The Bevy 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
93
94
95
96

use bevy::prelude::*;

use crate::transform2d::Transform2d;

#[derive(Bundle, Clone, Copy, Debug, Default, Reflect, FromReflect)]
pub struct Transform2dBundle {
    pub transform: Transform2d,
    pub transform_3d: Transform,
    pub global_transform: GlobalTransform,
}

impl Transform2dBundle {
    /// Creates a new identity [`TransformBundle`], with no translation, rotation, and a scale of 1 on all axes.
    pub const IDENTITY: Self = Transform2dBundle {
        transform: Transform2d::IDENTITY,
        transform_3d: Transform::IDENTITY,
        global_transform: GlobalTransform::IDENTITY,
    };

    /// Creates a new [`TransformBundle`] from a [`Transform`].
    pub const fn from_transform(transform: Transform2d) -> Self {
        Transform2dBundle {
            transform,
            ..Transform2dBundle::IDENTITY
        }
    }
}

impl From<Transform2d> for Transform2dBundle {
    #[inline]
    fn from(transform: Transform2d) -> Self {
        Transform2dBundle::from_transform(transform)
    }
}

/// A [`Bundle`] with the following [`Component`](bevy_ecs::component::Component)s:
/// * [`Visibility`] and [`ComputedVisibility`], which describe the visibility of an entity
/// * [`Transform`] and [`GlobalTransform`], which describe the position of an entity
///
/// * To show or hide an entity, you should set its [`Visibility`].
/// * To get the computed visibility of an entity, you should get its [`ComputedVisibility`].
/// * To place or move an entity, you should set its [`Transform`].
/// * To get the global transform of an entity, you should get its [`GlobalTransform`].
/// * For hierarchies to work correctly, you must have all four components.
///   * You may use the [`SpatialBundle`] to guarantee this.
#[derive(Bundle, Debug, Default)]
#[cfg(feature = "bevy_render")]
pub struct Spatial2dBundle {
    /// The visibility of the entity.
    pub visibility: Visibility,
    /// The computed visibility of the entity.
    pub computed: ComputedVisibility,
    /// The transform of the entity.
    pub transform: Transform2d,
    /// The 3D transform of the entity.
    pub transform_3d: Transform,
    /// The global transform of the entity.
    pub global_transform: GlobalTransform,
}

#[cfg(feature = "bevy_render")]
impl Spatial2dBundle {
    /// Creates a new [`Spatial2dBundle`] from a [`Transform2d`].
    ///
    /// This initializes [`GlobalTransform`] as identity, and visibility as visible.
    #[inline]
    pub const fn from_transform(transform: Transform2d) -> Self {
        Spatial2dBundle {
            transform,
            ..Self::VISIBLE_IDENTITY
        }
    }

    /// A visible [`Spatial2dBundle`], with no translation, rotation, and a scale of 1 on all axes.
    pub const VISIBLE_IDENTITY: Self = Spatial2dBundle {
        visibility: Visibility::VISIBLE,
        computed: ComputedVisibility::INVISIBLE,
        transform: Transform2d::IDENTITY,
        transform_3d: Transform::IDENTITY,
        global_transform: GlobalTransform::IDENTITY,
    };

    /// An invisible [`Spatial2dBundle`], with no translation, rotation, and a scale of 1 on all axes.
    pub const INVISIBLE_IDENTITY: Self = Spatial2dBundle {
        visibility: Visibility::INVISIBLE,
        ..Self::VISIBLE_IDENTITY
    };
}

#[cfg(feature = "bevy_render")]
impl From<Transform2d> for Spatial2dBundle {
    #[inline]
    fn from(transform: Transform2d) -> Self {
        Spatial2dBundle::from_transform(transform)
    }
}