Struct Resources 

pub struct Resources { /* private fields */ }

One session’s registry. The maps are secondary to the process-wide the process-wide mint (see the module doc), so a lookup that misses is a handle this session never registered or has since removed — never somebody else’s entry.

Implementations

impl Resources

pub fn new(session: SessionId) -> Self

The registry for session session; keys come from the process’s mint.

pub fn session(&self) -> SessionId

The session this registry belongs to.

pub fn font_family(&self, id: FontId) -> Option<&str>

The registered family name, if the handle is live here.

pub fn add_image(&mut self, width: u32, height: u32, rgba: Vec<u8>) -> ImageId

pub fn update_image( &mut self, id: ImageId, width: u32, height: u32, rgba: Vec<u8>, ) -> bool

Replaces an image’s pixels in place: the handle is unchanged, so every node declaring it shows the new pixels next frame with no view change; the dimensions may change. From the first update on the image is texture-backed for life. Returns whether the pixels were taken: false for a foreign or removed handle (noted as a miss), and for a buffer that is not width × height × 4 bytes, which changes nothing rather than handing a backend a short upload it would refuse with a validation error — the doors that take bytes from an app check the length first and say so; this is the guard behind them.

pub fn update_image_with( &mut self, id: ImageId, width: u32, height: u32, fill: impl FnOnce(&mut [u8]), ) -> bool

Self::update_image into a buffer the core recycles: fill is handed width × height × 4 bytes to write the new pixels into, and is not called for a foreign or removed handle (noted as a miss), or for a size whose byte count overflows. The bytes it is handed hold an earlier frame’s pixels, not zeros, so fill writes every one. The buffer is the image’s own when no display list still holds it, else the one the previous update replaced, else a new one — so a stream updated every frame, between frames or inside them, allocates at most three times and then never again. The replaced buffer is kept only for an image updated before at the same size, and let go SPARE_FRAMES frames after the last update. What every door that copies an app’s bytes goes through.

pub fn remove_image(&mut self, id: ImageId) -> Option<ImageEntry>

pub fn image(&self, id: ImageId) -> Option<&ImageEntry>

The pixels behind an image handle, if it is live here.

pub fn fragment(&self, id: FragmentId) -> Option<&Arc<str>>

The WGSL behind a fragment handle, if it is live here. A miss is what makes the node draw nothing, and records a foreign handle.

pub fn add_sound(&mut self, bytes: Vec<u8>) -> SoundId

Registers a sound from its encoded file bytes.

pub fn remove_sound(&mut self, id: SoundId) -> Option<SoundEntry>

pub fn has_sounds(&self) -> bool

Whether any sound is registered: what tells an audio backend it will be asked to play something, before it is.

pub fn sound(&self, id: SoundId) -> Option<&Arc<[u8]>>

The encoded bytes behind a sound handle, if it is live here.

Trait Implementations

impl Drop for Resources

fn drop(&mut self)

A session’s handles leave the mint with it, so the slots come back and a process that opens and closes many sessions (a test binary) does not keep every id it ever minted.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.