Trait bevy::ecs::Bundle

pub trait Bundle: DynamicBundle { }

A statically typed collection of components

See DynamicBundle

Implementations on Foreign Types

impl<D, C, B, A> Bundle for (D, C, B, A) where
    C: Component,
    B: Component,
    A: Component,
    D: Component, 

pub fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<(D, C, B, A), MissingComponent>

impl<B, A> Bundle for (B, A) where
    B: Component,
    A: Component, 

pub fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<(B, A), MissingComponent>

impl<L, K, J, I, H, G, F, E, D, C, B, A> Bundle for (L, K, J, I, H, G, F, E, D, C, B, A) where
    C: Component,
    E: Component,
    B: Component,
    L: Component,
    A: Component,
    D: Component,
    F: Component,
    G: Component,
    I: Component,
    H: Component,
    J: Component,
    K: Component, 

pub fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<(L, K, J, I, H, G, F, E, D, C, B, A), MissingComponent>

impl<C, B, A> Bundle for (C, B, A) where
    C: Component,
    B: Component,
    A: Component, 

pub fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<(C, B, A), MissingComponent>

impl<E, D, C, B, A> Bundle for (E, D, C, B, A) where
    C: Component,
    E: Component,
    B: Component,
    A: Component,
    D: Component, 

pub fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<(E, D, C, B, A), MissingComponent>

impl<A> Bundle for (A,) where
    A: Component, 

pub fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<(A,), MissingComponent>

impl<M, L, K, J, I, H, G, F, E, D, C, B, A> Bundle for (M, L, K, J, I, H, G, F, E, D, C, B, A) where
    C: Component,
    E: Component,
    B: Component,
    L: Component,
    A: Component,
    D: Component,
    F: Component,
    G: Component,
    I: Component,
    H: Component,
    J: Component,
    K: Component,
    M: Component, 

pub fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<(M, L, K, J, I, H, G, F, E, D, C, B, A), MissingComponent>

impl<H, G, F, E, D, C, B, A> Bundle for (H, G, F, E, D, C, B, A) where
    C: Component,
    E: Component,
    B: Component,
    A: Component,
    D: Component,
    F: Component,
    G: Component,
    H: Component, 

pub fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<(H, G, F, E, D, C, B, A), MissingComponent>

impl<G, F, E, D, C, B, A> Bundle for (G, F, E, D, C, B, A) where
    C: Component,
    E: Component,
    B: Component,
    A: Component,
    D: Component,
    F: Component,
    G: Component, 

pub fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<(G, F, E, D, C, B, A), MissingComponent>

impl<J, I, H, G, F, E, D, C, B, A> Bundle for (J, I, H, G, F, E, D, C, B, A) where
    C: Component,
    E: Component,
    B: Component,
    A: Component,
    D: Component,
    F: Component,
    G: Component,
    I: Component,
    H: Component,
    J: Component, 

pub fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<(J, I, H, G, F, E, D, C, B, A), MissingComponent>

impl<N, M, L, K, J, I, H, G, F, E, D, C, B, A> Bundle for (N, M, L, K, J, I, H, G, F, E, D, C, B, A) where
    C: Component,
    N: Component,
    E: Component,
    B: Component,
    L: Component,
    A: Component,
    D: Component,
    F: Component,
    G: Component,
    I: Component,
    H: Component,
    J: Component,
    K: Component,
    M: Component, 

pub fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<(N, M, L, K, J, I, H, G, F, E, D, C, B, A), MissingComponent>

impl<F, E, D, C, B, A> Bundle for (F, E, D, C, B, A) where
    C: Component,
    E: Component,
    B: Component,
    A: Component,
    D: Component,
    F: Component, 

pub fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<(F, E, D, C, B, A), MissingComponent>

impl<I, H, G, F, E, D, C, B, A> Bundle for (I, H, G, F, E, D, C, B, A) where
    C: Component,
    E: Component,
    B: Component,
    A: Component,
    D: Component,
    F: Component,
    G: Component,
    I: Component,
    H: Component, 

