Enum HandleTemplate 

pub enum HandleTemplate<T: Asset> {
    Path(AssetPath<'static>),
    Handle(Handle<T>),
    Value(ArcMutexValue<T>),
}

A Template that produces a Handle.

How asset paths are resolved in templates

When a type with a Handle<T> field derives FromTemplate, that field is replaced by its template type, HandleTemplate<T>, when created via BSN. We can see that HandleTemplate<T> has the following trait impl block:

impl<I: Into<AssetPath<'static>>, T: Asset> From<I> for HandleTemplate<T> {
    fn from(value: I) -> Self {
        Self::Path(value.into())
    }
}

AssetPath<'static> implements From<&'static str>. Because of that, assigning a string literal to a Handle<T> field automatically converts it into HandleTemplate<T>::Path with that asset path when used in the bsn! macro. Calls to bsn! automatically insert .into() conversions, and due to Rust’s blanket impl that turns From trait impls into their Into equivalents, the conversion from &'static str to AssetPath<'static> is handled automatically. Finally, the HandleTemplate<T>::Path generated gets converted to a Handle<T> during scene initialization, as the asset is loaded from the given path, and the resulting handle is assigned to the field, pointing to the asset that was found at the file path in our original string.

Variants

Path(AssetPath<'static>)

Creates a Handle by calling AssetServer::load on the given AssetPath.

Handle(Handle<T>)

Creates a Handle by cloning the given Handle value.

Value(ArcMutexValue<T>)

Creates a Handle by adding the given asset value using AssetServer::add. This will cache the resulting Handle on the template and reuse it for future template builds.

This should generally be constructed using HandleTemplate::value or asset_value.

Implementations

impl<T: Asset> HandleTemplate<T>

pub fn value(value: impl Into<T>) -> Self

This will create a new HandleTemplate for the given asset value. This makes it possible to define assets “inline” in templates / scenes that produce a Handle.

This supports Into to automatically convert values that can become A.

Trait Implementations

impl<T: Asset> Default for HandleTemplate<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Enum for HandleTemplate<T>

where HandleTemplate<T>: Any + Send + Sync, T: TypePath + Asset, Handle<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ArcMutexValue<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn field(&self, __name_param: &str) -> Option<&dyn PartialReflect>

Returns a reference to the value of the field (in the current variant) with the given name.

fn field_at(&self, __index_param: usize) -> Option<&dyn PartialReflect>

Returns a reference to the value of the field (in the current variant) at the given index.

fn field_mut(&mut self, __name_param: &str) -> Option<&mut dyn PartialReflect>

Returns a mutable reference to the value of the field (in the current variant) with the given name.

fn field_at_mut( &mut self, __index_param: usize, ) -> Option<&mut dyn PartialReflect>

Returns a mutable reference to the value of the field (in the current variant) at the given index.

fn index_of(&self, __name_param: &str) -> Option<usize>

Returns the index of the field (in the current variant) with the given name.

fn name_at(&self, __index_param: usize) -> Option<&str>

Returns the name of the field (in the current variant) with the given index.

fn iter_fields(&self) -> VariantFieldIter<'_>

Returns an iterator over the values of the current variant’s fields.

fn field_len(&self) -> usize

Returns the number of fields in the current variant.

fn variant_name(&self) -> &str

The name of the current variant.

fn variant_index(&self) -> usize

The index of the current variant.

fn variant_type(&self) -> VariantType

The type of the current variant.

fn to_dynamic_enum(&self) -> DynamicEnum

Creates a new DynamicEnum from this enum.

fn is_variant(&self, variant_type: VariantType) -> bool

Returns true if the current variant’s type matches the given one.

fn variant_path(&self) -> String

Returns the full path to the current variant.

fn get_represented_enum_info(&self) -> Option<&'static EnumInfo>

Will return None if TypeInfo is not available.

impl<T: Asset> From<Handle<T>> for HandleTemplate<T>

fn from(value: Handle<T>) -> Self

Converts to this type from the input type.

impl<I: Into<AssetPath<'static>>, T: Asset> From<I> for HandleTemplate<T>

fn from(value: I) -> Self

Converts to this type from the input type.

impl<T> FromReflect for HandleTemplate<T>

where HandleTemplate<T>: Any + Send + Sync, T: TypePath + Asset, Handle<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ArcMutexValue<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn from_reflect(__param0: &dyn PartialReflect) -> Option<Self>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl<T> GetTypeRegistration for HandleTemplate<T>

where HandleTemplate<T>: Any + Send + Sync, T: TypePath + Asset, Handle<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ArcMutexValue<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl<T> PartialReflect for HandleTemplate<T>

where HandleTemplate<T>: Any + Send + Sync, T: TypePath + Asset, Handle<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ArcMutexValue<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn try_apply( &mut self, __value_param: &dyn PartialReflect, ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&dyn Reflect>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &dyn PartialReflect

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

Casts this type to a mutable, reflected value.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool>

Returns a “partial equality” comparison result.

fn reflect_partial_cmp(&self, value: &dyn PartialReflect) -> Option<Ordering>

Returns a “partial comparison” result.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

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

Debug formatter for the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl<T> Reflect for HandleTemplate<T>

where HandleTemplate<T>: Any + Send + Sync, T: TypePath + Asset, Handle<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ArcMutexValue<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn into_any(self: Box<Self>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl<T: Asset> Template for HandleTemplate<T>

type Output = Handle<T>

The type of value produced by this Template.

fn build_template( &self, context: &mut TemplateContext<'_, '_>, ) -> Result<Handle<T>>

Uses this template and the given entity context to produce a Template::Output.

fn clone_template(&self) -> Self

Clones this template. See Clone.

impl<T> TypePath for HandleTemplate<T>

where HandleTemplate<T>: Any + Send + Sync, T: TypePath + Asset,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl<T> Typed for HandleTemplate<T>

where HandleTemplate<T>: Any + Send + Sync, T: TypePath + Asset, Handle<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection, ArcMutexValue<T>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.