Enum amethyst_assets::AssetPrefab

pub enum AssetPrefab<A, F = Box<dyn SerializableFormat<<A as Asset>::Data>>> where
    A: Asset,
    F: Format<A::Data>,  {
    Handle(Handle<A>),
    File(String, F),
    Placeholder,
}

Convenience PrefabData for loading assets of type A using Format F.

Will add a Handle<A> to the Entity

Type parameters:

• A: Asset,
• F: Format for loading A

Variants

Handle(Handle<A>)

From existing handle

File(String, F)

From file, (name, format)

Placeholder

Placeholder during loading

Trait Implementations

impl<A: Clone, F: Clone> Clone for AssetPrefab<A, F> where
    A: Asset,
    F: Format<A::Data>, 

fn clone(&self) -> AssetPrefab<A, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, F: Debug> Debug for AssetPrefab<A, F> where
    A: Asset,
    F: Format<A::Data>, 

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

Formats the value using the given formatter.

impl<'de, A, F> Deserialize<'de> for AssetPrefab<A, F> where
    A: Asset,
    F: Format<A::Data>,
    F: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'a, A, F> PrefabData<'a> for AssetPrefab<A, F> where
    A: Asset,
    F: Format<A::Data>, 

type SystemData = (ReadExpect<'a, Loader>, WriteStorage<'a, Handle<A>>, Read<'a, AssetStorage<A>>)

SystemData needed to perform the load

type Result = Handle<A>

The result type returned by the load operation

fn add_to_entity(
    &self,
    entity: Entity,
    system_data: &mut Self::SystemData,
    _: &[Entity],
    _: &[Entity]
) -> Result<Handle<A>, Error>

Add the data for this prefab onto the given Entity

fn load_sub_assets(
    &mut self,
    progress: &mut ProgressCounter,
    (loader, _, storage): &mut Self::SystemData
) -> Result<bool, Error>

Trigger asset loading for any sub assets.

impl<A, F> Serialize for AssetPrefab<A, F> where
    A: Asset,
    F: Format<A::Data>,
    F: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.