pub fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<(I, H, G, F, E, D, C, B, A), MissingComponent>

impl<K, J, I, H, G, F, E, D, C, B, A> Bundle for (K, J, I, H, G, F, E, D, C, B, A) where
    C: Component,
    E: Component,
    B: Component,
    A: Component,
    D: Component,
    F: Component,
    G: Component,
    I: Component,
    H: Component,
    J: Component,
    K: Component, 

pub fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<(K, J, I, H, G, F, E, D, C, B, A), MissingComponent>

impl Bundle for ()

pub fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<(), MissingComponent>

impl<O, N, M, L, K, J, I, H, G, F, E, D, C, B, A> Bundle for (O, N, M, L, K, J, I, H, G, F, E, D, C, B, A) where
    C: Component,
    N: Component,
    E: Component,
    B: Component,
    L: Component,
    A: Component,
    D: Component,
    F: Component,
    G: Component,
    I: Component,
    H: Component,
    J: Component,
    K: Component,
    M: Component,
    O: Component, 

pub fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<(O, N, M, L, K, J, I, H, G, F, E, D, C, B, A), MissingComponent>

Loading content...

Implementors

impl Bundle for LightBundle

pub fn with_static_ids<__hecs__T>(
    f: impl FnOnce(&[TypeId]) -> __hecs__T
) -> __hecs__T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<LightBundle, MissingComponent>

impl Bundle for PbrBundle

pub fn with_static_ids<__hecs__T>(
    f: impl FnOnce(&[TypeId]) -> __hecs__T
) -> __hecs__T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<PbrBundle, MissingComponent>

impl Bundle for Camera2dBundle

pub fn with_static_ids<__hecs__T>(
    f: impl FnOnce(&[TypeId]) -> __hecs__T
) -> __hecs__T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<Camera2dBundle, MissingComponent>

impl Bundle for Camera3dBundle

pub fn with_static_ids<__hecs__T>(
    f: impl FnOnce(&[TypeId]) -> __hecs__T
) -> __hecs__T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<Camera3dBundle, MissingComponent>

impl Bundle for MeshBundle

pub fn with_static_ids<__hecs__T>(
    f: impl FnOnce(&[TypeId]) -> __hecs__T
) -> __hecs__T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<MeshBundle, MissingComponent>

impl Bundle for SpriteBundle

pub fn with_static_ids<__hecs__T>(
    f: impl FnOnce(&[TypeId]) -> __hecs__T
) -> __hecs__T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<SpriteBundle, MissingComponent>

impl Bundle for SpriteSheetBundle

pub fn with_static_ids<__hecs__T>(
    f: impl FnOnce(&[TypeId]) -> __hecs__T
) -> __hecs__T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<SpriteSheetBundle, MissingComponent>

impl Bundle for ButtonBundle

pub fn with_static_ids<__hecs__T>(
    f: impl FnOnce(&[TypeId]) -> __hecs__T
) -> __hecs__T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<ButtonBundle, MissingComponent>

impl Bundle for CameraUiBundle

pub fn with_static_ids<__hecs__T>(
    f: impl FnOnce(&[TypeId]) -> __hecs__T
) -> __hecs__T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<CameraUiBundle, MissingComponent>

impl Bundle for ImageBundle

pub fn with_static_ids<__hecs__T>(
    f: impl FnOnce(&[TypeId]) -> __hecs__T
) -> __hecs__T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<ImageBundle, MissingComponent>

impl Bundle for NodeBundle

pub fn with_static_ids<__hecs__T>(
    f: impl FnOnce(&[TypeId]) -> __hecs__T
) -> __hecs__T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<NodeBundle, MissingComponent>

impl Bundle for TextBundle

pub fn with_static_ids<__hecs__T>(
    f: impl FnOnce(&[TypeId]) -> __hecs__T
) -> __hecs__T

pub fn static_type_info() -> Vec<TypeInfo, Global>

pub unsafe fn get(
    f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>
) -> Result<TextBundle, MissingComponent>

Loading content...