Creates a new embedded asset by embedding the bytes of the given path into the current binary
and registering those bytes with the embeddedAssetSource.
Returns the Path for a given embedded asset.
This is used internally by embedded_asset and can be used to get a Path
that matches the AssetPath used by that asset.
A generational runtime-only identifier for a specific Asset stored in Assets. This is optimized for efficient runtime
usage and is not suitable for identifying assets across app runs.
Provides “asset” loading and processing functionality. An Asset is a “runtime value” that is loaded from an AssetSource,
which can be something like a filesystem, a network, etc.
Loads and tracks the state of Asset values from a configured AssetReader. This can be used to kick off new asset loads and
retrieve their current load states.
A context that provides access to assets in AssetLoaders, tracks dependencies, and collects asset load state.
Any asset state accessed by LoadContext will be tracked and stored for use in dependency events and asset preprocessing.
The successful result of an AssetLoader::load call. This contains the loaded “root” asset and any other “labeled” assets produced
by the loader. It also holds the input AssetMeta (if it exists) and tracks dependencies:
The internal “strong” Asset handle storage for Handle::Strong and UntypedHandle::Strong. When this is dropped,
the Asset will be freed. It also stores some asset metadata for easy access from handles.
A unique runtime-only identifier for an Asset. This is cheap to Copy/Clone and is not directly tied to the
lifetime of the Asset. This means it can point to an Asset that no longer exists.
A strong or weak handle to a specific Asset. If a Handle is Handle::Strong, the Asset will be kept
alive until the Handle is dropped. If a Handle is Handle::Weak, it does not necessarily reference a live Asset,
nor will it keep assets alive.
An “untyped” / “generic-less” Asset identifier that behaves much like AssetId, but stores the Asset type
information at runtime instead of compile-time. This increases the size of the type, but it enables storing asset ids
across asset types together and enables comparisons between them.
An untyped variant of Handle, which internally stores the Asset type information at runtime
as a TypeId instead of encoding it in the compile-time type. This allows handles across Asset types
to be stored together and compared.