Enum Element

#[non_exhaustive]
pub enum Element {
    Object(String),
}

An Element is the lowest level of the project hierarchy.

It defines a specific element that can be drawn on the screen, commonly represented as an asset with additional metadata. For portability reasons we don’t store the full path of an asset, we simply store an ID which we can resolve later through the assets module.

We don’t have to store all information about the elements in the enum; things like translation, scale, rotation, enabled, … can all be inferred later from the components it’s placed alongside.

Examples

Here’s how to spawn a simple Element for the Walls.

    commands.spawn((
        Project::new("Roadside Inn"),
        children![(
            Level::new("Ground Floor"),
            children![(
                Layer::new("Walls", Transform::IDENTITY),
                children![(
                    Element::new_object(String::from("<hash-of-resolvable-asset")),
                )]
            )]
        )]
    ));

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Object(String)

Represents an image, no pathing, patterns, …

Implementations

impl Element

pub fn new_object(asset_id: String) -> Self

Generates a new Element for the given asset ID.

TODO: validate assets? maybe generate a full bundle?

Trait Implementations

impl Component for Element

where Self: Send + Sync + 'static,

Required Components: [Visibility].

A component’s Required Components are inserted whenever it is inserted. Note that this will also insert the required components of the required components, recursively, in depth-first order.

const STORAGE_TYPE: StorageType = bevy::ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

type Mutability = Immutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have [Component<Mutability = Mutable>], while immutable components will instead have [Component<Mutability = Immutable>].

fn register_required_components( requiree: ComponentId, components: &mut ComponentsRegistrator<'_>, required_components: &mut RequiredComponents, inheritance_depth: u16, recursion_check_stack: &mut Vec<ComponentId>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn map_entities<M: EntityMapper>(this: &mut Self, mapper: &mut M)

Maps the entities on this component using the given [EntityMapper]. This is used to remap entities in contexts like scenes and entity cloning. When deriving [Component], this is populated by annotating fields containing entities with #[entities]

fn register_component_hooks(hooks: &mut ComponentHooks)

👎Deprecated since 0.16.0: Use the individual hook methods instead (e.g., Component::on_add, etc.)

Called when registering this component, allowing mutable access to its [ComponentHooks].

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add [ComponentHook] for this [Component] if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert [ComponentHook] for this [Component] if one is defined.

fn on_replace() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_replace [ComponentHook] for this [Component] if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove [ComponentHook] for this [Component] if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn [ComponentHook] for this [Component] if one is defined.