Struct WeakAssetHandle 

pub struct WeakAssetHandle<A: Asset> { /* private fields */ }

A weak reference to an asset that doesn’t prevent unloading.

Unlike AssetHandle, a WeakAssetHandle does not contribute to the reference count of an asset. This is useful for caches and lookup tables where you want to reference assets without keeping them loaded.

Example

use goud_engine::assets::{Asset, AssetHandle, WeakAssetHandle};

struct Texture;
impl Asset for Texture {}

let strong: AssetHandle<Texture> = AssetHandle::new(1, 1);
let weak: WeakAssetHandle<Texture> = WeakAssetHandle::from_handle(&strong);

assert!(weak.is_valid());
assert_eq!(weak.index(), 1);
assert_eq!(weak.generation(), 1);

// Upgrade to strong handle for access (liveness must be checked separately)
let upgraded = weak.upgrade();
assert_eq!(upgraded.index(), 1);

Implementations

impl<A: Asset> WeakAssetHandle<A>

pub const INVALID: Self

The invalid weak handle constant.

pub fn from_handle(handle: &AssetHandle<A>) -> Self

Creates a weak handle from a strong handle.

pub const fn new(index: u32, generation: u32) -> Self

Creates a new weak handle with the given index and generation.

pub const fn index(&self) -> u32

Returns the index component.

pub const fn generation(&self) -> u32

Returns the generation component.

pub const fn is_valid(&self) -> bool

Returns true if not the INVALID sentinel.

pub fn upgrade(&self) -> AssetHandle<A>

Upgrades to a strong handle.

Note: This does NOT check if the asset is still alive. Use AssetServer::is_alive() to check liveness before using the handle.

Trait Implementations

impl<A: Asset> Clone for WeakAssetHandle<A>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Asset> Debug for WeakAssetHandle<A>

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

Formats the value using the given formatter.

impl<A: Asset> Default for WeakAssetHandle<A>

fn default() -> Self

Returns the “default value” for a type.

impl<A: Asset> From<&AssetHandle<A>> for WeakAssetHandle<A>

fn from(handle: &AssetHandle<A>) -> Self

Converts to this type from the input type.

impl<A: Asset> Hash for WeakAssetHandle<A>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<A: Asset> PartialEq for WeakAssetHandle<A>

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<A: Asset> Copy for WeakAssetHandle<A>

impl<A: Asset> Eq for WeakAssetHandle<A>