Struct bevy_inspector_egui::restricted_world_view::RestrictedWorldView

pub struct RestrictedWorldView<'w> { /* private fields */ }

A view into the world which may only access certain resources and components. A restricted form of &mut World.

Can be used to access a value, and give out the remaining “&mut World” somewhere else.

Example usage

use bevy_ecs::prelude::*;
use std::any::TypeId;
use bevy_inspector_egui::restricted_world_view::RestrictedWorldView;

let mut world = World::new();
let mut world = RestrictedWorldView::new(&mut world);

let (mut materials, world) = world.split_off_resource(TypeId::of::<Assets<StandardMaterial>>());
let materials = materials.get_resource_mut::<Assets<StandardMaterial>>();

pass_somewhere_else(world);

Implementations

impl<'w> RestrictedWorldView<'w>

Fundamental methods for working with a RestrictedWorldView

pub fn new(world: &'w mut World) -> RestrictedWorldView<'w>

Create a new RestrictedWorldView with permission to access everything.

pub fn resources_components(
    world: &'w mut World
) -> (RestrictedWorldView<'w>, RestrictedWorldView<'w>)

Splits the world into one view which may only be used for resource access, and another which may only be used for component access.

pub fn allows_access_to_resource(&self, type_id: TypeId) -> bool

Whether the resource with the given TypeId may be accessed from this world view

pub fn allows_access_to_component(&self, component: (Entity, TypeId)) -> bool

Whether the given component at the entity may be accessed from this world view

pub fn split_off_resource(
    &mut self,
    resource: TypeId
) -> (RestrictedWorldView<'_>, RestrictedWorldView<'_>)

Splits this view into one view that only has access the the resource resource (.0), and the rest (.1).

pub fn split_off_resource_typed<R: Resource>(
    self
) -> Option<(Mut<'w, R>, RestrictedWorldView<'w>)>

Like RestrictedWorldView::split_off_resource, but takes self and returns 'w lifetimes.

pub fn split_off_component(
    &mut self,
    component: (Entity, TypeId)
) -> (RestrictedWorldView<'_>, RestrictedWorldView<'_>)

Splits this view into one view that only has access the the component component.1 at the entity component.0 (.0), and the rest (.1).

pub fn split_off_components(
    &mut self,
    components: impl Iterator<Item = (Entity, TypeId)> + Copy
) -> (RestrictedWorldView<'_>, RestrictedWorldView<'_>)

Splits this view into one view that only has access the the component-entity pairs components (.0), and the rest (.1)

impl<'w> RestrictedWorldView<'w>

Some safe methods for getting values out of the RestrictedWorldView. Also has some methods for getting values in their Reflect form.

pub fn get_resource_mut<R: Resource>(&mut self) -> Result<Mut<'_, R>, Error>

Gets a mutable reference to the resource of the given type

pub fn get_two_resources_mut<R1: Resource, R2: Resource>(
    &mut self
) -> (Result<Mut<'_, R1>, Error>, Result<Mut<'_, R2>, Error>)

Gets mutable reference to two resources. Panics if R1 = R2.

pub fn get_resource_reflect_mut_by_id(
    &mut self,
    type_id: TypeId,
    type_registry: &TypeRegistry
) -> Result<(&mut dyn Reflect, impl FnOnce() + '_), Error>

Gets a mutable reference in form of a &mut dyn Reflect to the resource given by type_id.

Returns an error if the type does not register Reflect.

Also returns a impl FnOnce() to mark the value as changed.

pub fn get_entity_component_reflect(
    &mut self,
    entity: Entity,
    component: TypeId,
    type_registry: &TypeRegistry
) -> Result<(&mut dyn Reflect, bool, impl FnOnce() + '_), Error>

Gets a mutable reference in form of a &mut dyn Reflect to a component at an entity.

Returns an error if the type does not register Reflect.

Also returns a impl FnOnce() to mark the value as changed.

Trait Implementations

impl<'a> From<&'a mut World> for RestrictedWorldView<'a>

fn from(value: &'a mut World) -> Self

Converts to this type from the input type.