Struct BlockDef 

pub struct BlockDef { /* private fields */ }

Contains a Block and can be stored in a Universe. Together with Primitive::Indirect, this allows mutation of a block definition such that all its existing usages follow.

To perform such a mutation, use BlockDefTransaction.

Additionally, it caches the results of block evaluation to improve performance. Note that this cache only updates when the owning Universe is being stepped, or when a direct mutation to this BlockDef is performed, not when the contained Block sends a change notification.

Implementations

impl BlockDef

pub fn new(read_ticket: ReadTicket<'_>, block: Block) -> Self

Constructs a new BlockDef that stores the given block (which may be replaced in the future).

pub fn block(&self) -> &Block

Returns the current block value.

Note that if you wish to get the EvaluatedBlock result, you should obtain the cached value by calling BlockDef.evaluate(), or by using a Primitive::Indirect, not by calling .block().evaluate(), which is not cached.

pub fn evaluate( &self, read_ticket: ReadTicket<'_>, ) -> Result<EvaluatedBlock, EvalBlockError>

Returns the current cached evaluation of the current block value.

This returns the same success or error as Block::from(handle_to_self).evaluate() would, not the same as .block().evaluate() would.

Trait Implementations

impl<'a> Arbitrary<'a> for BlockDef

Available on crate feature arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl AsRef<Block> for BlockDef

fn as_ref(&self) -> &Block

Converts this type into a shared reference of the (usually inferred) input type.

impl Component for BlockDef

where Self: Send + Sync + 'static,

Required Components: [BlockDefNextValue].

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

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

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

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]

impl Debug for BlockDef

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Listen for BlockDef

Registers a listener for whenever the result of evaluation of this block definition changes. Note that this only occurs when the owning Universe is being stepped.

type Msg = BlockChange

The type of message which may be obtained from this source.

type Listener = <Notifier<<BlockDef as Listen>::Msg, Arc<dyn Listener<<BlockDef as Listen>::Msg> + Sync + Send>> as Listen>::Listener

The type which all added listeners must be convertible to.

fn listen_raw(&self, listener: Self::Listener)

Subscribe the given Listener to this source of messages.

fn listen<L>(&self, listener: L)

where L: IntoListener<Self::Listener, Self::Msg>, Self: Sized,

Subscribe the given Listener to this source of messages.

impl Transactional for BlockDef

type Transaction = BlockDefTransaction

The type of transaction which should be used with Self.

fn transact<'c, F, O>( &mut self, f: F, ) -> Result<O, ExecuteError<Self::Transaction>>

where F: FnOnce(&mut Self::Transaction, &Self) -> Result<O, <Self::Transaction as Merge>::Conflict>, Self::Transaction: Transaction<Target = Self, Context<'c> = (), Output = NoOutput> + Default,

Convenience method for building and then applying a transaction to self, equivalent to the following steps:

impl UTransactional for BlockDef

fn bind( target: Handle<Self>, transaction: Self::Transaction, ) -> UniverseTransaction

Specify the target of the transaction as a Handle, and erase its type, so that it can be combined with other transactions in the same universe.

impl UniverseMember for BlockDef

type Read<'ticket> = &'ticket BlockDef

Type returned by Handle::<T>::read() which is the way to read the T value after it has been inserted into the Universe.

impl VisitHandles for BlockDef

fn visit_handles(&self, visitor: &mut dyn HandleVisitor)

For each Handle contained within self that is reachable without traversing another Handle, call visitor with a reference to it.