Struct Handle 

pub struct Handle<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.

pub fn dangling() -> Self

where T: Default,

Creates a dangling handle backed by T::default().

This is useful as a placeholder until a real asset is loaded.

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 + Default> Default for AssetHandle<T>

fn default() -> Self

Returns the “default value” for a type.

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.

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

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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