Struct bevy::asset::ReflectAsset

pub struct ReflectAsset { /* private fields */ }

Type data for the TypeRegistry used to operate on reflected Assets.

This type provides similar methods to Assets<T> like get, add and remove, but can be used in situations where you don’t know which asset type T you want until runtime.

ReflectAsset can be obtained via TypeRegistration::data if the asset was registered using register_asset_reflect.

Implementations

impl ReflectAsset

pub fn type_uuid(&self) -> Uuid

The [bevy_reflect::TypeUuid] of the asset

pub fn handle_type_id(&self) -> TypeId

The TypeId of the Handle<T> for this asset

pub fn assets_resource_type_id(&self) -> TypeId

The TypeId of the Assets<T> resource

pub fn get<'w>(
    &self,
    world: &'w World,
    handle: HandleUntyped
) -> Option<&'w (dyn Reflect + 'static)>

Equivalent of Assets::get

pub fn get_mut<'w>(
    &self,
    world: &'w mut World,
    handle: HandleUntyped
) -> Option<&'w mut (dyn Reflect + 'static)>

Equivalent of Assets::get_mut

pub unsafe fn get_unchecked_mut<'w>(
    &self,
    world: &'w World,
    handle: HandleUntyped
) -> Option<&'w mut (dyn Reflect + 'static)>

Equivalent of Assets::get_mut, but does not require a mutable reference to the world.

Only use this method when you have ensured that you are the only one with access to the Assets resource of the asset type. Furthermore, this does not allow you to have look up two distinct handles, you can only have at most one alive at the same time. This means that this is not allowed:

let a = unsafe { reflect_asset.get_unchecked_mut(&world, handle_1).unwrap() };
let b = unsafe { reflect_asset.get_unchecked_mut(&world, handle_2).unwrap() };
// ^ not allowed, two mutable references through the same asset resource, even though the
// handles are distinct

println!("a = {a:?}, b = {b:?}");

Safety

This method does not prevent you from having two mutable pointers to the same data, violating Rust’s aliasing rules. To avoid this:

• Only call this method when you have exclusive access to the world (or use a scheduler that enforces unique access to the Assets resource).
• Don’t call this method more than once in the same scope.

pub fn add<'w>(
    &self,
    world: &'w mut World,
    value: &(dyn Reflect + 'static)
) -> HandleUntyped

Equivalent of Assets::add

pub fn set<'w>(
    &self,
    world: &'w mut World,
    handle: HandleUntyped,
    value: &(dyn Reflect + 'static)
) -> HandleUntyped

Equivalent of Assets::set

pub fn remove(
    &self,
    world: &mut World,
    handle: HandleUntyped
) -> Option<Box<dyn Reflect + 'static, Global>>

Equivalent of Assets::remove

pub fn len(&self, world: &World) -> usize

Equivalent of Assets::len

pub fn is_empty(&self, world: &World) -> bool

Equivalent of Assets::is_empty

pub fn ids<'w>(&self, world: &'w World) -> impl Iterator<Item = HandleId> + 'w

Equivalent of Assets::ids

Trait Implementations

impl Clone for ReflectAsset

fn clone(&self) -> ReflectAsset

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A> FromType<A> for ReflectAssetwhere
    A: Asset + FromReflect,

fn from_type() -> ReflectAsset