Struct AssetHandle

pub struct AssetHandle<T: Asset>(/* private fields */);

A thread-safe, reference-counted handle to a loaded asset’s data.

This struct acts as a smart pointer that provides shared ownership of asset data in memory. It is the primary way that game logic and systems should interact with loaded assets.

Cloning an AssetHandle is a very cheap operation, as it only increments an atomic reference counter. It does not duplicate the underlying asset data. The asset data is automatically deallocated when the last handle pointing to it is dropped.

This handle dereferences to &T, allowing for transparent, read-only access to the asset’s contents.

Examples

let texture = Texture {};

// The AssetAgent creates the first handle when loading is complete.
let handle1 = AssetHandle::new(texture);

// Other systems can clone the handle to share access.
let handle2 = handle1.clone();

// Accessing the data is done via dereferencing (like with `Arc` or `Box`).
// let width = handle1.width; // Assuming Texture has a `width` field.

Implementations

impl<T: Asset> AssetHandle<T>

pub fn new(asset: T) -> Self

Creates a new AssetHandle that takes ownership of the asset data.

This is typically called by an asset loading system (like an AssetAgent) once an asset has been successfully loaded into memory.

Trait Implementations

impl<T: Asset> Clone for AssetHandle<T>

fn clone(&self) -> Self

Clones the handle, incrementing the reference count to the underlying asset.

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

Performs copy-assignment from source.

impl<T: Debug + Asset> Debug for AssetHandle<T>

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

Formats the value using the given formatter.

impl<T: Asset> Deref for AssetHandle<T>

fn deref(&self) -> &Self::Target

Provides transparent, immutable access to the underlying asset data.

type Target = T

The resulting type after dereferencing.